@objectstack/spec 1.0.11 → 1.1.0

package/dist/kernel/index.js

@@ -30,8 +30,12 @@ __export(kernel_exports, {
   DependencyConflictSchema: () => DependencyConflictSchema,
   DependencyResolutionResultSchema: () => DependencyResolutionResultSchema,
   DeprecationNoticeSchema: () => DeprecationNoticeSchema,
+  DisablePackageRequestSchema: () => DisablePackageRequestSchema,
+  DisablePackageResponseSchema: () => DisablePackageResponseSchema,
   DistributedStateConfigSchema: () => DistributedStateConfigSchema,
   EVENT_PRIORITY_VALUES: () => EVENT_PRIORITY_VALUES,
+  EnablePackageRequestSchema: () => EnablePackageRequestSchema,
+  EnablePackageResponseSchema: () => EnablePackageResponseSchema,
   EventBusConfigSchema: () => EventBusConfigSchema,
   EventHandlerSchema: () => EventHandlerSchema,
   EventLogEntrySchema: () => EventLogEntrySchema,
@@ -51,15 +55,22 @@ __export(kernel_exports, {
   FeatureFlag: () => FeatureFlag,
   FeatureFlagSchema: () => FeatureFlagSchema,
   FeatureStrategy: () => FeatureStrategy,
+  GetPackageRequestSchema: () => GetPackageRequestSchema,
+  GetPackageResponseSchema: () => GetPackageResponseSchema,
   GracefulDegradationSchema: () => GracefulDegradationSchema,
   HealthStatusSchema: () => HealthStatusSchema,
   HookRegisteredEventSchema: () => HookRegisteredEventSchema,
   HookTriggeredEventSchema: () => HookTriggeredEventSchema,
   HotReloadConfigSchema: () => HotReloadConfigSchema,
+  InstallPackageRequestSchema: () => InstallPackageRequestSchema,
+  InstallPackageResponseSchema: () => InstallPackageResponseSchema,
+  InstalledPackageSchema: () => InstalledPackageSchema,
   KernelContextSchema: () => KernelContextSchema,
   KernelEventBaseSchema: () => KernelEventBaseSchema,
   KernelReadyEventSchema: () => KernelReadyEventSchema,
   KernelShutdownEventSchema: () => KernelShutdownEventSchema,
+  ListPackagesRequestSchema: () => ListPackagesRequestSchema,
+  ListPackagesResponseSchema: () => ListPackagesResponseSchema,
   ManifestSchema: () => ManifestSchema,
   MetadataCollectionInfoSchema: () => MetadataCollectionInfoSchema,
   MetadataExportOptionsSchema: () => MetadataExportOptionsSchema,
@@ -77,6 +88,7 @@ __export(kernel_exports, {
   OpsDomainModuleSchema: () => OpsDomainModuleSchema,
   OpsFilePathSchema: () => OpsFilePathSchema,
   OpsPluginStructureSchema: () => OpsPluginStructureSchema,
+  PackageStatusEnum: () => PackageStatusEnum,
   PermissionActionSchema: () => PermissionActionSchema,
   PermissionSchema: () => PermissionSchema,
   PermissionScopeSchema: () => PermissionScopeSchema,
@@ -139,6 +151,8 @@ __export(kernel_exports, {
   ServiceUnregisteredEventSchema: () => ServiceUnregisteredEventSchema,
   StartupOptionsSchema: () => StartupOptionsSchema,
   StartupOrchestrationResultSchema: () => StartupOrchestrationResultSchema,
+  UninstallPackageRequestSchema: () => UninstallPackageRequestSchema,
+  UninstallPackageResponseSchema: () => UninstallPackageResponseSchema,
   ValidationErrorSchema: () => ValidationErrorSchema,
   ValidationResultSchema: () => ValidationResultSchema,
   ValidationWarningSchema: () => ValidationWarningSchema,
@@ -270,7 +284,7 @@ var EventHandlerSchema = import_zod3.z.object({
   /**
    * Handler function
    */
-  handler: import_zod3.z.function().args(EventSchema).returns(import_zod3.z.promise(import_zod3.z.void())).describe("Handler function"),
+  handler: import_zod3.z.any().describe("Handler function"),
   /**
    * Execution priority
    */
@@ -294,17 +308,17 @@ var EventHandlerSchema = import_zod3.z.object({
   /**
    * Filter function
    */
-  filter: import_zod3.z.function().args(EventSchema).returns(import_zod3.z.boolean()).optional().describe("Optional filter to determine if handler should execute")
+  filter: import_zod3.z.any().optional().describe("Optional filter to determine if handler should execute")
 });
 var EventRouteSchema = import_zod3.z.object({
   from: import_zod3.z.string().describe("Source event pattern (supports wildcards, e.g., user.* or *.created)"),
   to: import_zod3.z.array(import_zod3.z.string()).describe("Target event names to route to"),
-  transform: import_zod3.z.function().optional().describe("Optional function to transform payload")
+  transform: import_zod3.z.any().optional().describe("Optional function to transform payload")
 });
 var EventPersistenceSchema = import_zod3.z.object({
   enabled: import_zod3.z.boolean().default(false).describe("Enable event persistence"),
   retention: import_zod3.z.number().int().positive().describe("Days to retain persisted events"),
-  filter: import_zod3.z.function().optional().describe("Optional filter function to select which events to persist"),
+  filter: import_zod3.z.any().optional().describe("Optional filter function to select which events to persist"),
   storage: import_zod3.z.enum(["database", "file", "s3", "custom"]).default("database").describe("Storage backend for persisted events")
 });
 var EventQueueConfigSchema = import_zod3.z.object({
@@ -496,7 +510,7 @@ var EventWebhookConfigSchema = import_zod3.z.object({
   /**
    * Event transformation
    */
-  transform: import_zod3.z.function().args(EventSchema).returns(import_zod3.z.any()).optional().describe("Transform event before sending"),
+  transform: import_zod3.z.any().optional().describe("Transform event before sending"),
   /**
    * Enabled
    */
@@ -567,7 +581,7 @@ var RealTimeNotificationConfigSchema = import_zod3.z.object({
   channels: import_zod3.z.array(import_zod3.z.object({
     name: import_zod3.z.string().describe("Channel name"),
     eventPattern: import_zod3.z.string().describe("Event pattern for channel"),
-    filter: import_zod3.z.function().args(EventSchema).returns(import_zod3.z.boolean()).optional().describe("Additional filter function")
+    filter: import_zod3.z.any().optional().describe("Additional filter function")
   })).optional().describe("Named channels for event broadcasting"),
   /**
    * Rate limiting
@@ -666,7 +680,7 @@ var FeatureFlag = Object.assign(FeatureFlagSchema, {
 });
 
 // src/kernel/manifest.zod.ts
-var import_zod8 = require("zod");
+var import_zod9 = require("zod");
 
 // src/kernel/plugin-capability.zod.ts
 var import_zod5 = require("zod");
@@ -1485,48 +1499,48 @@ var PluginLoadingStateSchema = import_zod6.z.object({
 var import_zod7 = require("zod");
 var PluginContextSchema = import_zod7.z.object({
   ql: import_zod7.z.object({
-    object: import_zod7.z.function().returns(import_zod7.z.any()),
+    object: import_zod7.z.any(),
     // Return any to allow method chaining
-    query: import_zod7.z.function().returns(import_zod7.z.any())
+    query: import_zod7.z.any()
   }).passthrough().describe("ObjectQL Engine Interface"),
   os: import_zod7.z.object({
-    getCurrentUser: import_zod7.z.function().returns(import_zod7.z.any()),
-    getConfig: import_zod7.z.function().returns(import_zod7.z.any())
+    getCurrentUser: import_zod7.z.any(),
+    getConfig: import_zod7.z.any()
   }).passthrough().describe("ObjectStack Kernel Interface"),
   logger: import_zod7.z.object({
-    debug: import_zod7.z.function().returns(import_zod7.z.void()),
-    info: import_zod7.z.function().returns(import_zod7.z.void()),
-    warn: import_zod7.z.function().returns(import_zod7.z.void()),
-    error: import_zod7.z.function().returns(import_zod7.z.void())
+    debug: import_zod7.z.any(),
+    info: import_zod7.z.any(),
+    warn: import_zod7.z.any(),
+    error: import_zod7.z.any()
   }).passthrough().describe("Logger Interface"),
   storage: import_zod7.z.object({
-    get: import_zod7.z.function().returns(import_zod7.z.any()),
-    set: import_zod7.z.function().returns(import_zod7.z.promise(import_zod7.z.void())),
-    delete: import_zod7.z.function().returns(import_zod7.z.promise(import_zod7.z.void()))
+    get: import_zod7.z.any(),
+    set: import_zod7.z.any(),
+    delete: import_zod7.z.any()
   }).passthrough().describe("Storage Interface"),
   i18n: import_zod7.z.object({
-    t: import_zod7.z.function().returns(import_zod7.z.string()),
-    getLocale: import_zod7.z.function().returns(import_zod7.z.string())
+    t: import_zod7.z.any(),
+    getLocale: import_zod7.z.any()
   }).passthrough().describe("Internationalization Interface"),
   metadata: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.any()),
   events: import_zod7.z.record(import_zod7.z.string(), import_zod7.z.any()),
   app: import_zod7.z.object({
     router: import_zod7.z.object({
-      get: import_zod7.z.function().returns(import_zod7.z.any()),
-      post: import_zod7.z.function().returns(import_zod7.z.any()),
-      use: import_zod7.z.function().returns(import_zod7.z.any())
+      get: import_zod7.z.any(),
+      post: import_zod7.z.any(),
+      use: import_zod7.z.any()
     }).passthrough()
   }).passthrough().describe("App Framework Interface"),
   drivers: import_zod7.z.object({
-    register: import_zod7.z.function().returns(import_zod7.z.void())
+    register: import_zod7.z.any()
   }).passthrough().describe("Driver Registry")
 });
 var PluginLifecycleSchema = import_zod7.z.object({
-  onInstall: import_zod7.z.function().args(PluginContextSchema).returns(import_zod7.z.promise(import_zod7.z.void())).optional(),
-  onEnable: import_zod7.z.function().args(PluginContextSchema).returns(import_zod7.z.promise(import_zod7.z.void())).optional(),
-  onDisable: import_zod7.z.function().args(PluginContextSchema).returns(import_zod7.z.promise(import_zod7.z.void())).optional(),
-  onUninstall: import_zod7.z.function().args(PluginContextSchema).returns(import_zod7.z.promise(import_zod7.z.void())).optional(),
-  onUpgrade: import_zod7.z.function().args(PluginContextSchema, import_zod7.z.string(), import_zod7.z.string()).returns(import_zod7.z.promise(import_zod7.z.void())).optional()
+  onInstall: import_zod7.z.any().optional(),
+  onEnable: import_zod7.z.any().optional(),
+  onDisable: import_zod7.z.any().optional(),
+  onUninstall: import_zod7.z.any().optional(),
+  onUpgrade: import_zod7.z.any().optional()
 });
 var CORE_PLUGIN_TYPES = [
   "ui",
@@ -1563,8 +1577,53 @@ function definePlugin(config) {
   return config;
 }
 
+// src/data/dataset.zod.ts
+var import_zod8 = require("zod");
+var DatasetMode = import_zod8.z.enum([
+  "insert",
+  // Try to insert, fail on duplicate
+  "update",
+  // Only update found records, ignore new
+  "upsert",
+  // Create new or Update existing (Standard)
+  "replace",
+  // Delete ALL records in object then insert (Dangerous - use for cache tables)
+  "ignore"
+  // Try to insert, silently skip duplicates
+]);
+var DatasetSchema = import_zod8.z.object({
+  /** 
+   * Target Object 
+   * The machine name of the object to populate.
+   */
+  object: import_zod8.z.string().regex(/^[a-z_][a-z0-9_]*$/).describe("Target Object Name"),
+  /** 
+   * Idempotency Key (The "Upsert" Key)
+   * The field used to check if a record already exists.
+   * Best Practice: Use a natural key like 'code', 'slug', 'username' or 'external_id'.
+   * Standard: '_id' (internal ID) is rarely used for portable seed data.
+   */
+  externalId: import_zod8.z.string().default("name").describe("Field match for uniqueness check"),
+  /** 
+   * Import Strategy
+   */
+  mode: DatasetMode.default("upsert").describe("Conflict resolution strategy"),
+  /**
+   * Environment Scope
+   * - 'all': Always load
+   * - 'dev': Only for development/demo
+   * - 'test': Only for CI/CD tests
+   */
+  env: import_zod8.z.array(import_zod8.z.enum(["prod", "dev", "test"])).default(["prod", "dev", "test"]).describe("Applicable environments"),
+  /** 
+   * The Payload
+   * Array of raw JSON objects matching the Object Schema.
+   */
+  records: import_zod8.z.array(import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any())).describe("Data records")
+});
+
 // src/kernel/manifest.zod.ts
-var ManifestSchema = import_zod8.z.object({
+var ManifestSchema = import_zod9.z.object({
   /** 
    * Unique package identifier using reverse domain notation.
    * Must be unique across the entire ecosystem.
@@ -1572,14 +1631,30 @@ var ManifestSchema = import_zod8.z.object({
    * @example "com.steedos.crm"
    * @example "org.apache.superset"
    */
-  id: import_zod8.z.string().describe("Unique package identifier (reverse domain style)"),
+  id: import_zod9.z.string().describe("Unique package identifier (reverse domain style)"),
+  /**
+   * Short namespace identifier for metadata scoping.
+   * Used as a prefix for objects and other metadata to prevent naming collisions
+   * across packages from different vendors.
+   * 
+   * Rules:
+   * - 2-20 characters, lowercase letters, digits, and underscores only.
+   * - Must be unique within a running instance.
+   * - Platform-reserved namespaces (no prefix applied): "base", "system".
+   * - FQN (Fully Qualified Name) = `{namespace}__{short_name}` (double underscore separator).
+   * 
+   * @example "crm"       → objects become crm__account, crm__deal
+   * @example "todo"      → objects become todo__task
+   * @example "base"      → objects keep short name (platform reserved)
+   */
+  namespace: import_zod9.z.string().regex(/^[a-z][a-z0-9_]{1,19}$/, "Namespace must be 2-20 chars, lowercase alphanumeric + underscore").optional().describe('Short namespace identifier for metadata scoping (e.g. "crm", "todo")'),
   /** 
    * Package version following semantic versioning (major.minor.patch).
    * 
    * @example "1.0.0"
    * @example "2.1.0-beta.1"
    */
-  version: import_zod8.z.string().regex(/^\d+\.\d+\.\d+$/).describe("Package version (semantic versioning)"),
+  version: import_zod9.z.string().regex(/^\d+\.\d+\.\d+$/).describe("Package version (semantic versioning)"),
   /** 
    * Type of the package in the ObjectStack ecosystem.
    * - plugin: General-purpose functionality extension (Runtime: standard)
@@ -1593,7 +1668,7 @@ var ManifestSchema = import_zod8.z.object({
    * - objectql: Core engine
    * - adapter: Host adapter (Express, Fastify)
    */
-  type: import_zod8.z.enum([
+  type: import_zod9.z.enum([
     "plugin",
     ...CORE_PLUGIN_TYPES,
     "module",
@@ -1607,40 +1682,40 @@ var ManifestSchema = import_zod8.z.object({
    * 
    * @example "Project Management"
    */
-  name: import_zod8.z.string().describe("Human-readable package name"),
+  name: import_zod9.z.string().describe("Human-readable package name"),
   /** 
    * Brief description of the package functionality.
    * Displayed in the marketplace and plugin manager.
    */
-  description: import_zod8.z.string().optional().describe("Package description"),
+  description: import_zod9.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_zod8.z.array(import_zod8.z.string()).optional().describe("Array of required permission strings"),
+  permissions: import_zod9.z.array(import_zod9.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_zod8.z.array(import_zod8.z.string()).optional().describe("Glob patterns for ObjectQL schemas files"),
+  objects: import_zod9.z.array(import_zod9.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_zod8.z.array(import_zod8.z.string()).optional().describe("Glob patterns for Datasource definitions"),
+  datasources: import_zod9.z.array(import_zod9.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_zod8.z.record(import_zod8.z.string(), import_zod8.z.string()).optional().describe("Package dependencies"),
+  dependencies: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.string()).optional().describe("Package dependencies"),
   /**
    * Plugin Configuration Schema.
    * Defines the settings this plugin exposes to the user via UI/ENV.
@@ -1655,110 +1730,114 @@ var ManifestSchema = import_zod8.z.object({
    *   }
    * }
    */
-  configuration: import_zod8.z.object({
-    title: import_zod8.z.string().optional(),
-    properties: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.object({
-      type: import_zod8.z.enum(["string", "number", "boolean", "array", "object"]).describe("Data type of the setting"),
-      default: import_zod8.z.any().optional().describe("Default value"),
-      description: import_zod8.z.string().optional().describe("Tooltip description"),
-      required: import_zod8.z.boolean().optional().describe("Is this setting required?"),
-      secret: import_zod8.z.boolean().optional().describe("If true, value is encrypted/masked (e.g. API Keys)"),
-      enum: import_zod8.z.array(import_zod8.z.string()).optional().describe("Allowed values for select inputs")
+  configuration: import_zod9.z.object({
+    title: import_zod9.z.string().optional(),
+    properties: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.object({
+      type: import_zod9.z.enum(["string", "number", "boolean", "array", "object"]).describe("Data type of the setting"),
+      default: import_zod9.z.any().optional().describe("Default value"),
+      description: import_zod9.z.string().optional().describe("Tooltip description"),
+      required: import_zod9.z.boolean().optional().describe("Is this setting required?"),
+      secret: import_zod9.z.boolean().optional().describe("If true, value is encrypted/masked (e.g. API Keys)"),
+      enum: import_zod9.z.array(import_zod9.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_zod8.z.object({
+  contributes: import_zod9.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_zod8.z.array(import_zod8.z.object({
-      id: import_zod8.z.string().describe('The generic identifier of the kind (e.g., "sys.bi.report")'),
-      globs: import_zod8.z.array(import_zod8.z.string()).describe('File patterns to watch (e.g., ["**/*.report.ts"])'),
-      description: import_zod8.z.string().optional().describe("Description of what this kind represents")
+    kinds: import_zod9.z.array(import_zod9.z.object({
+      id: import_zod9.z.string().describe('The generic identifier of the kind (e.g., "sys.bi.report")'),
+      globs: import_zod9.z.array(import_zod9.z.string()).describe('File patterns to watch (e.g., ["**/*.report.ts"])'),
+      description: import_zod9.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_zod8.z.array(import_zod8.z.string()).optional().describe("Events this plugin listens to"),
+    events: import_zod9.z.array(import_zod9.z.string()).optional().describe("Events this plugin listens to"),
     /**
      * Register UI Menus.
      */
-    menus: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.array(import_zod8.z.object({
-      id: import_zod8.z.string(),
-      label: import_zod8.z.string(),
-      command: import_zod8.z.string().optional()
+    menus: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.array(import_zod9.z.object({
+      id: import_zod9.z.string(),
+      label: import_zod9.z.string(),
+      command: import_zod9.z.string().optional()
     }))).optional().describe("UI Menu contributions"),
     /**
      * Register Custom Themes.
      */
-    themes: import_zod8.z.array(import_zod8.z.object({
-      id: import_zod8.z.string(),
-      label: import_zod8.z.string(),
-      path: import_zod8.z.string()
+    themes: import_zod9.z.array(import_zod9.z.object({
+      id: import_zod9.z.string(),
+      label: import_zod9.z.string(),
+      path: import_zod9.z.string()
     })).optional().describe("Theme contributions"),
     /**
      * Register Translations.
      * Path to translation files (e.g. "locales/en.json").
      */
-    translations: import_zod8.z.array(import_zod8.z.object({
-      locale: import_zod8.z.string(),
-      path: import_zod8.z.string()
+    translations: import_zod9.z.array(import_zod9.z.object({
+      locale: import_zod9.z.string(),
+      path: import_zod9.z.string()
     })).optional().describe("Translation resources"),
     /**
      * Register Server Actions.
      * Invocable functions exposed to Flows or API.
      */
-    actions: import_zod8.z.array(import_zod8.z.object({
-      name: import_zod8.z.string().describe("Unique action name"),
-      label: import_zod8.z.string().optional(),
-      description: import_zod8.z.string().optional(),
-      input: import_zod8.z.any().optional().describe("Input validation schema"),
-      output: import_zod8.z.any().optional().describe("Output schema")
+    actions: import_zod9.z.array(import_zod9.z.object({
+      name: import_zod9.z.string().describe("Unique action name"),
+      label: import_zod9.z.string().optional(),
+      description: import_zod9.z.string().optional(),
+      input: import_zod9.z.any().optional().describe("Input validation schema"),
+      output: import_zod9.z.any().optional().describe("Output schema")
     })).optional().describe("Exposed server actions"),
     /**
      * Register Storage Drivers.
      * Enables connecting to new types of datasources.
      */
-    drivers: import_zod8.z.array(import_zod8.z.object({
-      id: import_zod8.z.string().describe('Driver unique identifier (e.g. "postgres", "mongo")'),
-      label: import_zod8.z.string().describe("Human readable name"),
-      description: import_zod8.z.string().optional()
+    drivers: import_zod9.z.array(import_zod9.z.object({
+      id: import_zod9.z.string().describe('Driver unique identifier (e.g. "postgres", "mongo")'),
+      label: import_zod9.z.string().describe("Human readable name"),
+      description: import_zod9.z.string().optional()
     })).optional().describe("Driver contributions"),
     /**
      * Register Custom Field Types.
      * Extends the data model with new widget types.
      */
-    fieldTypes: import_zod8.z.array(import_zod8.z.object({
-      name: import_zod8.z.string().describe('Unique field type name (e.g. "vector")'),
-      label: import_zod8.z.string().describe("Display label"),
-      description: import_zod8.z.string().optional()
+    fieldTypes: import_zod9.z.array(import_zod9.z.object({
+      name: import_zod9.z.string().describe('Unique field type name (e.g. "vector")'),
+      label: import_zod9.z.string().describe("Display label"),
+      description: import_zod9.z.string().optional()
     })).optional().describe("Field Type contributions"),
     /**
      * Register Custom Query Operators/Functions.
      * Extends ObjectQL with new functions (e.g. distance()).
      */
-    functions: import_zod8.z.array(import_zod8.z.object({
-      name: import_zod8.z.string().describe('Function name (e.g. "distance")'),
-      description: import_zod8.z.string().optional(),
-      args: import_zod8.z.array(import_zod8.z.string()).optional().describe("Argument types"),
-      returnType: import_zod8.z.string().optional()
+    functions: import_zod9.z.array(import_zod9.z.object({
+      name: import_zod9.z.string().describe('Function name (e.g. "distance")'),
+      description: import_zod9.z.string().optional(),
+      args: import_zod9.z.array(import_zod9.z.string()).optional().describe("Argument types"),
+      returnType: import_zod9.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.
+   * 
+   * Uses the standard DatasetSchema which supports idempotent upsert via
+   * `externalId`, environment scoping via `env`, and multiple conflict
+   * resolution modes.
+   * 
+   * @deprecated Prefer using the top-level `data` field on the Stack Definition
+   * (defineStack({ data: [...] })) for better visibility and metadata registration.
+   * This field is retained for backward compatibility with manifest-only packages.
    */
-  data: import_zod8.z.array(import_zod8.z.object({
-    object: import_zod8.z.string().describe("Target Object Name"),
-    records: import_zod8.z.array(import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any())).describe("List of records to insert"),
-    mode: import_zod8.z.enum(["upsert", "insert", "ignore"]).default("upsert").describe("Seeding mode")
-  })).optional().describe("Initial seed data"),
+  data: import_zod9.z.array(DatasetSchema).optional().describe("Initial seed data (prefer top-level data field)"),
   /**
    * Plugin Capability Manifest.
    * Declares protocols implemented, interfaces provided, dependencies, and extension points.
@@ -1769,7 +1848,7 @@ var ManifestSchema = import_zod8.z.object({
    * Extension points contributed by this package.
    * Allows packages to extend UI components, add functionality, etc.
    */
-  extensions: import_zod8.z.record(import_zod8.z.string(), import_zod8.z.any()).optional().describe("Extension points and contributions"),
+  extensions: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).optional().describe("Extension points and contributions"),
   /**
    * Plugin Loading Configuration.
    * Configures how the plugin is loaded, initialized, and managed at runtime.
@@ -1779,22 +1858,22 @@ var ManifestSchema = import_zod8.z.object({
 });
 
 // src/kernel/metadata-loader.zod.ts
-var import_zod9 = require("zod");
-var MetadataFormatSchema = import_zod9.z.enum(["json", "yaml", "typescript", "javascript"]);
-var MetadataStatsSchema = import_zod9.z.object({
+var import_zod10 = require("zod");
+var MetadataFormatSchema = import_zod10.z.enum(["json", "yaml", "typescript", "javascript"]);
+var MetadataStatsSchema = import_zod10.z.object({
   /**
    * Size of the metadata file in bytes
    */
-  size: import_zod9.z.number().int().min(0).describe("File size in bytes"),
+  size: import_zod10.z.number().int().min(0).describe("File size in bytes"),
   /**
    * Last modification timestamp
    */
-  modifiedAt: import_zod9.z.date().describe("Last modified date"),
+  modifiedAt: import_zod10.z.date().describe("Last modified date"),
   /**
    * ETag for cache validation
    * Used for conditional requests (If-None-Match header)
    */
-  etag: import_zod9.z.string().describe("Entity tag for cache validation"),
+  etag: import_zod10.z.string().describe("Entity tag for cache validation"),
   /**
    * Serialization format
    */
@@ -1802,50 +1881,50 @@ var MetadataStatsSchema = import_zod9.z.object({
   /**
    * Full file path (if applicable)
    */
-  path: import_zod9.z.string().optional().describe("File system path"),
+  path: import_zod10.z.string().optional().describe("File system path"),
   /**
    * Additional metadata provider-specific properties
    */
-  metadata: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).optional().describe("Provider-specific metadata")
+  metadata: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional().describe("Provider-specific metadata")
 });
-var MetadataLoadOptionsSchema = import_zod9.z.object({
+var MetadataLoadOptionsSchema = import_zod10.z.object({
   /**
    * Glob patterns to match files
    * Example: ["**\/*.object.ts", "**\/*.object.json"]
    */
-  patterns: import_zod9.z.array(import_zod9.z.string()).optional().describe("File glob patterns"),
+  patterns: import_zod10.z.array(import_zod10.z.string()).optional().describe("File glob patterns"),
   /**
    * If-None-Match header for conditional loading
    * Only load if ETag doesn't match
    */
-  ifNoneMatch: import_zod9.z.string().optional().describe("ETag for conditional request"),
+  ifNoneMatch: import_zod10.z.string().optional().describe("ETag for conditional request"),
   /**
    * If-Modified-Since header for conditional loading
    */
-  ifModifiedSince: import_zod9.z.date().optional().describe("Only load if modified after this date"),
+  ifModifiedSince: import_zod10.z.date().optional().describe("Only load if modified after this date"),
   /**
    * Whether to validate against Zod schema
    */
-  validate: import_zod9.z.boolean().default(true).describe("Validate against schema"),
+  validate: import_zod10.z.boolean().default(true).describe("Validate against schema"),
   /**
    * Whether to use cache if available
    */
-  useCache: import_zod9.z.boolean().default(true).describe("Enable caching"),
+  useCache: import_zod10.z.boolean().default(true).describe("Enable caching"),
   /**
    * Filter function (serialized as string)
    * Example: "(item) => item.name.startsWith('sys_')"
    */
-  filter: import_zod9.z.string().optional().describe("Filter predicate as string"),
+  filter: import_zod10.z.string().optional().describe("Filter predicate as string"),
   /**
    * Maximum number of items to load
    */
-  limit: import_zod9.z.number().int().min(1).optional().describe("Maximum items to load"),
+  limit: import_zod10.z.number().int().min(1).optional().describe("Maximum items to load"),
   /**
    * Recursively search subdirectories
    */
-  recursive: import_zod9.z.boolean().default(true).describe("Search subdirectories")
+  recursive: import_zod10.z.boolean().default(true).describe("Search subdirectories")
 });
-var MetadataSaveOptionsSchema = import_zod9.z.object({
+var MetadataSaveOptionsSchema = import_zod10.z.object({
   /**
    * Serialization format
    */
@@ -1853,41 +1932,41 @@ var MetadataSaveOptionsSchema = import_zod9.z.object({
   /**
    * Prettify output (formatted with indentation)
    */
-  prettify: import_zod9.z.boolean().default(true).describe("Format with indentation"),
+  prettify: import_zod10.z.boolean().default(true).describe("Format with indentation"),
   /**
    * Indentation size (spaces)
    */
-  indent: import_zod9.z.number().int().min(0).max(8).default(2).describe("Indentation spaces"),
+  indent: import_zod10.z.number().int().min(0).max(8).default(2).describe("Indentation spaces"),
   /**
    * Sort object keys alphabetically
    */
-  sortKeys: import_zod9.z.boolean().default(false).describe("Sort object keys"),
+  sortKeys: import_zod10.z.boolean().default(false).describe("Sort object keys"),
   /**
    * Include default values in output
    */
-  includeDefaults: import_zod9.z.boolean().default(false).describe("Include default values"),
+  includeDefaults: import_zod10.z.boolean().default(false).describe("Include default values"),
   /**
    * Create backup before overwriting
    */
-  backup: import_zod9.z.boolean().default(false).describe("Create backup file"),
+  backup: import_zod10.z.boolean().default(false).describe("Create backup file"),
   /**
    * Overwrite if exists
    */
-  overwrite: import_zod9.z.boolean().default(true).describe("Overwrite existing file"),
+  overwrite: import_zod10.z.boolean().default(true).describe("Overwrite existing file"),
   /**
    * Atomic write (write to temp file, then rename)
    */
-  atomic: import_zod9.z.boolean().default(true).describe("Use atomic write operation"),
+  atomic: import_zod10.z.boolean().default(true).describe("Use atomic write operation"),
   /**
    * Custom file path (overrides default location)
    */
-  path: import_zod9.z.string().optional().describe("Custom output path")
+  path: import_zod10.z.string().optional().describe("Custom output path")
 });
-var MetadataExportOptionsSchema = import_zod9.z.object({
+var MetadataExportOptionsSchema = import_zod10.z.object({
   /**
    * Output file path
    */
-  output: import_zod9.z.string().describe("Output file path"),
+  output: import_zod10.z.string().describe("Output file path"),
   /**
    * Export format
    */
@@ -1895,60 +1974,60 @@ var MetadataExportOptionsSchema = import_zod9.z.object({
   /**
    * Filter predicate as string
    */
-  filter: import_zod9.z.string().optional().describe("Filter items to export"),
+  filter: import_zod10.z.string().optional().describe("Filter items to export"),
   /**
    * Include statistics in export
    */
-  includeStats: import_zod9.z.boolean().default(false).describe("Include metadata statistics"),
+  includeStats: import_zod10.z.boolean().default(false).describe("Include metadata statistics"),
   /**
    * Compress output
    */
-  compress: import_zod9.z.boolean().default(false).describe("Compress output (gzip)"),
+  compress: import_zod10.z.boolean().default(false).describe("Compress output (gzip)"),
   /**
    * Pretty print output
    */
-  prettify: import_zod9.z.boolean().default(true).describe("Pretty print output")
+  prettify: import_zod10.z.boolean().default(true).describe("Pretty print output")
 });
-var MetadataImportOptionsSchema = import_zod9.z.object({
+var MetadataImportOptionsSchema = import_zod10.z.object({
   /**
    * Conflict resolution strategy
    */
-  conflictResolution: import_zod9.z.enum(["skip", "overwrite", "merge", "fail"]).default("merge").describe("How to handle existing items"),
+  conflictResolution: import_zod10.z.enum(["skip", "overwrite", "merge", "fail"]).default("merge").describe("How to handle existing items"),
   /**
    * Validate items against schema
    */
-  validate: import_zod9.z.boolean().default(true).describe("Validate before import"),
+  validate: import_zod10.z.boolean().default(true).describe("Validate before import"),
   /**
    * Dry run (don't actually save)
    */
-  dryRun: import_zod9.z.boolean().default(false).describe("Simulate import without saving"),
+  dryRun: import_zod10.z.boolean().default(false).describe("Simulate import without saving"),
   /**
    * Continue on errors
    */
-  continueOnError: import_zod9.z.boolean().default(false).describe("Continue if validation fails"),
+  continueOnError: import_zod10.z.boolean().default(false).describe("Continue if validation fails"),
   /**
    * Transform function (as string)
    * Example: "(item) => ({ ...item, imported: true })"
    */
-  transform: import_zod9.z.string().optional().describe("Transform items before import")
+  transform: import_zod10.z.string().optional().describe("Transform items before import")
 });
-var MetadataLoadResultSchema = import_zod9.z.object({
+var MetadataLoadResultSchema = import_zod10.z.object({
   /**
    * Loaded data
    */
-  data: import_zod9.z.any().nullable().describe("Loaded metadata"),
+  data: import_zod10.z.any().nullable().describe("Loaded metadata"),
   /**
    * Whether data came from cache (304 Not Modified)
    */
-  fromCache: import_zod9.z.boolean().default(false).describe("Loaded from cache"),
+  fromCache: import_zod10.z.boolean().default(false).describe("Loaded from cache"),
   /**
    * Not modified (conditional request matched)
    */
-  notModified: import_zod9.z.boolean().default(false).describe("Not modified since last request"),
+  notModified: import_zod10.z.boolean().default(false).describe("Not modified since last request"),
   /**
    * ETag of loaded data
    */
-  etag: import_zod9.z.string().optional().describe("Entity tag"),
+  etag: import_zod10.z.string().optional().describe("Entity tag"),
   /**
    * Statistics about loaded data
    */
@@ -1956,166 +2035,273 @@ var MetadataLoadResultSchema = import_zod9.z.object({
   /**
    * Load time in milliseconds
    */
-  loadTime: import_zod9.z.number().min(0).optional().describe("Load duration in ms")
+  loadTime: import_zod10.z.number().min(0).optional().describe("Load duration in ms")
 });
-var MetadataSaveResultSchema = import_zod9.z.object({
+var MetadataSaveResultSchema = import_zod10.z.object({
   /**
    * Whether save was successful
    */
-  success: import_zod9.z.boolean().describe("Save successful"),
+  success: import_zod10.z.boolean().describe("Save successful"),
   /**
    * Path where file was saved
    */
-  path: import_zod9.z.string().describe("Output path"),
+  path: import_zod10.z.string().describe("Output path"),
   /**
    * Generated ETag
    */
-  etag: import_zod9.z.string().optional().describe("Generated entity tag"),
+  etag: import_zod10.z.string().optional().describe("Generated entity tag"),
   /**
    * File size in bytes
    */
-  size: import_zod9.z.number().int().min(0).optional().describe("File size"),
+  size: import_zod10.z.number().int().min(0).optional().describe("File size"),
   /**
    * Save time in milliseconds
    */
-  saveTime: import_zod9.z.number().min(0).optional().describe("Save duration in ms"),
+  saveTime: import_zod10.z.number().min(0).optional().describe("Save duration in ms"),
   /**
    * Backup path (if created)
    */
-  backupPath: import_zod9.z.string().optional().describe("Backup file path")
+  backupPath: import_zod10.z.string().optional().describe("Backup file path")
 });
-var MetadataWatchEventSchema = import_zod9.z.object({
+var MetadataWatchEventSchema = import_zod10.z.object({
   /**
    * Event type
    */
-  type: import_zod9.z.enum(["added", "changed", "deleted"]).describe("Event type"),
+  type: import_zod10.z.enum(["added", "changed", "deleted"]).describe("Event type"),
   /**
    * Metadata type (e.g., 'object', 'view', 'app')
    */
-  metadataType: import_zod9.z.string().describe("Type of metadata"),
+  metadataType: import_zod10.z.string().describe("Type of metadata"),
   /**
    * Item name/identifier
    */
-  name: import_zod9.z.string().describe("Item identifier"),
+  name: import_zod10.z.string().describe("Item identifier"),
   /**
    * Full file path
    */
-  path: import_zod9.z.string().describe("File path"),
+  path: import_zod10.z.string().describe("File path"),
   /**
    * Loaded item data (for added/changed events)
    */
-  data: import_zod9.z.any().optional().describe("Item data"),
+  data: import_zod10.z.any().optional().describe("Item data"),
   /**
    * Timestamp
    */
-  timestamp: import_zod9.z.date().describe("Event timestamp")
+  timestamp: import_zod10.z.date().describe("Event timestamp")
 });
-var MetadataCollectionInfoSchema = import_zod9.z.object({
+var MetadataCollectionInfoSchema = import_zod10.z.object({
   /**
    * Collection type (e.g., 'object', 'view', 'app')
    */
-  type: import_zod9.z.string().describe("Collection type"),
+  type: import_zod10.z.string().describe("Collection type"),
   /**
    * Total items in collection
    */
-  count: import_zod9.z.number().int().min(0).describe("Number of items"),
+  count: import_zod10.z.number().int().min(0).describe("Number of items"),
   /**
    * Formats found in collection
    */
-  formats: import_zod9.z.array(MetadataFormatSchema).describe("Formats in collection"),
+  formats: import_zod10.z.array(MetadataFormatSchema).describe("Formats in collection"),
   /**
    * Total size in bytes
    */
-  totalSize: import_zod9.z.number().int().min(0).optional().describe("Total size in bytes"),
+  totalSize: import_zod10.z.number().int().min(0).optional().describe("Total size in bytes"),
   /**
    * Last modified timestamp
    */
-  lastModified: import_zod9.z.date().optional().describe("Last modification date"),
+  lastModified: import_zod10.z.date().optional().describe("Last modification date"),
   /**
    * Collection location (path or URL)
    */
-  location: import_zod9.z.string().optional().describe("Collection location")
+  location: import_zod10.z.string().optional().describe("Collection location")
 });
-var MetadataLoaderContractSchema = import_zod9.z.object({
+var MetadataLoaderContractSchema = import_zod10.z.object({
   /**
    * Loader name/identifier
    */
-  name: import_zod9.z.string().describe("Loader identifier"),
+  name: import_zod10.z.string().describe("Loader identifier"),
   /**
    * Protocol handled by this loader (e.g. 'file', 'http', 's3')
    */
-  protocol: import_zod9.z.string().describe("Protocol identifier"),
+  protocol: import_zod10.z.string().describe("Protocol identifier"),
   /**
    * Detailed capabilities
    */
-  capabilities: import_zod9.z.object({
-    read: import_zod9.z.boolean().default(true),
-    write: import_zod9.z.boolean().default(false),
-    watch: import_zod9.z.boolean().default(false),
-    list: import_zod9.z.boolean().default(true)
+  capabilities: import_zod10.z.object({
+    read: import_zod10.z.boolean().default(true),
+    write: import_zod10.z.boolean().default(false),
+    watch: import_zod10.z.boolean().default(false),
+    list: import_zod10.z.boolean().default(true)
   }).describe("Loader capabilities"),
   /**
    * Supported formats
    */
-  supportedFormats: import_zod9.z.array(MetadataFormatSchema).describe("Supported formats"),
+  supportedFormats: import_zod10.z.array(MetadataFormatSchema).describe("Supported formats"),
   /**
    * Whether loader supports watching for changes
    */
-  supportsWatch: import_zod9.z.boolean().default(false).describe("Supports file watching"),
+  supportsWatch: import_zod10.z.boolean().default(false).describe("Supports file watching"),
   /**
    * Whether loader supports saving
    */
-  supportsWrite: import_zod9.z.boolean().default(true).describe("Supports write operations"),
+  supportsWrite: import_zod10.z.boolean().default(true).describe("Supports write operations"),
   /**
    * Whether loader supports caching
    */
-  supportsCache: import_zod9.z.boolean().default(true).describe("Supports caching")
+  supportsCache: import_zod10.z.boolean().default(true).describe("Supports caching")
 });
-var MetadataManagerConfigSchema = import_zod9.z.object({
+var MetadataManagerConfigSchema = import_zod10.z.object({
   /**
    * Root directory for metadata (for filesystem loaders)
    */
-  rootDir: import_zod9.z.string().optional().describe("Root directory path"),
+  rootDir: import_zod10.z.string().optional().describe("Root directory path"),
   /**
    * Enabled serialization formats
    */
-  formats: import_zod9.z.array(MetadataFormatSchema).default(["typescript", "json", "yaml"]).describe("Enabled formats"),
+  formats: import_zod10.z.array(MetadataFormatSchema).default(["typescript", "json", "yaml"]).describe("Enabled formats"),
   /**
    * Cache configuration
    */
-  cache: import_zod9.z.object({
-    enabled: import_zod9.z.boolean().default(true).describe("Enable caching"),
-    ttl: import_zod9.z.number().int().min(0).default(3600).describe("Cache TTL in seconds"),
-    maxSize: import_zod9.z.number().int().min(0).optional().describe("Max cache size in bytes")
+  cache: import_zod10.z.object({
+    enabled: import_zod10.z.boolean().default(true).describe("Enable caching"),
+    ttl: import_zod10.z.number().int().min(0).default(3600).describe("Cache TTL in seconds"),
+    maxSize: import_zod10.z.number().int().min(0).optional().describe("Max cache size in bytes")
   }).optional().describe("Cache settings"),
   /**
    * Watch for file changes
    */
-  watch: import_zod9.z.boolean().default(false).describe("Enable file watching"),
+  watch: import_zod10.z.boolean().default(false).describe("Enable file watching"),
   /**
    * Watch options
    */
-  watchOptions: import_zod9.z.object({
-    ignored: import_zod9.z.array(import_zod9.z.string()).optional().describe("Patterns to ignore"),
-    persistent: import_zod9.z.boolean().default(true).describe("Keep process running"),
-    ignoreInitial: import_zod9.z.boolean().default(true).describe("Ignore initial add events")
+  watchOptions: import_zod10.z.object({
+    ignored: import_zod10.z.array(import_zod10.z.string()).optional().describe("Patterns to ignore"),
+    persistent: import_zod10.z.boolean().default(true).describe("Keep process running"),
+    ignoreInitial: import_zod10.z.boolean().default(true).describe("Ignore initial add events")
   }).optional().describe("File watcher options"),
   /**
    * Validation settings
    */
-  validation: import_zod9.z.object({
-    strict: import_zod9.z.boolean().default(true).describe("Strict validation"),
-    throwOnError: import_zod9.z.boolean().default(true).describe("Throw on validation error")
+  validation: import_zod10.z.object({
+    strict: import_zod10.z.boolean().default(true).describe("Strict validation"),
+    throwOnError: import_zod10.z.boolean().default(true).describe("Throw on validation error")
   }).optional().describe("Validation settings"),
   /**
    * Loader-specific options
    */
-  loaderOptions: import_zod9.z.record(import_zod9.z.string(), import_zod9.z.any()).optional().describe("Loader-specific configuration")
+  loaderOptions: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional().describe("Loader-specific configuration")
+});
+
+// src/kernel/package-registry.zod.ts
+var import_zod11 = require("zod");
+var PackageStatusEnum = import_zod11.z.enum([
+  "installed",
+  // Successfully installed and enabled
+  "disabled",
+  // Installed but disabled (metadata not active)
+  "installing",
+  // Installation in progress
+  "uninstalling",
+  // Removal in progress
+  "error"
+  // Installation or runtime error
+]);
+var InstalledPackageSchema = import_zod11.z.object({
+  /** 
+   * The full package manifest (source of truth for package definition).
+   */
+  manifest: ManifestSchema,
+  /**
+   * Current lifecycle status.
+   */
+  status: PackageStatusEnum.default("installed"),
+  /**
+   * Whether the package is currently enabled (active).
+   * When disabled, the package's metadata is not loaded into the registry.
+   */
+  enabled: import_zod11.z.boolean().default(true),
+  /**
+   * ISO 8601 timestamp of when the package was installed.
+   */
+  installedAt: import_zod11.z.string().datetime().optional(),
+  /**
+   * ISO 8601 timestamp of last update.
+   */
+  updatedAt: import_zod11.z.string().datetime().optional(),
+  /**
+   * ISO 8601 timestamp of when the package was last enabled/disabled.
+   */
+  statusChangedAt: import_zod11.z.string().datetime().optional(),
+  /**
+   * Error message if status is 'error'.
+   */
+  errorMessage: import_zod11.z.string().optional(),
+  /**
+   * Configuration values set by the user for this package.
+   * Keys correspond to the package's `configuration.properties`.
+   */
+  settings: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional()
+});
+var ListPackagesRequestSchema = import_zod11.z.object({
+  /** Filter by status */
+  status: PackageStatusEnum.optional(),
+  /** Filter by package type */
+  type: ManifestSchema.shape.type.optional(),
+  /** Filter by enabled state */
+  enabled: import_zod11.z.boolean().optional()
+});
+var ListPackagesResponseSchema = import_zod11.z.object({
+  packages: import_zod11.z.array(InstalledPackageSchema),
+  total: import_zod11.z.number()
+});
+var GetPackageRequestSchema = import_zod11.z.object({
+  /** Package ID (reverse domain identifier from manifest) */
+  id: import_zod11.z.string()
+});
+var GetPackageResponseSchema = import_zod11.z.object({
+  package: InstalledPackageSchema
+});
+var InstallPackageRequestSchema = import_zod11.z.object({
+  /** The package manifest to install */
+  manifest: ManifestSchema,
+  /** Optional: user-provided settings at install time */
+  settings: import_zod11.z.record(import_zod11.z.string(), import_zod11.z.any()).optional(),
+  /** Whether to enable immediately after install (default: true) */
+  enableOnInstall: import_zod11.z.boolean().default(true)
+});
+var InstallPackageResponseSchema = import_zod11.z.object({
+  package: InstalledPackageSchema,
+  message: import_zod11.z.string().optional()
+});
+var UninstallPackageRequestSchema = import_zod11.z.object({
+  /** Package ID to uninstall */
+  id: import_zod11.z.string()
+});
+var UninstallPackageResponseSchema = import_zod11.z.object({
+  id: import_zod11.z.string(),
+  success: import_zod11.z.boolean(),
+  message: import_zod11.z.string().optional()
+});
+var EnablePackageRequestSchema = import_zod11.z.object({
+  /** Package ID to enable */
+  id: import_zod11.z.string()
+});
+var EnablePackageResponseSchema = import_zod11.z.object({
+  package: InstalledPackageSchema,
+  message: import_zod11.z.string().optional()
+});
+var DisablePackageRequestSchema = import_zod11.z.object({
+  /** Package ID to disable */
+  id: import_zod11.z.string()
+});
+var DisablePackageResponseSchema = import_zod11.z.object({
+  package: InstalledPackageSchema,
+  message: import_zod11.z.string().optional()
 });
 
 // src/kernel/plugin-lifecycle-advanced.zod.ts
-var import_zod10 = require("zod");
-var PluginHealthStatusSchema = import_zod10.z.enum([
+var import_zod12 = require("zod");
+var PluginHealthStatusSchema = import_zod12.z.enum([
   "healthy",
   // Plugin is operating normally
   "degraded",
@@ -2129,41 +2315,41 @@ var PluginHealthStatusSchema = import_zod10.z.enum([
   "unknown"
   // Health status cannot be determined
 ]).describe("Current health status of the plugin");
-var PluginHealthCheckSchema = import_zod10.z.object({
+var PluginHealthCheckSchema = import_zod12.z.object({
   /**
    * Health check interval in milliseconds
    */
-  interval: import_zod10.z.number().int().min(1e3).default(3e4).describe("How often to perform health checks (default: 30s)"),
+  interval: import_zod12.z.number().int().min(1e3).default(3e4).describe("How often to perform health checks (default: 30s)"),
   /**
    * Timeout for health check in milliseconds
    */
-  timeout: import_zod10.z.number().int().min(100).default(5e3).describe("Maximum time to wait for health check response"),
+  timeout: import_zod12.z.number().int().min(100).default(5e3).describe("Maximum time to wait for health check response"),
   /**
    * Number of consecutive failures before marking as unhealthy
    */
-  failureThreshold: import_zod10.z.number().int().min(1).default(3).describe("Consecutive failures needed to mark unhealthy"),
+  failureThreshold: import_zod12.z.number().int().min(1).default(3).describe("Consecutive failures needed to mark unhealthy"),
   /**
    * Number of consecutive successes to recover from unhealthy state
    */
-  successThreshold: import_zod10.z.number().int().min(1).default(1).describe("Consecutive successes needed to mark healthy"),
+  successThreshold: import_zod12.z.number().int().min(1).default(1).describe("Consecutive successes needed to mark healthy"),
   /**
    * Custom health check function name or endpoint
    */
-  checkMethod: import_zod10.z.string().optional().describe("Method name to call for health check"),
+  checkMethod: import_zod12.z.string().optional().describe("Method name to call for health check"),
   /**
    * Enable automatic restart on failure
    */
-  autoRestart: import_zod10.z.boolean().default(false).describe("Automatically restart plugin on health check failure"),
+  autoRestart: import_zod12.z.boolean().default(false).describe("Automatically restart plugin on health check failure"),
   /**
    * Maximum number of restart attempts
    */
-  maxRestartAttempts: import_zod10.z.number().int().min(0).default(3).describe("Maximum restart attempts before giving up"),
+  maxRestartAttempts: import_zod12.z.number().int().min(0).default(3).describe("Maximum restart attempts before giving up"),
   /**
    * Backoff strategy for restarts
    */
-  restartBackoff: import_zod10.z.enum(["fixed", "linear", "exponential"]).default("exponential").describe("Backoff strategy for restart delays")
+  restartBackoff: import_zod12.z.enum(["fixed", "linear", "exponential"]).default("exponential").describe("Backoff strategy for restart delays")
 });
-var PluginHealthReportSchema = import_zod10.z.object({
+var PluginHealthReportSchema = import_zod12.z.object({
   /**
    * Overall health status
    */
@@ -2171,99 +2357,99 @@ var PluginHealthReportSchema = import_zod10.z.object({
   /**
    * Timestamp of the health check
    */
-  timestamp: import_zod10.z.string().datetime(),
+  timestamp: import_zod12.z.string().datetime(),
   /**
    * Human-readable message about health status
    */
-  message: import_zod10.z.string().optional(),
+  message: import_zod12.z.string().optional(),
   /**
    * Detailed metrics
    */
-  metrics: import_zod10.z.object({
-    uptime: import_zod10.z.number().describe("Plugin uptime in milliseconds"),
-    memoryUsage: import_zod10.z.number().optional().describe("Memory usage in bytes"),
-    cpuUsage: import_zod10.z.number().optional().describe("CPU usage percentage"),
-    activeConnections: import_zod10.z.number().optional().describe("Number of active connections"),
-    errorRate: import_zod10.z.number().optional().describe("Error rate (errors per minute)"),
-    responseTime: import_zod10.z.number().optional().describe("Average response time in ms")
+  metrics: import_zod12.z.object({
+    uptime: import_zod12.z.number().describe("Plugin uptime in milliseconds"),
+    memoryUsage: import_zod12.z.number().optional().describe("Memory usage in bytes"),
+    cpuUsage: import_zod12.z.number().optional().describe("CPU usage percentage"),
+    activeConnections: import_zod12.z.number().optional().describe("Number of active connections"),
+    errorRate: import_zod12.z.number().optional().describe("Error rate (errors per minute)"),
+    responseTime: import_zod12.z.number().optional().describe("Average response time in ms")
   }).partial().optional(),
   /**
    * List of checks performed
    */
-  checks: import_zod10.z.array(import_zod10.z.object({
-    name: import_zod10.z.string().describe("Check name"),
-    status: import_zod10.z.enum(["passed", "failed", "warning"]),
-    message: import_zod10.z.string().optional(),
-    data: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional()
+  checks: import_zod12.z.array(import_zod12.z.object({
+    name: import_zod12.z.string().describe("Check name"),
+    status: import_zod12.z.enum(["passed", "failed", "warning"]),
+    message: import_zod12.z.string().optional(),
+    data: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).optional()
   })).optional(),
   /**
    * Dependencies health
    */
-  dependencies: import_zod10.z.array(import_zod10.z.object({
-    pluginId: import_zod10.z.string(),
+  dependencies: import_zod12.z.array(import_zod12.z.object({
+    pluginId: import_zod12.z.string(),
     status: PluginHealthStatusSchema,
-    message: import_zod10.z.string().optional()
+    message: import_zod12.z.string().optional()
   })).optional()
 });
-var DistributedStateConfigSchema = import_zod10.z.object({
+var DistributedStateConfigSchema = import_zod12.z.object({
   /**
    * Distributed cache provider
    */
-  provider: import_zod10.z.enum(["redis", "etcd", "custom"]).describe("Distributed state backend provider"),
+  provider: import_zod12.z.enum(["redis", "etcd", "custom"]).describe("Distributed state backend provider"),
   /**
    * Connection URL or endpoints
    */
-  endpoints: import_zod10.z.array(import_zod10.z.string()).optional().describe("Backend connection endpoints"),
+  endpoints: import_zod12.z.array(import_zod12.z.string()).optional().describe("Backend connection endpoints"),
   /**
    * Key prefix for namespacing
    */
-  keyPrefix: import_zod10.z.string().optional().describe('Prefix for all keys (e.g., "plugin:my-plugin:")'),
+  keyPrefix: import_zod12.z.string().optional().describe('Prefix for all keys (e.g., "plugin:my-plugin:")'),
   /**
    * Time to live in seconds
    */
-  ttl: import_zod10.z.number().int().min(0).optional().describe("State expiration time in seconds"),
+  ttl: import_zod12.z.number().int().min(0).optional().describe("State expiration time in seconds"),
   /**
    * Authentication configuration
    */
-  auth: import_zod10.z.object({
-    username: import_zod10.z.string().optional(),
-    password: import_zod10.z.string().optional(),
-    token: import_zod10.z.string().optional(),
-    certificate: import_zod10.z.string().optional()
+  auth: import_zod12.z.object({
+    username: import_zod12.z.string().optional(),
+    password: import_zod12.z.string().optional(),
+    token: import_zod12.z.string().optional(),
+    certificate: import_zod12.z.string().optional()
   }).optional(),
   /**
    * Replication settings
    */
-  replication: import_zod10.z.object({
-    enabled: import_zod10.z.boolean().default(true),
-    minReplicas: import_zod10.z.number().int().min(1).default(1)
+  replication: import_zod12.z.object({
+    enabled: import_zod12.z.boolean().default(true),
+    minReplicas: import_zod12.z.number().int().min(1).default(1)
   }).optional(),
   /**
    * Custom provider configuration
    */
-  customConfig: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()).optional().describe("Provider-specific configuration")
+  customConfig: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()).optional().describe("Provider-specific configuration")
 });
-var HotReloadConfigSchema = import_zod10.z.object({
+var HotReloadConfigSchema = import_zod12.z.object({
   /**
    * Enable hot reload capability
    */
-  enabled: import_zod10.z.boolean().default(false),
+  enabled: import_zod12.z.boolean().default(false),
   /**
    * Watch file patterns for auto-reload
    */
-  watchPatterns: import_zod10.z.array(import_zod10.z.string()).optional().describe("Glob patterns to watch for changes"),
+  watchPatterns: import_zod12.z.array(import_zod12.z.string()).optional().describe("Glob patterns to watch for changes"),
   /**
    * Debounce delay before reloading (milliseconds)
    */
-  debounceDelay: import_zod10.z.number().int().min(0).default(1e3).describe("Wait time after change detection before reload"),
+  debounceDelay: import_zod12.z.number().int().min(0).default(1e3).describe("Wait time after change detection before reload"),
   /**
    * Preserve plugin state during reload
    */
-  preserveState: import_zod10.z.boolean().default(true).describe("Keep plugin state across reloads"),
+  preserveState: import_zod12.z.boolean().default(true).describe("Keep plugin state across reloads"),
   /**
    * State serialization strategy
    */
-  stateStrategy: import_zod10.z.enum(["memory", "disk", "distributed", "none"]).default("memory").describe("How to preserve state during reload"),
+  stateStrategy: import_zod12.z.enum(["memory", "disk", "distributed", "none"]).default("memory").describe("How to preserve state during reload"),
   /**
    * Distributed state configuration (required when stateStrategy is "distributed")
    */
@@ -2271,25 +2457,25 @@ var HotReloadConfigSchema = import_zod10.z.object({
   /**
    * Graceful shutdown timeout
    */
-  shutdownTimeout: import_zod10.z.number().int().min(0).default(3e4).describe("Maximum time to wait for graceful shutdown"),
+  shutdownTimeout: import_zod12.z.number().int().min(0).default(3e4).describe("Maximum time to wait for graceful shutdown"),
   /**
    * Pre-reload hooks
    */
-  beforeReload: import_zod10.z.array(import_zod10.z.string()).optional().describe("Hook names to call before reload"),
+  beforeReload: import_zod12.z.array(import_zod12.z.string()).optional().describe("Hook names to call before reload"),
   /**
    * Post-reload hooks
    */
-  afterReload: import_zod10.z.array(import_zod10.z.string()).optional().describe("Hook names to call after reload")
+  afterReload: import_zod12.z.array(import_zod12.z.string()).optional().describe("Hook names to call after reload")
 });
-var GracefulDegradationSchema = import_zod10.z.object({
+var GracefulDegradationSchema = import_zod12.z.object({
   /**
    * Enable graceful degradation
    */
-  enabled: import_zod10.z.boolean().default(true),
+  enabled: import_zod12.z.boolean().default(true),
   /**
    * Fallback mode when dependencies fail
    */
-  fallbackMode: import_zod10.z.enum([
+  fallbackMode: import_zod12.z.enum([
     "minimal",
     // Provide minimal functionality
     "cached",
@@ -2304,33 +2490,33 @@ var GracefulDegradationSchema = import_zod10.z.object({
   /**
    * Critical dependencies that must be available
    */
-  criticalDependencies: import_zod10.z.array(import_zod10.z.string()).optional().describe("Plugin IDs that are required for operation"),
+  criticalDependencies: import_zod12.z.array(import_zod12.z.string()).optional().describe("Plugin IDs that are required for operation"),
   /**
    * Optional dependencies that can fail
    */
-  optionalDependencies: import_zod10.z.array(import_zod10.z.string()).optional().describe("Plugin IDs that are nice to have but not required"),
+  optionalDependencies: import_zod12.z.array(import_zod12.z.string()).optional().describe("Plugin IDs that are nice to have but not required"),
   /**
    * Feature flags for degraded mode
    */
-  degradedFeatures: import_zod10.z.array(import_zod10.z.object({
-    feature: import_zod10.z.string().describe("Feature name"),
-    enabled: import_zod10.z.boolean().describe("Whether feature is available in degraded mode"),
-    reason: import_zod10.z.string().optional()
+  degradedFeatures: import_zod12.z.array(import_zod12.z.object({
+    feature: import_zod12.z.string().describe("Feature name"),
+    enabled: import_zod12.z.boolean().describe("Whether feature is available in degraded mode"),
+    reason: import_zod12.z.string().optional()
   })).optional(),
   /**
    * Automatic recovery attempts
    */
-  autoRecovery: import_zod10.z.object({
-    enabled: import_zod10.z.boolean().default(true),
-    retryInterval: import_zod10.z.number().int().min(1e3).default(6e4).describe("Interval between recovery attempts (ms)"),
-    maxAttempts: import_zod10.z.number().int().min(0).default(5).describe("Maximum recovery attempts before giving up")
+  autoRecovery: import_zod12.z.object({
+    enabled: import_zod12.z.boolean().default(true),
+    retryInterval: import_zod12.z.number().int().min(1e3).default(6e4).describe("Interval between recovery attempts (ms)"),
+    maxAttempts: import_zod12.z.number().int().min(0).default(5).describe("Maximum recovery attempts before giving up")
   }).optional()
 });
-var PluginUpdateStrategySchema = import_zod10.z.object({
+var PluginUpdateStrategySchema = import_zod12.z.object({
   /**
    * Update mode
    */
-  mode: import_zod10.z.enum([
+  mode: import_zod12.z.enum([
     "manual",
     // Manual updates only
     "automatic",
@@ -2343,91 +2529,91 @@ var PluginUpdateStrategySchema = import_zod10.z.object({
   /**
    * Version constraints for automatic updates
    */
-  autoUpdateConstraints: import_zod10.z.object({
-    major: import_zod10.z.boolean().default(false).describe("Allow major version updates"),
-    minor: import_zod10.z.boolean().default(true).describe("Allow minor version updates"),
-    patch: import_zod10.z.boolean().default(true).describe("Allow patch version updates")
+  autoUpdateConstraints: import_zod12.z.object({
+    major: import_zod12.z.boolean().default(false).describe("Allow major version updates"),
+    minor: import_zod12.z.boolean().default(true).describe("Allow minor version updates"),
+    patch: import_zod12.z.boolean().default(true).describe("Allow patch version updates")
   }).optional(),
   /**
    * Update schedule (for scheduled mode)
    */
-  schedule: import_zod10.z.object({
+  schedule: import_zod12.z.object({
     /**
      * Cron expression for update window
      */
-    cron: import_zod10.z.string().optional(),
+    cron: import_zod12.z.string().optional(),
     /**
      * Timezone for schedule
      */
-    timezone: import_zod10.z.string().default("UTC"),
+    timezone: import_zod12.z.string().default("UTC"),
     /**
      * Maintenance window duration in minutes
      */
-    maintenanceWindow: import_zod10.z.number().int().min(1).default(60)
+    maintenanceWindow: import_zod12.z.number().int().min(1).default(60)
   }).optional(),
   /**
    * Rollback configuration
    */
-  rollback: import_zod10.z.object({
-    enabled: import_zod10.z.boolean().default(true),
+  rollback: import_zod12.z.object({
+    enabled: import_zod12.z.boolean().default(true),
     /**
      * Automatic rollback on failure
      */
-    automatic: import_zod10.z.boolean().default(true),
+    automatic: import_zod12.z.boolean().default(true),
     /**
      * Keep N previous versions for rollback
      */
-    keepVersions: import_zod10.z.number().int().min(1).default(3),
+    keepVersions: import_zod12.z.number().int().min(1).default(3),
     /**
      * Rollback timeout in milliseconds
      */
-    timeout: import_zod10.z.number().int().min(1e3).default(3e4)
+    timeout: import_zod12.z.number().int().min(1e3).default(3e4)
   }).optional(),
   /**
    * Pre-update validation
    */
-  validation: import_zod10.z.object({
+  validation: import_zod12.z.object({
     /**
      * Run compatibility checks before update
      */
-    checkCompatibility: import_zod10.z.boolean().default(true),
+    checkCompatibility: import_zod12.z.boolean().default(true),
     /**
      * Run tests before applying update
      */
-    runTests: import_zod10.z.boolean().default(false),
+    runTests: import_zod12.z.boolean().default(false),
     /**
      * Test suite to run
      */
-    testSuite: import_zod10.z.string().optional()
+    testSuite: import_zod12.z.string().optional()
   }).optional()
 });
-var PluginStateSnapshotSchema = import_zod10.z.object({
+var PluginStateSnapshotSchema = import_zod12.z.object({
   /**
    * Plugin identifier
    */
-  pluginId: import_zod10.z.string(),
+  pluginId: import_zod12.z.string(),
   /**
    * Version at time of snapshot
    */
-  version: import_zod10.z.string(),
+  version: import_zod12.z.string(),
   /**
    * Snapshot timestamp
    */
-  timestamp: import_zod10.z.string().datetime(),
+  timestamp: import_zod12.z.string().datetime(),
   /**
    * Serialized state data
    */
-  state: import_zod10.z.record(import_zod10.z.string(), import_zod10.z.any()),
+  state: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.any()),
   /**
    * State metadata
    */
-  metadata: import_zod10.z.object({
-    checksum: import_zod10.z.string().optional().describe("State checksum for verification"),
-    compressed: import_zod10.z.boolean().default(false),
-    encryption: import_zod10.z.string().optional().describe("Encryption algorithm if encrypted")
+  metadata: import_zod12.z.object({
+    checksum: import_zod12.z.string().optional().describe("State checksum for verification"),
+    compressed: import_zod12.z.boolean().default(false),
+    encryption: import_zod12.z.string().optional().describe("Encryption algorithm if encrypted")
   }).optional()
 });
-var AdvancedPluginLifecycleConfigSchema = import_zod10.z.object({
+var AdvancedPluginLifecycleConfigSchema = import_zod12.z.object({
   /**
    * Health monitoring configuration
    */
@@ -2447,47 +2633,47 @@ var AdvancedPluginLifecycleConfigSchema = import_zod10.z.object({
   /**
    * Resource limits
    */
-  resources: import_zod10.z.object({
-    maxMemory: import_zod10.z.number().int().optional().describe("Maximum memory in bytes"),
-    maxCpu: import_zod10.z.number().min(0).max(100).optional().describe("Maximum CPU percentage"),
-    maxConnections: import_zod10.z.number().int().optional().describe("Maximum concurrent connections"),
-    timeout: import_zod10.z.number().int().optional().describe("Operation timeout in milliseconds")
+  resources: import_zod12.z.object({
+    maxMemory: import_zod12.z.number().int().optional().describe("Maximum memory in bytes"),
+    maxCpu: import_zod12.z.number().min(0).max(100).optional().describe("Maximum CPU percentage"),
+    maxConnections: import_zod12.z.number().int().optional().describe("Maximum concurrent connections"),
+    timeout: import_zod12.z.number().int().optional().describe("Operation timeout in milliseconds")
   }).optional(),
   /**
    * Monitoring and observability
    */
-  observability: import_zod10.z.object({
-    enableMetrics: import_zod10.z.boolean().default(true),
-    enableTracing: import_zod10.z.boolean().default(true),
-    enableProfiling: import_zod10.z.boolean().default(false),
-    metricsInterval: import_zod10.z.number().int().min(1e3).default(6e4).describe("Metrics collection interval in ms")
+  observability: import_zod12.z.object({
+    enableMetrics: import_zod12.z.boolean().default(true),
+    enableTracing: import_zod12.z.boolean().default(true),
+    enableProfiling: import_zod12.z.boolean().default(false),
+    metricsInterval: import_zod12.z.number().int().min(1e3).default(6e4).describe("Metrics collection interval in ms")
   }).optional()
 });
 
 // src/kernel/plugin-lifecycle-events.zod.ts
-var import_zod11 = require("zod");
-var EventPhaseSchema = import_zod11.z.enum(["init", "start", "destroy"]).describe("Plugin lifecycle phase");
-var PluginEventBaseSchema = import_zod11.z.object({
+var import_zod13 = require("zod");
+var EventPhaseSchema = import_zod13.z.enum(["init", "start", "destroy"]).describe("Plugin lifecycle phase");
+var PluginEventBaseSchema = import_zod13.z.object({
   /**
    * Plugin name
    */
-  pluginName: import_zod11.z.string().describe("Name of the plugin"),
+  pluginName: import_zod13.z.string().describe("Name of the plugin"),
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds when event occurred")
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds when event occurred")
 });
 var PluginRegisteredEventSchema = PluginEventBaseSchema.extend({
   /**
    * Plugin version (optional)
    */
-  version: import_zod11.z.string().optional().describe("Plugin version")
+  version: import_zod13.z.string().optional().describe("Plugin version")
 });
 var PluginLifecyclePhaseEventSchema = PluginEventBaseSchema.extend({
   /**
    * Duration of the phase (milliseconds)
    */
-  duration: import_zod11.z.number().min(0).optional().describe("Duration of the lifecycle phase in milliseconds"),
+  duration: import_zod13.z.number().min(0).optional().describe("Duration of the lifecycle phase in milliseconds"),
   /**
    * Lifecycle phase
    */
@@ -2497,7 +2683,7 @@ var PluginErrorEventSchema = PluginEventBaseSchema.extend({
   /**
    * Error object
    */
-  error: import_zod11.z.instanceof(Error).describe("Error object"),
+  error: import_zod13.z.instanceof(Error).describe("Error object"),
   /**
    * Lifecycle phase where error occurred
    */
@@ -2505,91 +2691,91 @@ var PluginErrorEventSchema = PluginEventBaseSchema.extend({
   /**
    * Error message (for serialization)
    */
-  errorMessage: import_zod11.z.string().optional().describe("Error message"),
+  errorMessage: import_zod13.z.string().optional().describe("Error message"),
   /**
    * Error stack trace (for debugging)
    */
-  errorStack: import_zod11.z.string().optional().describe("Error stack trace")
+  errorStack: import_zod13.z.string().optional().describe("Error stack trace")
 });
-var ServiceRegisteredEventSchema = import_zod11.z.object({
+var ServiceRegisteredEventSchema = import_zod13.z.object({
   /**
    * Service name
    */
-  serviceName: import_zod11.z.string().describe("Name of the registered service"),
+  serviceName: import_zod13.z.string().describe("Name of the registered service"),
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds"),
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds"),
   /**
    * Service type (optional)
    */
-  serviceType: import_zod11.z.string().optional().describe("Type or interface name of the service")
+  serviceType: import_zod13.z.string().optional().describe("Type or interface name of the service")
 });
-var ServiceUnregisteredEventSchema = import_zod11.z.object({
+var ServiceUnregisteredEventSchema = import_zod13.z.object({
   /**
    * Service name
    */
-  serviceName: import_zod11.z.string().describe("Name of the unregistered service"),
+  serviceName: import_zod13.z.string().describe("Name of the unregistered service"),
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds")
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds")
 });
-var HookRegisteredEventSchema = import_zod11.z.object({
+var HookRegisteredEventSchema = import_zod13.z.object({
   /**
    * Hook name
    */
-  hookName: import_zod11.z.string().describe("Name of the hook"),
+  hookName: import_zod13.z.string().describe("Name of the hook"),
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds"),
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds"),
   /**
    * Number of handlers registered for this hook
    */
-  handlerCount: import_zod11.z.number().int().min(0).describe("Number of handlers registered for this hook")
+  handlerCount: import_zod13.z.number().int().min(0).describe("Number of handlers registered for this hook")
 });
-var HookTriggeredEventSchema = import_zod11.z.object({
+var HookTriggeredEventSchema = import_zod13.z.object({
   /**
    * Hook name
    */
-  hookName: import_zod11.z.string().describe("Name of the hook"),
+  hookName: import_zod13.z.string().describe("Name of the hook"),
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds"),
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds"),
   /**
    * Arguments passed to the hook
    */
-  args: import_zod11.z.array(import_zod11.z.any()).describe("Arguments passed to the hook handlers"),
+  args: import_zod13.z.array(import_zod13.z.any()).describe("Arguments passed to the hook handlers"),
   /**
    * Number of handlers that will handle this event
    */
-  handlerCount: import_zod11.z.number().int().min(0).optional().describe("Number of handlers that will handle this event")
+  handlerCount: import_zod13.z.number().int().min(0).optional().describe("Number of handlers that will handle this event")
 });
-var KernelEventBaseSchema = import_zod11.z.object({
+var KernelEventBaseSchema = import_zod13.z.object({
   /**
    * Event timestamp (Unix milliseconds)
    */
-  timestamp: import_zod11.z.number().int().describe("Unix timestamp in milliseconds")
+  timestamp: import_zod13.z.number().int().describe("Unix timestamp in milliseconds")
 });
 var KernelReadyEventSchema = KernelEventBaseSchema.extend({
   /**
    * Total initialization duration (milliseconds)
    */
-  duration: import_zod11.z.number().min(0).optional().describe("Total initialization duration in milliseconds"),
+  duration: import_zod13.z.number().min(0).optional().describe("Total initialization duration in milliseconds"),
   /**
    * Number of plugins initialized
    */
-  pluginCount: import_zod11.z.number().int().min(0).optional().describe("Number of plugins initialized")
+  pluginCount: import_zod13.z.number().int().min(0).optional().describe("Number of plugins initialized")
 });
 var KernelShutdownEventSchema = KernelEventBaseSchema.extend({
   /**
    * Shutdown reason (optional)
    */
-  reason: import_zod11.z.string().optional().describe("Reason for kernel shutdown")
+  reason: import_zod13.z.string().optional().describe("Reason for kernel shutdown")
 });
-var PluginLifecycleEventType = import_zod11.z.enum([
+var PluginLifecycleEventType = import_zod13.z.enum([
   "kernel:ready",
   "kernel:shutdown",
   "kernel:before-init",
@@ -2612,8 +2798,8 @@ var PluginLifecycleEventType = import_zod11.z.enum([
 ]).describe("Plugin lifecycle event type");
 
 // src/kernel/plugin-security-advanced.zod.ts
-var import_zod12 = require("zod");
-var PermissionScopeSchema = import_zod12.z.enum([
+var import_zod14 = require("zod");
+var PermissionScopeSchema = import_zod14.z.enum([
   "global",
   // Applies to entire system
   "tenant",
@@ -2625,7 +2811,7 @@ var PermissionScopeSchema = import_zod12.z.enum([
   "plugin"
   // Applies within plugin boundaries
 ]).describe("Scope of permission application");
-var PermissionActionSchema = import_zod12.z.enum([
+var PermissionActionSchema = import_zod14.z.enum([
   "create",
   // Create new resources
   "read",
@@ -2649,7 +2835,7 @@ var PermissionActionSchema = import_zod12.z.enum([
   "admin"
   // Administrative access
 ]).describe("Type of action being permitted");
-var ResourceTypeSchema = import_zod12.z.enum([
+var ResourceTypeSchema = import_zod14.z.enum([
   "data.object",
   // ObjectQL objects
   "data.record",
@@ -2683,11 +2869,11 @@ var ResourceTypeSchema = import_zod12.z.enum([
   "process.env"
   // Environment variables
 ]).describe("Type of resource being accessed");
-var PermissionSchema = import_zod12.z.object({
+var PermissionSchema = import_zod14.z.object({
   /**
    * Permission identifier
    */
-  id: import_zod12.z.string().describe("Unique permission identifier"),
+  id: import_zod14.z.string().describe("Unique permission identifier"),
   /**
    * Resource type
    */
@@ -2695,7 +2881,7 @@ var PermissionSchema = import_zod12.z.object({
   /**
    * Allowed actions
    */
-  actions: import_zod12.z.array(PermissionActionSchema),
+  actions: import_zod14.z.array(PermissionActionSchema),
   /**
    * Permission scope
    */
@@ -2703,50 +2889,50 @@ var PermissionSchema = import_zod12.z.object({
   /**
    * Resource filter
    */
-  filter: import_zod12.z.object({
+  filter: import_zod14.z.object({
     /**
      * Specific resource IDs
      */
-    resourceIds: import_zod12.z.array(import_zod12.z.string()).optional(),
+    resourceIds: import_zod14.z.array(import_zod14.z.string()).optional(),
     /**
      * Filter condition
      */
-    condition: import_zod12.z.string().optional().describe("Filter expression (e.g., owner = currentUser)"),
+    condition: import_zod14.z.string().optional().describe("Filter expression (e.g., owner = currentUser)"),
     /**
      * Field-level access
      */
-    fields: import_zod12.z.array(import_zod12.z.string()).optional().describe("Allowed fields for data resources")
+    fields: import_zod14.z.array(import_zod14.z.string()).optional().describe("Allowed fields for data resources")
   }).optional(),
   /**
    * Human-readable description
    */
-  description: import_zod12.z.string(),
+  description: import_zod14.z.string(),
   /**
    * Whether this permission is required or optional
    */
-  required: import_zod12.z.boolean().default(true),
+  required: import_zod14.z.boolean().default(true),
   /**
    * Justification for permission
    */
-  justification: import_zod12.z.string().optional().describe("Why this permission is needed")
+  justification: import_zod14.z.string().optional().describe("Why this permission is needed")
 });
-var PermissionSetSchema = import_zod12.z.object({
+var PermissionSetSchema = import_zod14.z.object({
   /**
    * All permissions required by plugin
    */
-  permissions: import_zod12.z.array(PermissionSchema),
+  permissions: import_zod14.z.array(PermissionSchema),
   /**
    * Permission groups for easier management
    */
-  groups: import_zod12.z.array(import_zod12.z.object({
-    name: import_zod12.z.string().describe("Group name"),
-    description: import_zod12.z.string(),
-    permissions: import_zod12.z.array(import_zod12.z.string()).describe("Permission IDs in this group")
+  groups: import_zod14.z.array(import_zod14.z.object({
+    name: import_zod14.z.string().describe("Group name"),
+    description: import_zod14.z.string(),
+    permissions: import_zod14.z.array(import_zod14.z.string()).describe("Permission IDs in this group")
   })).optional(),
   /**
    * Default grant strategy
    */
-  defaultGrant: import_zod12.z.enum([
+  defaultGrant: import_zod14.z.enum([
     "prompt",
     // Always prompt user
     "allow",
@@ -2757,11 +2943,11 @@ var PermissionSetSchema = import_zod12.z.object({
     // Inherit from parent
   ]).default("prompt")
 });
-var RuntimeConfigSchema = import_zod12.z.object({
+var RuntimeConfigSchema = import_zod14.z.object({
   /**
    * Runtime engine type
    */
-  engine: import_zod12.z.enum([
+  engine: import_zod14.z.enum([
     "v8-isolate",
     // V8 isolate-based isolation (lightweight, fast)
     "wasm",
@@ -2774,97 +2960,97 @@ var RuntimeConfigSchema = import_zod12.z.object({
   /**
    * Engine-specific configuration
    */
-  engineConfig: import_zod12.z.object({
+  engineConfig: import_zod14.z.object({
     /**
      * WASM-specific settings (when engine is "wasm")
      */
-    wasm: import_zod12.z.object({
+    wasm: import_zod14.z.object({
       /**
        * Maximum memory pages (64KB per page)
        */
-      maxMemoryPages: import_zod12.z.number().int().min(1).max(65536).optional().describe("Maximum WASM memory pages (64KB each)"),
+      maxMemoryPages: import_zod14.z.number().int().min(1).max(65536).optional().describe("Maximum WASM memory pages (64KB each)"),
       /**
        * Instruction execution limit
        */
-      instructionLimit: import_zod12.z.number().int().min(1).optional().describe("Maximum instructions before timeout"),
+      instructionLimit: import_zod14.z.number().int().min(1).optional().describe("Maximum instructions before timeout"),
       /**
        * Enable SIMD instructions
        */
-      enableSimd: import_zod12.z.boolean().default(false).describe("Enable WebAssembly SIMD support"),
+      enableSimd: import_zod14.z.boolean().default(false).describe("Enable WebAssembly SIMD support"),
       /**
        * Enable threads
        */
-      enableThreads: import_zod12.z.boolean().default(false).describe("Enable WebAssembly threads"),
+      enableThreads: import_zod14.z.boolean().default(false).describe("Enable WebAssembly threads"),
       /**
        * Enable bulk memory operations
        */
-      enableBulkMemory: import_zod12.z.boolean().default(true).describe("Enable bulk memory operations")
+      enableBulkMemory: import_zod14.z.boolean().default(true).describe("Enable bulk memory operations")
     }).optional(),
     /**
      * Container-specific settings (when engine is "container")
      */
-    container: import_zod12.z.object({
+    container: import_zod14.z.object({
       /**
        * Container image
        */
-      image: import_zod12.z.string().optional().describe("Container image to use"),
+      image: import_zod14.z.string().optional().describe("Container image to use"),
       /**
        * Container runtime
        */
-      runtime: import_zod12.z.enum(["docker", "podman", "containerd"]).default("docker"),
+      runtime: import_zod14.z.enum(["docker", "podman", "containerd"]).default("docker"),
       /**
        * Resource limits
        */
-      resources: import_zod12.z.object({
-        cpuLimit: import_zod12.z.string().optional().describe('CPU limit (e.g., "0.5", "2")'),
-        memoryLimit: import_zod12.z.string().optional().describe('Memory limit (e.g., "512m", "1g")')
+      resources: import_zod14.z.object({
+        cpuLimit: import_zod14.z.string().optional().describe('CPU limit (e.g., "0.5", "2")'),
+        memoryLimit: import_zod14.z.string().optional().describe('Memory limit (e.g., "512m", "1g")')
       }).optional(),
       /**
        * Network mode
        */
-      networkMode: import_zod12.z.enum(["none", "bridge", "host"]).default("bridge")
+      networkMode: import_zod14.z.enum(["none", "bridge", "host"]).default("bridge")
     }).optional(),
     /**
      * V8 Isolate-specific settings (when engine is "v8-isolate")
      */
-    v8Isolate: import_zod12.z.object({
+    v8Isolate: import_zod14.z.object({
       /**
        * Heap size limit in MB
        */
-      heapSizeMb: import_zod12.z.number().int().min(1).optional(),
+      heapSizeMb: import_zod14.z.number().int().min(1).optional(),
       /**
        * Enable snapshot
        */
-      enableSnapshot: import_zod12.z.boolean().default(true)
+      enableSnapshot: import_zod14.z.boolean().default(true)
     }).optional()
   }).optional(),
   /**
    * General resource limits (applies to all engines)
    */
-  resourceLimits: import_zod12.z.object({
+  resourceLimits: import_zod14.z.object({
     /**
      * Maximum memory in bytes
      */
-    maxMemory: import_zod12.z.number().int().optional().describe("Maximum memory allocation"),
+    maxMemory: import_zod14.z.number().int().optional().describe("Maximum memory allocation"),
     /**
      * Maximum CPU percentage
      */
-    maxCpu: import_zod12.z.number().min(0).max(100).optional().describe("Maximum CPU usage percentage"),
+    maxCpu: import_zod14.z.number().min(0).max(100).optional().describe("Maximum CPU usage percentage"),
     /**
      * Execution timeout in milliseconds
      */
-    timeout: import_zod12.z.number().int().min(0).optional().describe("Maximum execution time")
+    timeout: import_zod14.z.number().int().min(0).optional().describe("Maximum execution time")
   }).optional()
 });
-var SandboxConfigSchema = import_zod12.z.object({
+var SandboxConfigSchema = import_zod14.z.object({
   /**
    * Enable sandboxing
    */
-  enabled: import_zod12.z.boolean().default(true),
+  enabled: import_zod14.z.boolean().default(true),
   /**
    * Sandboxing level
    */
-  level: import_zod12.z.enum([
+  level: import_zod14.z.enum([
     "none",
     // No sandboxing
     "minimal",
@@ -2883,239 +3069,239 @@ var SandboxConfigSchema = import_zod12.z.object({
   /**
    * File system access
    */
-  filesystem: import_zod12.z.object({
-    mode: import_zod12.z.enum(["none", "readonly", "restricted", "full"]).default("restricted"),
-    allowedPaths: import_zod12.z.array(import_zod12.z.string()).optional().describe("Whitelisted paths"),
-    deniedPaths: import_zod12.z.array(import_zod12.z.string()).optional().describe("Blacklisted paths"),
-    maxFileSize: import_zod12.z.number().int().optional().describe("Maximum file size in bytes")
+  filesystem: import_zod14.z.object({
+    mode: import_zod14.z.enum(["none", "readonly", "restricted", "full"]).default("restricted"),
+    allowedPaths: import_zod14.z.array(import_zod14.z.string()).optional().describe("Whitelisted paths"),
+    deniedPaths: import_zod14.z.array(import_zod14.z.string()).optional().describe("Blacklisted paths"),
+    maxFileSize: import_zod14.z.number().int().optional().describe("Maximum file size in bytes")
   }).optional(),
   /**
    * Network access
    */
-  network: import_zod12.z.object({
-    mode: import_zod12.z.enum(["none", "local", "restricted", "full"]).default("restricted"),
-    allowedHosts: import_zod12.z.array(import_zod12.z.string()).optional().describe("Whitelisted hosts"),
-    deniedHosts: import_zod12.z.array(import_zod12.z.string()).optional().describe("Blacklisted hosts"),
-    allowedPorts: import_zod12.z.array(import_zod12.z.number()).optional().describe("Allowed port numbers"),
-    maxConnections: import_zod12.z.number().int().optional()
+  network: import_zod14.z.object({
+    mode: import_zod14.z.enum(["none", "local", "restricted", "full"]).default("restricted"),
+    allowedHosts: import_zod14.z.array(import_zod14.z.string()).optional().describe("Whitelisted hosts"),
+    deniedHosts: import_zod14.z.array(import_zod14.z.string()).optional().describe("Blacklisted hosts"),
+    allowedPorts: import_zod14.z.array(import_zod14.z.number()).optional().describe("Allowed port numbers"),
+    maxConnections: import_zod14.z.number().int().optional()
   }).optional(),
   /**
    * Process execution
    */
-  process: import_zod12.z.object({
-    allowSpawn: import_zod12.z.boolean().default(false).describe("Allow spawning child processes"),
-    allowedCommands: import_zod12.z.array(import_zod12.z.string()).optional().describe("Whitelisted commands"),
-    timeout: import_zod12.z.number().int().optional().describe("Process timeout in ms")
+  process: import_zod14.z.object({
+    allowSpawn: import_zod14.z.boolean().default(false).describe("Allow spawning child processes"),
+    allowedCommands: import_zod14.z.array(import_zod14.z.string()).optional().describe("Whitelisted commands"),
+    timeout: import_zod14.z.number().int().optional().describe("Process timeout in ms")
   }).optional(),
   /**
    * Memory limits
    */
-  memory: import_zod12.z.object({
-    maxHeap: import_zod12.z.number().int().optional().describe("Maximum heap size in bytes"),
-    maxStack: import_zod12.z.number().int().optional().describe("Maximum stack size in bytes")
+  memory: import_zod14.z.object({
+    maxHeap: import_zod14.z.number().int().optional().describe("Maximum heap size in bytes"),
+    maxStack: import_zod14.z.number().int().optional().describe("Maximum stack size in bytes")
   }).optional(),
   /**
    * CPU limits
    */
-  cpu: import_zod12.z.object({
-    maxCpuPercent: import_zod12.z.number().min(0).max(100).optional(),
-    maxThreads: import_zod12.z.number().int().optional()
+  cpu: import_zod14.z.object({
+    maxCpuPercent: import_zod14.z.number().min(0).max(100).optional(),
+    maxThreads: import_zod14.z.number().int().optional()
   }).optional(),
   /**
    * Environment variables
    */
-  environment: import_zod12.z.object({
-    mode: import_zod12.z.enum(["none", "readonly", "restricted", "full"]).default("readonly"),
-    allowedVars: import_zod12.z.array(import_zod12.z.string()).optional(),
-    deniedVars: import_zod12.z.array(import_zod12.z.string()).optional()
+  environment: import_zod14.z.object({
+    mode: import_zod14.z.enum(["none", "readonly", "restricted", "full"]).default("readonly"),
+    allowedVars: import_zod14.z.array(import_zod14.z.string()).optional(),
+    deniedVars: import_zod14.z.array(import_zod14.z.string()).optional()
   }).optional()
 });
-var SecurityVulnerabilitySchema = import_zod12.z.object({
+var SecurityVulnerabilitySchema = import_zod14.z.object({
   /**
    * CVE identifier
    */
-  cve: import_zod12.z.string().optional(),
+  cve: import_zod14.z.string().optional(),
   /**
    * Vulnerability identifier
    */
-  id: import_zod12.z.string(),
+  id: import_zod14.z.string(),
   /**
    * Severity level
    */
-  severity: import_zod12.z.enum(["critical", "high", "medium", "low", "info"]),
+  severity: import_zod14.z.enum(["critical", "high", "medium", "low", "info"]),
   /**
    * Category (e.g., SAST, DAST, Dependency)
    */
-  category: import_zod12.z.string().optional(),
+  category: import_zod14.z.string().optional(),
   /**
    * Title
    */
-  title: import_zod12.z.string(),
+  title: import_zod14.z.string(),
   /**
    * Location of the vulnerability
    */
-  location: import_zod12.z.string().optional(),
+  location: import_zod14.z.string().optional(),
   /**
    * Remediation steps
    */
-  remediation: import_zod12.z.string().optional(),
+  remediation: import_zod14.z.string().optional(),
   /**
    * Description
    */
-  description: import_zod12.z.string(),
+  description: import_zod14.z.string(),
   /**
    * Affected versions
    */
-  affectedVersions: import_zod12.z.array(import_zod12.z.string()),
+  affectedVersions: import_zod14.z.array(import_zod14.z.string()),
   /**
    * Fixed in versions
    */
-  fixedIn: import_zod12.z.array(import_zod12.z.string()).optional(),
+  fixedIn: import_zod14.z.array(import_zod14.z.string()).optional(),
   /**
    * CVSS score
    */
-  cvssScore: import_zod12.z.number().min(0).max(10).optional(),
+  cvssScore: import_zod14.z.number().min(0).max(10).optional(),
   /**
    * Exploit availability
    */
-  exploitAvailable: import_zod12.z.boolean().default(false),
+  exploitAvailable: import_zod14.z.boolean().default(false),
   /**
    * Patch available
    */
-  patchAvailable: import_zod12.z.boolean().default(false),
+  patchAvailable: import_zod14.z.boolean().default(false),
   /**
    * Workaround
    */
-  workaround: import_zod12.z.string().optional(),
+  workaround: import_zod14.z.string().optional(),
   /**
    * References
    */
-  references: import_zod12.z.array(import_zod12.z.string()).optional(),
+  references: import_zod14.z.array(import_zod14.z.string()).optional(),
   /**
    * Discovered date
    */
-  discoveredDate: import_zod12.z.string().datetime().optional(),
+  discoveredDate: import_zod14.z.string().datetime().optional(),
   /**
    * Published date
    */
-  publishedDate: import_zod12.z.string().datetime().optional()
+  publishedDate: import_zod14.z.string().datetime().optional()
 });
-var SecurityScanResultSchema = import_zod12.z.object({
+var SecurityScanResultSchema = import_zod14.z.object({
   /**
    * Scan timestamp
    */
-  timestamp: import_zod12.z.string().datetime(),
+  timestamp: import_zod14.z.string().datetime(),
   /**
    * Scanner information
    */
-  scanner: import_zod12.z.object({
-    name: import_zod12.z.string(),
-    version: import_zod12.z.string()
+  scanner: import_zod14.z.object({
+    name: import_zod14.z.string(),
+    version: import_zod14.z.string()
   }),
   /**
    * Overall status
    */
-  status: import_zod12.z.enum(["passed", "failed", "warning"]),
+  status: import_zod14.z.enum(["passed", "failed", "warning"]),
   /**
    * Vulnerabilities found
    */
-  vulnerabilities: import_zod12.z.array(SecurityVulnerabilitySchema).optional(),
+  vulnerabilities: import_zod14.z.array(SecurityVulnerabilitySchema).optional(),
   /**
    * Code quality issues
    */
-  codeIssues: import_zod12.z.array(import_zod12.z.object({
-    severity: import_zod12.z.enum(["error", "warning", "info"]),
-    type: import_zod12.z.string().describe("Issue type (e.g., sql-injection, xss)"),
-    file: import_zod12.z.string(),
-    line: import_zod12.z.number().int().optional(),
-    message: import_zod12.z.string(),
-    suggestion: import_zod12.z.string().optional()
+  codeIssues: import_zod14.z.array(import_zod14.z.object({
+    severity: import_zod14.z.enum(["error", "warning", "info"]),
+    type: import_zod14.z.string().describe("Issue type (e.g., sql-injection, xss)"),
+    file: import_zod14.z.string(),
+    line: import_zod14.z.number().int().optional(),
+    message: import_zod14.z.string(),
+    suggestion: import_zod14.z.string().optional()
   })).optional(),
   /**
    * Dependency vulnerabilities
    */
-  dependencyVulnerabilities: import_zod12.z.array(import_zod12.z.object({
-    package: import_zod12.z.string(),
-    version: import_zod12.z.string(),
+  dependencyVulnerabilities: import_zod14.z.array(import_zod14.z.object({
+    package: import_zod14.z.string(),
+    version: import_zod14.z.string(),
     vulnerability: SecurityVulnerabilitySchema
   })).optional(),
   /**
    * License compliance
    */
-  licenseCompliance: import_zod12.z.object({
-    status: import_zod12.z.enum(["compliant", "non-compliant", "unknown"]),
-    issues: import_zod12.z.array(import_zod12.z.object({
-      package: import_zod12.z.string(),
-      license: import_zod12.z.string(),
-      reason: import_zod12.z.string()
+  licenseCompliance: import_zod14.z.object({
+    status: import_zod14.z.enum(["compliant", "non-compliant", "unknown"]),
+    issues: import_zod14.z.array(import_zod14.z.object({
+      package: import_zod14.z.string(),
+      license: import_zod14.z.string(),
+      reason: import_zod14.z.string()
     })).optional()
   }).optional(),
   /**
    * Summary statistics
    */
-  summary: import_zod12.z.object({
-    totalVulnerabilities: import_zod12.z.number().int(),
-    criticalCount: import_zod12.z.number().int(),
-    highCount: import_zod12.z.number().int(),
-    mediumCount: import_zod12.z.number().int(),
-    lowCount: import_zod12.z.number().int(),
-    infoCount: import_zod12.z.number().int()
+  summary: import_zod14.z.object({
+    totalVulnerabilities: import_zod14.z.number().int(),
+    criticalCount: import_zod14.z.number().int(),
+    highCount: import_zod14.z.number().int(),
+    mediumCount: import_zod14.z.number().int(),
+    lowCount: import_zod14.z.number().int(),
+    infoCount: import_zod14.z.number().int()
   })
 });
-var SecurityPolicySchema = import_zod12.z.object({
+var SecurityPolicySchema = import_zod14.z.object({
   /**
    * Content Security Policy
    */
-  csp: import_zod12.z.object({
-    directives: import_zod12.z.record(import_zod12.z.string(), import_zod12.z.array(import_zod12.z.string())).optional(),
-    reportOnly: import_zod12.z.boolean().default(false)
+  csp: import_zod14.z.object({
+    directives: import_zod14.z.record(import_zod14.z.string(), import_zod14.z.array(import_zod14.z.string())).optional(),
+    reportOnly: import_zod14.z.boolean().default(false)
   }).optional(),
   /**
    * CORS policy
    */
-  cors: import_zod12.z.object({
-    allowedOrigins: import_zod12.z.array(import_zod12.z.string()),
-    allowedMethods: import_zod12.z.array(import_zod12.z.string()),
-    allowedHeaders: import_zod12.z.array(import_zod12.z.string()),
-    allowCredentials: import_zod12.z.boolean().default(false),
-    maxAge: import_zod12.z.number().int().optional()
+  cors: import_zod14.z.object({
+    allowedOrigins: import_zod14.z.array(import_zod14.z.string()),
+    allowedMethods: import_zod14.z.array(import_zod14.z.string()),
+    allowedHeaders: import_zod14.z.array(import_zod14.z.string()),
+    allowCredentials: import_zod14.z.boolean().default(false),
+    maxAge: import_zod14.z.number().int().optional()
   }).optional(),
   /**
    * Rate limiting
    */
-  rateLimit: import_zod12.z.object({
-    enabled: import_zod12.z.boolean().default(true),
-    maxRequests: import_zod12.z.number().int(),
-    windowMs: import_zod12.z.number().int().describe("Time window in milliseconds"),
-    strategy: import_zod12.z.enum(["fixed", "sliding", "token-bucket"]).default("sliding")
+  rateLimit: import_zod14.z.object({
+    enabled: import_zod14.z.boolean().default(true),
+    maxRequests: import_zod14.z.number().int(),
+    windowMs: import_zod14.z.number().int().describe("Time window in milliseconds"),
+    strategy: import_zod14.z.enum(["fixed", "sliding", "token-bucket"]).default("sliding")
   }).optional(),
   /**
    * Authentication requirements
    */
-  authentication: import_zod12.z.object({
-    required: import_zod12.z.boolean().default(true),
-    methods: import_zod12.z.array(import_zod12.z.enum(["jwt", "oauth2", "api-key", "session", "certificate"])),
-    tokenExpiration: import_zod12.z.number().int().optional().describe("Token expiration in seconds")
+  authentication: import_zod14.z.object({
+    required: import_zod14.z.boolean().default(true),
+    methods: import_zod14.z.array(import_zod14.z.enum(["jwt", "oauth2", "api-key", "session", "certificate"])),
+    tokenExpiration: import_zod14.z.number().int().optional().describe("Token expiration in seconds")
   }).optional(),
   /**
    * Encryption requirements
    */
-  encryption: import_zod12.z.object({
-    dataAtRest: import_zod12.z.boolean().default(false).describe("Encrypt data at rest"),
-    dataInTransit: import_zod12.z.boolean().default(true).describe("Enforce HTTPS/TLS"),
-    algorithm: import_zod12.z.string().optional().describe("Encryption algorithm"),
-    minKeyLength: import_zod12.z.number().int().optional().describe("Minimum key length in bits")
+  encryption: import_zod14.z.object({
+    dataAtRest: import_zod14.z.boolean().default(false).describe("Encrypt data at rest"),
+    dataInTransit: import_zod14.z.boolean().default(true).describe("Enforce HTTPS/TLS"),
+    algorithm: import_zod14.z.string().optional().describe("Encryption algorithm"),
+    minKeyLength: import_zod14.z.number().int().optional().describe("Minimum key length in bits")
   }).optional(),
   /**
    * Audit logging
    */
-  auditLog: import_zod12.z.object({
-    enabled: import_zod12.z.boolean().default(true),
-    events: import_zod12.z.array(import_zod12.z.string()).optional().describe("Events to log"),
-    retention: import_zod12.z.number().int().optional().describe("Log retention in days")
+  auditLog: import_zod14.z.object({
+    enabled: import_zod14.z.boolean().default(true),
+    events: import_zod14.z.array(import_zod14.z.string()).optional().describe("Events to log"),
+    retention: import_zod14.z.number().int().optional().describe("Log retention in days")
   }).optional()
 });
-var PluginTrustLevelSchema = import_zod12.z.enum([
+var PluginTrustLevelSchema = import_zod14.z.enum([
   "verified",
   // Official/verified plugin
   "trusted",
@@ -3127,11 +3313,11 @@ var PluginTrustLevelSchema = import_zod12.z.enum([
   "blocked"
   // Blocked/malicious
 ]).describe("Trust level of the plugin");
-var PluginSecurityManifestSchema = import_zod12.z.object({
+var PluginSecurityManifestSchema = import_zod14.z.object({
   /**
    * Plugin identifier
    */
-  pluginId: import_zod12.z.string(),
+  pluginId: import_zod14.z.string(),
   /**
    * Trust level
    */
@@ -3151,54 +3337,54 @@ var PluginSecurityManifestSchema = import_zod12.z.object({
   /**
    * Security scan results
    */
-  scanResults: import_zod12.z.array(SecurityScanResultSchema).optional(),
+  scanResults: import_zod14.z.array(SecurityScanResultSchema).optional(),
   /**
    * Known vulnerabilities
    */
-  vulnerabilities: import_zod12.z.array(SecurityVulnerabilitySchema).optional(),
+  vulnerabilities: import_zod14.z.array(SecurityVulnerabilitySchema).optional(),
   /**
    * Code signing
    */
-  codeSigning: import_zod12.z.object({
-    signed: import_zod12.z.boolean(),
-    signature: import_zod12.z.string().optional(),
-    certificate: import_zod12.z.string().optional(),
-    algorithm: import_zod12.z.string().optional(),
-    timestamp: import_zod12.z.string().datetime().optional()
+  codeSigning: import_zod14.z.object({
+    signed: import_zod14.z.boolean(),
+    signature: import_zod14.z.string().optional(),
+    certificate: import_zod14.z.string().optional(),
+    algorithm: import_zod14.z.string().optional(),
+    timestamp: import_zod14.z.string().datetime().optional()
   }).optional(),
   /**
    * Security certifications
    */
-  certifications: import_zod12.z.array(import_zod12.z.object({
-    name: import_zod12.z.string().describe("Certification name (e.g., SOC 2, ISO 27001)"),
-    issuer: import_zod12.z.string(),
-    issuedDate: import_zod12.z.string().datetime(),
-    expiryDate: import_zod12.z.string().datetime().optional(),
-    certificateUrl: import_zod12.z.string().url().optional()
+  certifications: import_zod14.z.array(import_zod14.z.object({
+    name: import_zod14.z.string().describe("Certification name (e.g., SOC 2, ISO 27001)"),
+    issuer: import_zod14.z.string(),
+    issuedDate: import_zod14.z.string().datetime(),
+    expiryDate: import_zod14.z.string().datetime().optional(),
+    certificateUrl: import_zod14.z.string().url().optional()
   })).optional(),
   /**
    * Security contact
    */
-  securityContact: import_zod12.z.object({
-    email: import_zod12.z.string().email().optional(),
-    url: import_zod12.z.string().url().optional(),
-    pgpKey: import_zod12.z.string().optional()
+  securityContact: import_zod14.z.object({
+    email: import_zod14.z.string().email().optional(),
+    url: import_zod14.z.string().url().optional(),
+    pgpKey: import_zod14.z.string().optional()
   }).optional(),
   /**
    * Vulnerability disclosure policy
    */
-  vulnerabilityDisclosure: import_zod12.z.object({
-    policyUrl: import_zod12.z.string().url().optional(),
-    responseTime: import_zod12.z.number().int().optional().describe("Expected response time in hours"),
-    bugBounty: import_zod12.z.boolean().default(false)
+  vulnerabilityDisclosure: import_zod14.z.object({
+    policyUrl: import_zod14.z.string().url().optional(),
+    responseTime: import_zod14.z.number().int().optional().describe("Expected response time in hours"),
+    bugBounty: import_zod14.z.boolean().default(false)
   }).optional()
 });
 
 // src/kernel/plugin-structure.zod.ts
-var import_zod13 = require("zod");
+var import_zod15 = require("zod");
 var SNAKE_CASE_REGEX = /^[a-z][a-z0-9_]*$/;
 var OPS_FILE_SUFFIX_REGEX = /\.(object|field|trigger|function|view|page|dashboard|flow|app|router|service)\.ts$/;
-var OpsFilePathSchema = import_zod13.z.string().superRefine((path, ctx) => {
+var OpsFilePathSchema = import_zod15.z.string().superRefine((path, ctx) => {
   if (!path.startsWith("src/")) {
     return;
   }
@@ -3207,7 +3393,7 @@ var OpsFilePathSchema = import_zod13.z.string().superRefine((path, ctx) => {
     const domainDir = parts[1];
     if (!SNAKE_CASE_REGEX.test(domainDir)) {
       ctx.addIssue({
-        code: import_zod13.z.ZodIssueCode.custom,
+        code: import_zod15.z.ZodIssueCode.custom,
         message: `Domain directory '${domainDir}' must be lowercase snake_case`
       });
     }
@@ -3216,31 +3402,31 @@ var OpsFilePathSchema = import_zod13.z.string().superRefine((path, ctx) => {
   if (filename === "index.ts" || filename === "main.ts") return;
   if (!SNAKE_CASE_REGEX.test(filename.split(".")[0])) {
     ctx.addIssue({
-      code: import_zod13.z.ZodIssueCode.custom,
+      code: import_zod15.z.ZodIssueCode.custom,
       message: `Filename '${filename}' base name must be lowercase snake_case`
     });
   }
   if (!OPS_FILE_SUFFIX_REGEX.test(filename)) {
   }
 });
-var OpsDomainModuleSchema = import_zod13.z.object({
-  name: import_zod13.z.string().regex(SNAKE_CASE_REGEX),
-  files: import_zod13.z.array(import_zod13.z.string())
+var OpsDomainModuleSchema = import_zod15.z.object({
+  name: import_zod15.z.string().regex(SNAKE_CASE_REGEX),
+  files: import_zod15.z.array(import_zod15.z.string())
 }).superRefine((module2, ctx) => {
   if (!module2.files.includes("index.ts")) {
     ctx.addIssue({
-      code: import_zod13.z.ZodIssueCode.custom,
+      code: import_zod15.z.ZodIssueCode.custom,
       message: `Module '${module2.name}' is missing an 'index.ts' entry point.`
     });
   }
 });
-var OpsPluginStructureSchema = import_zod13.z.object({
-  root: import_zod13.z.string(),
-  files: import_zod13.z.array(import_zod13.z.string()).describe("List of all file paths relative to root")
+var OpsPluginStructureSchema = import_zod15.z.object({
+  root: import_zod15.z.string(),
+  files: import_zod15.z.array(import_zod15.z.string()).describe("List of all file paths relative to root")
 }).superRefine((project, ctx) => {
   if (!project.files.includes("objectstack.config.ts")) {
     ctx.addIssue({
-      code: import_zod13.z.ZodIssueCode.custom,
+      code: import_zod15.z.ZodIssueCode.custom,
       message: "Missing 'objectstack.config.ts' configuration file."
     });
   }
@@ -3255,93 +3441,93 @@ var OpsPluginStructureSchema = import_zod13.z.object({
 });
 
 // src/kernel/plugin-validator.zod.ts
-var import_zod14 = require("zod");
-var ValidationErrorSchema = import_zod14.z.object({
+var import_zod16 = require("zod");
+var ValidationErrorSchema = import_zod16.z.object({
   /**
    * Field that failed validation
    */
-  field: import_zod14.z.string().describe("Field name that failed validation"),
+  field: import_zod16.z.string().describe("Field name that failed validation"),
   /**
    * Human-readable error message
    */
-  message: import_zod14.z.string().describe("Human-readable error message"),
+  message: import_zod16.z.string().describe("Human-readable error message"),
   /**
    * Machine-readable error code (optional)
    */
-  code: import_zod14.z.string().optional().describe("Machine-readable error code")
+  code: import_zod16.z.string().optional().describe("Machine-readable error code")
 });
-var ValidationWarningSchema = import_zod14.z.object({
+var ValidationWarningSchema = import_zod16.z.object({
   /**
    * Field with warning
    */
-  field: import_zod14.z.string().describe("Field name with warning"),
+  field: import_zod16.z.string().describe("Field name with warning"),
   /**
    * Human-readable warning message
    */
-  message: import_zod14.z.string().describe("Human-readable warning message"),
+  message: import_zod16.z.string().describe("Human-readable warning message"),
   /**
    * Machine-readable warning code (optional)
    */
-  code: import_zod14.z.string().optional().describe("Machine-readable warning code")
+  code: import_zod16.z.string().optional().describe("Machine-readable warning code")
 });
-var ValidationResultSchema = import_zod14.z.object({
+var ValidationResultSchema = import_zod16.z.object({
   /**
    * Whether validation passed
    */
-  valid: import_zod14.z.boolean().describe("Whether the plugin passed validation"),
+  valid: import_zod16.z.boolean().describe("Whether the plugin passed validation"),
   /**
    * Validation errors (if any)
    */
-  errors: import_zod14.z.array(ValidationErrorSchema).optional().describe("Validation errors"),
+  errors: import_zod16.z.array(ValidationErrorSchema).optional().describe("Validation errors"),
   /**
    * Validation warnings (non-fatal issues)
    */
-  warnings: import_zod14.z.array(ValidationWarningSchema).optional().describe("Validation warnings")
+  warnings: import_zod16.z.array(ValidationWarningSchema).optional().describe("Validation warnings")
 });
-var PluginMetadataSchema = import_zod14.z.object({
+var PluginMetadataSchema = import_zod16.z.object({
   /**
    * Unique plugin identifier (snake_case)
    */
-  name: import_zod14.z.string().min(1).describe("Unique plugin identifier"),
+  name: import_zod16.z.string().min(1).describe("Unique plugin identifier"),
   /**
    * Plugin version (semver)
    */
-  version: import_zod14.z.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Semantic version (e.g., 1.0.0)"),
+  version: import_zod16.z.string().regex(/^\d+\.\d+\.\d+$/).optional().describe("Semantic version (e.g., 1.0.0)"),
   /**
    * Plugin dependencies (array of plugin names)
    */
-  dependencies: import_zod14.z.array(import_zod14.z.string()).optional().describe("Array of plugin names this plugin depends on"),
+  dependencies: import_zod16.z.array(import_zod16.z.string()).optional().describe("Array of plugin names this plugin depends on"),
   /**
    * Plugin signature for cryptographic verification (optional)
    */
-  signature: import_zod14.z.string().optional().describe("Cryptographic signature for plugin verification")
+  signature: import_zod16.z.string().optional().describe("Cryptographic signature for plugin verification")
   /**
    * Additional plugin metadata
    */
 }).passthrough().describe("Plugin metadata for validation");
 
 // src/kernel/plugin-versioning.zod.ts
-var import_zod15 = require("zod");
-var SemanticVersionSchema = import_zod15.z.object({
-  major: import_zod15.z.number().int().min(0).describe("Major version (breaking changes)"),
-  minor: import_zod15.z.number().int().min(0).describe("Minor version (backward compatible features)"),
-  patch: import_zod15.z.number().int().min(0).describe("Patch version (backward compatible fixes)"),
-  preRelease: import_zod15.z.string().optional().describe("Pre-release identifier (alpha, beta, rc.1)"),
-  build: import_zod15.z.string().optional().describe("Build metadata")
+var import_zod17 = require("zod");
+var SemanticVersionSchema = import_zod17.z.object({
+  major: import_zod17.z.number().int().min(0).describe("Major version (breaking changes)"),
+  minor: import_zod17.z.number().int().min(0).describe("Minor version (backward compatible features)"),
+  patch: import_zod17.z.number().int().min(0).describe("Patch version (backward compatible fixes)"),
+  preRelease: import_zod17.z.string().optional().describe("Pre-release identifier (alpha, beta, rc.1)"),
+  build: import_zod17.z.string().optional().describe("Build metadata")
 }).describe("Semantic version number");
-var VersionConstraintSchema = import_zod15.z.union([
-  import_zod15.z.string().regex(/^[\d.]+$/).describe("Exact version: `1.2.3`"),
-  import_zod15.z.string().regex(/^\^[\d.]+$/).describe("Compatible with: `^1.2.3` (`>=1.2.3 <2.0.0`)"),
-  import_zod15.z.string().regex(/^~[\d.]+$/).describe("Approximately: `~1.2.3` (`>=1.2.3 <1.3.0`)"),
-  import_zod15.z.string().regex(/^>=[\d.]+$/).describe("Greater than or equal: `>=1.2.3`"),
-  import_zod15.z.string().regex(/^>[\d.]+$/).describe("Greater than: `>1.2.3`"),
-  import_zod15.z.string().regex(/^<=[\d.]+$/).describe("Less than or equal: `<=1.2.3`"),
-  import_zod15.z.string().regex(/^<[\d.]+$/).describe("Less than: `<1.2.3`"),
-  import_zod15.z.string().regex(/^[\d.]+ - [\d.]+$/).describe("Range: `1.2.3 - 2.3.4`"),
-  import_zod15.z.literal("*").describe("Any version"),
-  import_zod15.z.literal("latest").describe("Latest stable version")
+var VersionConstraintSchema = import_zod17.z.union([
+  import_zod17.z.string().regex(/^[\d.]+$/).describe("Exact version: `1.2.3`"),
+  import_zod17.z.string().regex(/^\^[\d.]+$/).describe("Compatible with: `^1.2.3` (`>=1.2.3 <2.0.0`)"),
+  import_zod17.z.string().regex(/^~[\d.]+$/).describe("Approximately: `~1.2.3` (`>=1.2.3 <1.3.0`)"),
+  import_zod17.z.string().regex(/^>=[\d.]+$/).describe("Greater than or equal: `>=1.2.3`"),
+  import_zod17.z.string().regex(/^>[\d.]+$/).describe("Greater than: `>1.2.3`"),
+  import_zod17.z.string().regex(/^<=[\d.]+$/).describe("Less than or equal: `<=1.2.3`"),
+  import_zod17.z.string().regex(/^<[\d.]+$/).describe("Less than: `<1.2.3`"),
+  import_zod17.z.string().regex(/^[\d.]+ - [\d.]+$/).describe("Range: `1.2.3 - 2.3.4`"),
+  import_zod17.z.literal("*").describe("Any version"),
+  import_zod17.z.literal("latest").describe("Latest stable version")
 ]);
-var CompatibilityLevelSchema = import_zod15.z.enum([
+var CompatibilityLevelSchema = import_zod17.z.enum([
   "fully-compatible",
   // 100% compatible, drop-in replacement
   "backward-compatible",
@@ -3353,15 +3539,15 @@ var CompatibilityLevelSchema = import_zod15.z.enum([
   "incompatible"
   // Completely incompatible
 ]).describe("Compatibility level between versions");
-var BreakingChangeSchema = import_zod15.z.object({
+var BreakingChangeSchema = import_zod17.z.object({
   /**
    * Version where the change was introduced
    */
-  introducedIn: import_zod15.z.string().describe("Version that introduced this breaking change"),
+  introducedIn: import_zod17.z.string().describe("Version that introduced this breaking change"),
   /**
    * Type of breaking change
    */
-  type: import_zod15.z.enum([
+  type: import_zod17.z.enum([
     "api-removed",
     // API removed
     "api-renamed",
@@ -3380,63 +3566,63 @@ var BreakingChangeSchema = import_zod15.z.object({
   /**
    * What was changed
    */
-  description: import_zod15.z.string(),
+  description: import_zod17.z.string(),
   /**
    * Migration guide
    */
-  migrationGuide: import_zod15.z.string().optional().describe("How to migrate from old to new"),
+  migrationGuide: import_zod17.z.string().optional().describe("How to migrate from old to new"),
   /**
    * Deprecated in version
    */
-  deprecatedIn: import_zod15.z.string().optional().describe("Version where old API was deprecated"),
+  deprecatedIn: import_zod17.z.string().optional().describe("Version where old API was deprecated"),
   /**
    * Will be removed in version
    */
-  removedIn: import_zod15.z.string().optional().describe("Version where old API will be removed"),
+  removedIn: import_zod17.z.string().optional().describe("Version where old API will be removed"),
   /**
    * Automated migration available
    */
-  automatedMigration: import_zod15.z.boolean().default(false).describe("Whether automated migration tool is available"),
+  automatedMigration: import_zod17.z.boolean().default(false).describe("Whether automated migration tool is available"),
   /**
    * Impact severity
    */
-  severity: import_zod15.z.enum(["critical", "major", "minor"]).describe("Impact severity")
+  severity: import_zod17.z.enum(["critical", "major", "minor"]).describe("Impact severity")
 });
-var DeprecationNoticeSchema = import_zod15.z.object({
+var DeprecationNoticeSchema = import_zod17.z.object({
   /**
    * Feature or API being deprecated
    */
-  feature: import_zod15.z.string().describe("Deprecated feature identifier"),
+  feature: import_zod17.z.string().describe("Deprecated feature identifier"),
   /**
    * Version when deprecated
    */
-  deprecatedIn: import_zod15.z.string(),
+  deprecatedIn: import_zod17.z.string(),
   /**
    * Planned removal version
    */
-  removeIn: import_zod15.z.string().optional(),
+  removeIn: import_zod17.z.string().optional(),
   /**
    * Reason for deprecation
    */
-  reason: import_zod15.z.string(),
+  reason: import_zod17.z.string(),
   /**
    * Recommended alternative
    */
-  alternative: import_zod15.z.string().optional().describe("What to use instead"),
+  alternative: import_zod17.z.string().optional().describe("What to use instead"),
   /**
    * Migration path
    */
-  migrationPath: import_zod15.z.string().optional().describe("How to migrate to alternative")
+  migrationPath: import_zod17.z.string().optional().describe("How to migrate to alternative")
 });
-var CompatibilityMatrixEntrySchema = import_zod15.z.object({
+var CompatibilityMatrixEntrySchema = import_zod17.z.object({
   /**
    * Source version
    */
-  from: import_zod15.z.string().describe("Version being upgraded from"),
+  from: import_zod17.z.string().describe("Version being upgraded from"),
   /**
    * Target version
    */
-  to: import_zod15.z.string().describe("Version being upgraded to"),
+  to: import_zod17.z.string().describe("Version being upgraded to"),
   /**
    * Compatibility level
    */
@@ -3444,60 +3630,60 @@ var CompatibilityMatrixEntrySchema = import_zod15.z.object({
   /**
    * Breaking changes list
    */
-  breakingChanges: import_zod15.z.array(BreakingChangeSchema).optional(),
+  breakingChanges: import_zod17.z.array(BreakingChangeSchema).optional(),
   /**
    * Migration required
    */
-  migrationRequired: import_zod15.z.boolean().default(false),
+  migrationRequired: import_zod17.z.boolean().default(false),
   /**
    * Migration complexity
    */
-  migrationComplexity: import_zod15.z.enum(["trivial", "simple", "moderate", "complex", "major"]).optional(),
+  migrationComplexity: import_zod17.z.enum(["trivial", "simple", "moderate", "complex", "major"]).optional(),
   /**
    * Estimated migration time in hours
    */
-  estimatedMigrationTime: import_zod15.z.number().optional(),
+  estimatedMigrationTime: import_zod17.z.number().optional(),
   /**
    * Migration script available
    */
-  migrationScript: import_zod15.z.string().optional().describe("Path to migration script"),
+  migrationScript: import_zod17.z.string().optional().describe("Path to migration script"),
   /**
    * Test coverage for migration
    */
-  testCoverage: import_zod15.z.number().min(0).max(100).optional().describe("Percentage of migration covered by tests")
+  testCoverage: import_zod17.z.number().min(0).max(100).optional().describe("Percentage of migration covered by tests")
 });
-var PluginCompatibilityMatrixSchema = import_zod15.z.object({
+var PluginCompatibilityMatrixSchema = import_zod17.z.object({
   /**
    * Plugin identifier
    */
-  pluginId: import_zod15.z.string(),
+  pluginId: import_zod17.z.string(),
   /**
    * Current version
    */
-  currentVersion: import_zod15.z.string(),
+  currentVersion: import_zod17.z.string(),
   /**
    * Compatibility entries
    */
-  compatibilityMatrix: import_zod15.z.array(CompatibilityMatrixEntrySchema),
+  compatibilityMatrix: import_zod17.z.array(CompatibilityMatrixEntrySchema),
   /**
    * Supported versions
    */
-  supportedVersions: import_zod15.z.array(import_zod15.z.object({
-    version: import_zod15.z.string(),
-    supported: import_zod15.z.boolean(),
-    endOfLife: import_zod15.z.string().datetime().optional().describe("End of support date"),
-    securitySupport: import_zod15.z.boolean().default(false).describe("Still receives security updates")
+  supportedVersions: import_zod17.z.array(import_zod17.z.object({
+    version: import_zod17.z.string(),
+    supported: import_zod17.z.boolean(),
+    endOfLife: import_zod17.z.string().datetime().optional().describe("End of support date"),
+    securitySupport: import_zod17.z.boolean().default(false).describe("Still receives security updates")
   })),
   /**
    * Minimum compatible version
    */
-  minimumCompatibleVersion: import_zod15.z.string().optional().describe("Oldest version that can be directly upgraded")
+  minimumCompatibleVersion: import_zod17.z.string().optional().describe("Oldest version that can be directly upgraded")
 });
-var DependencyConflictSchema = import_zod15.z.object({
+var DependencyConflictSchema = import_zod17.z.object({
   /**
    * Type of conflict
    */
-  type: import_zod15.z.enum([
+  type: import_zod17.z.enum([
     "version-mismatch",
     // Different versions required
     "missing-dependency",
@@ -3512,20 +3698,20 @@ var DependencyConflictSchema = import_zod15.z.object({
   /**
    * Plugins involved in conflict
    */
-  plugins: import_zod15.z.array(import_zod15.z.object({
-    pluginId: import_zod15.z.string(),
-    version: import_zod15.z.string(),
-    requirement: import_zod15.z.string().optional().describe("What this plugin requires")
+  plugins: import_zod17.z.array(import_zod17.z.object({
+    pluginId: import_zod17.z.string(),
+    version: import_zod17.z.string(),
+    requirement: import_zod17.z.string().optional().describe("What this plugin requires")
   })),
   /**
    * Conflict description
    */
-  description: import_zod15.z.string(),
+  description: import_zod17.z.string(),
   /**
    * Possible resolutions
    */
-  resolutions: import_zod15.z.array(import_zod15.z.object({
-    strategy: import_zod15.z.enum([
+  resolutions: import_zod17.z.array(import_zod17.z.object({
+    strategy: import_zod17.z.enum([
       "upgrade",
       // Upgrade one or more plugins
       "downgrade",
@@ -3537,58 +3723,58 @@ var DependencyConflictSchema = import_zod15.z.object({
       "manual"
       // Manual intervention required
     ]),
-    description: import_zod15.z.string(),
-    automaticResolution: import_zod15.z.boolean().default(false),
-    riskLevel: import_zod15.z.enum(["low", "medium", "high"])
+    description: import_zod17.z.string(),
+    automaticResolution: import_zod17.z.boolean().default(false),
+    riskLevel: import_zod17.z.enum(["low", "medium", "high"])
   })).optional(),
   /**
    * Severity of conflict
    */
-  severity: import_zod15.z.enum(["critical", "error", "warning", "info"])
+  severity: import_zod17.z.enum(["critical", "error", "warning", "info"])
 });
-var DependencyResolutionResultSchema = import_zod15.z.object({
+var DependencyResolutionResultSchema = import_zod17.z.object({
   /**
    * Resolution successful
    */
-  success: import_zod15.z.boolean(),
+  success: import_zod17.z.boolean(),
   /**
    * Resolved plugin versions
    */
-  resolved: import_zod15.z.array(import_zod15.z.object({
-    pluginId: import_zod15.z.string(),
-    version: import_zod15.z.string(),
-    resolvedVersion: import_zod15.z.string()
+  resolved: import_zod17.z.array(import_zod17.z.object({
+    pluginId: import_zod17.z.string(),
+    version: import_zod17.z.string(),
+    resolvedVersion: import_zod17.z.string()
   })).optional(),
   /**
    * Conflicts found
    */
-  conflicts: import_zod15.z.array(DependencyConflictSchema).optional(),
+  conflicts: import_zod17.z.array(DependencyConflictSchema).optional(),
   /**
    * Warnings
    */
-  warnings: import_zod15.z.array(import_zod15.z.string()).optional(),
+  warnings: import_zod17.z.array(import_zod17.z.string()).optional(),
   /**
    * Installation order (topologically sorted)
    */
-  installationOrder: import_zod15.z.array(import_zod15.z.string()).optional().describe("Plugin IDs in order they should be installed"),
+  installationOrder: import_zod17.z.array(import_zod17.z.string()).optional().describe("Plugin IDs in order they should be installed"),
   /**
    * Dependency graph
    */
-  dependencyGraph: import_zod15.z.record(import_zod15.z.string(), import_zod15.z.array(import_zod15.z.string())).optional().describe("Map of plugin ID to its dependencies")
+  dependencyGraph: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.array(import_zod17.z.string())).optional().describe("Map of plugin ID to its dependencies")
 });
-var MultiVersionSupportSchema = import_zod15.z.object({
+var MultiVersionSupportSchema = import_zod17.z.object({
   /**
    * Enable multi-version support
    */
-  enabled: import_zod15.z.boolean().default(false),
+  enabled: import_zod17.z.boolean().default(false),
   /**
    * Maximum concurrent versions
    */
-  maxConcurrentVersions: import_zod15.z.number().int().min(1).default(2).describe("How many versions can run at the same time"),
+  maxConcurrentVersions: import_zod17.z.number().int().min(1).default(2).describe("How many versions can run at the same time"),
   /**
    * Version selection strategy
    */
-  selectionStrategy: import_zod15.z.enum([
+  selectionStrategy: import_zod17.z.enum([
     "latest",
     // Always use latest version
     "stable",
@@ -3605,26 +3791,26 @@ var MultiVersionSupportSchema = import_zod15.z.object({
   /**
    * Version routing rules
    */
-  routing: import_zod15.z.array(import_zod15.z.object({
-    condition: import_zod15.z.string().describe("Routing condition (e.g., tenant, user, feature flag)"),
-    version: import_zod15.z.string().describe("Version to use when condition matches"),
-    priority: import_zod15.z.number().int().default(100).describe("Rule priority")
+  routing: import_zod17.z.array(import_zod17.z.object({
+    condition: import_zod17.z.string().describe("Routing condition (e.g., tenant, user, feature flag)"),
+    version: import_zod17.z.string().describe("Version to use when condition matches"),
+    priority: import_zod17.z.number().int().default(100).describe("Rule priority")
   })).optional(),
   /**
    * Gradual rollout configuration
    */
-  rollout: import_zod15.z.object({
-    enabled: import_zod15.z.boolean().default(false),
-    strategy: import_zod15.z.enum(["percentage", "blue-green", "canary"]),
-    percentage: import_zod15.z.number().min(0).max(100).optional().describe("Percentage of traffic to new version"),
-    duration: import_zod15.z.number().int().optional().describe("Rollout duration in milliseconds")
+  rollout: import_zod17.z.object({
+    enabled: import_zod17.z.boolean().default(false),
+    strategy: import_zod17.z.enum(["percentage", "blue-green", "canary"]),
+    percentage: import_zod17.z.number().min(0).max(100).optional().describe("Percentage of traffic to new version"),
+    duration: import_zod17.z.number().int().optional().describe("Rollout duration in milliseconds")
   }).optional()
 });
-var PluginVersionMetadataSchema = import_zod15.z.object({
+var PluginVersionMetadataSchema = import_zod17.z.object({
   /**
    * Plugin identifier
    */
-  pluginId: import_zod15.z.string(),
+  pluginId: import_zod17.z.string(),
   /**
    * Version number
    */
@@ -3632,57 +3818,57 @@ var PluginVersionMetadataSchema = import_zod15.z.object({
   /**
    * Version string (computed)
    */
-  versionString: import_zod15.z.string().describe("Full version string (e.g., 1.2.3-beta.1+build.123)"),
+  versionString: import_zod17.z.string().describe("Full version string (e.g., 1.2.3-beta.1+build.123)"),
   /**
    * Release date
    */
-  releaseDate: import_zod15.z.string().datetime(),
+  releaseDate: import_zod17.z.string().datetime(),
   /**
    * Release notes
    */
-  releaseNotes: import_zod15.z.string().optional(),
+  releaseNotes: import_zod17.z.string().optional(),
   /**
    * Breaking changes
    */
-  breakingChanges: import_zod15.z.array(BreakingChangeSchema).optional(),
+  breakingChanges: import_zod17.z.array(BreakingChangeSchema).optional(),
   /**
    * Deprecations
    */
-  deprecations: import_zod15.z.array(DeprecationNoticeSchema).optional(),
+  deprecations: import_zod17.z.array(DeprecationNoticeSchema).optional(),
   /**
    * Compatibility matrix
    */
-  compatibilityMatrix: import_zod15.z.array(CompatibilityMatrixEntrySchema).optional(),
+  compatibilityMatrix: import_zod17.z.array(CompatibilityMatrixEntrySchema).optional(),
   /**
    * Security vulnerabilities fixed
    */
-  securityFixes: import_zod15.z.array(import_zod15.z.object({
-    cve: import_zod15.z.string().optional().describe("CVE identifier"),
-    severity: import_zod15.z.enum(["critical", "high", "medium", "low"]),
-    description: import_zod15.z.string(),
-    fixedIn: import_zod15.z.string().describe("Version where vulnerability was fixed")
+  securityFixes: import_zod17.z.array(import_zod17.z.object({
+    cve: import_zod17.z.string().optional().describe("CVE identifier"),
+    severity: import_zod17.z.enum(["critical", "high", "medium", "low"]),
+    description: import_zod17.z.string(),
+    fixedIn: import_zod17.z.string().describe("Version where vulnerability was fixed")
   })).optional(),
   /**
    * Download statistics
    */
-  statistics: import_zod15.z.object({
-    downloads: import_zod15.z.number().int().min(0).optional(),
-    installations: import_zod15.z.number().int().min(0).optional(),
-    ratings: import_zod15.z.number().min(0).max(5).optional()
+  statistics: import_zod17.z.object({
+    downloads: import_zod17.z.number().int().min(0).optional(),
+    installations: import_zod17.z.number().int().min(0).optional(),
+    ratings: import_zod17.z.number().min(0).max(5).optional()
   }).optional(),
   /**
    * Support status
    */
-  support: import_zod15.z.object({
-    status: import_zod15.z.enum(["active", "maintenance", "deprecated", "eol"]),
-    endOfLife: import_zod15.z.string().datetime().optional(),
-    securitySupport: import_zod15.z.boolean().default(true)
+  support: import_zod17.z.object({
+    status: import_zod17.z.enum(["active", "maintenance", "deprecated", "eol"]),
+    endOfLife: import_zod17.z.string().datetime().optional(),
+    securitySupport: import_zod17.z.boolean().default(true)
   })
 });
 
 // src/kernel/service-registry.zod.ts
-var import_zod16 = require("zod");
-var ServiceScopeType = import_zod16.z.enum([
+var import_zod18 = require("zod");
+var ServiceScopeType = import_zod18.z.enum([
   "singleton",
   // Single instance shared across the application
   "transient",
@@ -3690,11 +3876,11 @@ var ServiceScopeType = import_zod16.z.enum([
   "scoped"
   // Instance per scope (request, session, transaction, etc.)
 ]).describe("Service scope type");
-var ServiceMetadataSchema = import_zod16.z.object({
+var ServiceMetadataSchema = import_zod18.z.object({
   /**
    * Service name (unique identifier)
    */
-  name: import_zod16.z.string().min(1).describe("Unique service name identifier"),
+  name: import_zod18.z.string().min(1).describe("Unique service name identifier"),
   /**
    * Service scope type
    */
@@ -3702,47 +3888,47 @@ var ServiceMetadataSchema = import_zod16.z.object({
   /**
    * Service type or interface name (optional)
    */
-  type: import_zod16.z.string().optional().describe("Service type or interface name"),
+  type: import_zod18.z.string().optional().describe("Service type or interface name"),
   /**
    * Registration timestamp (Unix milliseconds)
    */
-  registeredAt: import_zod16.z.number().int().optional().describe("Unix timestamp in milliseconds when service was registered"),
+  registeredAt: import_zod18.z.number().int().optional().describe("Unix timestamp in milliseconds when service was registered"),
   /**
    * Additional metadata
    */
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any()).optional().describe("Additional service-specific metadata")
+  metadata: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).optional().describe("Additional service-specific metadata")
 });
-var ServiceRegistryConfigSchema = import_zod16.z.object({
+var ServiceRegistryConfigSchema = import_zod18.z.object({
   /**
    * Strict mode: throw errors on invalid operations
    * @default true
    */
-  strictMode: import_zod16.z.boolean().optional().default(true).describe("Throw errors on invalid operations (duplicate registration, service not found, etc.)"),
+  strictMode: import_zod18.z.boolean().optional().default(true).describe("Throw errors on invalid operations (duplicate registration, service not found, etc.)"),
   /**
    * Allow overwriting existing services
    * @default false
    */
-  allowOverwrite: import_zod16.z.boolean().optional().default(false).describe("Allow overwriting existing service registrations"),
+  allowOverwrite: import_zod18.z.boolean().optional().default(false).describe("Allow overwriting existing service registrations"),
   /**
    * Enable logging for service operations
    * @default false
    */
-  enableLogging: import_zod16.z.boolean().optional().default(false).describe("Enable logging for service registration and retrieval"),
+  enableLogging: import_zod18.z.boolean().optional().default(false).describe("Enable logging for service registration and retrieval"),
   /**
    * Custom scope types (beyond singleton, transient, scoped)
    * @default ['singleton', 'transient', 'scoped']
    */
-  scopeTypes: import_zod16.z.array(import_zod16.z.string()).optional().describe("Supported scope types"),
+  scopeTypes: import_zod18.z.array(import_zod18.z.string()).optional().describe("Supported scope types"),
   /**
    * Maximum number of services (prevent memory leaks)
    */
-  maxServices: import_zod16.z.number().int().min(1).optional().describe("Maximum number of services that can be registered")
+  maxServices: import_zod18.z.number().int().min(1).optional().describe("Maximum number of services that can be registered")
 });
-var ServiceFactoryRegistrationSchema = import_zod16.z.object({
+var ServiceFactoryRegistrationSchema = import_zod18.z.object({
   /**
    * Service name (unique identifier)
    */
-  name: import_zod16.z.string().min(1).describe("Unique service name identifier"),
+  name: import_zod18.z.string().min(1).describe("Unique service name identifier"),
   /**
    * Service scope type
    */
@@ -3750,137 +3936,137 @@ var ServiceFactoryRegistrationSchema = import_zod16.z.object({
   /**
    * Factory type (sync or async)
    */
-  factoryType: import_zod16.z.enum(["sync", "async"]).optional().default("sync").describe("Whether factory is synchronous or asynchronous"),
+  factoryType: import_zod18.z.enum(["sync", "async"]).optional().default("sync").describe("Whether factory is synchronous or asynchronous"),
   /**
    * Whether this is a singleton (cache factory result)
    */
-  singleton: import_zod16.z.boolean().optional().default(true).describe("Whether to cache the factory result (singleton pattern)")
+  singleton: import_zod18.z.boolean().optional().default(true).describe("Whether to cache the factory result (singleton pattern)")
 });
-var ScopeConfigSchema = import_zod16.z.object({
+var ScopeConfigSchema = import_zod18.z.object({
   /**
    * Type of scope (request, session, transaction, etc.)
    */
-  scopeType: import_zod16.z.string().describe("Type of scope"),
+  scopeType: import_zod18.z.string().describe("Type of scope"),
   /**
    * Scope identifier (optional, auto-generated if not provided)
    */
-  scopeId: import_zod16.z.string().optional().describe("Unique scope identifier"),
+  scopeId: import_zod18.z.string().optional().describe("Unique scope identifier"),
   /**
    * Scope metadata (context information)
    */
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any()).optional().describe("Scope-specific context metadata")
+  metadata: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).optional().describe("Scope-specific context metadata")
 });
-var ScopeInfoSchema = import_zod16.z.object({
+var ScopeInfoSchema = import_zod18.z.object({
   /**
    * Scope identifier
    */
-  scopeId: import_zod16.z.string().describe("Unique scope identifier"),
+  scopeId: import_zod18.z.string().describe("Unique scope identifier"),
   /**
    * Type of scope
    */
-  scopeType: import_zod16.z.string().describe("Type of scope"),
+  scopeType: import_zod18.z.string().describe("Type of scope"),
   /**
    * Creation timestamp (Unix milliseconds)
    */
-  createdAt: import_zod16.z.number().int().describe("Unix timestamp in milliseconds when scope was created"),
+  createdAt: import_zod18.z.number().int().describe("Unix timestamp in milliseconds when scope was created"),
   /**
    * Number of services in this scope
    */
-  serviceCount: import_zod16.z.number().int().min(0).optional().describe("Number of services registered in this scope"),
+  serviceCount: import_zod18.z.number().int().min(0).optional().describe("Number of services registered in this scope"),
   /**
    * Scope metadata
    */
-  metadata: import_zod16.z.record(import_zod16.z.string(), import_zod16.z.any()).optional().describe("Scope-specific context metadata")
+  metadata: import_zod18.z.record(import_zod18.z.string(), import_zod18.z.any()).optional().describe("Scope-specific context metadata")
 });
 
 // src/kernel/startup-orchestrator.zod.ts
-var import_zod17 = require("zod");
-var StartupOptionsSchema = import_zod17.z.object({
+var import_zod19 = require("zod");
+var StartupOptionsSchema = import_zod19.z.object({
   /**
    * Maximum time (ms) to wait for each plugin to start
    * @default 30000 (30 seconds)
    */
-  timeout: import_zod17.z.number().int().min(0).optional().default(3e4).describe("Maximum time in milliseconds to wait for each plugin to start"),
+  timeout: import_zod19.z.number().int().min(0).optional().default(3e4).describe("Maximum time in milliseconds to wait for each plugin to start"),
   /**
    * Whether to rollback (destroy) already-started plugins on failure
    * @default true
    */
-  rollbackOnFailure: import_zod17.z.boolean().optional().default(true).describe("Whether to rollback already-started plugins if any plugin fails"),
+  rollbackOnFailure: import_zod19.z.boolean().optional().default(true).describe("Whether to rollback already-started plugins if any plugin fails"),
   /**
    * Whether to run health checks after startup
    * @default false
    */
-  healthCheck: import_zod17.z.boolean().optional().default(false).describe("Whether to run health checks after plugin startup"),
+  healthCheck: import_zod19.z.boolean().optional().default(false).describe("Whether to run health checks after plugin startup"),
   /**
    * Whether to run plugins in parallel (if dependencies allow)
    * @default false (sequential startup)
    */
-  parallel: import_zod17.z.boolean().optional().default(false).describe("Whether to start plugins in parallel when dependencies allow"),
+  parallel: import_zod19.z.boolean().optional().default(false).describe("Whether to start plugins in parallel when dependencies allow"),
   /**
    * Custom context to pass to plugin lifecycle methods
    */
-  context: import_zod17.z.any().optional().describe("Custom context object to pass to plugin lifecycle methods")
+  context: import_zod19.z.any().optional().describe("Custom context object to pass to plugin lifecycle methods")
 });
-var HealthStatusSchema = import_zod17.z.object({
+var HealthStatusSchema = import_zod19.z.object({
   /**
    * Whether the plugin is healthy
    */
-  healthy: import_zod17.z.boolean().describe("Whether the plugin is healthy"),
+  healthy: import_zod19.z.boolean().describe("Whether the plugin is healthy"),
   /**
    * Health check timestamp (Unix milliseconds)
    */
-  timestamp: import_zod17.z.number().int().describe("Unix timestamp in milliseconds when health check was performed"),
+  timestamp: import_zod19.z.number().int().describe("Unix timestamp in milliseconds when health check was performed"),
   /**
    * Optional health details (plugin-specific)
    */
-  details: import_zod17.z.record(import_zod17.z.string(), import_zod17.z.any()).optional().describe("Optional plugin-specific health details"),
+  details: import_zod19.z.record(import_zod19.z.string(), import_zod19.z.any()).optional().describe("Optional plugin-specific health details"),
   /**
    * Optional error message if unhealthy
    */
-  message: import_zod17.z.string().optional().describe("Error message if plugin is unhealthy")
+  message: import_zod19.z.string().optional().describe("Error message if plugin is unhealthy")
 });
-var PluginStartupResultSchema = import_zod17.z.object({
+var PluginStartupResultSchema = import_zod19.z.object({
   /**
    * Plugin that was started
    */
-  plugin: import_zod17.z.object({
-    name: import_zod17.z.string(),
-    version: import_zod17.z.string().optional()
+  plugin: import_zod19.z.object({
+    name: import_zod19.z.string(),
+    version: import_zod19.z.string().optional()
   }).passthrough().describe("Plugin metadata"),
   /**
    * Whether startup was successful
    */
-  success: import_zod17.z.boolean().describe("Whether the plugin started successfully"),
+  success: import_zod19.z.boolean().describe("Whether the plugin started successfully"),
   /**
    * Time taken to start (milliseconds)
    */
-  duration: import_zod17.z.number().min(0).describe("Time taken to start the plugin in milliseconds"),
+  duration: import_zod19.z.number().min(0).describe("Time taken to start the plugin in milliseconds"),
   /**
    * Error if startup failed
    */
-  error: import_zod17.z.instanceof(Error).optional().describe("Error object if startup failed"),
+  error: import_zod19.z.instanceof(Error).optional().describe("Error object if startup failed"),
   /**
    * Health status after startup (if healthCheck enabled)
    */
   health: HealthStatusSchema.optional().describe("Health status after startup if health check was enabled")
 });
-var StartupOrchestrationResultSchema = import_zod17.z.object({
+var StartupOrchestrationResultSchema = import_zod19.z.object({
   /**
    * Individual plugin startup results
    */
-  results: import_zod17.z.array(PluginStartupResultSchema).describe("Startup results for each plugin"),
+  results: import_zod19.z.array(PluginStartupResultSchema).describe("Startup results for each plugin"),
   /**
    * Total time taken for all plugins (milliseconds)
    */
-  totalDuration: import_zod17.z.number().min(0).describe("Total time taken for all plugins in milliseconds"),
+  totalDuration: import_zod19.z.number().min(0).describe("Total time taken for all plugins in milliseconds"),
   /**
    * Whether all plugins started successfully
    */
-  allSuccessful: import_zod17.z.boolean().describe("Whether all plugins started successfully"),
+  allSuccessful: import_zod19.z.boolean().describe("Whether all plugins started successfully"),
   /**
    * Plugins that were rolled back (if rollbackOnFailure was enabled)
    */
-  rolledBack: import_zod17.z.array(import_zod17.z.string()).optional().describe("Names of plugins that were rolled back")
+  rolledBack: import_zod19.z.array(import_zod19.z.string()).optional().describe("Names of plugins that were rolled back")
 });
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
@@ -3894,8 +4080,12 @@ var StartupOrchestrationResultSchema = import_zod17.z.object({
   DependencyConflictSchema,
   DependencyResolutionResultSchema,
   DeprecationNoticeSchema,
+  DisablePackageRequestSchema,
+  DisablePackageResponseSchema,
   DistributedStateConfigSchema,
   EVENT_PRIORITY_VALUES,
+  EnablePackageRequestSchema,
+  EnablePackageResponseSchema,
   EventBusConfigSchema,
   EventHandlerSchema,
   EventLogEntrySchema,
@@ -3915,15 +4105,22 @@ var StartupOrchestrationResultSchema = import_zod17.z.object({
   FeatureFlag,
   FeatureFlagSchema,
   FeatureStrategy,
+  GetPackageRequestSchema,
+  GetPackageResponseSchema,
   GracefulDegradationSchema,
   HealthStatusSchema,
   HookRegisteredEventSchema,
   HookTriggeredEventSchema,
   HotReloadConfigSchema,
+  InstallPackageRequestSchema,
+  InstallPackageResponseSchema,
+  InstalledPackageSchema,
   KernelContextSchema,
   KernelEventBaseSchema,
   KernelReadyEventSchema,
   KernelShutdownEventSchema,
+  ListPackagesRequestSchema,
+  ListPackagesResponseSchema,
   ManifestSchema,
   MetadataCollectionInfoSchema,
   MetadataExportOptionsSchema,
@@ -3941,6 +4138,7 @@ var StartupOrchestrationResultSchema = import_zod17.z.object({
   OpsDomainModuleSchema,
   OpsFilePathSchema,
   OpsPluginStructureSchema,
+  PackageStatusEnum,
   PermissionActionSchema,
   PermissionSchema,
   PermissionScopeSchema,
@@ -4003,6 +4201,8 @@ var StartupOrchestrationResultSchema = import_zod17.z.object({
   ServiceUnregisteredEventSchema,
   StartupOptionsSchema,
   StartupOrchestrationResultSchema,
+  UninstallPackageRequestSchema,
+  UninstallPackageResponseSchema,
   ValidationErrorSchema,
   ValidationResultSchema,
   ValidationWarningSchema,