@quazardous/qdadm 2.4.4 → 2.5.0

package/src/gen/connectors/OpenAPIConnector.ts

@@ -9,6 +9,7 @@
 
 import { BaseConnector, type ConnectorOptions, type ParseResult, type ParseWarning } from './BaseConnector'
 import { getDefaultType, type CustomMappings } from '../FieldMapper'
+import { humanizeFieldName } from '../../utils/humanize'
 import type { UnifiedEntitySchema, UnifiedFieldSchema, UnifiedFieldType } from '../schema'
 
 /**
@@ -48,6 +49,19 @@ export interface OpenAPIConnectorOptions extends ConnectorOptions {
   operationFilter?: OperationFilter | null
   /** Custom type mappings for FieldMapper */
   customMappings?: CustomMappings
+  /**
+   * Infer a label from the field name when the schema has no `description`
+   * (#1255): 'humanize' turns `botUuid` into "Bot Uuid". Opt-in — it changes
+   * generated output. Default: off (label only from `description`).
+   */
+  inferLabels?: 'humanize' | false
+  /**
+   * Infer `readOnly` from operation shape (#1255): a field that appears in
+   * responses but in no request-body schema is marked `readOnly: true`
+   * (an entity with no write operations gets all fields readOnly). Opt-in —
+   * it changes generated output. Schema-declared `readOnly` always wins.
+   */
+  inferReadOnly?: boolean
 }
 
 /**
@@ -64,6 +78,8 @@ interface EntityWorkingData {
   rawSchema: OpenAPISchema | null
   /** Extracted fields */
   fields: Map<string, UnifiedFieldSchema>
+  /** Field names seen in request-body schemas (for readOnly inference, #1255) */
+  requestFields: Set<string>
 }
 
 /**
@@ -173,6 +189,12 @@ export class OpenAPIConnector extends BaseConnector {
   /** Custom type mappings */
   customMappings: CustomMappings
 
