@objectstack/spec 1.0.6 → 1.0.8

package/dist/kernel/index.mjs

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