@objectstack/spec 1.0.11 → 1.1.0

package/dist/kernel/index.mjs

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