+  /** Label inference mode (#1255) */
+  inferLabels: 'humanize' | false
+
+  /** Whether to infer readOnly from operation shape (#1255) */
+  inferReadOnly: boolean
+
   /**
    * Create a new OpenAPI connector
    *
@@ -185,6 +207,8 @@ export class OpenAPIConnector extends BaseConnector {
     this.dataWrapper = options.dataWrapper ?? 'data'
     this.operationFilter = options.operationFilter || null
     this.customMappings = options.customMappings || {}
+    this.inferLabels = options.inferLabels ?? false
+    this.inferReadOnly = options.inferReadOnly ?? false
   }
 
   /**
@@ -201,10 +225,11 @@ export class OpenAPIConnector extends BaseConnector {
    * })
    */
   parse(source: unknown): UnifiedEntitySchema[] {
-    const spec = source as OpenAPISpec
-    this._validateSource(spec)
-    const entities = this._extractEntities(spec)
-    return Array.from(entities.values())
+    const { schemas, warnings } = this.parseWithWarnings(source)
+    for (const warning of warnings) {
+      console.warn(`⚠ [${this.name}] ${warning.path}: ${warning.message}`)
+    }
+    return schemas
   }
 
   /**
@@ -267,6 +292,7 @@ export class OpenAPIConnector extends BaseConnector {
           idField: null,
           rawSchema: null,
           fields: new Map(),
+          requestFields: new Set(),
         })
       }
 
@@ -371,6 +397,8 @@ export class OpenAPIConnector extends BaseConnector {
         const requestSchema = this._extractRequestSchema(op, spec)
         if (requestSchema) {
           this._extractFields(requestSchema, entity.fields, spec, warnings, path)
+          // Track writable field names for readOnly inference (#1255)
+          this._collectFieldNames(requestSchema, spec, entity.requestFields)
         }
       }
     }
@@ -565,6 +593,20 @@ export class OpenAPIConnector extends BaseConnector {
         continue
       }
 
+      // Bare object schema: no contract at all. fast-json-stringify (Fastify)
+      // serializes such a field to `{}` at runtime, stripping every key (#1240).
+      if (this._isBareObjectSchema(resolvedSchema)) {
+        warnings.push({
+          path: `${sourcePath}#${fieldName}`,
+          message:
+            `object schema has no \`properties\` and \`additionalProperties\` is not set. ` +
+            `Under Fastify (fast-json-stringify) this serializes to \`{}\` at runtime ` +
+            `and the generated field type is unusable. ` +
+            `For a free-form JSON blob, declare \`additionalProperties: true\`.`,
+          code: 'EMPTY_OBJECT_SCHEMA',
+        })
+      }
+
       // Use FieldMapper for type conversion
       const type = getDefaultType(resolvedSchema, this.customMappings)
 
@@ -578,6 +620,8 @@ export class OpenAPIConnector extends BaseConnector {
       // Add optional properties
       if (resolvedSchema.description) {
         field.label = resolvedSchema.description
+      } else if (this.inferLabels === 'humanize') {
+        field.label = humanizeFieldName(fieldName)
       }
       if (resolvedSchema.format) {
         field.format = resolvedSchema.format
@@ -604,6 +648,57 @@ export class OpenAPIConnector extends BaseConnector {
     }
   }
 
+  /**
+   * Collect field names from a schema the same way _extractFields names them
+   * (top-level + one-level-nested dotted keys). Used to track which fields
+   * appear in request bodies, for readOnly inference (#1255).
+   *
+   * @private
+   * @param schema - JSON Schema object
+   * @param spec - Full spec for ref resolution
+   * @param into - Set collecting the names
+   * @param prefix - Prefix for nested field names
+   */
+  private _collectFieldNames(
+    schema: OpenAPISchema,
+    spec: OpenAPISpec,
+    into: Set<string>,
+    prefix: string = ''
+  ): void {
+    if (!schema || !schema.properties) return
+
+    for (const [name, propSchema] of Object.entries(schema.properties)) {
+      const fieldName = prefix ? `${prefix}.${name}` : name
+      into.add(fieldName)
+
+      const resolvedSchema = propSchema.$ref ? this._resolveRef(propSchema.$ref, spec) : propSchema
+      if (resolvedSchema?.type === 'object' && resolvedSchema.properties && !prefix) {
+        this._collectFieldNames(resolvedSchema, spec, into, fieldName)
+      }
+    }
+  }
+
+  /**
+   * Detect a "bare" object schema: type object with no properties, no
+   * additionalProperties contract, and no composition/reference that could
+   * supply one. Such a schema is the quasi-always-footgun case (#1240) —
+   * objects with `properties`, a sub-schema `additionalProperties`, `$ref`
+   * or oneOf/anyOf/allOf are deliberately excluded.
+   *
+   * @private
+   * @param schema - Resolved property schema
+   * @returns True if the schema is a contract-less object
+   */
+  private _isBareObjectSchema(schema: OpenAPISchema): boolean {
+    if (schema.type !== 'object') return false
+    if (schema.properties && Object.keys(schema.properties).length > 0) return false
+    const additionalProperties = schema.additionalProperties
+    if (additionalProperties === true) return false
+    if (additionalProperties && typeof additionalProperties === 'object') return false
+    if (schema.$ref || schema.oneOf || schema.anyOf || schema.allOf) return false
+    return true
+  }
+
   /**
    * Merge field info from secondary source into primary
    *
@@ -667,6 +762,17 @@ export class OpenAPIConnector extends BaseConnector {
     const schemas: Map<string, UnifiedEntitySchema> = new Map()
 
     for (const [name, data] of entityData) {
+      // readOnly inference (#1255): a field never seen in a request body is
+      // not writable through this API. Entities without write operations end
+      // up with every field readOnly. Schema-declared readOnly is preserved.
+      if (this.inferReadOnly) {
+        for (const field of data.fields.values()) {
+          if (!field.readOnly && !data.requestFields.has(field.name)) {
+            field.readOnly = true
+          }
+        }
+      }
+
       const schema: UnifiedEntitySchema = {
         name: data.name,
         endpoint: data.endpoint,

package/src/gen/generateManagers.test.js

@@ -436,6 +436,84 @@ describe('generateManagers', () => {
     })
   })
 
+  describe('baseClass option (#1253)', () => {
+    function entityConfig(extra = {}) {
+      return {
+        schema: {
+          name: 'users',
+          endpoint: '/users',
+          fields: {
+            id: { name: 'id', type: 'number' },
+            name: { name: 'name', type: 'text', required: true }
+          }
+        },
+        endpoint: '/users',
+        storageImport: '@quazardous/qdadm',
+        storageClass: 'ApiStorage',
+        ...extra
+      }
+    }
+
+    it('class mode extends the global baseClass and imports it', async () => {
+      await generateManagers({
+        output: testOutputDir,
+        classMode: true,
+        baseClass: { import: '@/managers/SkyEntityManager', name: 'SkyEntityManager' },
+        entities: { users: entityConfig() }
+      })
+
+      const content = await readFile(join(testOutputDir, 'users.ts'), 'utf-8')
+      expect(content).toContain("import { SkyEntityManager } from '@/managers/SkyEntityManager'")
+      expect(content).toContain('extends SkyEntityManager<UsersEntity>')
+      expect(content).not.toContain("import { EntityManager } from '@quazardous/qdadm'")
+      // Options/record types still come from qdadm
+      expect(content).toContain("import type { EntityRecord, EntityManagerOptions } from '@quazardous/qdadm'")
+    })
+
+    it('instance mode instantiates the baseClass', async () => {
+      await generateManagers({
+        output: testOutputDir,
+        baseClass: { import: './base', name: 'MyBase' },
+        entities: { users: entityConfig() }
+      })
+
+      const content = await readFile(join(testOutputDir, 'usersManager.ts'), 'utf-8')
+      expect(content).toContain("import { MyBase } from './base'")
+      expect(content).toContain('new MyBase<UsersEntity>(')
+      expect(content).not.toContain('new EntityManager<UsersEntity>(')
+    })
+
+    it('per-entity baseClass overrides the global one', async () => {
+      await generateManagers({
+        output: testOutputDir,
+        classMode: true,
+        baseClass: { import: './globalBase', name: 'GlobalBase' },
+        entities: {
+          users: entityConfig({
+            baseClass: { import: './localBase', name: 'LocalBase' }
+          })
+        }
+      })
+
+      const content = await readFile(join(testOutputDir, 'users.ts'), 'utf-8')
+      expect(content).toContain("import { LocalBase } from './localBase'")
+      expect(content).toContain('extends LocalBase<UsersEntity>')
+      expect(content).not.toContain('GlobalBase')
+    })
+
+    it('defaults to EntityManager when no baseClass is given', async () => {
+      await generateManagers({
+        output: testOutputDir,
+        classMode: true,
+        entities: { users: entityConfig() }
+      })
+
+      const content = await readFile(join(testOutputDir, 'users.ts'), 'utf-8')
+      expect(content).toContain("import { EntityManager } from '@quazardous/qdadm'")
+      expect(content).toContain('extends EntityManager<UsersEntity>')
+    })
+  })
+
   describe('default output directory', () => {
     it('uses default output when not specified', async () => {
       // This test would write to actual src/generated/managers/

package/src/gen/generateManagers.ts

@@ -22,6 +22,21 @@ import type { EntityDecorator } from './decorators'
  */
 const DEFAULT_OUTPUT_DIR = 'src/generated/managers/'
 
