@soederpop/luca 0.0.3 → 0.0.4

package/src/scaffolds/generated.ts

@@ -1,5 +1,5 @@
 // Auto-generated scaffold and MCP readme content
-// Generated at: 2026-03-07T16:53:46.702Z
+// Generated at: 2026-03-10T18:58:23.358Z
 // Source: docs/scaffolds/*.md and docs/mcp/readme.md
 //
 // Do not edit manually. Run: luca build-scaffolds

package/src/server.ts

@@ -29,6 +29,9 @@ export class Server<T extends ServerState = ServerState, K extends ServerOptions
     static override optionsSchema = ServerOptionsSchema
     static override eventsSchema = ServerEventsSchema
 
+    /** Self-register a Server subclass from a static initialization block. */
+    static register: (SubClass: typeof Server, id?: string) => typeof Server
+
     override get initialState() : T {
       return ({
         port: this.options.port || 3000,
@@ -133,3 +136,43 @@ export class ServersRegistry extends Registry<Server<any>> {
 export const servers = new ServersRegistry()
 
 export const helperCache = new Map()
+
+/**
+ * Self-register a Server subclass from a static initialization block.
+ * IMPORTANT: Place the static block AFTER all static override declarations
+ * so schemas, envVars, and other metadata are set before interceptRegistration fires.
+ *
+ * @example
+ * ```typescript
+ * export class ExpressServer extends Server {
+ *   static override stateSchema = ServerStateSchema
+ *   static override optionsSchema = ExpressServerOptionsSchema
+ *   static { Server.register(this, 'express') }  // must come last
+ * }
+ * ```
+ */
+Server.register = function registerServer(
+  SubClass: typeof Server,
+  id?: string,
+) {
+  const registryId = id ?? SubClass.name[0]!.toLowerCase() + SubClass.name.slice(1)
+
+  // Auto-set shortcut if not explicitly overridden on this class
+  if (!Object.getOwnPropertyDescriptor(SubClass, 'shortcut')?.value ||
+      (SubClass as any).shortcut === 'unspecified') {
+    ;(SubClass as any).shortcut = `servers.${registryId}` as const
+  }
+
+  // Register in the servers registry (interceptRegistration sees all statics above)
+  servers.register(registryId, SubClass as any)
+
+  // Generate default attach() if not explicitly overridden on this class
+  if (!Object.getOwnPropertyDescriptor(SubClass, 'attach')) {
+    ;(SubClass as any).attach = (container: any) => {
+      servers.register(registryId, SubClass as any)
+      return container
+    }
+  }
+
+  return SubClass
+}

package/src/servers/express.ts

@@ -1,10 +1,9 @@
-import type { NodeContainer } from '../node/container.js'
 import express from 'express'
 import type { Express } from 'express'
 import cors from 'cors'
 import { z } from 'zod'
 import { ServerStateSchema, ServerOptionsSchema } from '../schemas/base.js'
-import { servers, type StartOptions, Server, type ServersInterface, type ServerState } from '../server.js'
+import { type StartOptions, Server, type ServerState } from '../server.js'
 import { Endpoint, type EndpointModule } from '../endpoint.js'
 
 declare module '../server' {
@@ -24,14 +23,33 @@ export type ExpressServerOptions = z.infer<typeof ExpressServerOptionsSchema>
 
 const defaultCreate = (app: Express, server: Server) => app
 
+/**
+ * Express.js HTTP server with automatic endpoint mounting, CORS, and SPA history fallback.
+ *
+ * Wraps an Express application with convention-based endpoint discovery. Endpoints
+ * defined as modules are automatically mounted as routes. Supports static file serving,
+ * CORS configuration, and single-page app history fallback out of the box.
+ *
+ * @extends Server
+ *
+ * @example
+ * ```typescript
+ * const server = container.server('express', { cors: true, static: './public' })
+ * await server.start({ port: 3000 })
+ *
+ * // Mount endpoints programmatically
+ * server.mount(myEndpoint)
+ *
+ * // Access the underlying Express app
+ * server.app.get('/health', (req, res) => res.json({ ok: true }))
+ * ```
+ */
 export class ExpressServer<T extends ServerState = ServerState, K extends ExpressServerOptions = ExpressServerOptions> extends Server<T,K> {
     static override shortcut = 'servers.express' as const
     static override stateSchema = ServerStateSchema
     static override optionsSchema = ExpressServerOptionsSchema
-    
-    static override attach(container: NodeContainer & ServersInterface) {
-      return container
-    }
+
+    static { Server.register(this, 'express') }
   
     _app?: Express
     _listener?: any
@@ -204,6 +222,4 @@ export class ExpressServer<T extends ServerState = ServerState, K extends Expres
     }
 }
 
-servers.register('express', ExpressServer)
-
 export default ExpressServer

package/src/servers/mcp.ts

@@ -1,7 +1,7 @@
 import type { NodeContainer } from '../node/container.js'
 import { z } from 'zod'
 import { MCPServerStateSchema, MCPServerOptionsSchema, MCPServerEventsSchema } from '../schemas/base.js'
-import { servers, Server, type ServersInterface, type ServerState } from '../server.js'
+import { Server } from '../server.js'
 import { Server as MCPProtocolServer } from '@modelcontextprotocol/sdk/server/index.js'
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js'
 import {
@@ -297,9 +297,7 @@ export class MCPServer extends Server<MCPServerState, MCPServerOptions> {
   static override optionsSchema = MCPServerOptionsSchema
   static override eventsSchema = MCPServerEventsSchema
 
-  static override attach(container: NodeContainer & ServersInterface) {
-    return container
-  }
+  static { Server.register(this, 'mcp') }
 
   _mcpServer?: MCPProtocolServer
   _tools: Map<string, RegisteredTool> = new Map()
@@ -800,6 +798,4 @@ export class MCPServer extends Server<MCPServerState, MCPServerOptions> {
   }
 }
 
-servers.register('mcp', MCPServer)
-
 export default MCPServer

package/src/servers/socket.ts

@@ -1,7 +1,6 @@
-import type { NodeContainer } from '../node/container.js'
 import { z } from 'zod'
 import { ServerStateSchema, ServerOptionsSchema } from '../schemas/base.js'
-import { type StartOptions, servers, Server, type ServersInterface, type ServerState } from '../server.js';
+import { type StartOptions, Server, type ServerState } from '../server.js';
 import { WebSocketServer as BaseServer } from 'ws'
 
 declare module '../server' {
@@ -15,14 +14,32 @@ export const SocketServerOptionsSchema = ServerOptionsSchema.extend({
 })
 export type SocketServerOptions = z.infer<typeof SocketServerOptionsSchema>
 
+/**
+ * WebSocket server built on the `ws` library with optional JSON message framing.
+ *
+ * Manages WebSocket connections, tracks connected clients, and bridges
+ * messages to Luca's event bus. When `json` mode is enabled, messages
+ * are automatically parsed and stringified.
+ *
+ * @extends Server
+ *
+ * @example
+ * ```typescript
+ * const ws = container.server('websocket', { json: true })
+ * await ws.start({ port: 8080 })
+ *
+ * ws.on('message', (client, data) => {
+ *   console.log('Received:', data)
+ *   ws.broadcast({ echo: data })
+ * })
+ * ```
+ */
 export class WebsocketServer<T extends ServerState = ServerState, K extends SocketServerOptions = SocketServerOptions> extends Server<T,K> {
     static override shortcut = 'servers.websocket' as const
     static override stateSchema = ServerStateSchema
     static override optionsSchema = SocketServerOptionsSchema
 
-    static override attach(container: NodeContainer & ServersInterface) {
-      return container
-    }
+    static { Server.register(this, 'websocket') }
     
     _wss?: BaseServer 
 
@@ -115,6 +132,4 @@ export class WebsocketServer<T extends ServerState = ServerState, K extends Sock
     }
 }
 
-servers.register('websocket', WebsocketServer)
-
 export default WebsocketServer

package/src/web/clients/socket.ts

@@ -1,5 +1,5 @@
 import Websocket from 'isomorphic-ws'
-import { WebSocketClient, clients, type WebSocketClientState, type WebSocketClientOptions } from '../../client'
+import { Client, WebSocketClient, type WebSocketClientState, type WebSocketClientOptions } from '../../client'
 
 /**
  * Web-specific WebSocket client implementation using isomorphic-ws.
@@ -12,9 +12,7 @@ export class SocketClient<T extends WebSocketClientState = WebSocketClientState,
 
   static override shortcut = 'clients.websocket' as const
 
-  static override attach(...args: any[]) {
-    clients.register('websocket', SocketClient)
-  }
+  static { Client.register(this, 'websocket') }
 
   /**
    * Send data over the WebSocket with an ID envelope.
@@ -79,4 +77,4 @@ export class SocketClient<T extends WebSocketClientState = WebSocketClientState,
   }
 }
 
-export default clients.register('websocket', SocketClient)
+export default SocketClient

package/src/web/features/asset-loader.ts

@@ -1,21 +1,29 @@
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from "../feature.js";
-import { Container } from "../container.js";
+import { Feature } from "../feature.js";
 
-/** 
- * The AssetLoader provides an API for injecting scripts and stylesheets into the page.
- * 
- * It also provides a convenient way of loading any library from unpkg.com
-*/
+/**
+ * Injects scripts and stylesheets into the page at runtime.
+ *
+ * Provides helpers for loading external libraries from unpkg.com,
+ * injecting arbitrary script/link tags, and managing load state.
+ * Used by other web features (e.g. Esbuild) to pull in dependencies on demand.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const loader = container.feature('assetLoader')
+ * await loader.loadScript('https://unpkg.com/lodash')
+ * await AssetLoader.loadStylesheet('https://unpkg.com/normalize.css')
+ * ```
+ */
 export class AssetLoader extends Feature {
-  static attach(container: Container & { assetLoader?: AssetLoader }) {
-    container.features.register("assetLoader", AssetLoader);
-  }
-
   static override stateSchema = FeatureStateSchema
   static override optionsSchema = FeatureOptionsSchema
   static override shortcut = "features.assetLoader" as const
 
+  static { Feature.register(this, 'assetLoader') }
+
   static loadStylesheet(href: string) {
     return new Promise((resolve, reject) => {
       const link = document.createElement("link");
@@ -61,4 +69,4 @@ export class AssetLoader extends Feature {
   }
 }
 
-export default features.register("assetLoader", AssetLoader);
+export default AssetLoader;

package/src/web/features/container-link.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { features, Feature } from '../feature.js'
-import type { Container } from '../../container.js'
+import { Feature } from '../feature.js'
 
 // --- Message Types ---
 
@@ -124,9 +123,7 @@ export class ContainerLink extends Feature<ContainerLinkState, ContainerLinkOpti
   static override optionsSchema = ContainerLinkOptionsSchema
   static override eventsSchema = ContainerLinkEventsSchema
 
-  static attach(container: Container & { containerLink?: ContainerLink }) {
-    container.features.register('containerLink', ContainerLink)
-  }
+  static { Feature.register(this as any, 'containerLink') }
 
   private _ws?: WebSocket
   private _reconnectTimer?: ReturnType<typeof setTimeout>
@@ -382,4 +379,4 @@ export class ContainerLink extends Feature<ContainerLinkState, ContainerLinkOpti
   }
 }
 
-export default features.register('containerLink', ContainerLink)
+export default ContainerLink

package/src/web/features/esbuild.ts

@@ -1,7 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, type FeatureState, features } from "../feature.js";
-import { Container } from "../container.js";
+import { Feature, type FeatureState } from "../feature.js";
 import type * as esbuild from 'esbuild-wasm';
 
 export const EsbuildWebOptionsSchema = FeatureOptionsSchema.extend({
@@ -11,14 +10,29 @@ export const EsbuildWebOptionsSchema = FeatureOptionsSchema.extend({
 
 export type EsbuildWebOptions = z.infer<typeof EsbuildWebOptionsSchema>
 
+/**
+ * Browser-side TypeScript/ESM compilation feature using esbuild-wasm.
+ *
+ * Loads esbuild's WebAssembly build via the AssetLoader, then provides
+ * `compile()` and `transform()` methods that work entirely in the browser.
+ * Useful for live playgrounds, in-browser REPLs, and client-side bundling.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const esbuild = container.feature('esbuild')
+ * await esbuild.start()
+ * const result = await esbuild.compile('const x: number = 1')
+ * console.log(result.code)
+ * ```
+ */
 export class Esbuild extends Feature<FeatureState, EsbuildWebOptions> {
-  static attach(container: Container & { assetLoader?: Esbuild}) {
-    container.features.register("esbuild", Esbuild);
-  }
-
   static override stateSchema = FeatureStateSchema
   static override optionsSchema = EsbuildWebOptionsSchema
   static override shortcut = "features.esbuild" as const
+
+  static { Feature.register(this as any, 'esbuild') }
   
   /** Returns the assetLoader feature for loading external libraries from unpkg. */
   get assetLoader() {
@@ -74,6 +88,6 @@ export class Esbuild extends Feature<FeatureState, EsbuildWebOptions> {
 
 }
 
-export default features.register("esbuild", Esbuild);
+export default Esbuild;
 
 const compileCache = new Map()

package/src/web/features/helpers.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { Feature, features } from '../feature.js'
+import { Feature } from '../feature.js'
 import { Client } from '../../client.js'
 import type { Registry } from '../../registry.js'
 import type { AssetLoader } from './asset-loader.js'
@@ -79,6 +79,8 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
   static override optionsSchema = HelpersOptionsSchema
   static override eventsSchema = HelpersEventsSchema
 
+  static { Feature.register(this as any, 'helpers') }
+
   private _manifest: Manifest | null = null
 
   private get registryMap(): Record<RegistryType, { registry: Registry<any> }> {
@@ -264,4 +266,4 @@ export class Helpers extends Feature<HelpersState, HelpersOptions> {
   }
 }
 
-export default features.register('helpers', Helpers)
+export default Helpers

package/src/web/features/network.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { features, Feature } from "../feature.js";
-import type { Container, ContainerContext } from "../container.js";
+import { Feature } from "../feature.js";
+import type { ContainerContext } from "../container.js";
 
 export const NetworkStateSchema = FeatureStateSchema.extend({
   offline: z.boolean().describe('Whether the browser is currently offline'),
@@ -12,6 +12,25 @@ export const NetworkOptionsSchema = FeatureOptionsSchema.extend({})
 export type NetworkState = z.infer<typeof NetworkStateSchema>
 export type NetworkOptions = z.infer<typeof NetworkOptionsSchema>
 
+/**
+ * Tracks browser online/offline connectivity state.
+ *
+ * Listens for the browser's `online` and `offline` events and keeps the
+ * feature state in sync. Other features can observe the `offline` state
+ * value or listen for change events to react to connectivity changes.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const network = container.feature('network')
+ * console.log(network.state.get('offline')) // false when online
+ *
+ * network.on('stateChanged', ({ offline }) => {
+ *   console.log(offline ? 'Went offline' : 'Back online')
+ * })
+ * ```
+ */
 export class Network<
   T extends NetworkState = NetworkState,
   K extends NetworkOptions = NetworkOptions
@@ -19,10 +38,8 @@ export class Network<
   static override stateSchema = NetworkStateSchema
   static override optionsSchema = NetworkOptionsSchema
   static override shortcut = "features.network" as const
-  
-  static attach(container: Container & { network?: Network }) {
-    container.features.register("network", Network);
-  }
+
+  static { Feature.register(this as any, 'network') }
   
   constructor(options: K, context: ContainerContext) {
     super(options, context);
@@ -58,4 +75,4 @@ export class Network<
   }
 }
 
-export default features.register('network', Network)
+export default Network

package/src/web/features/speech.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from "../feature.js";
-import { Container, type ContainerContext } from "../container.js";
+import { Feature } from "../feature.js";
+import { type ContainerContext } from "../container.js";
 
 export const SpeechOptionsSchema = FeatureOptionsSchema.extend({
   voice: z.string().optional().describe('The voice to use for the speech'),
@@ -23,18 +23,35 @@ type Voice = {
   default: boolean;
 };  
 
+/**
+ * Text-to-speech synthesis using the Web Speech API (SpeechSynthesis).
+ *
+ * Wraps the browser's built-in speech synthesis, providing voice selection,
+ * queue management, and state tracking. Voices are discovered on init and
+ * exposed via state for UI binding.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const speech = container.feature('speech')
+ * speech.say('Hello from the browser!')
+ *
+ * // Choose a specific voice
+ * const speech = container.feature('speech', { voice: 'Google UK English Female' })
+ * speech.say('Cheerio!')
+ * ```
+ */
 export class Speech<
   T extends SpeechState = SpeechState,
   K extends SpeechOptions = SpeechOptions
 > extends Feature<T, K> {
 
-  static attach(container: Container & { speech?: Speech }) {
-    container.features.register("speech", Speech);
-  }
-
   static override stateSchema = SpeechStateSchema
   static override optionsSchema = SpeechOptionsSchema
   static override shortcut = "features.speech" as const
+
+  static { Feature.register(this as any, 'speech') }
   
   constructor(options: K, context: ContainerContext) {
     super(options,context)  
@@ -84,4 +101,4 @@ export class Speech<
   }
 }
 
-export default features.register("speech", Speech);
+export default Speech;

package/src/web/features/vault.ts

@@ -1,8 +1,7 @@
 // @ts-nocheck
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from '../feature.js'
-import { WebContainer} from '../container.js'
+import { Feature } from '../feature.js'
 
 export const WebVaultStateSchema = FeatureStateSchema.extend({
   secret: z.string().optional().describe('Base64-encoded AES-GCM encryption secret key'),
@@ -15,10 +14,29 @@ export const WebVaultOptionsSchema = FeatureOptionsSchema.extend({
 export type WebVaultState = z.infer<typeof WebVaultStateSchema>
 export type WebVaultOptions = z.infer<typeof WebVaultOptionsSchema>
 
+/**
+ * AES-256-GCM encryption and decryption for the browser using the Web Crypto API.
+ *
+ * Generates or accepts a secret key and provides `encrypt()` / `decrypt()` methods
+ * that work entirely client-side. Keys are stored as base64-encoded state so they
+ * can persist across sessions when needed.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const vault = container.feature('vault')
+ * const encrypted = await vault.encrypt('secret data')
+ * const decrypted = await vault.decrypt(encrypted)
+ * console.log(decrypted) // 'secret data'
+ * ```
+ */
 export class WebVault extends Feature<WebVaultState, WebVaultOptions> {
   static override stateSchema = WebVaultStateSchema
   static override optionsSchema = WebVaultOptionsSchema
   static override shortcut = "features.vault" as const
+
+  static { Feature.register(this, 'vault') }
   
   async secret({ refresh = false, set = true } = {}) : Promise<ArrayBuffer> {
     if (!this.state.get('secret') && this.options.secret) {
@@ -67,7 +85,7 @@ export class WebVault extends Feature<WebVaultState, WebVaultOptions> {
   }
 }
 
-export default features.register('vault', WebVault)
+export default WebVault
 
 async function generateSecretKey(): Promise<ArrayBuffer> {
   const key = await crypto.subtle.generateKey(

package/src/web/features/vm.ts

@@ -3,8 +3,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import vm from '../shims/isomorphic-vm'
-import { Feature, features } from "../feature.js";
-import { Container } from '../../container.js';
+import { Feature } from "../feature.js";
 
 export const VMStateSchema = FeatureStateSchema.extend({})
 
@@ -15,25 +14,33 @@ export const VMOptionsSchema = FeatureOptionsSchema.extend({
 export type VMState = z.infer<typeof VMStateSchema>
 export type VMOptions = z.infer<typeof VMOptionsSchema>
 
-/** 
- * The VM features providers a virtual machine for executing JavaScript code in a sandboxed environment.
- * 
- * The Vm feature automatically injects the container.context object into the global scope, so these things
- * can be referenced in the code and the code can use anything provided by the container. 
-*/
+/**
+ * Sandboxed JavaScript execution environment for the browser.
+ *
+ * Automatically injects the container's context object into the global scope,
+ * so evaluated code can use anything provided by the container. Useful for
+ * live code playgrounds, plugin systems, and dynamic script evaluation.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const vm = container.feature('vm')
+ * const result = vm.run('1 + 2 + 3') // 6
+ * const greeting = vm.run('container.uuid') // accesses container globals
+ * ```
+ */
 export class VM<
   T extends VMState = VMState,
   K extends VMOptions = VMOptions
 > extends Feature<T, K> {
 
-  static attach(container: Container) {
-    container.features.register('vm', VM)    
-  }
-
   static override stateSchema = VMStateSchema
   static override optionsSchema = VMOptionsSchema
   static override shortcut = "features.vm" as const
 
+  static { Feature.register(this, 'vm') }
+
   createScript(code: string) {
     return new vm.Script(code)
   }
@@ -75,4 +82,4 @@ export class VM<
   }
 }
 
-export default features.register("vm", VM);
+export default VM;

package/src/web/features/voice-recognition.ts

@@ -1,7 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from "../../feature.js";
-import { type WebFeatures, type Container, type ContainerContext } from '../container.js'
+import { Feature } from "../../feature.js";
+import { type ContainerContext } from '../container.js'
 
 export const VoiceRecognitionOptionsSchema = FeatureOptionsSchema.extend({
   language: z.string().optional().describe('BCP 47 language code for recognition (e.g. en-US)'),
@@ -17,20 +17,37 @@ export const VoiceRecognitionStateSchema = FeatureStateSchema.extend({
 export type VoiceRecognitionOptions = z.infer<typeof VoiceRecognitionOptionsSchema>
 export type VoiceRecognitionState = z.infer<typeof VoiceRecognitionStateSchema>
 
+/**
+ * Speech-to-text recognition using the Web Speech API (SpeechRecognition).
+ *
+ * Wraps the browser's built-in speech recognition, supporting continuous
+ * listening, interim results, and language selection. Recognized text is
+ * accumulated in state and emitted as events for real-time transcription UIs.
+ *
+ * @extends Feature
+ *
+ * @example
+ * ```typescript
+ * const voice = container.feature('voice', { continuous: true, autoListen: true })
+ *
+ * voice.on('transcript', ({ text }) => {
+ *   console.log('Heard:', text)
+ * })
+ *
+ * // Or start manually
+ * voice.start()
+ * ```
+ */
 export class VoiceRecognition<T extends VoiceRecognitionState = VoiceRecognitionState, K extends VoiceRecognitionOptions = VoiceRecognitionOptions> extends Feature<T, K> {
   // @ts-ignore-next-line
   private recognition: SpeechRecognition | null = null;
 
-  static attach(container: Container<WebFeatures> & { voice?: VoiceRecognition }, options?: VoiceRecognitionOptions) {
-    container.features.register('voice', VoiceRecognition)
-    container.feature('voice', { enable: true })
-    return container
-  }
-
   static override stateSchema = VoiceRecognitionStateSchema
   static override optionsSchema = VoiceRecognitionOptionsSchema
   static override shortcut = "features.voice" as const
 
+  static { Feature.register(this as any, 'voice') }
+
   constructor(options: K, context: ContainerContext) {
     super(options, context);
 
@@ -126,4 +143,4 @@ export class VoiceRecognition<T extends VoiceRecognitionState = VoiceRecognition
   }
 }
 
-export default features.register("voice", VoiceRecognition);
+export default VoiceRecognition;