@objectstack/spec 1.0.6 → 1.0.7

package/dist/index.mjs

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