@objectstack/spec 1.0.6 → 1.0.7

package/dist/hub/index.mjs

@@ -1,8 +1,8 @@
 // src/hub/composer.zod.ts
-import { z as z4 } from "zod";
+import { z as z5 } from "zod";
 
 // src/kernel/manifest.zod.ts
-import { z as z3 } from "zod";
+import { z as z4 } from "zod";
 
 // src/kernel/plugin-capability.zod.ts
 import { z } from "zod";
@@ -817,8 +817,87 @@ var PluginLoadingStateSchema = z2.object({
   retryCount: z2.number().int().min(0).default(0)
 }).describe("Plugin loading state");
 
+// src/kernel/plugin.zod.ts
+import { z as z3 } from "zod";
+var PluginContextSchema = z3.object({
+  ql: z3.object({
+    object: z3.function().returns(z3.any()),
+    // Return any to allow method chaining
+    query: z3.function().returns(z3.any())
+  }).passthrough().describe("ObjectQL Engine Interface"),
+  os: z3.object({
+    getCurrentUser: z3.function().returns(z3.any()),
+    getConfig: z3.function().returns(z3.any())
+  }).passthrough().describe("ObjectStack Kernel Interface"),
+  logger: z3.object({
+    debug: z3.function().returns(z3.void()),
+    info: z3.function().returns(z3.void()),
+    warn: z3.function().returns(z3.void()),
+    error: z3.function().returns(z3.void())
+  }).passthrough().describe("Logger Interface"),
+  storage: z3.object({
+    get: z3.function().returns(z3.any()),
+    set: z3.function().returns(z3.promise(z3.void())),
+    delete: z3.function().returns(z3.promise(z3.void()))
+  }).passthrough().describe("Storage Interface"),
+  i18n: z3.object({
+    t: z3.function().returns(z3.string()),
+    getLocale: z3.function().returns(z3.string())
+  }).passthrough().describe("Internationalization Interface"),
+  metadata: z3.record(z3.string(), z3.any()),
+  events: z3.record(z3.string(), z3.any()),
+  app: z3.object({
+    router: z3.object({
+      get: z3.function().returns(z3.any()),
+      post: z3.function().returns(z3.any()),
+      use: z3.function().returns(z3.any())
+    }).passthrough()
+  }).passthrough().describe("App Framework Interface"),
+  drivers: z3.object({
+    register: z3.function().returns(z3.void())
+  }).passthrough().describe("Driver Registry")
+});
+var PluginLifecycleSchema = z3.object({
+  onInstall: z3.function().args(PluginContextSchema).returns(z3.promise(z3.void())).optional(),
+  onEnable: z3.function().args(PluginContextSchema).returns(z3.promise(z3.void())).optional(),
+  onDisable: z3.function().args(PluginContextSchema).returns(z3.promise(z3.void())).optional(),
+  onUninstall: z3.function().args(PluginContextSchema).returns(z3.promise(z3.void())).optional(),
+  onUpgrade: z3.function().args(PluginContextSchema, z3.string(), z3.string()).returns(z3.promise(z3.void())).optional()
+});
+var CORE_PLUGIN_TYPES = [
+  "ui",
+  // Frontend: Serves static assets/SPA (e.g. Console, Studio)
+  "driver",
+  // Connectivity: Database or Storage adapters (e.g. SQL, S3)
+  "server",
+  // Protocol: HTTP/RPC Servers (e.g. Hono, GraphQL)
+  "app",
+  // Business: Vertical Solution Bundle (Metadata + Logic)
+  "theme",
+  // Appearance: UI Overrides & CSS Variables
+  "agent",
+  // AI: Autonomous Agent & Tool Definitions
+  "objectql"
+  // Core: ObjectQL Engine Data Provider
+];
+var PluginSchema = PluginLifecycleSchema.extend({
+  id: z3.string().min(1).optional().describe("Unique Plugin ID (e.g. com.example.crm)"),
+  type: z3.enum([
+    "standard",
+    // Default: General purpose backend logic (Service, Hook, etc.)
+    ...CORE_PLUGIN_TYPES
+  ]).default("standard").optional().describe("Plugin Type categorization for runtime behavior"),
+  staticPath: z3.string().optional().describe('Absolute path to static assets (Required for type="ui-plugin")'),
+  slug: z3.string().regex(/^[a-z0-9-_]+$/).optional().describe('URL path segment (Required for type="ui-plugin")'),
+  default: z3.boolean().optional().describe('Serve at root path (Only one "ui-plugin" can be default)'),
+  version: z3.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Semantic Version"),
+  description: z3.string().optional(),
+  author: z3.string().optional(),
+  homepage: z3.string().url().optional()
+});
+
 // src/kernel/manifest.zod.ts
