@soederpop/luca 0.0.2 → 0.0.4

package/src/node/features/repl.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from "../feature.js";
+import { Feature } from "../feature.js";
 import vm from 'vm'
 import readline from 'readline'
 import { displayResult } from '../../commands/eval.js'
@@ -36,6 +36,7 @@ export class Repl<
   static override shortcut = "features.repl" as const
   static override stateSchema = ReplStateSchema
   static override optionsSchema = ReplOptionsSchema
+  static { Feature.register(this, 'repl') }
 
   /** Whether the REPL session is currently running. */
   get isStarted() {
@@ -191,4 +192,4 @@ export class Repl<
   }
 }
 
-export default features.register("repl", Repl);
+export default Repl

package/src/node/features/runpod.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from '../feature'
+import { Feature } from '../feature'
 import axios from 'axios'
 
 export const RunpodStateSchema = FeatureStateSchema.extend({})
@@ -35,6 +35,7 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
   static override envVars = ['RUNPOD_API_KEY']
   static override stateSchema = RunpodStateSchema
   static override optionsSchema = RunpodOptionsSchema
+  static { Feature.register(this, 'runpod') }
 
 	/** The proc feature used for executing CLI commands like runpodctl. */
 	get proc() {
@@ -607,8 +608,7 @@ export class Runpod extends Feature<RunpodState, RunpodOptions> {
 
 }
 
-export default features.register('runpod', Runpod)
-
+export default Runpod
 /** Shell-escape a string for safe use in SSH commands */
 function esc(s: string): string {
 	return `'${s.replace(/'/g, "'\\''")}'`

package/src/node/features/secure-shell.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from '../feature.js'
+import { Feature } from '../feature.js'
 
 export const SecureShellStateSchema = FeatureStateSchema.extend({
 	/** Whether an SSH connection is currently active */
@@ -49,6 +49,7 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
   static override shortcut = 'features.secureShell' as const
   static override stateSchema = SecureShellStateSchema
   static override optionsSchema = SecureShellOptionsSchema
+  static { Feature.register(this, 'secureShell') }
 
 	override get initialState(): SecureShellState {
 		return {
@@ -245,4 +246,4 @@ export class SecureShell extends Feature<SecureShellState, SecureShellOptions> {
 	}
 }
 
-export default features.register('secureShell', SecureShell)
+export default SecureShell

package/src/node/features/semantic-search.ts

@@ -1,8 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import type { Container } from '@soederpop/luca/container'
 import { type AvailableFeatures } from '@soederpop/luca/feature'
-import { features, Feature } from '../feature.js'
+import { Feature } from '../feature.js'
 import { Database } from 'bun:sqlite'
 import { createHash } from 'node:crypto'
 import { mkdirSync, existsSync, statSync } from 'node:fs'
@@ -275,6 +274,7 @@ export class SemanticSearch extends Feature<SemanticSearchState, SemanticSearchO
 	static override stateSchema = SemanticSearchStateSchema
 	static override optionsSchema = SemanticSearchOptionsSchema
 	static override shortcut = 'features.semanticSearch' as const
+	static { Feature.register(this, 'semanticSearch') }
 
 	private _db: Database | null = null
 	private _llamaContext: any = null
@@ -283,10 +283,6 @@ export class SemanticSearch extends Feature<SemanticSearchState, SemanticSearchO
 	private _idleTimer: ReturnType<typeof setTimeout> | null = null
 	private _dimensions: number
 
-	static attach(container: Container<AvailableFeatures, any>) {
-		features.register('semanticSearch', SemanticSearch)
-		return container
-	}
 
 	override get initialState(): SemanticSearchState {
 		return {
@@ -922,3 +918,5 @@ export class SemanticSearch extends Feature<SemanticSearchState, SemanticSearchO
 		this.state.set('dbReady', false)
 	}
 }
+
+export default SemanticSearch

package/src/node/features/sqlite.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { Database } from 'bun:sqlite'
-import { Feature, features } from '../feature.js'
+import { Feature } from '../feature.js'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
 import type { ContainerContext } from '../../container.js'
 
@@ -69,6 +69,7 @@ export class Sqlite extends Feature<SqliteState, SqliteOptions> {
   static override stateSchema = SqliteStateSchema
   static override optionsSchema = SqliteOptionsSchema
   static override eventsSchema = SqliteEventsSchema
+  static { Feature.register(this, 'sqlite') }
 
   private _db: Database
 
@@ -247,8 +248,7 @@ export class Sqlite extends Feature<SqliteState, SqliteOptions> {
   }
 }
 
-export default features.register('sqlite', Sqlite)
-
+export default Sqlite
 declare module '../../feature.js' {
   interface AvailableFeatures {
     sqlite: typeof Sqlite

package/src/node/features/telegram.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 { Bot, webhookCallback, type Context, type Middleware } from 'grammy'
 
 type UserFromGetMe = Awaited<ReturnType<Bot['api']['getMe']>>
@@ -80,6 +80,7 @@ export class Telegram extends Feature<TelegramState, TelegramOptions> {
   static override stateSchema = TelegramStateSchema
   static override optionsSchema = TelegramOptionsSchema
   static override eventsSchema = TelegramEventsSchema
+  static { Feature.register(this, 'telegram') }
 
   private _bot?: Bot
 
@@ -339,4 +340,4 @@ export class Telegram extends Feature<TelegramState, TelegramOptions> {
 
 }
 
-export default features.register('telegram', Telegram)
+export default Telegram

package/src/node/features/tts.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 { createHash } from 'crypto'
 
 const CHATTERBOX_ENDPOINT = 'https://api.runpod.ai/v2/chatterbox-turbo/runsync'
@@ -61,6 +61,7 @@ export class TTS extends Feature<TTSState, TTSOptions> {
   static override stateSchema = TTSStateSchema
   static override optionsSchema = TTSOptionsSchema
   static override eventsSchema = TTSEventsSchema
+  static { Feature.register(this, 'tts') }
 
   /** RunPod API key from options or environment. */
   get apiKey(): string {
@@ -181,4 +182,4 @@ export class TTS extends Feature<TTSState, TTSOptions> {
   }
 }
 
-export default features.register('tts', TTS)
+export default TTS

package/src/node/features/ui.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema } from '../../schemas/base.js'
-import { features, Feature } from "../feature.js";
+import { Feature } from "../feature.js";
 import colors from "chalk";
 import type { Fonts } from "figlet";
 
@@ -119,6 +119,7 @@ type ColoredPrintFunction = PrintFunction & {
  * ```
  */
 export class UI<T extends UIState = UIState> extends Feature<T> {
+  static { Feature.register(this, 'ui') }
   /** The shortcut path for accessing this feature */
   static override shortcut = "features.ui" as const
   static override stateSchema = UIStateSchema
@@ -819,8 +820,7 @@ export class UI<T extends UIState = UIState> extends Feature<T> {
   }
 }
 
-export default features.register("ui", UI);
-
+export default UI
 /**
  * Predefined color palette for automatic color assignment.
  * 

package/src/node/features/vault.ts

@@ -1,8 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import crypto from 'node:crypto'
-import { Feature, features } from '../feature.js'
-import { type NodeContainer } from '../container.js'
+import { Feature } from '../feature.js'
 import { type ContainerContext } from '../../container.js'
 
 export const VaultStateSchema = FeatureStateSchema.extend({
@@ -43,17 +42,8 @@ export class Vault extends Feature<VaultState, VaultOptions> {
   static override shortcut = 'features.vault' as const
   static override stateSchema = VaultStateSchema
   static override optionsSchema = VaultOptionsSchema
+  static { Feature.register(this, 'vault') }
 
-  /**
-   * Attach hook for the Vault feature. Currently a no-op placeholder
-   * for future container-level initialization logic.
-   *
-   * @param c - The node container instance
-   */
-  static attach(c: NodeContainer) {
-
-  }
-  
   constructor(options: VaultOptions, context: ContainerContext) {
     let secret = options.secret
     
@@ -136,8 +126,7 @@ export class Vault extends Feature<VaultState, VaultOptions> {
   }
 }
 
-export default features.register('vault', Vault)
-
+export default Vault
 function generateSecretKey(): Buffer {
   return crypto.randomBytes(32);
 }

package/src/node/features/vm.ts

@@ -2,7 +2,7 @@ import { z } from 'zod'
 import { createRequire } from 'module'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import vm from 'vm'
-import { Feature, features } from "../feature.js";
+import { Feature } from "../feature.js";
 
 export const VMStateSchema = FeatureStateSchema.extend({})
 export type VMState = z.infer<typeof VMStateSchema>
@@ -45,6 +45,7 @@ export class VM<
   static override shortcut = "features.vm" as const
   static override stateSchema = VMStateSchema
   static override optionsSchema = VMOptionsSchema
+  static { Feature.register(this, 'vm') }
 
   /** Map of virtual module IDs to their exports, consulted before Node's native require */
   modules: Map<string, any> = new Map()
@@ -193,8 +194,45 @@ export class VM<
    * }
    * ```
    */
+  /**
+   * Wrap code containing top-level `await` in an async IIFE, injecting
+   * `return` before the last expression so the value is not lost.
+   *
+   * If the code does not contain `await`, or is already wrapped in an
+   * async function/arrow, it is returned unchanged.
+   */
+  wrapTopLevelAwait(code: string): string {
+    if (!/\bawait\b/.test(code) || /^\s*\(?\s*async\b/.test(code)) {
+      return code
+    }
+
+    const lines = code.split('\n')
+
+    // Find the last non-empty line
+    let lastIdx = lines.length - 1
+    while (lastIdx > 0 && !lines[lastIdx].trim()) lastIdx--
+
+    let lastLine = lines[lastIdx]!
+
+    // For single-line code with semicolons (e.g. CLI eval), split the last line
+    // into statements and only try to return the final statement.
+    const stmts = lastLine.split(';').map(s => s.trim()).filter(Boolean)
+    if (stmts.length > 1) {
+      const finalStmt = stmts[stmts.length - 1]!
+      if (!/^\s*(var|let|const|if|for|while|switch|try|throw|class|function|return)\b/.test(finalStmt)) {
+        stmts[stmts.length - 1] = `return ${finalStmt}`
+      }
+      lines[lastIdx] = stmts.join('; ')
+    } else if (!/^\s*(var|let|const|if|for|while|switch|try|throw|class|function|return)\b/.test(lastLine)) {
+      lines[lastIdx] = `return ${lastLine}`
+    }
+
+    return `(async () => {\n${lines.join('\n')}\n})()`
+  }
+
   async run<T extends any>(code: string, ctx: any = {}): Promise<T> {
-    const script = this.createScript(code)
+    const wrapped = this.wrapTopLevelAwait(code)
+    const script = this.createScript(wrapped)
     const context = this.isContext(ctx) ? ctx : this.createContext(ctx)
 
     return (await script.runInContext(context)) as T
@@ -309,4 +347,4 @@ export class VM<
   }
 }
 
-export default features.register("vm", VM);
+export default VM

package/src/node/features/window-manager.ts

@@ -1,6 +1,7 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema, FeatureEventsSchema } from '../../schemas/base.js'
-import { Feature, features } from '../feature.js'
+import { Feature } from '../feature.js'
+import { Bus } from '../../bus.js'
 import { Server as NetServer, Socket } from 'net'
 import { homedir } from 'os'
 import { join, dirname } from 'path'
@@ -154,17 +155,76 @@ export interface WindowAckResult {
   [key: string]: any
 }
 
+// --- Layout Types ---
+
+/**
+ * A single entry in a layout configuration.
+ * Use `type: 'tty'` for terminal windows, `type: 'window'` (or omit) for browser windows.
+ * If `type` is omitted, entries with a `command` field are treated as TTY, otherwise as window.
+ */
+export type LayoutEntry =
+  | ({ type: 'window' } & SpawnOptions)
+  | ({ type: 'tty' } & SpawnTTYOptions)
+  | ({ type?: undefined } & SpawnOptions)
+  | ({ type?: undefined; command: string } & SpawnTTYOptions)
+
+// --- WindowHandle Events ---
+
+interface WindowHandleEvents {
+  close: [msg: any]
+  terminalExited: [msg: any]
+}
+
 // --- WindowHandle ---
 
 /**
  * A lightweight handle to a single native window.
  * Delegates all operations back to the WindowManager instance.
+ * Emits lifecycle events (`close`, `terminalExited`) when the native app reports them.
+ *
+ * @example
+ * ```typescript
+ * const handle = await windowManager.spawn({ url: 'https://example.com' })
+ * handle.on('close', (msg) => console.log('window closed', msg))
+ * handle.on('terminalExited', (info) => console.log('process exited', info))
+ * ```
  */
 export class WindowHandle {
+  private _events = new Bus<WindowHandleEvents>()
+
+  /** The original ack result from spawning this window. */
+  public result: WindowAckResult
+
   constructor(
     public readonly windowId: string,
-    private manager: WindowManager
-  ) {}
+    private manager: WindowManager,
+    result?: WindowAckResult
+  ) {
+    this.result = result ?? {}
+  }
+
+  /** Register a listener for a lifecycle event. */
+  on<E extends keyof WindowHandleEvents>(event: E, listener: (...args: WindowHandleEvents[E]) => void): this {
+    this._events.on(event, listener)
+    return this
+  }
+
+  /** Remove a listener for a lifecycle event. */
+  off<E extends keyof WindowHandleEvents>(event: E, listener?: (...args: WindowHandleEvents[E]) => void): this {
+    this._events.off(event, listener)
+    return this
+  }
+
+  /** Register a one-time listener for a lifecycle event. */
+  once<E extends keyof WindowHandleEvents>(event: E, listener: (...args: WindowHandleEvents[E]) => void): this {
+    this._events.once(event, listener)
+    return this
+  }
+
+  /** Emit a lifecycle event on this handle. */
+  emit<E extends keyof WindowHandleEvents>(event: E, ...args: WindowHandleEvents[E]): void {
+    this._events.emit(event, ...args)
+  }
 
   /** Bring this window to the front. */
   async focus(): Promise<WindowAckResult> {
@@ -234,8 +294,8 @@ interface ClientConnection {
  * ```typescript
  * const wm = container.feature('windowManager', { enable: true, autoListen: true })
  *
- * const result = await wm.spawn({ url: 'https://google.com', width: 800, height: 600 })
- * const handle = wm.window(result.windowId)
+ * const handle = await wm.spawn({ url: 'https://google.com', width: 800, height: 600 })
+ * handle.on('close', (msg) => console.log('window closed'))
  * await handle.navigate('https://news.ycombinator.com')
  * const title = await handle.eval('document.title')
  * await handle.close()
@@ -252,11 +312,13 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
   static override stateSchema = WindowManagerStateSchema
   static override optionsSchema = WindowManagerOptionsSchema
   static override eventsSchema = WindowManagerEventsSchema
+  static { Feature.register(this, 'windowManager') }
 
   private _server?: NetServer
   private _client?: ClientConnection
   private _pending = new Map<string, PendingRequest>()
   private _trackedWindows = new Set<string>()
+  private _handles = new Map<string, WindowHandle>()
 
   private normalizeRequestId(value: unknown): string | undefined {
     if (typeof value !== 'string') return undefined
@@ -405,6 +467,7 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
     }
     this._pending.clear()
     this._trackedWindows.clear()
+    this._handles.clear()
 
     if (this._client) {
       this._client.socket.destroy()
@@ -436,26 +499,29 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
    * Sends a window dispatch to the app and waits for the ack.
    *
    * @param opts - Window configuration (url, dimensions, chrome options)
-   * @returns The window ack result including `windowId`
+   * @returns A WindowHandle for the spawned window (with `.result` containing the ack data)
    */
-  async spawn(opts: SpawnOptions = {}): Promise<WindowAckResult> {
+  async spawn(opts: SpawnOptions = {}): Promise<WindowHandle> {
     const { window: windowChrome, ...flat } = opts
 
+    let ackResult: WindowAckResult
     if (windowChrome) {
-      return this.sendWindowCommand({
+      ackResult = await this.sendWindowCommand({
         action: 'open',
         request: {
           ...flat,
           window: windowChrome,
         },
       })
+    } else {
+      ackResult = await this.sendWindowCommand({
+        action: 'open',
+        ...flat,
+        alwaysOnTop: flat.alwaysOnTop ?? false,
+      })
     }
 
-    return this.sendWindowCommand({
-      action: 'open',
-      ...flat,
-      alwaysOnTop: flat.alwaysOnTop ?? false,
-    })
+    return this.getOrCreateHandle(ackResult.windowId, ackResult)
   }
 
   /**
@@ -464,23 +530,26 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
    * Closing the window terminates the process.
    *
    * @param opts - Terminal configuration (command, args, cwd, dimensions, etc.)
-   * @returns The window ack result including `windowId` and `pid`
+   * @returns A WindowHandle for the spawned terminal (with `.result` containing the ack data)
    */
-  async spawnTTY(opts: SpawnTTYOptions): Promise<WindowAckResult> {
+  async spawnTTY(opts: SpawnTTYOptions): Promise<WindowHandle> {
     const { window: windowChrome, ...flat } = opts
 
+    let ackResult: WindowAckResult
     if (windowChrome) {
-      return this.sendWindowCommand({
+      ackResult = await this.sendWindowCommand({
         action: 'terminal',
         ...flat,
         window: windowChrome,
       })
+    } else {
+      ackResult = await this.sendWindowCommand({
+        action: 'terminal',
+        ...flat,
+      })
     }
 
-    return this.sendWindowCommand({
-      action: 'terminal',
-      ...flat,
-    })
+    return this.getOrCreateHandle(ackResult.windowId, ackResult)
   }
 
   /**
@@ -573,12 +642,78 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
 
   /**
    * Get a WindowHandle for chainable operations on a specific window.
+   * Returns the tracked handle if one exists, otherwise creates a new one.
    *
    * @param windowId - The window ID
    * @returns A WindowHandle instance
    */
   window(windowId: string): WindowHandle {
-    return new WindowHandle(windowId, this)
+    return this.getOrCreateHandle(windowId)
+  }
+
+  /**
+   * Spawn multiple windows in parallel from a layout configuration.
+   * Returns handles in the same order as the config entries.
+   *
+   * @param config - Array of layout entries (window or tty)
+   * @returns Array of WindowHandle instances
+   *
+   * @example
+   * ```typescript
+   * const handles = await wm.spawnLayout([
+   *   { type: 'window', url: 'https://google.com', width: 800, height: 600 },
+   *   { type: 'tty', command: 'htop' },
+   *   { url: 'https://github.com' }, // defaults to window
+   * ])
+   * ```
+   */
+  async spawnLayout(config: LayoutEntry[]): Promise<WindowHandle[]> {
+    const promises = config.map(entry => {
+      if (entry.type === 'tty' || ('command' in entry && !entry.type)) {
+        const { type, ...opts } = entry as { type?: string } & SpawnTTYOptions
+        return this.spawnTTY(opts)
+      } else {
+        const { type, ...opts } = entry as { type?: string } & SpawnOptions
+        return this.spawn(opts)
+      }
+    })
+    return Promise.all(promises)
+  }
+
+  /**
+   * Spawn multiple layouts sequentially. Each layout's windows spawn in parallel,
+   * but the next layout waits for the previous one to fully complete.
+   *
+   * @param configs - Array of layout configurations
+   * @returns Array of handle arrays, one per layout
+   *
+   * @example
+   * ```typescript
+   * const [firstBatch, secondBatch] = await wm.spawnLayouts([
+   *   [{ url: 'https://google.com' }, { url: 'https://github.com' }],
+   *   [{ type: 'tty', command: 'htop' }],
+   * ])
+   * ```
+   */
+  async spawnLayouts(configs: LayoutEntry[][]): Promise<WindowHandle[][]> {
+    const results: WindowHandle[][] = []
+    for (const config of configs) {
+      results.push(await this.spawnLayout(config))
+    }
+    return results
+  }
+
+  /** Get or create a tracked WindowHandle for a given windowId. */
+  private getOrCreateHandle(windowId: string | undefined, result?: WindowAckResult): WindowHandle {
+    const id = windowId || randomUUID()
+    let handle = this._handles.get(id)
+    if (!handle) {
+      handle = new WindowHandle(id, this, result)
+      this._handles.set(id, handle)
+    } else if (result) {
+      handle.result = result
+    }
+    return handle
   }
 
   // --- Private internals ---
@@ -612,6 +747,7 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
       if (this._client === client) {
         this._client = undefined
         this._trackedWindows.clear()
+        this._handles.clear()
         this.setState({ clientConnected: false, windowCount: 0 })
 
         // Resolve all pending requests — the app is gone, no acks coming
@@ -664,10 +800,17 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
 
     if (msg.type === 'windowClosed') {
       this.trackWindowClosed(msg.windowId)
+      const handle = this._handles.get(msg.windowId)
+      if (handle) {
+        handle.emit('close', msg)
+        this._handles.delete(msg.windowId)
+      }
       this.emit('windowClosed', msg)
     }
 
     if (msg.type === 'terminalExited') {
+      const handle = msg.windowId ? this._handles.get(msg.windowId) : undefined
+      if (handle) handle.emit('terminalExited', msg)
       this.emit('terminalExited', msg)
     }
 
@@ -801,4 +944,4 @@ export class WindowManager extends Feature<WindowManagerState, WindowManagerOpti
   }
 }
 
-export default features.register('windowManager', WindowManager)
+export default WindowManager

package/src/node/features/yaml-tree.ts

@@ -1,6 +1,6 @@
 import { z } from 'zod'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
-import { Feature, features } from "../feature.js";
+import { Feature } from "../feature.js";
 import { NodeContainer } from "../container.js";
 import { camelCase, omit, set } from 'lodash-es'
 
@@ -36,6 +36,7 @@ export type YamlTreeState = z.infer<typeof YamlTreeStateSchema>
  * @extends {Feature<T>}
  */
 export class YamlTree<T extends YamlTreeState = YamlTreeState> extends Feature<T> {
+  static { Feature.register(this, 'yamlTree') }
   /** The shortcut path for accessing this feature */
   static override shortcut = "features.yamlTree" as const
   static override stateSchema = YamlTreeStateSchema
@@ -49,7 +50,6 @@ export class YamlTree<T extends YamlTreeState = YamlTreeState> extends Feature<T
    * @returns The container for method chaining
    */
   static attach(container: NodeContainer & { yamlTree?: YamlTree }) {
-    container.features.register("yamlTree", YamlTree);
     container.yamlTree = container.feature("yamlTree", { enable: true });
   }
 
@@ -145,5 +145,4 @@ export class YamlTree<T extends YamlTreeState = YamlTreeState> extends Feature<T
   }
 }
 
-export default features.register("yamlTree", YamlTree);
-
+export default YamlTree

package/src/node/features/yaml.ts

@@ -1,5 +1,5 @@
 import * as yaml from 'js-yaml'
-import { Feature, features } from '../feature.js'
+import { Feature } from '../feature.js'
 import { FeatureStateSchema, FeatureOptionsSchema } from '../../schemas/base.js'
 import { NodeContainer } from '../container.js'
 
@@ -33,6 +33,7 @@ export class YAML extends Feature {
   static override shortcut = 'features.yaml' as const
   static override stateSchema = FeatureStateSchema
   static override optionsSchema = FeatureOptionsSchema
+  static { Feature.register(this, 'yaml') }
 
   /**
    * Automatically attaches the YAML feature to Node containers.
@@ -129,4 +130,4 @@ export class YAML extends Feature {
   }
 }
 
-export default features.register('yaml', YAML)
+export default YAML

package/src/registry.ts

@@ -101,7 +101,7 @@ abstract class Registry<T extends Helper> {
       throw new Error(
         `${this.scope} "${id}" is not registered.${suggestion}\n\n` +
         `To fix this, ensure the module that defines "${id}" is imported (e.g. import './${this.scope}/${id}') ` +
-        `or registered on the container (e.g. container.use(${id[0]!.toUpperCase() + id.slice(1)})).`
+        `or registered on the container (e.g. container.use(${id ? id[0]!.toUpperCase() + id.slice(1) : 'MyHelper'})).`
       )
     }