+/**
+ * Custom base class for generated managers (#1253).
+ *
+ * The class MUST extend EntityManager, stay generic over the entity type
+ * and pass constructor options through — the generated code does
+ * `class Generated<X>Manager extends <name><XEntity>` and calls
+ * `super({ ...schema options, storage, ...options })`.
+ */
+export interface GenerateManagersBaseClass {
+  /** Import specifier (e.g. '@/managers/SkyEntityManager') */
+  import: string
+  /** Exported class name (e.g. 'SkyEntityManager') */
+  name: string
+}
+
 /**
  * Entity configuration for generation
  */
@@ -40,6 +55,8 @@ export interface GenerateManagersEntityConfig {
   decorators?: EntityDecorator
   /** Generate class instead of instance (for extension) */
   classMode?: boolean
+  /** Base class for this entity's generated manager (overrides global) */
+  baseClass?: GenerateManagersBaseClass
 }
 
 /**
@@ -50,6 +67,8 @@ export interface GenerateManagersConfig {
   output?: string
   /** Generate classes instead of instances (for extension pattern) */
   classMode?: boolean
+  /** Base class for all generated managers (default: EntityManager) */
+  baseClass?: GenerateManagersBaseClass
   /** Entity configurations keyed by entity name */
   entities: Record<string, GenerateManagersEntityConfig>
 }