-var ManifestSchema = z3.object({
+var ManifestSchema = z4.object({
   /** 
    * Unique package identifier using reverse domain notation.
    * Must be unique across the entire ecosystem.
@@ -826,65 +905,75 @@ var ManifestSchema = z3.object({
    * @example "com.steedos.crm"
    * @example "org.apache.superset"
    */
-  id: z3.string().describe("Unique package identifier (reverse domain style)"),
+  id: z4.string().describe("Unique package identifier (reverse domain style)"),
   /** 
    * Package version following semantic versioning (major.minor.patch).
    * 
    * @example "1.0.0"
    * @example "2.1.0-beta.1"
    */
-  version: z3.string().regex(/^\d+\.\d+\.\d+$/).describe("Package version (semantic versioning)"),
+  version: z4.string().regex(/^\d+\.\d+\.\d+$/).describe("Package version (semantic versioning)"),
   /** 
    * Type of the package in the ObjectStack ecosystem.
-   * - app: Business application package (contains objects, UIs)
-   * - plugin: General-purpose functionality extension (adds logic, hooks)
-   * - driver: Southbound interface - Database/external service adapter (Postgres, MongoDB, S3)
+   * - plugin: General-purpose functionality extension (Runtime: standard)
+   * - app: Business application package
+   * - driver: Connectivity adapter
+   * - server: Protocol gateway (Hono, GraphQL)
+   * - ui: Frontend package (Static/SPA)
+   * - theme: UI Theme
+   * - agent: AI Agent
    * - module: Reusable code library/shared module
-   * - objectql: Core engine - Data layer implementation
-   * - gateway: Northbound interface - API protocol entry point (GraphQL, REST, RPC, OData)
-   * - adapter: Host adapter - Runtime container (Express, Hono, Fastify, Serverless)
+   * - objectql: Core engine
+   * - adapter: Host adapter (Express, Fastify)
    */
-  type: z3.enum(["app", "plugin", "driver", "module", "objectql", "gateway", "adapter"]).describe("Type of package"),
+  type: z4.enum([
+    "plugin",
+    ...CORE_PLUGIN_TYPES,
+    "module",
+    "gateway",
+    // Deprecated: use 'server'
+    "adapter"
+  ]).describe("Type of package"),
   /** 
    * Human-readable name of the package.
    * Displayed in the UI for users.
    * 
    * @example "Project Management"
    */
-  name: z3.string().describe("Human-readable package name"),
+  name: z4.string().describe("Human-readable package name"),
   /** 
    * Brief description of the package functionality.
    * Displayed in the marketplace and plugin manager.
    */
-  description: z3.string().optional().describe("Package description"),
+  description: z4.string().optional().describe("Package description"),
   /** 
    * Array of permission strings that the package requires.
    * These form the "Scope" requested by the package at installation.
    * 
    * @example ["system.user.read", "system.data.write"]
    */
-  permissions: z3.array(z3.string()).optional().describe("Array of required permission strings"),
+  permissions: z4.array(z4.string()).optional().describe("Array of required permission strings"),
   /** 
    * Glob patterns specifying ObjectQL schemas files.
    * Matches `*.object.yml` or `*.object.ts` files to load business objects.
    * 
    * @example ["./src/objects/*.object.yml"]
    */
-  objects: z3.array(z3.string()).optional().describe("Glob patterns for ObjectQL schemas files"),
+  objects: z4.array(z4.string()).optional().describe("Glob patterns for ObjectQL schemas files"),
   /**
    * Defines system level DataSources.
    * Matches `*.datasource.yml` files.
    * 
    * @example ["./src/datasources/*.datasource.mongo.yml"]
    */
-  datasources: z3.array(z3.string()).optional().describe("Glob patterns for Datasource definitions"),
+  datasources: z4.array(z4.string()).optional().describe("Glob patterns for Datasource definitions"),
   /**
    * Package Dependencies.
    * Map of package IDs to version requirements.
    * 
    * @example { "@steedos/plugin-auth": "^2.0.0" }
    */
-  dependencies: z3.record(z3.string(), z3.string()).optional().describe("Package dependencies"),
+  dependencies: z4.record(z4.string(), z4.string()).optional().describe("Package dependencies"),
   /**
    * Plugin Configuration Schema.
    * Defines the settings this plugin exposes to the user via UI/ENV.
@@ -899,109 +988,109 @@ var ManifestSchema = z3.object({
    *   }
    * }
    */
-  configuration: z3.object({
-    title: z3.string().optional(),
-    properties: z3.record(z3.string(), z3.object({
-      type: z3.enum(["string", "number", "boolean", "array", "object"]).describe("Data type of the setting"),
-      default: z3.any().optional().describe("Default value"),
-      description: z3.string().optional().describe("Tooltip description"),
-      required: z3.boolean().optional().describe("Is this setting required?"),
-      secret: z3.boolean().optional().describe("If true, value is encrypted/masked (e.g. API Keys)"),
-      enum: z3.array(z3.string()).optional().describe("Allowed values for select inputs")
+  configuration: z4.object({
+    title: z4.string().optional(),
+    properties: z4.record(z4.string(), z4.object({
+      type: z4.enum(["string", "number", "boolean", "array", "object"]).describe("Data type of the setting"),
+      default: z4.any().optional().describe("Default value"),
+      description: z4.string().optional().describe("Tooltip description"),
+      required: z4.boolean().optional().describe("Is this setting required?"),
+      secret: z4.boolean().optional().describe("If true, value is encrypted/masked (e.g. API Keys)"),
+      enum: z4.array(z4.string()).optional().describe("Allowed values for select inputs")
     })).describe("Map of configuration keys to their definitions")
   }).optional().describe("Plugin configuration settings"),
   /**
    * Contribution Points (VS Code Style).
    * formalized way to extend the platform capabilities.
    */
-  contributes: z3.object({
+  contributes: z4.object({
     /**
      * Register new Metadata Kinds (CRDs).
      * Enables the system to parse and validate new file types.
      * Example: Registering a BI plugin to handle *.report.ts
      */
-    kinds: z3.array(z3.object({
-      id: z3.string().describe('The generic identifier of the kind (e.g., "sys.bi.report")'),
-      globs: z3.array(z3.string()).describe('File patterns to watch (e.g., ["**/*.report.ts"])'),
-      description: z3.string().optional().describe("Description of what this kind represents")
+    kinds: z4.array(z4.object({
+      id: z4.string().describe('The generic identifier of the kind (e.g., "sys.bi.report")'),
+      globs: z4.array(z4.string()).describe('File patterns to watch (e.g., ["**/*.report.ts"])'),
+      description: z4.string().optional().describe("Description of what this kind represents")
     })).optional().describe("New Metadata Types to recognize"),
     /**
      * Register System Hooks.
      * Declares that this plugin listens to specific system events.
      */
-    events: z3.array(z3.string()).optional().describe("Events this plugin listens to"),
+    events: z4.array(z4.string()).optional().describe("Events this plugin listens to"),
     /**
      * Register UI Menus.
      */
-    menus: z3.record(z3.string(), z3.array(z3.object({
-      id: z3.string(),
-      label: z3.string(),
-      command: z3.string().optional()
+    menus: z4.record(z4.string(), z4.array(z4.object({
+      id: z4.string(),
+      label: z4.string(),
+      command: z4.string().optional()
     }))).optional().describe("UI Menu contributions"),
     /**
      * Register Custom Themes.
      */
-    themes: z3.array(z3.object({
-      id: z3.string(),
-      label: z3.string(),
-      path: z3.string()
+    themes: z4.array(z4.object({
+      id: z4.string(),
+      label: z4.string(),
+      path: z4.string()
     })).optional().describe("Theme contributions"),
     /**
      * Register Translations.
      * Path to translation files (e.g. "locales/en.json").
      */
-    translations: z3.array(z3.object({
-      locale: z3.string(),
-      path: z3.string()
+    translations: z4.array(z4.object({
+      locale: z4.string(),
+      path: z4.string()
     })).optional().describe("Translation resources"),
     /**
      * Register Server Actions.
      * Invocable functions exposed to Flows or API.
      */
-    actions: z3.array(z3.object({
-      name: z3.string().describe("Unique action name"),
-      label: z3.string().optional(),
-      description: z3.string().optional(),
-      input: z3.any().optional().describe("Input validation schema"),
-      output: z3.any().optional().describe("Output schema")
+    actions: z4.array(z4.object({
+      name: z4.string().describe("Unique action name"),
+      label: z4.string().optional(),
+      description: z4.string().optional(),
+      input: z4.any().optional().describe("Input validation schema"),
+      output: z4.any().optional().describe("Output schema")
     })).optional().describe("Exposed server actions"),
     /**
      * Register Storage Drivers.
      * Enables connecting to new types of datasources.
      */
-    drivers: z3.array(z3.object({
-      id: z3.string().describe('Driver unique identifier (e.g. "postgres", "mongo")'),
-      label: z3.string().describe("Human readable name"),
-      description: z3.string().optional()
+    drivers: z4.array(z4.object({
+      id: z4.string().describe('Driver unique identifier (e.g. "postgres", "mongo")'),
+      label: z4.string().describe("Human readable name"),
+      description: z4.string().optional()
     })).optional().describe("Driver contributions"),
     /**
      * Register Custom Field Types.
      * Extends the data model with new widget types.
      */
-    fieldTypes: z3.array(z3.object({
-      name: z3.string().describe('Unique field type name (e.g. "vector")'),
-      label: z3.string().describe("Display label"),
-      description: z3.string().optional()
+    fieldTypes: z4.array(z4.object({
+      name: z4.string().describe('Unique field type name (e.g. "vector")'),
+      label: z4.string().describe("Display label"),
+      description: z4.string().optional()
     })).optional().describe("Field Type contributions"),
     /**
      * Register Custom Query Operators/Functions.
      * Extends ObjectQL with new functions (e.g. distance()).
      */
-    functions: z3.array(z3.object({
-      name: z3.string().describe('Function name (e.g. "distance")'),
-      description: z3.string().optional(),
-      args: z3.array(z3.string()).optional().describe("Argument types"),
-      returnType: z3.string().optional()
+    functions: z4.array(z4.object({
+      name: z4.string().describe('Function name (e.g. "distance")'),
+      description: z4.string().optional(),
+      args: z4.array(z4.string()).optional().describe("Argument types"),
+      returnType: z4.string().optional()
     })).optional().describe("Query Function contributions")
   }).optional().describe("Platform contributions"),
   /** 
    * Initial data seeding configuration.
    * Defines default records to be inserted when the package is installed.
    */
-  data: z3.array(z3.object({
-    object: z3.string().describe("Target Object Name"),
-    records: z3.array(z3.record(z3.string(), z3.any())).describe("List of records to insert"),
-    mode: z3.enum(["upsert", "insert", "ignore"]).default("upsert").describe("Seeding mode")
+  data: z4.array(z4.object({
+    object: z4.string().describe("Target Object Name"),
+    records: z4.array(z4.record(z4.string(), z4.any())).describe("List of records to insert"),
+    mode: z4.enum(["upsert", "insert", "ignore"]).default("upsert").describe("Seeding mode")
   })).optional().describe("Initial seed data"),
   /**
    * Plugin Capability Manifest.
@@ -1013,7 +1102,7 @@ var ManifestSchema = z3.object({
    * Extension points contributed by this package.
    * Allows packages to extend UI components, add functionality, etc.
    */
-  extensions: z3.record(z3.string(), z3.any()).optional().describe("Extension points and contributions"),
+  extensions: z4.record(z4.string(), z4.any()).optional().describe("Extension points and contributions"),
   /**
    * Plugin Loading Configuration.
    * Configures how the plugin is loaded, initialized, and managed at runtime.
@@ -1023,61 +1112,61 @@ var ManifestSchema = z3.object({
 });
 
 // src/hub/composer.zod.ts
-var DependencyRequirementSchema = z4.object({
-  id: z4.string().describe('Plugin ID (e.g. "com.example.crm")'),
-  version: z4.string().default("latest").describe('SemVer range or "latest"'),
+var DependencyRequirementSchema = z5.object({
+  id: z5.string().describe('Plugin ID (e.g. "com.example.crm")'),
+  version: z5.string().default("latest").describe('SemVer range or "latest"'),
   /**
    * Configuration Overrides
    * Tenant-specific settings that override plugin defaults.
    * Example: { "currency": "USD", "apiKey": "..." }
    */
-  configuration: z4.record(z4.string(), z4.any()).optional().describe("Configuration overrides"),
+  configuration: z5.record(z5.string(), z5.any()).optional().describe("Configuration overrides"),
   /**
    * Feature Flags
    * Enable/Disable specific features within the plugin.
    */
-  features: z4.record(z4.string(), z4.boolean()).optional().describe("Feature toggles")
+  features: z5.record(z5.string(), z5.boolean()).optional().describe("Feature toggles")
 });
-var BillOfMaterialsSchema = z4.object({
-  tenantId: z4.string().describe("Target Tenant ID"),
+var BillOfMaterialsSchema = z5.object({
+  tenantId: z5.string().describe("Target Tenant ID"),
   /**
    * List of installed plugins/apps.
    * implementation order matters (later plugins override earlier ones by default).
    */
-  dependencies: z4.array(DependencyRequirementSchema).describe("Installed packages"),
+  dependencies: z5.array(DependencyRequirementSchema).describe("Installed packages"),
   /**
    * Environment Variables injection.
    * Maps abstract keys to secure vault references or concrete values.
    */
-  environment: z4.record(z4.string(), z4.string()).optional(),
+  environment: z5.record(z5.string(), z5.string()).optional(),
   /**
    * Global Resolution Strategy
    * How to handle conflicts when multiple plugins define the same resource.
    */
-  resolutionStrategy: z4.enum(["strict", "override", "merge"]).default("override").describe("Conflict resolution strategy (strict=fail, override=last-wins, merge=deep-merge)")
+  resolutionStrategy: z5.enum(["strict", "override", "merge"]).default("override").describe("Conflict resolution strategy (strict=fail, override=last-wins, merge=deep-merge)")
 });
-var ConflictReportSchema = z4.object({
-  resourceType: z4.enum(["object", "field", "api", "ui"]).describe("Type of colliding resource"),
-  resourceId: z4.string().describe("ID of the resource"),
-  sources: z4.array(z4.string()).describe("List of plugin IDs defining this resource"),
-  resolution: z4.string().describe('How it was resolved (e.g. "com.example.erp won")'),
-  severity: z4.enum(["info", "warning", "error"]).describe("Severity of the conflict")
+var ConflictReportSchema = z5.object({
+  resourceType: z5.enum(["object", "field", "api", "ui"]).describe("Type of colliding resource"),
+  resourceId: z5.string().describe("ID of the resource"),
+  sources: z5.array(z5.string()).describe("List of plugin IDs defining this resource"),
+  resolution: z5.string().describe('How it was resolved (e.g. "com.example.erp won")'),
+  severity: z5.enum(["info", "warning", "error"]).describe("Severity of the conflict")
 });
-var ComposerRequestSchema = z4.object({
+var ComposerRequestSchema = z5.object({
   bom: BillOfMaterialsSchema,
   /**
    * Target Runtime Version
    * Ensure generated manifest is compatible with the specific runtime version.
    */
-  runtimeVersion: z4.string().optional(),
+  runtimeVersion: z5.string().optional(),
   /**
    * Dry Run
    * If true, generates report but does not persist the manifest.
    */
-  dryRun: z4.boolean().default(false)
+  dryRun: z5.boolean().default(false)
 });
-var ComposerResponseSchema = z4.object({
-  success: z4.boolean(),
+var ComposerResponseSchema = z5.object({
+  success: z5.boolean(),
   /**
    * The Holy Grail: The Executable System Manifest.
    * This is what the Runtime loads to boot.
@@ -1087,150 +1176,150 @@ var ComposerResponseSchema = z4.object({
    * Manifest URL
    * Presigned URL to download the manifest if stored externally (e.g. Vercel KV/S3).
    */
-  manifestUrl: z4.string().url().optional().describe("Presigned download URL"),
+  manifestUrl: z5.string().url().optional().describe("Presigned download URL"),
   /**
    * Compilation Metadata
    */
-  buildId: z4.string(),
-  timestamp: z4.string().datetime(),
-  duration: z4.number().describe("Compilation time in ms"),
+  buildId: z5.string(),
+  timestamp: z5.string().datetime(),
+  duration: z5.number().describe("Compilation time in ms"),
   /**
    * Analysis
    */
-  conflicts: z4.array(ConflictReportSchema).optional(),
-  errors: z4.array(z4.string()).optional()
+  conflicts: z5.array(ConflictReportSchema).optional(),
+  errors: z5.array(z5.string()).optional()
 });
 
 // src/hub/marketplace.zod.ts
-import { z as z6 } from "zod";
+import { z as z7 } from "zod";
 
 // src/hub/plugin-registry.zod.ts
-import { z as z5 } from "zod";
-var PluginVendorSchema = z5.object({
+import { z as z6 } from "zod";
+var PluginVendorSchema = z6.object({
   /**
    * Vendor identifier (reverse domain notation)
    * Example: "com.acme", "org.apache", "com.objectstack"
    */
-  id: z5.string().regex(/^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/).describe("Vendor identifier (reverse domain)"),
+  id: z6.string().regex(/^[a-z][a-z0-9]*(\.[a-z][a-z0-9]*)+$/).describe("Vendor identifier (reverse domain)"),
   /**
    * Vendor display name
    */
-  name: z5.string(),
+  name: z6.string(),
   /**
    * Vendor website
    */
-  website: z5.string().url().optional(),
+  website: z6.string().url().optional(),
   /**
    * Contact email
    */
-  email: z5.string().email().optional(),
+  email: z6.string().email().optional(),
   /**
    * Verification status
    */
-  verified: z5.boolean().default(false).describe("Whether vendor is verified by ObjectStack"),
+  verified: z6.boolean().default(false).describe("Whether vendor is verified by ObjectStack"),
   /**
    * Trust level
    */
-  trustLevel: z5.enum(["official", "verified", "community", "unverified"]).default("unverified")
+  trustLevel: z6.enum(["official", "verified", "community", "unverified"]).default("unverified")
 });
-var PluginQualityMetricsSchema = z5.object({
+var PluginQualityMetricsSchema = z6.object({
   /**
    * Test coverage percentage
    */
-  testCoverage: z5.number().min(0).max(100).optional(),
+  testCoverage: z6.number().min(0).max(100).optional(),
   /**
    * Documentation score (0-100)
    */
-  documentationScore: z5.number().min(0).max(100).optional(),
+  documentationScore: z6.number().min(0).max(100).optional(),
   /**
    * Code quality score (0-100)
    */
-  codeQuality: z5.number().min(0).max(100).optional(),
+  codeQuality: z6.number().min(0).max(100).optional(),
   /**
    * Security scan status
    */
-  securityScan: z5.object({
-    lastScanDate: z5.string().datetime().optional(),
-    vulnerabilities: z5.object({
-      critical: z5.number().int().min(0).default(0),
-      high: z5.number().int().min(0).default(0),
-      medium: z5.number().int().min(0).default(0),
-      low: z5.number().int().min(0).default(0)
+  securityScan: z6.object({
+    lastScanDate: z6.string().datetime().optional(),
+    vulnerabilities: z6.object({
+      critical: z6.number().int().min(0).default(0),
+      high: z6.number().int().min(0).default(0),
+      medium: z6.number().int().min(0).default(0),
+      low: z6.number().int().min(0).default(0)
     }).optional(),
-    passed: z5.boolean().default(false)
+    passed: z6.boolean().default(false)
   }).optional(),
   /**
    * Conformance test results
    */
-  conformanceTests: z5.array(z5.object({
-    protocolId: z5.string().describe("Protocol being tested"),
-    passed: z5.boolean(),
-    totalTests: z5.number().int().min(0),
-    passedTests: z5.number().int().min(0),
-    lastRunDate: z5.string().datetime().optional()
+  conformanceTests: z6.array(z6.object({
+    protocolId: z6.string().describe("Protocol being tested"),
+    passed: z6.boolean(),
+    totalTests: z6.number().int().min(0),
+    passedTests: z6.number().int().min(0),
+    lastRunDate: z6.string().datetime().optional()
   })).optional()
 });
-var PluginStatisticsSchema = z5.object({
+var PluginStatisticsSchema = z6.object({
   /**
    * Total downloads
    */
-  downloads: z5.number().int().min(0).default(0),
+  downloads: z6.number().int().min(0).default(0),
   /**
    * Downloads in the last 30 days
    */
-  downloadsLastMonth: z5.number().int().min(0).default(0),
+  downloadsLastMonth: z6.number().int().min(0).default(0),
   /**
    * Number of active installations
    */
-  activeInstallations: z5.number().int().min(0).default(0),
+  activeInstallations: z6.number().int().min(0).default(0),
   /**
    * User ratings
    */
-  ratings: z5.object({
-    average: z5.number().min(0).max(5).default(0),
-    count: z5.number().int().min(0).default(0),
-    distribution: z5.object({
-      "5": z5.number().int().min(0).default(0),
-      "4": z5.number().int().min(0).default(0),
-      "3": z5.number().int().min(0).default(0),
-      "2": z5.number().int().min(0).default(0),
-      "1": z5.number().int().min(0).default(0)
+  ratings: z6.object({
+    average: z6.number().min(0).max(5).default(0),
+    count: z6.number().int().min(0).default(0),
+    distribution: z6.object({
+      "5": z6.number().int().min(0).default(0),
+      "4": z6.number().int().min(0).default(0),
+      "3": z6.number().int().min(0).default(0),
+      "2": z6.number().int().min(0).default(0),
+      "1": z6.number().int().min(0).default(0)
     }).optional()
   }).optional(),
   /**
    * GitHub stars (if open source)
    */
-  stars: z5.number().int().min(0).optional(),
+  stars: z6.number().int().min(0).optional(),
   /**
    * Number of dependent plugins
    */
-  dependents: z5.number().int().min(0).default(0)
+  dependents: z6.number().int().min(0).default(0)
 });
-var PluginRegistryEntrySchema = z5.object({
+var PluginRegistryEntrySchema = z6.object({
   /**
    * Plugin identifier (must match manifest.id)
    */
-  id: z5.string().regex(/^([a-z][a-z0-9]*\.)+[a-z][a-z0-9-]+$/).describe("Plugin identifier (reverse domain notation)"),
+  id: z6.string().regex(/^([a-z][a-z0-9]*\.)+[a-z][a-z0-9-]+$/).describe("Plugin identifier (reverse domain notation)"),
   /**
    * Current version
    */
-  version: z5.string().regex(/^\d+\.\d+\.\d+$/),
+  version: z6.string().regex(/^\d+\.\d+\.\d+$/),
   /**
    * Plugin display name
    */
-  name: z5.string(),
+  name: z6.string(),
   /**
    * Short description
    */
-  description: z5.string().optional(),
+  description: z6.string().optional(),
   /**
    * Detailed documentation/README
    */
-  readme: z5.string().optional(),
+  readme: z6.string().optional(),
   /**
    * Plugin type/category
    */
-  category: z5.enum([
+  category: z6.enum([
     "data",
     // Data management, storage, databases
     "integration",
@@ -1257,7 +1346,7 @@ var PluginRegistryEntrySchema = z5.object({
   /**
    * Tags for categorization
    */
-  tags: z5.array(z5.string()).optional(),
+  tags: z6.array(z6.string()).optional(),
   /**
    * Vendor information
    */
@@ -1269,42 +1358,42 @@ var PluginRegistryEntrySchema = z5.object({
   /**
    * Compatibility information
    */
-  compatibility: z5.object({
+  compatibility: z6.object({
     /**
      * Minimum ObjectStack version required
      */
-    minObjectStackVersion: z5.string().optional(),
+    minObjectStackVersion: z6.string().optional(),
     /**
      * Maximum ObjectStack version supported
      */
-    maxObjectStackVersion: z5.string().optional(),
+    maxObjectStackVersion: z6.string().optional(),
     /**
      * Node.js version requirement
      */
-    nodeVersion: z5.string().optional(),
+    nodeVersion: z6.string().optional(),
     /**
      * Supported platforms
      */
-    platforms: z5.array(z5.enum(["linux", "darwin", "win32", "browser"])).optional()
+    platforms: z6.array(z6.enum(["linux", "darwin", "win32", "browser"])).optional()
   }).optional(),
   /**
    * Links and resources
    */
-  links: z5.object({
-    homepage: z5.string().url().optional(),
-    repository: z5.string().url().optional(),
-    documentation: z5.string().url().optional(),
-    bugs: z5.string().url().optional(),
-    changelog: z5.string().url().optional()
+  links: z6.object({
+    homepage: z6.string().url().optional(),
+    repository: z6.string().url().optional(),
+    documentation: z6.string().url().optional(),
+    bugs: z6.string().url().optional(),
+    changelog: z6.string().url().optional()
   }).optional(),
   /**
    * Media assets
    */
-  media: z5.object({
-    icon: z5.string().url().optional(),
-    logo: z5.string().url().optional(),
-    screenshots: z5.array(z5.string().url()).optional(),
-    video: z5.string().url().optional()
+  media: z6.object({
+    icon: z6.string().url().optional(),
+    logo: z6.string().url().optional(),
+    screenshots: z6.array(z6.string().url()).optional(),
+    video: z6.string().url().optional()
   }).optional(),
   /**
    * Quality metrics
@@ -1317,70 +1406,70 @@ var PluginRegistryEntrySchema = z5.object({
   /**
    * License information
    */
-  license: z5.string().optional().describe("SPDX license identifier"),
+  license: z6.string().optional().describe("SPDX license identifier"),
   /**
    * Pricing (if commercial)
    */
-  pricing: z5.object({
-    model: z5.enum(["free", "freemium", "paid", "enterprise"]),
-    price: z5.number().min(0).optional(),
-    currency: z5.string().default("USD").optional(),
-    billingPeriod: z5.enum(["one-time", "monthly", "yearly"]).optional()
+  pricing: z6.object({
+    model: z6.enum(["free", "freemium", "paid", "enterprise"]),
+    price: z6.number().min(0).optional(),
+    currency: z6.string().default("USD").optional(),
+    billingPeriod: z6.enum(["one-time", "monthly", "yearly"]).optional()
   }).optional(),
   /**
    * Publication dates
    */
-  publishedAt: z5.string().datetime().optional(),
-  updatedAt: z5.string().datetime().optional(),
+  publishedAt: z6.string().datetime().optional(),
+  updatedAt: z6.string().datetime().optional(),
   /**
    * Deprecation status
    */
-  deprecated: z5.boolean().default(false),
-  deprecationMessage: z5.string().optional(),
-  replacedBy: z5.string().optional().describe("Plugin ID that replaces this one"),
+  deprecated: z6.boolean().default(false),
+  deprecationMessage: z6.string().optional(),
+  replacedBy: z6.string().optional().describe("Plugin ID that replaces this one"),
   /**
    * Feature flags
    */
-  flags: z5.object({
-    experimental: z5.boolean().default(false),
-    beta: z5.boolean().default(false),
-    featured: z5.boolean().default(false),
-    verified: z5.boolean().default(false)
+  flags: z6.object({
+    experimental: z6.boolean().default(false),
+    beta: z6.boolean().default(false),
+    featured: z6.boolean().default(false),
+    verified: z6.boolean().default(false)
   }).optional()
 });
-var PluginSearchFiltersSchema = z5.object({
+var PluginSearchFiltersSchema = z6.object({
   /**
    * Search query
    */
-  query: z5.string().optional(),
+  query: z6.string().optional(),
   /**
    * Filter by category
    */
-  category: z5.array(z5.string()).optional(),
+  category: z6.array(z6.string()).optional(),
   /**
    * Filter by tags
    */
-  tags: z5.array(z5.string()).optional(),
+  tags: z6.array(z6.string()).optional(),
   /**
    * Filter by vendor trust level
    */
-  trustLevel: z5.array(z5.enum(["official", "verified", "community", "unverified"])).optional(),
+  trustLevel: z6.array(z6.enum(["official", "verified", "community", "unverified"])).optional(),
   /**
    * Filter by protocols implemented
    */
-  implementsProtocols: z5.array(z5.string()).optional(),
+  implementsProtocols: z6.array(z6.string()).optional(),
   /**
    * Filter by pricing model
    */
-  pricingModel: z5.array(z5.enum(["free", "freemium", "paid", "enterprise"])).optional(),
+  pricingModel: z6.array(z6.enum(["free", "freemium", "paid", "enterprise"])).optional(),
   /**
    * Minimum rating
    */
-  minRating: z5.number().min(0).max(5).optional(),
+  minRating: z6.number().min(0).max(5).optional(),
   /**
    * Sort options
    */
-  sortBy: z5.enum([
+  sortBy: z6.enum([
     "relevance",
     "downloads",
     "rating",
@@ -1390,97 +1479,97 @@ var PluginSearchFiltersSchema = z5.object({
   /**
    * Sort order
    */
-  sortOrder: z5.enum(["asc", "desc"]).default("desc").optional(),
+  sortOrder: z6.enum(["asc", "desc"]).default("desc").optional(),
   /**
    * Pagination
    */
-  page: z5.number().int().min(1).default(1).optional(),
-  limit: z5.number().int().min(1).max(100).default(20).optional()
+  page: z6.number().int().min(1).default(1).optional(),
+  limit: z6.number().int().min(1).max(100).default(20).optional()
 });
-var PluginInstallConfigSchema = z5.object({
+var PluginInstallConfigSchema = z6.object({
   /**
    * Plugin identifier to install
    */
-  pluginId: z5.string(),
+  pluginId: z6.string(),
   /**
    * Version to install (supports semver ranges)
    */
-  version: z5.string().optional().describe("Defaults to latest"),
+  version: z6.string().optional().describe("Defaults to latest"),
   /**
    * Plugin-specific configuration values
    */
-  config: z5.record(z5.string(), z5.any()).optional(),
+  config: z6.record(z6.string(), z6.any()).optional(),
   /**
    * Whether to auto-update
    */
-  autoUpdate: z5.boolean().default(false).optional(),
+  autoUpdate: z6.boolean().default(false).optional(),
   /**
    * Installation options
    */
-  options: z5.object({
+  options: z6.object({
     /**
      * Skip dependency installation
      */
-    skipDependencies: z5.boolean().default(false).optional(),
+    skipDependencies: z6.boolean().default(false).optional(),
     /**
      * Force reinstall
      */
-    force: z5.boolean().default(false).optional(),
+    force: z6.boolean().default(false).optional(),
     /**
      * Installation target
      */
-    target: z5.enum(["system", "space", "user"]).default("space").optional()
+    target: z6.enum(["system", "space", "user"]).default("space").optional()
   }).optional()
 });
 
 // src/hub/marketplace.zod.ts
 var PluginAuthorSchema = PluginVendorSchema;
-var PluginPricingSchema = z6.object({
-  type: z6.enum(["free", "one_time", "recurring"]),
-  currency: z6.string().default("USD"),
-  amount: z6.number().min(0),
-  interval: z6.enum(["month", "year"]).optional().describe("Required if type is recurring"),
-  trialDays: z6.number().int().optional()
+var PluginPricingSchema = z7.object({
+  type: z7.enum(["free", "one_time", "recurring"]),
+  currency: z7.string().default("USD"),
+  amount: z7.number().min(0),
+  interval: z7.enum(["month", "year"]).optional().describe("Required if type is recurring"),
+  trialDays: z7.number().int().optional()
 });
-var PluginVersionSchema = z6.object({
-  version: z6.string().describe("SemVer string (e.g. 1.0.0)"),
-  publishedAt: z6.string().datetime().describe("Publication date"),
-  downloadUrl: z6.string().url().describe("Archive download URL"),
-  checksum: z6.string().optional().describe("Integrity checksum (shasum)"),
-  engine: z6.object({
-    node: z6.string().optional(),
-    objectstack: z6.string().describe("Required ObjectStack kernel version range")
+var PluginVersionSchema = z7.object({
+  version: z7.string().describe("SemVer string (e.g. 1.0.0)"),
+  publishedAt: z7.string().datetime().describe("Publication date"),
+  downloadUrl: z7.string().url().describe("Archive download URL"),
+  checksum: z7.string().optional().describe("Integrity checksum (shasum)"),
+  engine: z7.object({
+    node: z7.string().optional(),
+    objectstack: z7.string().describe("Required ObjectStack kernel version range")
   }).optional().describe("Engine compatibility"),
-  dependencies: z6.record(z6.string(), z6.string()).optional().describe("Runtime plugin dependencies"),
-  changeLog: z6.string().optional().describe("Release notes")
+  dependencies: z7.record(z7.string(), z7.string()).optional().describe("Runtime plugin dependencies"),
+  changeLog: z7.string().optional().describe("Release notes")
 });
-var MarketplacePluginSchema = z6.object({
+var MarketplacePluginSchema = z7.object({
   /**
    * Package Identifier
    * Usually the NPM package name (e.g. "@steedos/plugin-crm")
    */
-  id: z6.string(),
+  id: z7.string(),
   /**
    * Version History
    * Registry of all available versions
    */
-  versions: z6.record(z6.string(), PluginVersionSchema).optional().describe("Map of versions (1.0.0) -> Details"),
+  versions: z7.record(z7.string(), PluginVersionSchema).optional().describe("Map of versions (1.0.0) -> Details"),
   /**
    * Display Name
    */
-  label: z6.string(),
+  label: z7.string(),
   /**
    * Short Description
    */
-  description: z6.string().optional(),
+  description: z7.string().optional(),
   /**
    * Detailed README / Documentation content
    */
-  readme: z6.string().optional(),
+  readme: z7.string().optional(),
   /**
    * Latest Version
    */
-  version: z6.string(),
+  version: z7.string(),
   /**
    * Vendor / Publisher
    */
@@ -1488,8 +1577,8 @@ var MarketplacePluginSchema = z6.object({
   /**
    * Categorization
    */
-  tags: z6.array(z6.string()).optional(),
-  category: z6.enum([
+  tags: z7.array(z7.string()).optional(),
+  category: z7.enum([
     "app",
     "integration",
     "theme",
@@ -1504,29 +1593,29 @@ var MarketplacePluginSchema = z6.object({
   /**
    * Assets
    */
-  icon: z6.string().url().optional(),
-  screenshots: z6.array(z6.string().url()).optional(),
+  icon: z7.string().url().optional(),
+  screenshots: z7.array(z7.string().url()).optional(),
   /**
    * Links
    */
-  homepage: z6.string().url().optional(),
-  repository: z6.string().url().optional(),
-  bugs: z6.string().url().optional(),
+  homepage: z7.string().url().optional(),
+  repository: z7.string().url().optional(),
+  bugs: z7.string().url().optional(),
   /**
    * Statistics
    */
-  downloads: z6.number().int().optional(),
-  rating: z6.number().min(0).max(5).optional(),
+  downloads: z7.number().int().optional(),
+  rating: z7.number().min(0).max(5).optional(),
   /**
    * Commercial Information
    */
   pricing: PluginPricingSchema.optional(),
-  verified: z6.boolean().default(false).describe("Is verified maintaned by ObjectStack")
+  verified: z7.boolean().default(false).describe("Is verified maintaned by ObjectStack")
 });
 
 // src/hub/registry-config.zod.ts
-import { z as z7 } from "zod";
-var RegistrySyncPolicySchema = z7.enum([
+import { z as z8 } from "zod";
+var RegistrySyncPolicySchema = z8.enum([
   "manual",
   // Manual synchronization only
   "auto",
@@ -1534,11 +1623,11 @@ var RegistrySyncPolicySchema = z7.enum([
   "proxy"
   // Proxy requests to upstream without caching
 ]).describe("Registry synchronization strategy");
-var RegistryUpstreamSchema = z7.object({
+var RegistryUpstreamSchema = z8.object({
   /**
    * Upstream registry URL
    */
-  url: z7.string().url().describe("Upstream registry endpoint"),
+  url: z8.string().url().describe("Upstream registry endpoint"),
   /**
    * Synchronization policy
    */
@@ -1546,43 +1635,43 @@ var RegistryUpstreamSchema = z7.object({
   /**
    * Sync interval in seconds (for auto sync)
    */
-  syncInterval: z7.number().int().min(60).optional().describe("Auto-sync interval in seconds"),
+  syncInterval: z8.number().int().min(60).optional().describe("Auto-sync interval in seconds"),
   /**
    * Authentication credentials
    */
-  auth: z7.object({
-    type: z7.enum(["none", "basic", "bearer", "api-key", "oauth2"]).default("none"),
-    username: z7.string().optional(),
-    password: z7.string().optional(),
-    token: z7.string().optional(),
-    apiKey: z7.string().optional()
+  auth: z8.object({
+    type: z8.enum(["none", "basic", "bearer", "api-key", "oauth2"]).default("none"),
+    username: z8.string().optional(),
+    password: z8.string().optional(),
+    token: z8.string().optional(),
+    apiKey: z8.string().optional()
   }).optional(),
   /**
    * TLS/SSL configuration
    */
-  tls: z7.object({
-    enabled: z7.boolean().default(true),
-    verifyCertificate: z7.boolean().default(true),
-    certificate: z7.string().optional(),
-    privateKey: z7.string().optional()
+  tls: z8.object({
+    enabled: z8.boolean().default(true),
+    verifyCertificate: z8.boolean().default(true),
+    certificate: z8.string().optional(),
+    privateKey: z8.string().optional()
   }).optional(),
   /**
    * Timeout settings
    */
-  timeout: z7.number().int().min(1e3).default(3e4).describe("Request timeout in milliseconds"),
+  timeout: z8.number().int().min(1e3).default(3e4).describe("Request timeout in milliseconds"),
   /**
    * Retry configuration
    */
-  retry: z7.object({
-    maxAttempts: z7.number().int().min(0).default(3),
-    backoff: z7.enum(["fixed", "linear", "exponential"]).default("exponential")
+  retry: z8.object({
+    maxAttempts: z8.number().int().min(0).default(3),
+    backoff: z8.enum(["fixed", "linear", "exponential"]).default("exponential")
   }).optional()
 });
-var RegistryConfigSchema = z7.object({
+var RegistryConfigSchema = z8.object({
   /**
    * Registry type
    */
-  type: z7.enum([
+  type: z8.enum([
     "public",
     // Public marketplace (e.g., plugins.objectstack.com)
     "private",
@@ -1593,76 +1682,76 @@ var RegistryConfigSchema = z7.object({
   /**
    * Upstream registries (for hybrid/private registries)
    */
-  upstream: z7.array(RegistryUpstreamSchema).optional().describe("Upstream registries to sync from or proxy to"),
+  upstream: z8.array(RegistryUpstreamSchema).optional().describe("Upstream registries to sync from or proxy to"),
   /**
    * Scopes managed by this registry
    */
-  scope: z7.array(z7.string()).optional().describe("npm-style scopes managed by this registry (e.g., @my-corp, @enterprise)"),
+  scope: z8.array(z8.string()).optional().describe("npm-style scopes managed by this registry (e.g., @my-corp, @enterprise)"),
   /**
    * Default scope for new plugins
    */
-  defaultScope: z7.string().optional().describe("Default scope prefix for new plugins"),
+  defaultScope: z8.string().optional().describe("Default scope prefix for new plugins"),
   /**
    * Registry storage configuration
    */
-  storage: z7.object({
+  storage: z8.object({
     /**
      * Storage backend type
      */
-    backend: z7.enum(["local", "s3", "gcs", "azure-blob", "oss"]).default("local"),
+    backend: z8.enum(["local", "s3", "gcs", "azure-blob", "oss"]).default("local"),
     /**
      * Storage path or bucket name
      */
-    path: z7.string().optional(),
+    path: z8.string().optional(),
     /**
      * Credentials
      */
-    credentials: z7.record(z7.string(), z7.any()).optional()
+    credentials: z8.record(z8.string(), z8.any()).optional()
   }).optional(),
   /**
    * Registry visibility
    */
-  visibility: z7.enum(["public", "private", "internal"]).default("private").describe("Who can access this registry"),
+  visibility: z8.enum(["public", "private", "internal"]).default("private").describe("Who can access this registry"),
   /**
    * Access control
    */
-  accessControl: z7.object({
+  accessControl: z8.object({
     /**
      * Require authentication for read
      */
-    requireAuthForRead: z7.boolean().default(false),
+    requireAuthForRead: z8.boolean().default(false),
     /**
      * Require authentication for write
      */
-    requireAuthForWrite: z7.boolean().default(true),
+    requireAuthForWrite: z8.boolean().default(true),
     /**
      * Allowed users/teams
      */
-    allowedPrincipals: z7.array(z7.string()).optional()
+    allowedPrincipals: z8.array(z8.string()).optional()
   }).optional(),
   /**
    * Caching configuration
    */
-  cache: z7.object({
-    enabled: z7.boolean().default(true),
-    ttl: z7.number().int().min(0).default(3600).describe("Cache TTL in seconds"),
-    maxSize: z7.number().int().optional().describe("Maximum cache size in bytes")
+  cache: z8.object({
+    enabled: z8.boolean().default(true),
+    ttl: z8.number().int().min(0).default(3600).describe("Cache TTL in seconds"),
+    maxSize: z8.number().int().optional().describe("Maximum cache size in bytes")
   }).optional(),
   /**
    * Mirroring configuration (for high availability)
    */
-  mirrors: z7.array(z7.object({
-    url: z7.string().url(),
-    priority: z7.number().int().min(1).default(1)
+  mirrors: z8.array(z8.object({
+    url: z8.string().url(),
+    priority: z8.number().int().min(1).default(1)
   })).optional().describe("Mirror registries for redundancy")
 });
 
 // src/hub/space.zod.ts
-import { z as z9 } from "zod";
+import { z as z10 } from "zod";
 
 // src/hub/tenant.zod.ts
-import { z as z8 } from "zod";
-var TenantIsolationLevel = z8.enum([
+import { z as z9 } from "zod";
+var TenantIsolationLevel = z9.enum([
   "shared_schema",
   // Shared DB, shared schema, row-level isolation (most economical)
   "isolated_schema",
@@ -1670,29 +1759,29 @@ var TenantIsolationLevel = z8.enum([
   "isolated_db"
   // Separate database per tenant (maximum isolation)
 ]);
-var TenantQuotaSchema = z8.object({
+var TenantQuotaSchema = z9.object({
   /**
    * Maximum number of users allowed for this tenant
    */
-  maxUsers: z8.number().int().positive().optional().describe("Maximum number of users"),
+  maxUsers: z9.number().int().positive().optional().describe("Maximum number of users"),
   /**
    * Maximum storage space in bytes
    */
-  maxStorage: z8.number().int().positive().optional().describe("Maximum storage in bytes"),
+  maxStorage: z9.number().int().positive().optional().describe("Maximum storage in bytes"),
   /**
    * API rate limit (requests per minute)
    */
-  apiRateLimit: z8.number().int().positive().optional().describe("API requests per minute")
+  apiRateLimit: z9.number().int().positive().optional().describe("API requests per minute")
 });
-var TenantSchema = z8.object({
+var TenantSchema = z9.object({
   /**
    * Unique tenant identifier
    */
-  id: z8.string().describe("Unique tenant identifier"),
+  id: z9.string().describe("Unique tenant identifier"),
   /**
    * Tenant display name
    */
-  name: z8.string().describe("Tenant display name"),
+  name: z9.string().describe("Tenant display name"),
   /**
    * Data isolation level
    */
@@ -1700,26 +1789,26 @@ var TenantSchema = z8.object({
   /**
    * Custom configuration values
    */
-  customizations: z8.record(z8.string(), z8.any()).optional().describe("Custom configuration values"),
+  customizations: z9.record(z9.string(), z9.any()).optional().describe("Custom configuration values"),
   /**
    * Resource quotas
    */
   quotas: TenantQuotaSchema.optional()
 });
-var RowLevelIsolationStrategySchema = z8.object({
-  strategy: z8.literal("shared_schema").describe("Row-level isolation strategy"),
+var RowLevelIsolationStrategySchema = z9.object({
+  strategy: z9.literal("shared_schema").describe("Row-level isolation strategy"),
   /**
    * Database configuration for row-level isolation
    */
-  database: z8.object({
+  database: z9.object({
     /**
      * Whether to enable Row-Level Security (RLS)
      */
-    enableRLS: z8.boolean().default(true).describe("Enable PostgreSQL Row-Level Security"),
+    enableRLS: z9.boolean().default(true).describe("Enable PostgreSQL Row-Level Security"),
     /**
      * Tenant context setting method
      */
-    contextMethod: z8.enum([
+    contextMethod: z9.enum([
       "session_variable",
       // SET app.current_tenant = 'tenant_123'
       "search_path",
@@ -1730,63 +1819,63 @@ var RowLevelIsolationStrategySchema = z8.object({
     /**
      * Session variable name for tenant context
      */
-    contextVariable: z8.string().default("app.current_tenant").describe("Session variable name"),
+    contextVariable: z9.string().default("app.current_tenant").describe("Session variable name"),
     /**
      * Whether to validate tenant_id at application level
      */
-    applicationValidation: z8.boolean().default(true).describe("Application-level tenant validation")
+    applicationValidation: z9.boolean().default(true).describe("Application-level tenant validation")
   }).optional().describe("Database configuration"),
   /**
    * Performance optimization settings
    */
-  performance: z8.object({
+  performance: z9.object({
     /**
      * Whether to use partial indexes for tenant_id
      */
-    usePartialIndexes: z8.boolean().default(true).describe("Use partial indexes per tenant"),
+    usePartialIndexes: z9.boolean().default(true).describe("Use partial indexes per tenant"),
     /**
      * Whether to use table partitioning
      */
-    usePartitioning: z8.boolean().default(false).describe("Use table partitioning by tenant_id"),
+    usePartitioning: z9.boolean().default(false).describe("Use table partitioning by tenant_id"),
     /**
      * Connection pool size per tenant
      */
-    poolSizePerTenant: z8.number().int().positive().optional().describe("Connection pool size per tenant")
+    poolSizePerTenant: z9.number().int().positive().optional().describe("Connection pool size per tenant")
   }).optional().describe("Performance settings")
 });
-var SchemaLevelIsolationStrategySchema = z8.object({
-  strategy: z8.literal("isolated_schema").describe("Schema-level isolation strategy"),
+var SchemaLevelIsolationStrategySchema = z9.object({
+  strategy: z9.literal("isolated_schema").describe("Schema-level isolation strategy"),
   /**
    * Schema configuration
    */
-  schema: z8.object({
+  schema: z9.object({
     /**
      * Schema naming pattern
      * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
      * The tenant_id will be sanitized before substitution to prevent SQL injection
      */
-    namingPattern: z8.string().default("tenant_{tenant_id}").describe("Schema naming pattern"),
+    namingPattern: z9.string().default("tenant_{tenant_id}").describe("Schema naming pattern"),
     /**
      * Whether to include public schema in search_path
      */
-    includePublicSchema: z8.boolean().default(true).describe("Include public schema"),
+    includePublicSchema: z9.boolean().default(true).describe("Include public schema"),
     /**
      * Default schema for shared resources
      */
-    sharedSchema: z8.string().default("public").describe("Schema for shared resources"),
+    sharedSchema: z9.string().default("public").describe("Schema for shared resources"),
     /**
      * Whether to automatically create schema on tenant creation
      */
-    autoCreateSchema: z8.boolean().default(true).describe("Auto-create schema")
+    autoCreateSchema: z9.boolean().default(true).describe("Auto-create schema")
   }).optional().describe("Schema configuration"),
   /**
    * Migration configuration
    */
-  migrations: z8.object({
+  migrations: z9.object({
     /**
      * Migration strategy
      */
-    strategy: z8.enum([
+    strategy: z9.enum([
       "parallel",
       // Run migrations on all schemas in parallel
       "sequential",
@@ -1797,42 +1886,42 @@ var SchemaLevelIsolationStrategySchema = z8.object({
     /**
      * Maximum concurrent migrations
      */
-    maxConcurrent: z8.number().int().positive().default(10).describe("Max concurrent migrations"),
+    maxConcurrent: z9.number().int().positive().default(10).describe("Max concurrent migrations"),
     /**
      * Whether to rollback on first failure
      */
-    rollbackOnError: z8.boolean().default(true).describe("Rollback on error")
+    rollbackOnError: z9.boolean().default(true).describe("Rollback on error")
   }).optional().describe("Migration configuration"),
   /**
    * Performance optimization settings
    */
-  performance: z8.object({
+  performance: z9.object({
     /**
      * Whether to use connection pooling per schema
      */
-    poolPerSchema: z8.boolean().default(false).describe("Separate pool per schema"),
+    poolPerSchema: z9.boolean().default(false).describe("Separate pool per schema"),
     /**
      * Schema cache TTL in seconds
      */
-    schemaCacheTTL: z8.number().int().positive().default(3600).describe("Schema cache TTL")
+    schemaCacheTTL: z9.number().int().positive().default(3600).describe("Schema cache TTL")
   }).optional().describe("Performance settings")
 });
-var DatabaseLevelIsolationStrategySchema = z8.object({
-  strategy: z8.literal("isolated_db").describe("Database-level isolation strategy"),
+var DatabaseLevelIsolationStrategySchema = z9.object({
+  strategy: z9.literal("isolated_db").describe("Database-level isolation strategy"),
   /**
    * Database configuration
    */
-  database: z8.object({
+  database: z9.object({
     /**
      * Database naming pattern
      * Use {tenant_id} as placeholder (must contain only alphanumeric and underscores)
      * The tenant_id will be sanitized before substitution to prevent SQL injection
      */
-    namingPattern: z8.string().default("tenant_{tenant_id}").describe("Database naming pattern"),
+    namingPattern: z9.string().default("tenant_{tenant_id}").describe("Database naming pattern"),
     /**
      * Database server/cluster assignment strategy
      */
-    serverStrategy: z8.enum([
+    serverStrategy: z9.enum([
       "shared",
       // All tenant databases on same server
       "sharded",
@@ -1843,41 +1932,41 @@ var DatabaseLevelIsolationStrategySchema = z8.object({
     /**
      * Whether to use separate credentials per tenant
      */
-    separateCredentials: z8.boolean().default(true).describe("Separate credentials per tenant"),
+    separateCredentials: z9.boolean().default(true).describe("Separate credentials per tenant"),
     /**
      * Whether to automatically create database on tenant creation
      */
-    autoCreateDatabase: z8.boolean().default(true).describe("Auto-create database")
+    autoCreateDatabase: z9.boolean().default(true).describe("Auto-create database")
   }).optional().describe("Database configuration"),
   /**
    * Connection pooling configuration
    */
-  connectionPool: z8.object({
+  connectionPool: z9.object({
     /**
      * Pool size per tenant database
      */
-    poolSize: z8.number().int().positive().default(10).describe("Connection pool size"),
+    poolSize: z9.number().int().positive().default(10).describe("Connection pool size"),
     /**
      * Maximum number of tenant pools to keep active
      */
-    maxActivePools: z8.number().int().positive().default(100).describe("Max active pools"),
+    maxActivePools: z9.number().int().positive().default(100).describe("Max active pools"),
     /**
      * Idle pool timeout in seconds
      */
-    idleTimeout: z8.number().int().positive().default(300).describe("Idle pool timeout"),
+    idleTimeout: z9.number().int().positive().default(300).describe("Idle pool timeout"),
     /**
      * Whether to use connection pooler (PgBouncer, etc.)
      */
-    usePooler: z8.boolean().default(true).describe("Use connection pooler")
+    usePooler: z9.boolean().default(true).describe("Use connection pooler")
   }).optional().describe("Connection pool configuration"),
   /**
    * Backup and restore configuration
    */
-  backup: z8.object({
+  backup: z9.object({
     /**
      * Backup strategy per tenant
      */
-    strategy: z8.enum([
+    strategy: z9.enum([
       "individual",
       // Separate backup per tenant
       "consolidated",
@@ -1888,82 +1977,82 @@ var DatabaseLevelIsolationStrategySchema = z8.object({
     /**
      * Backup frequency in hours
      */
-    frequencyHours: z8.number().int().positive().default(24).describe("Backup frequency"),
+    frequencyHours: z9.number().int().positive().default(24).describe("Backup frequency"),
     /**
      * Retention period in days
      */
-    retentionDays: z8.number().int().positive().default(30).describe("Backup retention days")
+    retentionDays: z9.number().int().positive().default(30).describe("Backup retention days")
   }).optional().describe("Backup configuration"),
   /**
    * Encryption configuration
    */
-  encryption: z8.object({
+  encryption: z9.object({
     /**
      * Whether to use per-tenant encryption keys
      */
-    perTenantKeys: z8.boolean().default(false).describe("Per-tenant encryption keys"),
+    perTenantKeys: z9.boolean().default(false).describe("Per-tenant encryption keys"),
     /**
      * Encryption algorithm
      */
-    algorithm: z8.string().default("AES-256-GCM").describe("Encryption algorithm"),
+    algorithm: z9.string().default("AES-256-GCM").describe("Encryption algorithm"),
     /**
      * Key management service
      */
-    keyManagement: z8.enum(["aws_kms", "azure_key_vault", "gcp_kms", "hashicorp_vault", "custom"]).optional().describe("Key management service")
+    keyManagement: z9.enum(["aws_kms", "azure_key_vault", "gcp_kms", "hashicorp_vault", "custom"]).optional().describe("Key management service")
   }).optional().describe("Encryption configuration")
 });
-var TenantIsolationConfigSchema = z8.discriminatedUnion("strategy", [
+var TenantIsolationConfigSchema = z9.discriminatedUnion("strategy", [
   RowLevelIsolationStrategySchema,
   SchemaLevelIsolationStrategySchema,
   DatabaseLevelIsolationStrategySchema
 ]);
-var TenantSecurityPolicySchema = z8.object({
+var TenantSecurityPolicySchema = z9.object({
   /**
    * Encryption requirements
    */
-  encryption: z8.object({
+  encryption: z9.object({
     /**
      * Require encryption at rest
      */
-    atRest: z8.boolean().default(true).describe("Require encryption at rest"),
+    atRest: z9.boolean().default(true).describe("Require encryption at rest"),
     /**
      * Require encryption in transit
      */
-    inTransit: z8.boolean().default(true).describe("Require encryption in transit"),
+    inTransit: z9.boolean().default(true).describe("Require encryption in transit"),
     /**
      * Require field-level encryption for sensitive data
      */
-    fieldLevel: z8.boolean().default(false).describe("Require field-level encryption")
+    fieldLevel: z9.boolean().default(false).describe("Require field-level encryption")
   }).optional().describe("Encryption requirements"),
   /**
    * Access control requirements
    */
-  accessControl: z8.object({
+  accessControl: z9.object({
     /**
      * Require multi-factor authentication
      */
-    requireMFA: z8.boolean().default(false).describe("Require MFA"),
+    requireMFA: z9.boolean().default(false).describe("Require MFA"),
     /**
      * Require SSO/SAML authentication
      */
-    requireSSO: z8.boolean().default(false).describe("Require SSO"),
+    requireSSO: z9.boolean().default(false).describe("Require SSO"),
     /**
      * IP whitelist
      */
-    ipWhitelist: z8.array(z8.string()).optional().describe("Allowed IP addresses"),
+    ipWhitelist: z9.array(z9.string()).optional().describe("Allowed IP addresses"),
     /**
      * Session timeout in seconds
      */
-    sessionTimeout: z8.number().int().positive().default(3600).describe("Session timeout")
+    sessionTimeout: z9.number().int().positive().default(3600).describe("Session timeout")
   }).optional().describe("Access control requirements"),
   /**
    * Audit and compliance requirements
    */
-  compliance: z8.object({
+  compliance: z9.object({
     /**
      * Compliance standards to enforce
      */
-    standards: z8.array(z8.enum([
+    standards: z9.array(z9.enum([
       "sox",
       "hipaa",
       "gdpr",
@@ -1974,77 +2063,77 @@ var TenantSecurityPolicySchema = z8.object({
     /**
      * Require audit logging for all operations
      */
-    requireAuditLog: z8.boolean().default(true).describe("Require audit logging"),
+    requireAuditLog: z9.boolean().default(true).describe("Require audit logging"),
     /**
      * Audit log retention period in days
      */
-    auditRetentionDays: z8.number().int().positive().default(365).describe("Audit retention days"),
+    auditRetentionDays: z9.number().int().positive().default(365).describe("Audit retention days"),
     /**
      * Data residency requirements
      */
-    dataResidency: z8.object({
+    dataResidency: z9.object({
       /**
        * Required geographic region
        */
-      region: z8.string().optional().describe("Required region (e.g., US, EU, APAC)"),
+      region: z9.string().optional().describe("Required region (e.g., US, EU, APAC)"),
       /**
        * Prohibited regions
        */
-      excludeRegions: z8.array(z8.string()).optional().describe("Prohibited regions")
+      excludeRegions: z9.array(z9.string()).optional().describe("Prohibited regions")
     }).optional().describe("Data residency requirements")
   }).optional().describe("Compliance requirements")
 });
 
 // src/hub/space.zod.ts
-var SubscriptionStatus = z9.enum([
+var SubscriptionStatus = z10.enum([
   "active",
   "past_due",
   "canceled",
   "trialing",
   "incomplete"
 ]);
-var SpaceSubscriptionSchema = z9.object({
-  planId: z9.string().describe("Reference to Plan Code"),
+var SpaceSubscriptionSchema = z10.object({
+  planId: z10.string().describe("Reference to Plan Code"),
   status: SubscriptionStatus,
-  currentPeriodEnd: z9.string().datetime().optional(),
-  stripeCustomerId: z9.string().optional(),
-  stripeSubscriptionId: z9.string().optional(),
+  currentPeriodEnd: z10.string().datetime().optional(),
+  stripeCustomerId: z10.string().optional(),
+  stripeSubscriptionId: z10.string().optional(),
   /**
    * Purchased Add-ons from Marketplace
    */
-  addons: z9.array(z9.object({
-    pluginId: z9.string().describe("Marketplace Plugin ID (NPM package name)"),
-    quantity: z9.number().default(1),
+  addons: z10.array(z10.object({
+    pluginId: z10.string().describe("Marketplace Plugin ID (NPM package name)"),
+    quantity: z10.number().default(1),
     status: SubscriptionStatus.default("active")
   })).optional(),
   /**
    * Quota Usage Snapshot
    * Cached usage metrics for quick display/validation.
    */
-  usage: z9.record(z9.string(), z9.number()).optional()
+  usage: z10.record(z10.string(), z10.number()).optional()
 });
-var DeploymentTargetSchema = z9.object({
-  provider: z9.enum(["vercel", "docker", "kubernetes"]),
-  region: z9.string().optional(),
-  url: z9.string().url().optional().describe("Public Access URL"),
-  env: z9.record(z9.string(), z9.string()).optional().describe("Runtime Environment Variables")
+var DeploymentTargetSchema = z10.object({
+  provider: z10.enum(["vercel", "docker", "kubernetes"]),
+  region: z10.string().optional(),
+  url: z10.string().url().optional().describe("Public Access URL"),
+  env: z10.record(z10.string(), z10.string()).optional().describe("Runtime Environment Variables")
 });
-var HubSpaceSchema = z9.object({
-  id: z9.string().uuid(),
+var HubSpaceSchema = z10.object({
+  id: z10.string().uuid(),
   /**
    * Display Name
    */
-  name: z9.string(),
-  slug: z9.string().describe("URL friendly identifier"),
+  name: z10.string(),
+  slug: z10.string().describe("URL friendly identifier"),
   /**
    * Owner (User or Org ID in Hub)
    */
-  ownerId: z9.string(),
+  ownerId: z10.string(),
   /**
    * The Runtime Instance Definition
    * Defines the technical execution environment.
    */
-  runtime: z9.object({
+  runtime: z10.object({
     isolation: TenantIsolationLevel.describe("Data isolation strategy"),
     quotas: TenantQuotaSchema.optional().describe("Resource quotas")
   }).optional().describe("Runtime instance configuration"),
@@ -2056,11 +2145,11 @@ var HubSpaceSchema = z9.object({
   /**
    * The Current Actual State (Last Successful Build)
    */
-  lastBuild: z9.object({
-    id: z9.string(),
-    timestamp: z9.string().datetime(),
-    manifestUrl: z9.string().url().optional(),
-    status: z9.enum(["pending", "success", "failed"])
+  lastBuild: z10.object({
+    id: z10.string(),
+    timestamp: z10.string().datetime(),
+    manifestUrl: z10.string().url().optional(),
+    status: z10.enum(["pending", "success", "failed"])
   }).optional(),
   /**
    * Commercial / Billing Info
@@ -2070,13 +2159,13 @@ var HubSpaceSchema = z9.object({
    * Infrastructure Settings
    */
   deployment: DeploymentTargetSchema.optional(),
-  createdAt: z9.string(),
-  updatedAt: z9.string()
+  createdAt: z10.string(),
+  updatedAt: z10.string()
 });
 
 // src/hub/license.zod.ts
-import { z as z10 } from "zod";
-var MetricType = z10.enum([
+import { z as z11 } from "zod";
+var MetricType = z11.enum([
   "boolean",
   // Feature Flag (Enabled/Disabled)
   "counter",
@@ -2084,115 +2173,115 @@ var MetricType = z10.enum([
   "gauge"
   // Current Level (e.g. Storage Used, Users Active) - Point in time
 ]);
-var FeatureSchema = z10.object({
-  code: z10.string().regex(/^[a-z_][a-z0-9_.]*$/).describe("Feature code (e.g. core.api_access)"),
-  label: z10.string(),
-  description: z10.string().optional(),
+var FeatureSchema = z11.object({
+  code: z11.string().regex(/^[a-z_][a-z0-9_.]*$/).describe("Feature code (e.g. core.api_access)"),
+  label: z11.string(),
+  description: z11.string().optional(),
   type: MetricType.default("boolean"),
   /** For counters/gauges */
-  unit: z10.enum(["count", "bytes", "seconds", "percent"]).optional(),
+  unit: z11.enum(["count", "bytes", "seconds", "percent"]).optional(),
   /** Dependencies (e.g. 'audit_log' requires 'enterprise_tier') */
-  requires: z10.array(z10.string()).optional()
+  requires: z11.array(z11.string()).optional()
 });
-var PlanSchema = z10.object({
-  code: z10.string().describe("Plan code (e.g. pro_v1)"),
-  label: z10.string(),
-  active: z10.boolean().default(true),
+var PlanSchema = z11.object({
+  code: z11.string().describe("Plan code (e.g. pro_v1)"),
+  label: z11.string(),
+  active: z11.boolean().default(true),
   /** Feature Entitlements */
-  features: z10.array(z10.string()).describe("List of enabled boolean features"),
+  features: z11.array(z11.string()).describe("List of enabled boolean features"),
   /** Limit Quotas */
-  limits: z10.record(z10.string(), z10.number()).describe("Map of metric codes to limit values (e.g. { storage_gb: 10 })"),
+  limits: z11.record(z11.string(), z11.number()).describe("Map of metric codes to limit values (e.g. { storage_gb: 10 })"),
   /** Pricing (Optional Metadata) */
-  currency: z10.string().default("USD").optional(),
-  priceMonthly: z10.number().optional(),
-  priceYearly: z10.number().optional()
+  currency: z11.string().default("USD").optional(),
+  priceMonthly: z11.number().optional(),
+  priceYearly: z11.number().optional()
 });
-var LicenseSchema = z10.object({
+var LicenseSchema = z11.object({
   /** Identity */
-  spaceId: z10.string().describe("Target Space ID"),
-  planCode: z10.string(),
+  spaceId: z11.string().describe("Target Space ID"),
+  planCode: z11.string(),
   /** Validity */
-  issuedAt: z10.string().datetime(),
-  expiresAt: z10.string().datetime().optional(),
+  issuedAt: z11.string().datetime(),
+  expiresAt: z11.string().datetime().optional(),
   // Null = Perpetual
   /** Status */
-  status: z10.enum(["active", "expired", "suspended", "trial"]),
+  status: z11.enum(["active", "expired", "suspended", "trial"]),
   /** Overrides (Specific to this space, exceeding the plan) */
-  customFeatures: z10.array(z10.string()).optional(),
-  customLimits: z10.record(z10.string(), z10.number()).optional(),
+  customFeatures: z11.array(z11.string()).optional(),
+  customLimits: z11.record(z11.string(), z11.number()).optional(),
   /** Authorized Add-ons */
-  plugins: z10.array(z10.string()).optional().describe("List of enabled plugin package IDs"),
+  plugins: z11.array(z11.string()).optional().describe("List of enabled plugin package IDs"),
   /** Signature */
-  signature: z10.string().optional().describe("Cryptographic signature of the license")
+  signature: z11.string().optional().describe("Cryptographic signature of the license")
 });
 
 // src/hub/hub-federation.zod.ts
-import { z as z11 } from "zod";
-var RegionSchema = z11.object({
+import { z as z12 } from "zod";
+var RegionSchema = z12.object({
   /**
    * Region identifier (e.g., us-east-1, eu-west-1, ap-southeast-1)
    */
-  id: z11.string().regex(/^[a-z]{2}-[a-z]+-\d+$/).describe("Region identifier"),
+  id: z12.string().regex(/^[a-z]{2}-[a-z]+-\d+$/).describe("Region identifier"),
   /**
    * Display name
    */
-  name: z11.string().describe("Human-readable region name"),
+  name: z12.string().describe("Human-readable region name"),
   /**
    * Geographic location
    */
-  location: z11.object({
-    continent: z11.enum(["NA", "SA", "EU", "AF", "AS", "OC", "AN"]),
-    country: z11.string().regex(/^[A-Z]{2}$/).describe("ISO 3166-1 alpha-2 country code"),
-    city: z11.string().optional(),
-    latitude: z11.number().min(-90).max(90).optional(),
-    longitude: z11.number().min(-180).max(180).optional()
+  location: z12.object({
+    continent: z12.enum(["NA", "SA", "EU", "AF", "AS", "OC", "AN"]),
+    country: z12.string().regex(/^[A-Z]{2}$/).describe("ISO 3166-1 alpha-2 country code"),
+    city: z12.string().optional(),
+    latitude: z12.number().min(-90).max(90).optional(),
+    longitude: z12.number().min(-180).max(180).optional()
   }),
   /**
    * Cloud provider and region mapping
    */
-  provider: z11.object({
-    name: z11.enum(["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]),
-    region: z11.string().describe("Provider-specific region identifier")
+  provider: z12.object({
+    name: z12.enum(["aws", "azure", "gcp", "cloudflare", "vercel", "self-hosted"]),
+    region: z12.string().describe("Provider-specific region identifier")
   }).optional(),
   /**
    * Region capabilities
    */
-  capabilities: z11.object({
-    databases: z11.array(z11.enum(["postgres", "mysql", "mongodb", "redis"])).default([]),
-    storage: z11.array(z11.enum(["s3", "azure-blob", "gcs"])).default([]),
-    compute: z11.array(z11.enum(["containers", "serverless", "vm"])).default([]),
-    cdn: z11.boolean().default(false)
+  capabilities: z12.object({
+    databases: z12.array(z12.enum(["postgres", "mysql", "mongodb", "redis"])).default([]),
+    storage: z12.array(z12.enum(["s3", "azure-blob", "gcs"])).default([]),
+    compute: z12.array(z12.enum(["containers", "serverless", "vm"])).default([]),
+    cdn: z12.boolean().default(false)
   }).optional(),
   /**
    * Compliance and certifications
    */
-  compliance: z11.array(z11.enum(["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"])).default([]),
+  compliance: z12.array(z12.enum(["gdpr", "hipaa", "soc2", "iso27001", "pci-dss"])).default([]),
   /**
    * Region status
    */
-  status: z11.enum(["active", "read-only", "maintenance", "deprecated"]).default("active"),
+  status: z12.enum(["active", "read-only", "maintenance", "deprecated"]).default("active"),
   /**
    * Resource limits for this region
    */
-  limits: z11.object({
-    maxSpaces: z11.number().int().positive().optional(),
-    maxTenants: z11.number().int().positive().optional(),
-    maxStorage: z11.number().int().positive().optional().describe("Bytes")
+  limits: z12.object({
+    maxSpaces: z12.number().int().positive().optional(),
+    maxTenants: z12.number().int().positive().optional(),
+    maxStorage: z12.number().int().positive().optional().describe("Bytes")
   }).optional()
 });
-var HubInstanceSchema = z11.object({
+var HubInstanceSchema = z12.object({
   /**
    * Instance identifier
    */
-  id: z11.string().uuid(),
+  id: z12.string().uuid(),
   /**
    * Region where this hub is deployed
    */
-  regionId: z11.string(),
+  regionId: z12.string(),
   /**
    * Hub role in federation
    */
-  role: z11.enum([
+  role: z12.enum([
     "primary",
     // Primary/master hub
     "secondary",
@@ -2203,71 +2292,71 @@ var HubInstanceSchema = z11.object({
   /**
    * Endpoint URLs
    */
-  endpoints: z11.object({
-    api: z11.string().url().describe("Public API endpoint"),
-    admin: z11.string().url().optional().describe("Admin console"),
-    grpc: z11.string().optional().describe("gRPC endpoint for inter-hub communication")
+  endpoints: z12.object({
+    api: z12.string().url().describe("Public API endpoint"),
+    admin: z12.string().url().optional().describe("Admin console"),
+    grpc: z12.string().optional().describe("gRPC endpoint for inter-hub communication")
   }),
   /**
    * Replication configuration
    */
-  replication: z11.object({
+  replication: z12.object({
     /**
      * Source hub for replication (if this is a secondary)
      */
-    primaryHubId: z11.string().uuid().optional(),
+    primaryHubId: z12.string().uuid().optional(),
     /**
      * Replication lag tolerance in seconds
      */
-    lagTolerance: z11.number().int().positive().default(5),
+    lagTolerance: z12.number().int().positive().default(5),
     /**
      * Replication mode
      */
-    mode: z11.enum(["sync", "async", "semi-sync"]).default("async")
+    mode: z12.enum(["sync", "async", "semi-sync"]).default("async")
   }).optional(),
   /**
    * Health status
    */
-  health: z11.object({
-    status: z11.enum(["healthy", "degraded", "unhealthy"]),
-    lastCheck: z11.string().datetime(),
-    uptime: z11.number().describe("Seconds")
+  health: z12.object({
+    status: z12.enum(["healthy", "degraded", "unhealthy"]),
+    lastCheck: z12.string().datetime(),
+    uptime: z12.number().describe("Seconds")
   }).optional(),
   /**
    * Version
    */
-  version: z11.string(),
+  version: z12.string(),
   /**
    * Metadata
    */
-  createdAt: z11.string().datetime(),
-  updatedAt: z11.string().datetime()
+  createdAt: z12.string().datetime(),
+  updatedAt: z12.string().datetime()
 });
-var FederationTopologySchema = z11.object({
+var FederationTopologySchema = z12.object({
   /**
    * Federation identifier
    */
-  id: z11.string().uuid(),
+  id: z12.string().uuid(),
   /**
    * Federation name
    */
-  name: z11.string(),
+  name: z12.string(),
   /**
    * Regions in this federation
    */
-  regions: z11.array(RegionSchema),
+  regions: z12.array(RegionSchema),
   /**
    * Hub instances
    */
-  hubs: z11.array(HubInstanceSchema),
+  hubs: z12.array(HubInstanceSchema),
   /**
    * Routing strategy
    */
-  routing: z11.object({
+  routing: z12.object({
     /**
      * How to route tenant requests
      */
-    strategy: z11.enum([
+    strategy: z12.enum([
       "geo-proximity",
       // Route to nearest region
       "data-residency",
@@ -2280,117 +2369,117 @@ var FederationTopologySchema = z11.object({
     /**
      * Failover behavior
      */
-    failover: z11.object({
-      enabled: z11.boolean().default(true),
-      maxRetries: z11.number().int().min(0).default(3),
-      timeout: z11.number().int().positive().default(5e3).describe("Milliseconds")
+    failover: z12.object({
+      enabled: z12.boolean().default(true),
+      maxRetries: z12.number().int().min(0).default(3),
+      timeout: z12.number().int().positive().default(5e3).describe("Milliseconds")
     })
   }),
   /**
    * Data synchronization settings
    */
-  synchronization: z11.object({
+  synchronization: z12.object({
     /**
      * What data to sync across regions
      */
-    scope: z11.object({
+    scope: z12.object({
       /**
        * Sync plugin registry
        */
-      plugins: z11.boolean().default(true),
+      plugins: z12.boolean().default(true),
       /**
        * Sync tenant metadata (not data)
        */
-      tenants: z11.boolean().default(true),
+      tenants: z12.boolean().default(true),
       /**
        * Sync spaces metadata
        */
-      spaces: z11.boolean().default(false),
+      spaces: z12.boolean().default(false),
       /**
        * Sync licenses
        */
-      licenses: z11.boolean().default(true)
+      licenses: z12.boolean().default(true)
     }),
     /**
      * Sync frequency
      */
-    frequency: z11.enum(["realtime", "hourly", "daily"]).default("realtime"),
+    frequency: z12.enum(["realtime", "hourly", "daily"]).default("realtime"),
     /**
      * Conflict resolution
      */
-    conflictResolution: z11.enum(["last-write-wins", "primary-wins", "manual"]).default("last-write-wins")
+    conflictResolution: z12.enum(["last-write-wins", "primary-wins", "manual"]).default("last-write-wins")
   })
 });
-var TenantPlacementPolicySchema = z11.object({
+var TenantPlacementPolicySchema = z12.object({
   /**
    * Tenant identifier
    */
-  tenantId: z11.string(),
+  tenantId: z12.string(),
   /**
    * Primary region (where tenant data lives)
    */
-  primaryRegion: z11.string(),
+  primaryRegion: z12.string(),
   /**
    * Replica regions (for disaster recovery)
    */
-  replicaRegions: z11.array(z11.string()).default([]),
+  replicaRegions: z12.array(z12.string()).default([]),
   /**
    * Data residency constraints
    */
-  dataResidency: z11.object({
+  dataResidency: z12.object({
     /**
      * Allowed regions for data storage
      */
-    allowedRegions: z11.array(z11.string()).optional(),
+    allowedRegions: z12.array(z12.string()).optional(),
     /**
      * Prohibited regions
      */
-    prohibitedRegions: z11.array(z11.string()).default([]),
+    prohibitedRegions: z12.array(z12.string()).default([]),
     /**
      * Continent restriction
      */
-    continent: z11.enum(["NA", "SA", "EU", "AF", "AS", "OC", "AN"]).optional()
+    continent: z12.enum(["NA", "SA", "EU", "AF", "AS", "OC", "AN"]).optional()
   }).optional(),
   /**
    * Failover policy
    */
-  failover: z11.object({
+  failover: z12.object({
     /**
      * Enable automatic failover
      */
-    enabled: z11.boolean().default(true),
+    enabled: z12.boolean().default(true),
     /**
      * Preferred failover order (region IDs)
      */
-    preferredOrder: z11.array(z11.string()).default([]),
+    preferredOrder: z12.array(z12.string()).default([]),
     /**
      * Maximum acceptable latency for failover target (ms)
      */
-    maxLatency: z11.number().int().positive().default(100)
+    maxLatency: z12.number().int().positive().default(100)
   }).optional(),
   /**
    * Latency requirements
    */
-  latency: z11.object({
+  latency: z12.object({
     /**
      * Maximum acceptable latency for primary region (ms)
      */
-    maxPrimaryLatency: z11.number().int().positive().default(50),
+    maxPrimaryLatency: z12.number().int().positive().default(50),
     /**
      * Maximum acceptable latency for replicas (ms)
      */
-    maxReplicaLatency: z11.number().int().positive().default(200)
+    maxReplicaLatency: z12.number().int().positive().default(200)
   }).optional()
 });
-var ReplicationJobSchema = z11.object({
+var ReplicationJobSchema = z12.object({
   /**
    * Job identifier
    */
-  id: z11.string().uuid(),
+  id: z12.string().uuid(),
   /**
    * Job type
    */
-  type: z11.enum([
+  type: z12.enum([
     "initial-sync",
     // First-time full sync
     "incremental",
@@ -2401,84 +2490,84 @@ var ReplicationJobSchema = z11.object({
   /**
    * Source hub
    */
-  sourceHubId: z11.string().uuid(),
+  sourceHubId: z12.string().uuid(),
   /**
    * Target hub(s)
    */
-  targetHubIds: z11.array(z11.string().uuid()),
+  targetHubIds: z12.array(z12.string().uuid()),
   /**
    * Resource scope
    */
-  scope: z11.object({
+  scope: z12.object({
     /**
      * Resource type
      */
-    resourceType: z11.enum(["plugin", "tenant", "space", "license", "all"]),
+    resourceType: z12.enum(["plugin", "tenant", "space", "license", "all"]),
     /**
      * Specific resource IDs (empty = all)
      */
-    resourceIds: z11.array(z11.string()).default([])
+    resourceIds: z12.array(z12.string()).default([])
   }),
   /**
    * Job status
    */
-  status: z11.enum(["pending", "running", "completed", "failed", "cancelled"]),
+  status: z12.enum(["pending", "running", "completed", "failed", "cancelled"]),
   /**
    * Progress
    */
-  progress: z11.object({
-    total: z11.number().int().min(0),
-    completed: z11.number().int().min(0),
-    failed: z11.number().int().min(0)
+  progress: z12.object({
+    total: z12.number().int().min(0),
+    completed: z12.number().int().min(0),
+    failed: z12.number().int().min(0)
   }).optional(),
   /**
    * Timestamps
    */
-  createdAt: z11.string().datetime(),
-  startedAt: z11.string().datetime().optional(),
-  completedAt: z11.string().datetime().optional(),
+  createdAt: z12.string().datetime(),
+  startedAt: z12.string().datetime().optional(),
+  completedAt: z12.string().datetime().optional(),
   /**
    * Errors
    */
-  errors: z11.array(z11.object({
-    timestamp: z11.string().datetime(),
-    resourceId: z11.string(),
-    error: z11.string()
+  errors: z12.array(z12.object({
+    timestamp: z12.string().datetime(),
+    resourceId: z12.string(),
+    error: z12.string()
   })).default([])
 });
-var GlobalRegistryEntrySchema = z11.object({
+var GlobalRegistryEntrySchema = z12.object({
   /**
    * Resource identifier
    */
-  resourceId: z11.string(),
+  resourceId: z12.string(),
   /**
    * Resource type
    */
-  resourceType: z11.enum(["plugin", "tenant", "space", "license"]),
+  resourceType: z12.enum(["plugin", "tenant", "space", "license"]),
   /**
    * Regions where this resource exists
    */
-  locations: z11.array(z11.object({
-    regionId: z11.string(),
-    hubId: z11.string().uuid(),
-    isPrimary: z11.boolean().default(false),
-    lastSyncedAt: z11.string().datetime().optional(),
-    version: z11.string().optional()
+  locations: z12.array(z12.object({
+    regionId: z12.string(),
+    hubId: z12.string().uuid(),
+    isPrimary: z12.boolean().default(false),
+    lastSyncedAt: z12.string().datetime().optional(),
+    version: z12.string().optional()
   })),
   /**
    * Global version vector clock (for conflict detection)
    */
-  versionVector: z11.record(z11.string(), z11.number().int()).optional()
+  versionVector: z12.record(z12.string(), z12.number().int()).optional()
 });
-var EdgeLocationSchema = z11.object({
+var EdgeLocationSchema = z12.object({
   /**
    * Location identifier
    */
-  id: z11.string(),
+  id: z12.string(),
   /**
    * Parent region
    */
-  regionId: z11.string(),
+  regionId: z12.string(),
   /**
    * Location details
    */
@@ -2486,24 +2575,24 @@ var EdgeLocationSchema = z11.object({
   /**
    * Caching configuration
    */
-  cache: z11.object({
+  cache: z12.object({
     /**
      * What to cache at edge
      */
-    resources: z11.array(z11.enum(["plugins", "static-assets", "api-responses"])).default([]),
+    resources: z12.array(z12.enum(["plugins", "static-assets", "api-responses"])).default([]),
     /**
      * TTL in seconds
      */
-    ttl: z11.number().int().positive().default(3600),
+    ttl: z12.number().int().positive().default(3600),
     /**
      * Cache size limit (bytes)
      */
-    maxSize: z11.number().int().positive().optional()
+    maxSize: z12.number().int().positive().optional()
   }),
   /**
    * Status
    */
-  status: z11.enum(["active", "inactive"]).default("active")
+  status: z12.enum(["active", "inactive"]).default("active")
 });
 var HubFederationProtocol = {
   Region: RegionSchema,
@@ -2516,31 +2605,31 @@ var HubFederationProtocol = {
 };
 
 // src/hub/plugin-security.zod.ts
-import { z as z12 } from "zod";
-var VulnerabilitySeverity = z12.enum([
+import { z as z13 } from "zod";
+var VulnerabilitySeverity = z13.enum([
   "critical",
   "high",
   "medium",
   "low",
   "info"
 ]);
-var SecurityVulnerabilitySchema = z12.object({
+var SecurityVulnerabilitySchema = z13.object({
   /**
    * CVE identifier (if applicable)
    */
-  cve: z12.string().regex(/^CVE-\d{4}-\d+$/).optional().describe("CVE identifier"),
+  cve: z13.string().regex(/^CVE-\d{4}-\d+$/).optional().describe("CVE identifier"),
   /**
    * Vulnerability identifier (GHSA, SNYK, etc.)
    */
-  id: z12.string().describe("Vulnerability ID"),
+  id: z13.string().describe("Vulnerability ID"),
   /**
    * Title
    */
-  title: z12.string(),
+  title: z13.string(),
   /**
    * Description
    */
-  description: z12.string(),
+  description: z13.string(),
   /**
    * Severity
    */
@@ -2548,149 +2637,149 @@ var SecurityVulnerabilitySchema = z12.object({
   /**
    * CVSS score (0-10)
    */
-  cvss: z12.number().min(0).max(10).optional(),
+  cvss: z13.number().min(0).max(10).optional(),
   /**
    * Affected package
    */
-  package: z12.object({
-    name: z12.string(),
-    version: z12.string(),
-    ecosystem: z12.string().optional()
+  package: z13.object({
+    name: z13.string(),
+    version: z13.string(),
+    ecosystem: z13.string().optional()
   }),
   /**
    * Vulnerable version range
    */
-  vulnerableVersions: z12.string().describe("Semver range of vulnerable versions"),
+  vulnerableVersions: z13.string().describe("Semver range of vulnerable versions"),
   /**
    * Patched versions
    */
-  patchedVersions: z12.string().optional().describe("Semver range of patched versions"),
+  patchedVersions: z13.string().optional().describe("Semver range of patched versions"),
   /**
    * References
    */
-  references: z12.array(z12.object({
-    type: z12.enum(["advisory", "article", "report", "web"]),
-    url: z12.string().url()
+  references: z13.array(z13.object({
+    type: z13.enum(["advisory", "article", "report", "web"]),
+    url: z13.string().url()
   })).default([]),
   /**
    * CWE (Common Weakness Enumeration)
    */
-  cwe: z12.array(z12.string()).default([]),
+  cwe: z13.array(z13.string()).default([]),
   /**
    * Published date
    */
-  publishedAt: z12.string().datetime().optional(),
+  publishedAt: z13.string().datetime().optional(),
   /**
    * Mitigation advice
    */
-  mitigation: z12.string().optional()
+  mitigation: z13.string().optional()
 });
-var SecurityScanResultSchema = z12.object({
+var SecurityScanResultSchema = z13.object({
   /**
    * Scan identifier
    */
-  scanId: z12.string().uuid(),
+  scanId: z13.string().uuid(),
   /**
    * Plugin being scanned
    */
-  plugin: z12.object({
-    id: z12.string(),
-    version: z12.string()
+  plugin: z13.object({
+    id: z13.string(),
+    version: z13.string()
   }),
   /**
    * Scan timestamp
    */
-  scannedAt: z12.string().datetime(),
+  scannedAt: z13.string().datetime(),
   /**
    * Scanner information
    */
-  scanner: z12.object({
-    name: z12.string().describe("Scanner name (e.g., snyk, osv, trivy)"),
-    version: z12.string()
+  scanner: z13.object({
+    name: z13.string().describe("Scanner name (e.g., snyk, osv, trivy)"),
+    version: z13.string()
   }),
   /**
    * Scan status
    */
-  status: z12.enum(["passed", "failed", "warning"]),
+  status: z13.enum(["passed", "failed", "warning"]),
   /**
    * Vulnerabilities found
    */
-  vulnerabilities: z12.array(SecurityVulnerabilitySchema),
+  vulnerabilities: z13.array(SecurityVulnerabilitySchema),
   /**
    * Vulnerability summary
    */
-  summary: z12.object({
-    critical: z12.number().int().min(0).default(0),
-    high: z12.number().int().min(0).default(0),
-    medium: z12.number().int().min(0).default(0),
-    low: z12.number().int().min(0).default(0),
-    info: z12.number().int().min(0).default(0),
-    total: z12.number().int().min(0).default(0)
+  summary: z13.object({
+    critical: z13.number().int().min(0).default(0),
+    high: z13.number().int().min(0).default(0),
+    medium: z13.number().int().min(0).default(0),
+    low: z13.number().int().min(0).default(0),
+    info: z13.number().int().min(0).default(0),
+    total: z13.number().int().min(0).default(0)
   }),
   /**
    * License compliance issues
    */
-  licenseIssues: z12.array(z12.object({
-    package: z12.string(),
-    license: z12.string(),
-    reason: z12.string(),
-    severity: z12.enum(["error", "warning", "info"])
+  licenseIssues: z13.array(z13.object({
+    package: z13.string(),
+    license: z13.string(),
+    reason: z13.string(),
+    severity: z13.enum(["error", "warning", "info"])
   })).default([]),
   /**
    * Code quality issues
    */
-  codeQuality: z12.object({
-    score: z12.number().min(0).max(100).optional(),
-    issues: z12.array(z12.object({
-      type: z12.enum(["security", "quality", "style"]),
-      severity: z12.enum(["error", "warning", "info"]),
-      message: z12.string(),
-      file: z12.string().optional(),
-      line: z12.number().int().optional()
+  codeQuality: z13.object({
+    score: z13.number().min(0).max(100).optional(),
+    issues: z13.array(z13.object({
+      type: z13.enum(["security", "quality", "style"]),
+      severity: z13.enum(["error", "warning", "info"]),
+      message: z13.string(),
+      file: z13.string().optional(),
+      line: z13.number().int().optional()
     })).default([])
   }).optional(),
   /**
    * Next scan scheduled
    */
-  nextScanAt: z12.string().datetime().optional()
+  nextScanAt: z13.string().datetime().optional()
 });
-var SecurityPolicySchema = z12.object({
+var SecurityPolicySchema = z13.object({
   /**
    * Policy identifier
    */
-  id: z12.string(),
+  id: z13.string(),
   /**
    * Policy name
    */
-  name: z12.string(),
+  name: z13.string(),
   /**
    * Automatic scanning
    */
-  autoScan: z12.object({
-    enabled: z12.boolean().default(true),
-    frequency: z12.enum(["on-publish", "daily", "weekly", "monthly"]).default("daily")
+  autoScan: z13.object({
+    enabled: z13.boolean().default(true),
+    frequency: z13.enum(["on-publish", "daily", "weekly", "monthly"]).default("daily")
   }),
   /**
    * Vulnerability thresholds
    */
-  thresholds: z12.object({
+  thresholds: z13.object({
     /**
      * Block plugin if critical vulnerabilities exceed this
      */
-    maxCritical: z12.number().int().min(0).default(0),
+    maxCritical: z13.number().int().min(0).default(0),
     /**
      * Block plugin if high vulnerabilities exceed this
      */
-    maxHigh: z12.number().int().min(0).default(0),
+    maxHigh: z13.number().int().min(0).default(0),
     /**
      * Warn if medium vulnerabilities exceed this
      */
-    maxMedium: z12.number().int().min(0).default(5)
+    maxMedium: z13.number().int().min(0).default(5)
   }),
   /**
    * Allowed licenses
    */
-  allowedLicenses: z12.array(z12.string()).default([
+  allowedLicenses: z13.array(z13.string()).default([
     "MIT",
     "Apache-2.0",
     "BSD-3-Clause",
@@ -2700,152 +2789,152 @@ var SecurityPolicySchema = z12.object({
   /**
    * Prohibited licenses
    */
-  prohibitedLicenses: z12.array(z12.string()).default([
+  prohibitedLicenses: z13.array(z13.string()).default([
     "GPL-3.0",
     "AGPL-3.0"
   ]),
   /**
    * Code signing requirements
    */
-  codeSigning: z12.object({
-    required: z12.boolean().default(false),
-    allowedSigners: z12.array(z12.string()).default([])
+  codeSigning: z13.object({
+    required: z13.boolean().default(false),
+    allowedSigners: z13.array(z13.string()).default([])
   }).optional(),
   /**
    * Sandbox restrictions
    */
-  sandbox: z12.object({
+  sandbox: z13.object({
     /**
      * Restrict network access
      */
-    networkAccess: z12.enum(["none", "localhost", "allowlist", "all"]).default("all"),
+    networkAccess: z13.enum(["none", "localhost", "allowlist", "all"]).default("all"),
     /**
      * Allowed network destinations (if allowlist)
      */
-    allowedDestinations: z12.array(z12.string()).default([]),
+    allowedDestinations: z13.array(z13.string()).default([]),
     /**
      * File system access
      */
-    filesystemAccess: z12.enum(["none", "read-only", "temp-only", "full"]).default("full"),
+    filesystemAccess: z13.enum(["none", "read-only", "temp-only", "full"]).default("full"),
     /**
      * Maximum memory (MB)
      */
-    maxMemoryMB: z12.number().int().positive().optional(),
+    maxMemoryMB: z13.number().int().positive().optional(),
     /**
      * Maximum CPU time (seconds)
      */
-    maxCPUSeconds: z12.number().int().positive().optional()
+    maxCPUSeconds: z13.number().int().positive().optional()
   }).optional()
 });
-var PackageDependencySchema = z12.object({
+var PackageDependencySchema = z13.object({
   /**
    * Package name/ID
    */
-  name: z12.string(),
+  name: z13.string(),
   /**
    * Version constraint (semver range)
    */
-  versionConstraint: z12.string().describe("Semver range (e.g., `^1.0.0`, `>=2.0.0 <3.0.0`)"),
+  versionConstraint: z13.string().describe("Semver range (e.g., `^1.0.0`, `>=2.0.0 <3.0.0`)"),
   /**
    * Dependency type
    */
-  type: z12.enum(["required", "optional", "peer", "dev"]).default("required"),
+  type: z13.enum(["required", "optional", "peer", "dev"]).default("required"),
   /**
    * Resolved version (filled during resolution)
    */
-  resolvedVersion: z12.string().optional()
+  resolvedVersion: z13.string().optional()
 });
-var DependencyGraphNodeSchema = z12.object({
+var DependencyGraphNodeSchema = z13.object({
   /**
    * Package identifier
    */
-  id: z12.string(),
+  id: z13.string(),
   /**
    * Package version
    */
-  version: z12.string(),
+  version: z13.string(),
   /**
    * Dependencies of this package
    */
-  dependencies: z12.array(PackageDependencySchema).default([]),
+  dependencies: z13.array(PackageDependencySchema).default([]),
   /**
    * Depth in dependency tree
    */
-  depth: z12.number().int().min(0),
+  depth: z13.number().int().min(0),
   /**
    * Whether this is a direct dependency
    */
-  isDirect: z12.boolean(),
+  isDirect: z13.boolean(),
   /**
    * Package metadata
    */
-  metadata: z12.object({
-    name: z12.string(),
-    description: z12.string().optional(),
-    license: z12.string().optional(),
-    homepage: z12.string().url().optional()
+  metadata: z13.object({
+    name: z13.string(),
+    description: z13.string().optional(),
+    license: z13.string().optional(),
+    homepage: z13.string().url().optional()
   }).optional()
 });
-var DependencyGraphSchema = z12.object({
+var DependencyGraphSchema = z13.object({
   /**
    * Root package
    */
-  root: z12.object({
-    id: z12.string(),
-    version: z12.string()
+  root: z13.object({
+    id: z13.string(),
+    version: z13.string()
   }),
   /**
    * All nodes in the graph
    */
-  nodes: z12.array(DependencyGraphNodeSchema),
+  nodes: z13.array(DependencyGraphNodeSchema),
   /**
    * Edges (dependency relationships)
    */
-  edges: z12.array(z12.object({
-    from: z12.string().describe("Package ID"),
-    to: z12.string().describe("Package ID"),
-    constraint: z12.string().describe("Version constraint")
+  edges: z13.array(z13.object({
+    from: z13.string().describe("Package ID"),
+    to: z13.string().describe("Package ID"),
+    constraint: z13.string().describe("Version constraint")
   })),
   /**
    * Resolution statistics
    */
-  stats: z12.object({
-    totalDependencies: z12.number().int().min(0),
-    directDependencies: z12.number().int().min(0),
-    maxDepth: z12.number().int().min(0)
+  stats: z13.object({
+    totalDependencies: z13.number().int().min(0),
+    directDependencies: z13.number().int().min(0),
+    maxDepth: z13.number().int().min(0)
   })
 });
-var DependencyConflictSchema = z12.object({
+var DependencyConflictSchema = z13.object({
   /**
    * Package with conflict
    */
-  package: z12.string(),
+  package: z13.string(),
   /**
    * Conflicting versions
    */
-  conflicts: z12.array(z12.object({
-    version: z12.string(),
-    requestedBy: z12.array(z12.string()).describe("Packages that require this version"),
-    constraint: z12.string()
+  conflicts: z13.array(z13.object({
+    version: z13.string(),
+    requestedBy: z13.array(z13.string()).describe("Packages that require this version"),
+    constraint: z13.string()
   })),
   /**
    * Suggested resolution
    */
-  resolution: z12.object({
-    strategy: z12.enum(["pick-highest", "pick-lowest", "manual"]),
-    version: z12.string().optional(),
-    reason: z12.string().optional()
+  resolution: z13.object({
+    strategy: z13.enum(["pick-highest", "pick-lowest", "manual"]),
+    version: z13.string().optional(),
+    reason: z13.string().optional()
   }).optional(),
   /**
    * Severity
    */
-  severity: z12.enum(["error", "warning", "info"])
+  severity: z13.enum(["error", "warning", "info"])
 });
-var DependencyResolutionResultSchema = z12.object({
+var DependencyResolutionResultSchema = z13.object({
   /**
    * Resolution status
    */
-  status: z12.enum(["success", "conflict", "error"]),
+  status: z13.enum(["success", "conflict", "error"]),
   /**
    * Resolved dependency graph
    */
@@ -2853,207 +2942,207 @@ var DependencyResolutionResultSchema = z12.object({
   /**
    * Conflicts detected
    */
-  conflicts: z12.array(DependencyConflictSchema).default([]),
+  conflicts: z13.array(DependencyConflictSchema).default([]),
   /**
    * Errors encountered
    */
-  errors: z12.array(z12.object({
-    package: z12.string(),
-    error: z12.string()
+  errors: z13.array(z13.object({
+    package: z13.string(),
+    error: z13.string()
   })).default([]),
   /**
    * Installation order (topological sort)
    */
-  installOrder: z12.array(z12.string()).default([]),
+  installOrder: z13.array(z13.string()).default([]),
   /**
    * Resolution time (ms)
    */
-  resolvedIn: z12.number().int().min(0).optional()
+  resolvedIn: z13.number().int().min(0).optional()
 });
-var SBOMEntrySchema = z12.object({
+var SBOMEntrySchema = z13.object({
   /**
    * Component name
    */
-  name: z12.string(),
+  name: z13.string(),
   /**
    * Component version
    */
-  version: z12.string(),
+  version: z13.string(),
   /**
    * Package URL (purl)
    */
-  purl: z12.string().optional().describe("Package URL identifier"),
+  purl: z13.string().optional().describe("Package URL identifier"),
   /**
    * License
    */
-  license: z12.string().optional(),
+  license: z13.string().optional(),
   /**
    * Hashes
    */
-  hashes: z12.object({
-    sha256: z12.string().optional(),
-    sha512: z12.string().optional()
+  hashes: z13.object({
+    sha256: z13.string().optional(),
+    sha512: z13.string().optional()
   }).optional(),
   /**
    * Supplier
    */
-  supplier: z12.object({
-    name: z12.string(),
-    url: z12.string().url().optional()
+  supplier: z13.object({
+    name: z13.string(),
+    url: z13.string().url().optional()
   }).optional(),
   /**
    * External references
    */
-  externalRefs: z12.array(z12.object({
-    type: z12.enum(["website", "repository", "documentation", "issue-tracker"]),
-    url: z12.string().url()
+  externalRefs: z13.array(z13.object({
+    type: z13.enum(["website", "repository", "documentation", "issue-tracker"]),
+    url: z13.string().url()
   })).default([])
 });
-var SBOMSchema = z12.object({
+var SBOMSchema = z13.object({
   /**
    * SBOM format
    */
-  format: z12.enum(["spdx", "cyclonedx"]).default("cyclonedx"),
+  format: z13.enum(["spdx", "cyclonedx"]).default("cyclonedx"),
   /**
    * SBOM version
    */
-  version: z12.string(),
+  version: z13.string(),
   /**
    * Plugin metadata
    */
-  plugin: z12.object({
-    id: z12.string(),
-    version: z12.string(),
-    name: z12.string()
+  plugin: z13.object({
+    id: z13.string(),
+    version: z13.string(),
+    name: z13.string()
   }),
   /**
    * Components (dependencies)
    */
-  components: z12.array(SBOMEntrySchema),
+  components: z13.array(SBOMEntrySchema),
   /**
    * Generation timestamp
    */
-  generatedAt: z12.string().datetime(),
+  generatedAt: z13.string().datetime(),
   /**
    * Generator tool
    */
-  generator: z12.object({
-    name: z12.string(),
-    version: z12.string()
+  generator: z13.object({
+    name: z13.string(),
+    version: z13.string()
   }).optional()
 });
-var PluginProvenanceSchema = z12.object({
+var PluginProvenanceSchema = z13.object({
   /**
    * Plugin identifier
    */
-  pluginId: z12.string(),
+  pluginId: z13.string(),
   /**
    * Plugin version
    */
-  version: z12.string(),
+  version: z13.string(),
   /**
    * Build information
    */
-  build: z12.object({
+  build: z13.object({
     /**
      * Build timestamp
      */
-    timestamp: z12.string().datetime(),
+    timestamp: z13.string().datetime(),
     /**
      * Build environment
      */
-    environment: z12.object({
-      os: z12.string(),
-      arch: z12.string(),
-      nodeVersion: z12.string()
+    environment: z13.object({
+      os: z13.string(),
+      arch: z13.string(),
+      nodeVersion: z13.string()
     }).optional(),
     /**
      * Source repository
      */
-    source: z12.object({
-      repository: z12.string().url(),
-      commit: z12.string().regex(/^[a-f0-9]{40}$/),
-      branch: z12.string().optional(),
-      tag: z12.string().optional()
+    source: z13.object({
+      repository: z13.string().url(),
+      commit: z13.string().regex(/^[a-f0-9]{40}$/),
+      branch: z13.string().optional(),
+      tag: z13.string().optional()
     }).optional(),
     /**
      * Builder identity
      */
-    builder: z12.object({
-      name: z12.string(),
-      email: z12.string().email().optional()
+    builder: z13.object({
+      name: z13.string(),
+      email: z13.string().email().optional()
     }).optional()
   }),
   /**
    * Artifact hashes
    */
-  artifacts: z12.array(z12.object({
-    filename: z12.string(),
-    sha256: z12.string(),
-    size: z12.number().int().positive()
+  artifacts: z13.array(z13.object({
+    filename: z13.string(),
+    sha256: z13.string(),
+    size: z13.number().int().positive()
   })),
   /**
    * Signatures
    */
-  signatures: z12.array(z12.object({
-    algorithm: z12.enum(["rsa", "ecdsa", "ed25519"]),
-    publicKey: z12.string(),
-    signature: z12.string(),
-    signedBy: z12.string(),
-    timestamp: z12.string().datetime()
+  signatures: z13.array(z13.object({
+    algorithm: z13.enum(["rsa", "ecdsa", "ed25519"]),
+    publicKey: z13.string(),
+    signature: z13.string(),
+    signedBy: z13.string(),
+    timestamp: z13.string().datetime()
   })).default([]),
   /**
    * Attestations
    */
-  attestations: z12.array(z12.object({
-    type: z12.enum(["code-review", "security-scan", "test-results", "ci-build"]),
-    status: z12.enum(["passed", "failed"]),
-    url: z12.string().url().optional(),
-    timestamp: z12.string().datetime()
+  attestations: z13.array(z13.object({
+    type: z13.enum(["code-review", "security-scan", "test-results", "ci-build"]),
+    status: z13.enum(["passed", "failed"]),
+    url: z13.string().url().optional(),
+    timestamp: z13.string().datetime()
   })).default([])
 });
-var PluginTrustScoreSchema = z12.object({
+var PluginTrustScoreSchema = z13.object({
   /**
    * Plugin identifier
    */
-  pluginId: z12.string(),
+  pluginId: z13.string(),
   /**
    * Overall trust score (0-100)
    */
-  score: z12.number().min(0).max(100),
+  score: z13.number().min(0).max(100),
   /**
    * Score components
    */
-  components: z12.object({
+  components: z13.object({
     /**
      * Vendor reputation (0-100)
      */
-    vendorReputation: z12.number().min(0).max(100),
+    vendorReputation: z13.number().min(0).max(100),
     /**
      * Security scan results (0-100)
      */
-    securityScore: z12.number().min(0).max(100),
+    securityScore: z13.number().min(0).max(100),
     /**
      * Code quality (0-100)
      */
-    codeQuality: z12.number().min(0).max(100),
+    codeQuality: z13.number().min(0).max(100),
     /**
      * Community engagement (0-100)
      */
-    communityScore: z12.number().min(0).max(100),
+    communityScore: z13.number().min(0).max(100),
     /**
      * Update frequency (0-100)
      */
-    maintenanceScore: z12.number().min(0).max(100)
+    maintenanceScore: z13.number().min(0).max(100)
   }),
   /**
    * Trust level
    */
-  level: z12.enum(["verified", "trusted", "neutral", "untrusted", "blocked"]),
+  level: z13.enum(["verified", "trusted", "neutral", "untrusted", "blocked"]),
   /**
    * Verification badges
    */
-  badges: z12.array(z12.enum([
+  badges: z13.array(z13.enum([
     "official",
     // Official ObjectStack plugin
     "verified-vendor",
@@ -3070,7 +3159,7 @@ var PluginTrustScoreSchema = z12.object({
   /**
    * Last updated
    */
-  updatedAt: z12.string().datetime()
+  updatedAt: z13.string().datetime()
 });
 var PluginSecurityProtocol = {
   VulnerabilitySeverity,