@objectstack/spec 1.0.6 → 1.0.8

package/dist/index.js

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