@@ -175,12 +194,19 @@ function serializeValue(value: unknown, indent: number = 0): string {
 function generateManagerSource(
   entityName: string,
   entityConfig: GenerateManagersEntityConfig,
-  globalOptions: { classMode?: boolean } = {}
+  globalOptions: { classMode?: boolean; baseClass?: GenerateManagersBaseClass } = {}
 ): string {
   const { schema, endpoint, storageImport, storageClass, storageOptions = {}, decorators } = entityConfig
   const classMode = entityConfig.classMode ?? globalOptions.classMode ?? false
   const className = toPascalCase(entityName)
 
+  // Custom base class (#1253): per-entity wins over global, default EntityManager.
+  const baseClass = entityConfig.baseClass ?? globalOptions.baseClass
+  const baseName = baseClass?.name ?? 'EntityManager'
+  const baseImport = baseClass
+    ? `import { ${baseClass.name} } from '${baseClass.import}'`
+    : `import { EntityManager } from '@quazardous/qdadm'`
+
   // Build storage options object
   const fullStorageOptions: Record<string, unknown> = {
     endpoint,
@@ -240,7 +266,7 @@ function generateManagerSource(
  * Endpoint: ${endpoint}
  */
 
-import { EntityManager } from '@quazardous/qdadm'
+${baseImport}
 import type { EntityRecord, EntityManagerOptions } from '@quazardous/qdadm'
 import { ${storageClass} } from '${storageImport}'
 
@@ -249,9 +275,9 @@ ${entityInterface}
 /**
  * Generated base manager for ${entityName}
  *
- * @extends EntityManager
+ * @extends ${baseName}
  */
-export class Generated${className}Manager extends EntityManager<${className}Entity> {
+export class Generated${className}Manager extends ${baseName}<${className}Entity> {
   constructor(options: Partial<EntityManagerOptions<${className}Entity>> = {}) {
     super({
       ...${serializeValue(managerOptions, 2)},
@@ -274,7 +300,7 @@ export class Generated${className}Manager extends EntityManager<${className}Enti
  * Endpoint: ${endpoint}
  */
 
-import { EntityManager } from '@quazardous/qdadm'
+${baseImport}
 import type { EntityRecord } from '@quazardous/qdadm'
 import { ${storageClass} } from '${storageImport}'
 
@@ -295,7 +321,7 @@ const storageOptions = ${serializeValue(fullStorageOptions, 0)}
  *
  * Provides CRUD operations for ${entityName} entity.
  */
-export const ${entityName}Manager = new EntityManager<${className}Entity>({
+export const ${entityName}Manager = new ${baseName}<${className}Entity>({
   ...${serializeValue(managerOptions, 0)},
   storage: new ${storageClass}<${className}Entity>(storageOptions)
 })
@@ -349,7 +375,7 @@ export async function generateManagers(config: GenerateManagersConfig): Promise<
   }
 
   const outputDir = config.output || DEFAULT_OUTPUT_DIR
-  const globalOptions = { classMode: config.classMode ?? false }
+  const globalOptions = { classMode: config.classMode ?? false, baseClass: config.baseClass }
   const generatedFiles: string[] = []
 
   // Validate each entity config

package/src/gen/index.ts

@@ -63,4 +63,5 @@ export {
   generateEntityInterface,
   type GenerateManagersConfig,
   type GenerateManagersEntityConfig,
+  type GenerateManagersBaseClass,
 } from './generateManagers'

package/src/index.ts

@@ -96,6 +96,8 @@ export {
   type SeverityMapValue,
   type SeverityMap,
   type RoutingContext,
+  type StorageResolution,
+  type ResolvedStorage,
   type PresaveContext,
   type PostsaveContext,
   type PredeleteContext,
@@ -150,6 +152,30 @@ export type {
 // ════════════════════════════════════════════════════════════════════════════
 export * from './orchestrator/index'
 
+/**
+ * Typed manager registry (#1253) — augment it from your app to make
+ * `getManager()` / `useEntity()` return your concrete EntityManager
+ * subclasses instead of `EntityManager<EntityRecord>`:
+ *
+ * ```ts
+ * declare module '@quazardous/qdadm' {
+ *   interface QdadmManagerRegistry {
+ *     bots: BotsManager
+ *     botPools: BotPoolsManager
+ *   }
+ * }
+ * ```
+ *
+ * Entity names not declared here keep the current fallback behavior.
+ *
+ * NOTE: deliberately declared in this file (not re-exported from a
+ * sub-module) — TypeScript module augmentation does not merge through
+ * re-export aliases, and consumers augment '@quazardous/qdadm', which
+ * resolves here.
+ */
+// eslint-disable-next-line @typescript-eslint/no-empty-object-type
+export interface QdadmManagerRegistry {}
+
 // ════════════════════════════════════════════════════════════════════════════
 // COMPOSABLES (excluding types that conflict with other modules)
 // ════════════════════════════════════════════════════════════════════════════

package/src/kernel/Kernel.api.ts

@@ -1,14 +1,14 @@
 import type { AxiosLikeClient, AxiosError } from './Kernel.types'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with API client methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyApiMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyApiMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Setup an axios client with automatic auth and error handling

package/src/kernel/Kernel.auth.ts

@@ -1,14 +1,14 @@
 import { authFactory, CompositeAuthAdapter } from '../entity/auth'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with auth-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyAuthMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyAuthMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Resolve entityAuthAdapter through authFactory

package/src/kernel/Kernel.i18n.ts

@@ -9,13 +9,13 @@
 
 import { I18n } from '../i18n/I18n'
 import type { I18nOptions } from '../i18n/types'
+import type { Kernel } from './Kernel'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyI18nMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyI18nMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   proto._createI18n = function (this: Self): void {
     const opts = (this.options.i18n as I18nOptions | undefined) ?? {}

package/src/kernel/Kernel.modules.ts

@@ -1,15 +1,15 @@
 import { initModules, setSectionOrder } from '../module/moduleRegistry'
 import { createModuleLoader, type ModuleLike } from './ModuleLoader'
 import { createKernelContext, type KernelContext } from './KernelContext'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with module-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyModuleMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyModuleMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Fire entity cache warmups

package/src/kernel/Kernel.registries.ts

@@ -13,15 +13,15 @@ import { ActiveStack } from '../chain/ActiveStack.js'
 import { StackHydrator } from '../chain/StackHydrator.js'
 import { Orchestrator } from '../orchestrator/Orchestrator'
 import type { EntityAuthAdapter } from '../entity/auth/EntityAuthAdapter'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with registry-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyRegistryMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyRegistryMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Create signal bus for event-driven communication.

package/src/kernel/Kernel.routing.ts

@@ -8,15 +8,15 @@ import {
   type RouteRecordNormalized,
 } from 'vue-router'
 import { getRoutes } from '../module/moduleRegistry'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Patch Kernel prototype with routing-related methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyRoutingMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyRoutingMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Create Vue Router.

package/src/kernel/Kernel.vue.ts

@@ -16,8 +16,9 @@ import ToastListener from '../toast/ToastListener.vue'
 import { createQdadm } from '../plugin.js'
 import { createNotificationStore, NOTIFICATION_KEY } from '../notifications/NotificationStore'
 import { I18N_INJECTION_KEY } from '../i18n/useI18n'
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+import type { Kernel } from './Kernel'
+// #1196 Phase B — this-typing against the real Kernel shape (was Self = any)
+type Self = Kernel
 
 /**
  * Reactive reference to the debug bar component, set by the Kernel
@@ -57,9 +58,8 @@ export function setQdadmDebugBar(component: Component | null): void {
 /**
  * Patch Kernel prototype with Vue app creation methods.
  */
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyVueMethods(KernelClass: { prototype: any }): void {
-  const proto = KernelClass.prototype as Self
+export function applyVueMethods(KernelClass: { prototype: Kernel }): void {
+  const proto = KernelClass.prototype
 
   /**
    * Create layout components map for useLayoutResolver

package/src/kernel/KernelContext.entities.ts

@@ -8,13 +8,13 @@ import { managerFactory, type ManagerFactoryContext } from '../entity/factory.js
 import type { EntityManager } from '../entity/EntityManager'
 import { UsersManager } from '../security/UsersManager'
 import type { UserEntityOptions } from './KernelContext.types'
+import type { KernelContext } from './KernelContext'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real KernelContext shape (was Self = any)
+type Self = KernelContext
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyEntityMethods(KernelContextClass: { prototype: any }): void {
-  const proto = KernelContextClass.prototype as Self
+export function applyEntityMethods(KernelContextClass: { prototype: KernelContext }): void {
+  const proto = KernelContextClass.prototype
 
   /**
    * Register an entity manager.

package/src/kernel/KernelContext.events.ts

@@ -12,13 +12,13 @@ import type {
   HookHandler,
   SignalHandler,
 } from './KernelContext.types'
+import type { KernelContext } from './KernelContext'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real KernelContext shape (was Self = any)
+type Self = KernelContext
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyEventMethods(KernelContextClass: { prototype: any }): void {
-  const proto = KernelContextClass.prototype as Self
+export function applyEventMethods(KernelContextClass: { prototype: KernelContext }): void {
+  const proto = KernelContextClass.prototype
 
   proto.on = function (
     this: Self,

package/src/kernel/KernelContext.i18n.ts

@@ -6,13 +6,13 @@
  */
 
 import type { AliasPattern, MessagesBundle, TranslationProvider } from '../i18n/types'
+import type { KernelContext } from './KernelContext'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real KernelContext shape (was Self = any)
+type Self = KernelContext
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyI18nMethods(KernelContextClass: { prototype: any }): void {
-  const proto = KernelContextClass.prototype as Self
+export function applyI18nMethods(KernelContextClass: { prototype: KernelContext }): void {
+  const proto = KernelContextClass.prototype
 
   proto.messages = function (this: Self, locale: string, bundle: MessagesBundle): Self {
     if (this._kernel.i18nInstance) {

package/src/kernel/KernelContext.permissions.ts

@@ -5,13 +5,13 @@
  */
 
 import type { PermissionMeta, PermissionOptions } from './KernelContext.types'
+import type { KernelContext } from './KernelContext'
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-type Self = any
+// #1196 Phase B — this-typing against the real KernelContext shape (was Self = any)
+type Self = KernelContext
 
-// eslint-disable-next-line @typescript-eslint/no-explicit-any
-export function applyPermissionMethods(KernelContextClass: { prototype: any }): void {
-  const proto = KernelContextClass.prototype as Self
+export function applyPermissionMethods(KernelContextClass: { prototype: KernelContext }): void {
+  const proto = KernelContextClass.prototype
 
   proto.permissions = function (
     this: Self,