@objectstack/spec 1.0.5 → 1.0.7

package/dist/hub/index.js

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