@electrojs/runtime 1.0.7 → 1.0.9

package/dist/index.d.mts

@@ -252,6 +252,7 @@ declare function scanModules(rootModule: Constructor): AppDefinition;
  * @Injectable()
  * class DatabaseService implements LifecycleTarget {
  *     async onInit() { await this.connect(); }
+ *     async onStart() { await this.startReplication(); }
  *     async onShutdown() { await this.disconnect(); }
  * }
  * ```
@@ -263,7 +264,9 @@ declare function scanModules(rootModule: Constructor): AppDefinition;
 interface LifecycleTarget {
   /** Called during initialization phase. Use for setting up connections, state, etc. */
   onInit?(): void | Promise<void>;
-  /** Called after all modules have been initialized. Use for cross-module coordination. */
+  /** Called after the Electron app is ready. Use for startup side effects such as windows, jobs, and launch flows. */
+  onStart?(): void | Promise<void>;
+  /** Called after startup work completes. Use for final coordination before the kernel becomes `started`. */
   onReady?(): void | Promise<void>;
   /** Called during graceful shutdown. Use for releasing resources, closing connections. */
   onShutdown?(): void | Promise<void>;
@@ -274,6 +277,8 @@ interface LifecycleTarget {
  * Represents the current phase of a module's lifecycle.
  *
  * Transitions follow a strict state machine: creating -> ready -> started -> stopping -> stopped.
+ * Modules may also transition directly from `ready` to `stopped` if the kernel is
+ * shut down after initialization but before startup completes.
  * Any state can also transition to "failed".
  */
 type ModuleStatus = "creating" | "ready" | "started" | "stopping" | "stopped" | "failed";
@@ -386,6 +391,7 @@ interface AppKernelOptions {
  * @example
  * ```ts
  * const kernel = AppKernel.create(AppModule);
+ * await kernel.initialize();
  * await kernel.start();
  *
  * // ... app is running ...
@@ -394,10 +400,10 @@ interface AppKernelOptions {
  * ```
  *
  * @remarks
- * - Calling {@link start} when already started is a no-op.
- * - If startup fails, the kernel automatically rolls back initialized modules and
+ * - Calling {@link initialize} when already initialized is a no-op.
+ * - Calling {@link start} from `idle` first performs {@link initialize} for backward compatibility.
+ * - If initialization or startup fails, the kernel automatically rolls back initialized modules and
  *   transitions to `failed`.
- * - {@link shutdown} can only be called from the `started` state.
  */
 declare class AppKernel {
   private state;
@@ -407,289 +413,250 @@ declare class AppKernel {
   private readonly logger;
   private readonly stateListeners;
   private readonly disposers;
+  private initializeTask?;
+  private startTask?;
+  private shutdownTask?;
   private constructor();
   /**
    * Creates a new kernel instance for the given root module.
-   * The kernel starts in the `idle` state -- call {@link start} to bootstrap the application.
+   * The kernel starts in the `idle` state -- call {@link initialize} and/or {@link start} to bootstrap the application.
    */
   static create(rootModule: Constructor, options?: AppKernelOptions): AppKernel;
   /**
-   * Bootstraps and starts the application.
+   * Builds the application graph and runs the initialization lifecycle.
    *
    * Performs module scanning, validation, DI container creation, module instantiation,
-   * capability installation, and runs `onInit` / `onReady` lifecycle hooks.
-   * On failure, automatically rolls back and transitions to `failed`.
+   * capability installation, and runs `onInit`.
    *
-   * @remarks No-op if already started. Must be called from `idle` state.
+   * @remarks Safe to call before `app.whenReady()`. No-op if already initialized or started.
    * @throws {BootstrapError} On invalid module graph or decorator metadata.
    * @throws {LifecycleError} On lifecycle hook failure.
    */
+  initialize(): Promise<void>;
+  /**
+   * Starts the application after initialization.
+   *
+   * Runs `onStart` and `onReady` lifecycle hooks. Bridge calls from renderer processes
+   * become available at the beginning of the `starting` phase.
+   *
+   * @remarks No-op if already started. Calling from `idle` first performs {@link initialize}.
+   * @throws {LifecycleError} On lifecycle hook failure.
+   */
   start(): Promise<void>;
   /**
    * Gracefully shuts down the application.
    *
-   * Runs `onShutdown` / `onDispose` lifecycle hooks in reverse module order,
-   * then disposes framework services (jobs, windows, views).
+   * Runs `onShutdown` / `onDispose` for started kernels, or only `onDispose` if the
+   * kernel was initialized but never started.
    *
-   * @remarks No-op if `idle` or already `stopped`. Throws if not in `started` state.
-   * @throws {LifecycleError} If the kernel is not in the `started` state.
+   * @remarks No-op if `idle`, `stopped`, or already `failed`.
+   * @throws {LifecycleError} If shutdown is requested while startup is still in progress.
    */
   shutdown(): Promise<void>;
   /** Returns the current kernel lifecycle state. */
   getState(): KernelState;
   /** Convenience check: returns `true` only when the kernel is in the `started` state. */
   isStarted(): boolean;
-  /** Returns the scanned app definition, or `undefined` if the kernel has not been started yet. */
+  /** Returns the scanned app definition, or `undefined` if the kernel has not been initialized yet. */
   getDefinition(): AppDefinition | undefined;
-  /** Returns the live module references, or an empty array if the kernel has not been started yet. */
+  /** Returns the live module references, or an empty array if the kernel has not been initialized yet. */
   getModuleRefs(): readonly ModuleRef[];
   /** @internal Hook for subsystems that need to react to kernel state changes. */
   onStateChange(callback: (state: KernelState) => void): void;
+  private performInitialize;
+  private performStart;
+  private performShutdown;
+  private getPreviousRunningState;
   private registerFrameworkServices;
   private disposeServices;
   private transitionTo;
   private safeDisposeServices;
 }
 //#endregion
-//#region src/container/inject.d.ts
+//#region src/desktop/view-manager.d.ts
 /**
- * Resolve a dependency from the current injection context.
+ * Framework-internal registry that tracks all `@View()` providers in the application.
  *
- * This is the primary way framework-managed classes obtain their dependencies.
- * It reads the active {@link Injector} from `AsyncLocalStorage` and delegates to
- * {@link Injector.get}.
+ * Handles registration (including injecting the source URL into the base class)
+ * and provides lookup by view ID. Consumers typically interact with views through
+ * their {@link ViewProvider} subclass rather than this manager directly.
  *
- * @remarks
- * `inject()` is only available inside a framework-managed execution scope:
- * - **Construction** -- property initializers of `@Injectable()`, `@Module()`, `@View()`, or `@Window()` classes
- * - **Lifecycle hooks** -- `onInit`, `onReady`, `onShutdown`, `onDispose`
- * - **Capability handlers** -- methods decorated with `@command`, `@query`, `@signal`, or `@job`
+ * @internal
+ */
+declare class ViewManager {
+  private readonly views;
+  /**
+   * Register a view provider and apply its `@View()` source URL.
+   *
+   * @remarks Silently skips providers that do not have view metadata.
+   */
+  register(providerRef: ProviderRef): void;
+  /** Look up a registered view provider by its view ID. */
+  get(viewId: string): ProviderRef | undefined;
+  /** Return all registered view providers. */
+  list(): readonly ProviderRef[];
+  /** Clear the registry. Does not destroy any underlying web contents. */
+  dispose(): Promise<void>;
+}
+//#endregion
+//#region src/desktop/view-provider.d.ts
+declare const VIEW_STATE: unique symbol;
+interface ViewAuthoringSurface {
+  readonly contentView: WebContentsView | undefined;
+  readonly webContents: WebContents | undefined;
+  load(): Promise<void>;
+  setBounds(bounds: Rectangle): void;
+  setBackgroundColor(color: string): void;
+  focus(): void;
+  setWindowButtonVisibility(visible: boolean): void;
+}
+/**
+ * Abstract base class for view providers decorated with `@View()`.
  *
- * Calling it anywhere else (e.g. in a `setTimeout` callback or a plain function)
- * throws {@link DIError} with code `ELECTRO_DI_NO_INJECTION_CONTEXT`.
+ * Extend this class to define a renderable view in your application. The framework
+ * injects the source URL from the `@View()` decorator, and your subclass gains access
+ * to methods for loading content, positioning, and styling.
+ *
+ * Views are created with strict security defaults: `sandbox: true`,
+ * `contextIsolation: true`, and `nodeIntegration: false`.
+ *
+ * @remarks The `WebContentsView` is lazily created on the first call to {@link load}.
  *
  * @example
  * ```ts
- * @Injectable()
- * class MyService {
- *   private readonly config = inject(AppConfig);
+ * @View({ source: 'view:main', access: ['app:getVersion'] })
+ * class MainView extends ViewProvider {
+ *     async onStart() {
+ *         await this.load();
+ *         this.setBounds({ x: 0, y: 0, width: 800, height: 600 });
+ *     }
  * }
  * ```
- *
- * @throws {@link DIError} if no injection context is active or the token cannot be resolved.
  */
-declare function inject<T>(token: InjectionToken<T>): T;
+declare abstract class ViewProvider {
+  private [VIEW_STATE];
+  /** The underlying Electron `WebContentsView`, or `undefined` if not yet created. */
+  get contentView(): WebContentsView | undefined;
+  /** The `WebContents` associated with this view, or `undefined` if not yet created. */
+  get webContents(): WebContents | undefined;
+  /**
+   * Create the underlying `WebContentsView` (if needed) and load the configured source URL.
+   *
+   * The view is lazily created on the first call. Subsequent calls reload the source.
+   * If the previous view was destroyed (e.g. parent window closed), a new one is created.
+   * No-ops if no source URL has been configured.
+   */
+  load(): Promise<void>;
+  /** Set the position and size of this view within its parent window. */
+  setBounds(bounds: Rectangle): void;
+  /** Set the background color of the view (e.g. `"#ffffff"` or `"transparent"`). */
+  setBackgroundColor(color: string): void;
+  /** Give keyboard focus to this view's web contents. */
+  focus(): void;
+  /** Show or hide the native window traffic-light buttons for this view (macOS). */
+  setWindowButtonVisibility(visible: boolean): void;
+  private createView;
+  private static resolveSource;
+  /** @internal Called by the framework to set the view source from @View metadata. */
+  static __setSource(instance: ViewProvider, source: string): void;
+  /** @internal Called by the framework to set web preferences from @View metadata. */
+  static __setWebPreferences(instance: ViewProvider, webPreferences: WebPreferences): void;
+}
 //#endregion
-//#region src/container/injection-context.d.ts
+//#region src/desktop/window-manager.d.ts
 /**
- * Ambient injection context backed by `AsyncLocalStorage`.
- *
- * The framework uses `InjectionContext` to make the current {@link Injector} available
- * to {@link inject} calls without requiring explicit injector references. It is set
- * automatically during provider construction, lifecycle hooks, and capability handlers.
+ * Framework-internal registry that tracks all `@Window()` providers in the application.
  *
- * @remarks
- * This is a framework-internal API. Application code should use {@link inject} instead
- * of interacting with `InjectionContext` directly.
+ * Handles registration (including injecting `@Window()` configuration into the base class)
+ * and provides lookup by window ID. Consumers typically interact with windows through
+ * their {@link WindowProvider} subclass rather than this manager directly.
  *
  * @internal
  */
-declare const InjectionContext: {
-  /**
-   * Execute `fn` within the scope of the given injector.
-   * Any {@link inject} call made synchronously inside `fn` will resolve from this injector.
-   */
-  readonly run: <T>(injector: Injector, fn: () => T) => T;
+declare class WindowManager {
+  private readonly windows;
   /**
-   * Execute `fn` within the scope of the given injector, additionally tracking `owner`
-   * as the object currently being constructed or invoked.
+   * Register a window provider and apply its `@Window()` configuration.
+   *
+   * @remarks Silently skips providers that do not have window metadata.
    */
-  readonly runOwned: <T>(injector: Injector, owner: object, fn: () => T) => T; /** Return the injector for the current execution context, or `undefined` if none is active. */
-  readonly current: () => Injector | undefined; /** Return the owner object of the current execution context, or `undefined` if not set. */
-  readonly currentOwner: () => object | undefined; /** Whether a framework-managed injection context is currently active. */
-  readonly isActive: () => boolean;
-};
-//#endregion
-//#region src/modules/registry.d.ts
-/**
- * Serializable point-in-time view of a provider's registration state.
- * Produced by {@link ModuleRegistry.snapshot} for runtime introspection and tooling.
- */
-interface ProviderSnapshot {
-  readonly id: string;
-  readonly target: string;
-  readonly kind: "provider" | "view" | "window";
-  readonly scope: string;
-  /** Bridge channels this provider exposes (commands and queries). */
-  readonly bridgeChannels: readonly string[];
-  /** Signal IDs this provider subscribes to. */
-  readonly signalIds: readonly string[];
-  /** Scheduled job IDs registered by this provider. */
-  readonly jobIds: readonly string[];
+  register(providerRef: ProviderRef): void;
+  /** Look up a registered window provider by its window ID. */
+  get(windowId: string): ProviderRef | undefined;
+  /** Return all registered window providers. */
+  list(): readonly ProviderRef[];
+  /** Close all managed windows and clear the registry. */
+  dispose(): Promise<void>;
 }
-/**
- * Serializable point-in-time view of a module's registration and lifecycle state.
- * Produced by {@link ModuleRegistry.snapshot} for runtime introspection and tooling (e.g. CLI module graph).
- */
-interface ModuleSnapshot {
-  readonly id: string;
-  readonly target: string;
-  readonly status: ModuleStatus;
-  /** IDs of modules this module imports. */
-  readonly imports: readonly string[];
-  /** Class names of providers this module exports. */
-  readonly exports: readonly string[];
-  readonly providers: readonly ProviderSnapshot[];
+//#endregion
+//#region src/desktop/window-provider.d.ts
+declare const WINDOW_STATE: unique symbol;
+interface WindowAuthoringSurface {
+  readonly window: BaseWindow | undefined;
+  create(): void;
+  mount(view: Pick<ViewProvider, "contentView">): void;
+  show(): void;
+  hide(): void;
+  focus(): void;
+  close(): void;
+  getBounds(): Rectangle | undefined;
 }
 /**
- * Central registry of all loaded modules in the application.
+ * Abstract base class for window providers decorated with `@Window()`.
  *
- * Provides lookup by class constructor or module ID, and produces serializable
- * snapshots for runtime introspection (e.g. CLI `inspect` commands, debug tooling).
- * Populated once during bootstrap by the capability installer.
+ * Extend this class to define a window in your application. The framework injects
+ * configuration from the `@Window()` decorator metadata, and your subclass gains
+ * access to lifecycle methods like {@link create}, {@link show}, {@link mount}, and {@link close}.
+ *
+ * @remarks The native `BaseWindow` instance is only available after calling {@link create}.
+ * Calling lifecycle methods before `create()` is safe (they no-op) but the window
+ * will not exist on screen.
  *
  * @example
  * ```ts
- * const registry = injector.get(ModuleRegistry);
- * const snapshot = registry.snapshot(); // serializable module graph
+ * @Window({ width: 800, height: 600, show: false })
+ * class MainWindow extends WindowProvider {
+ *     async onStart() {
+ *         this.create();
+ *         this.mount(this.mainView);
+ *         this.show();
+ *     }
+ * }
  * ```
  */
-declare class ModuleRegistry {
-  private readonly modulesByTarget;
-  private readonly modulesById;
-  /** @internal Populate the registry from bootstrap. Called once by the capability installer. */
-  load(moduleRefs: readonly ModuleRef[]): void;
-  /** Looks up a module by its decorated class constructor. */
-  getByTarget(target: Constructor): ModuleRef | undefined;
-  /** Looks up a module by its unique string identifier. */
-  getById(moduleId: string): ModuleRef | undefined;
-  /** Returns all registered modules. */
-  getAll(): readonly ModuleRef[];
-  /** Produces a serializable snapshot of the entire module graph for introspection. */
-  snapshot(): readonly ModuleSnapshot[];
+declare abstract class WindowProvider {
+  private [WINDOW_STATE];
+  /** The underlying Electron `BaseWindow` instance, or `undefined` if not yet created. */
+  get window(): BaseWindow | undefined;
+  /** Create the native `BaseWindow` using configuration from the `@Window()` decorator. */
+  create(): void;
+  /**
+   * Attach a view's content to this window.
+   *
+   * The view's `WebContentsView` is added as a child view of the window's content area.
+   * No-ops silently if the window or view has not been created yet.
+   */
+  mount(view: ViewProvider): void;
+  /** Show the window. No-ops if the window has not been created. */
+  show(): void;
+  /** Hide the window without destroying it. */
+  hide(): void;
+  /** Bring the window to the front and give it focus. */
+  focus(): void;
+  /** Close and destroy the native window, releasing its resources. */
+  close(): void;
+  /** Return the window's current screen bounds, or `undefined` if not created. */
+  getBounds(): Rectangle | undefined;
+  /** @internal Called by the framework to set the window configuration from @Window metadata. */
+  static __setConfiguration(instance: WindowProvider, configuration?: BaseWindowConstructorOptions): void;
 }
 //#endregion
-//#region src/modules/validator.d.ts
+//#region src/jobs/context.d.ts
 /**
- * Validates a scanned {@link AppDefinition} for structural correctness before bootstrap.
+ * Execution context passed to every job handler invocation.
  *
- * Checks performed:
- * - Unique module IDs
- * - Exports reference declared providers
- * - No cyclic module imports
- * - Unique view/window IDs
- * - Unique bridge channel names
- * - Unique job IDs
- * - Provider role exclusivity (a class cannot be both a view and a window)
- * - View access references point to existing bridge channels
- *
- * @throws {BootstrapError} On the first validation failure encountered.
- */
-declare function validateAppDefinition(definition: AppDefinition): void;
-//#endregion
-//#region src/signals/relay.d.ts
-/**
- * Callback invoked by {@link PublicationRelay} whenever a signal is published.
- *
- * Typically used by the renderer registry to forward signals from the main process
- * to renderer processes that have opted in via `@View({ signals: [...] })`.
- */
-type SignalPublishListener = (signalId: string, payload: unknown) => void;
-//#endregion
-//#region src/signals/context.d.ts
-/**
- * Metadata object passed to {@link ContextualSignalHandler} callbacks when a signal is published.
- *
- * Provides contextual information about the publication event. Handlers that need
- * access to this metadata should declare two parameters (context, payload) so the
- * {@link SignalBus} treats them as contextual handlers.
- */
-declare class SignalContext {
-  /** Epoch timestamp (milliseconds) captured at the moment the signal was dispatched to this handler. */
-  readonly timestamp: number;
-}
-//#endregion
-//#region src/signals/bus.d.ts
-/**
- * A callback that receives only the signal payload.
- *
- * Use this form when the handler does not need access to the {@link SignalContext}.
- */
-type SignalListener<T = unknown> = (payload: T) => void | Promise<void>;
-/**
- * A callback that receives both a {@link SignalContext} and the signal payload.
- *
- * Use this form when the handler needs metadata about the publication (e.g. timestamp).
- */
-type ContextualSignalHandler<T = unknown> = (context: SignalContext, payload: T) => void | Promise<void>;
-/**
- * Union of the two supported handler signatures for {@link SignalBus.subscribe}.
- *
- * The bus distinguishes between the two forms by arity: handlers with two or more
- * parameters are treated as {@link ContextualSignalHandler}, all others as {@link SignalListener}.
- */
-type SignalHandler<T = unknown> = SignalListener<T> | ContextualSignalHandler<T>;
-/**
- * Fire-and-forget publish/subscribe signal bus for decoupled inter-module communication.
- *
- * Handlers are dispatched asynchronously via `queueMicrotask`, so `publish()` never blocks
- * the caller. Each handler runs inside the dependency-injection context that was active at
- * the time `subscribe()` was called, which means `inject()` works correctly inside handlers.
- *
- * @example
- * ```ts
- * // Subscribe to a signal (returns an unsubscribe function)
- * const unsub = signalBus.subscribe('user:login', (payload) => {
- *     console.log('User logged in:', payload.userId);
- * });
- *
- * // Publish a signal — all handlers run asynchronously
- * signalBus.publish('user:login', { userId: '42' });
- *
- * // Unsubscribe when no longer needed
- * unsub();
- * ```
- *
- * @example
- * ```ts
- * // Contextual handler with access to SignalContext
- * signalBus.subscribe('data:sync', (context, payload) => {
- *     console.log('Signal published at:', context.timestamp);
- * });
- * ```
- */
-declare class SignalBus {
-  private readonly handlers;
-  private readonly relay;
-  /**
-   * Register a handler for the given signal.
-   *
-   * The handler is bound to the current injection context at call time, so
-   * `inject()` resolves correctly even though the handler runs asynchronously.
-   *
-   * @returns A dispose function that removes the subscription.
-   */
-  subscribe<T>(signalId: string, handler: SignalHandler<T>): () => void;
-  /**
-   * Publish a signal to all registered handlers.
-   *
-   * Handlers are invoked asynchronously via `queueMicrotask` and their errors are
-   * logged but never propagated to the publisher. The signal is also forwarded to
-   * any connected {@link PublicationRelay} listeners (e.g. renderer processes).
-   *
-   * @remarks Payload is optional for signals that carry no data (`SignalBus.publish<void>('app:ready')`).
-   */
-  publish<T = void>(signalId: string, payload?: T): void;
-  /** @internal Connect a relay listener (used by renderer registry). */
-  connectRelay(listener: SignalPublishListener): () => void;
-}
-//#endregion
-//#region src/jobs/context.d.ts
-/**
- * Execution context passed to every job handler invocation.
- *
- * Provides cooperative cancellation and progress reporting. The handler should
- * periodically check {@link isCanceled} and abort work when it returns `true`.
+ * Provides cooperative cancellation and progress reporting. The handler should
+ * periodically check {@link isCanceled} and abort work when it returns `true`.
  *
  * @example
  * ```ts
@@ -819,242 +786,398 @@ declare class JobRegistry {
   private executeJob;
 }
 //#endregion
-//#region src/desktop/renderer-session.d.ts
+//#region src/modules/registry.d.ts
 /**
- * Tracks the capabilities of a single renderer process (identified by `webContentsId`).
+ * Serializable point-in-time view of a provider's registration state.
+ * Produced by {@link ModuleRegistry.snapshot} for runtime introspection and tooling.
+ */
+interface ProviderSnapshot {
+  readonly id: string;
+  readonly target: string;
+  readonly kind: "provider" | "view" | "window";
+  readonly scope: string;
+  /** Bridge channels this provider exposes (commands and queries). */
+  readonly bridgeChannels: readonly string[];
+  /** Signal IDs this provider subscribes to. */
+  readonly signalIds: readonly string[];
+  /** Scheduled job IDs registered by this provider. */
+  readonly jobIds: readonly string[];
+}
+/**
+ * Serializable point-in-time view of a module's registration and lifecycle state.
+ * Produced by {@link ModuleRegistry.snapshot} for runtime introspection and tooling (e.g. CLI module graph).
+ */
+interface ModuleSnapshot {
+  readonly id: string;
+  readonly target: string;
+  readonly status: ModuleStatus;
+  /** IDs of modules this module imports. */
+  readonly imports: readonly string[];
+  /** Class names of providers this module exports. */
+  readonly exports: readonly string[];
+  readonly providers: readonly ProviderSnapshot[];
+}
+/**
+ * Central registry of all loaded modules in the application.
  *
- * Each session records which bridge channels the renderer may invoke and which signals
- * it is allowed to receive, as declared in the `@View()` decorator metadata. The
- * {@link BridgeAccessGuard} and signal relay use this information to enforce per-view
- * access control.
+ * Provides lookup by class constructor or module ID, and produces serializable
+ * snapshots for runtime introspection (e.g. CLI `inspect` commands, debug tooling).
+ * Populated once during bootstrap by the capability installer.
  *
- * @internal Created and managed by {@link RendererRegistry}.
+ * @example
+ * ```ts
+ * const registry = injector.get(ModuleRegistry);
+ * const snapshot = registry.snapshot(); // serializable module graph
+ * ```
  */
-declare class RendererSession {
-  /** The Electron `webContents.id` that uniquely identifies this renderer process. */
-  readonly rendererId: number;
-  /** The view ID this renderer is associated with. */
-  readonly viewId: string;
-  /** Set of bridge channel names this renderer is allowed to invoke. */
-  readonly access: ReadonlySet<string>;
-  /** Set of signal IDs this renderer is allowed to receive. */
-  readonly allowedSignals: ReadonlySet<string>;
-  constructor(/** The Electron `webContents.id` that uniquely identifies this renderer process. */
-
-  rendererId: number, viewDef: ViewDefinition);
-  /** Check whether this renderer has access to the given bridge channel. */
-  hasAccess(channel: string): boolean;
-  /** Check whether this renderer is allowed to receive the given signal. */
-  canReceiveSignal(signalId: string): boolean;
+declare class ModuleRegistry {
+  private readonly modulesByTarget;
+  private readonly modulesById;
+  /** @internal Populate the registry from bootstrap. Called once by the capability installer. */
+  load(moduleRefs: readonly ModuleRef[]): void;
+  /** Looks up a module by its decorated class constructor. */
+  getByTarget(target: Constructor): ModuleRef | undefined;
+  /** Looks up a module by its unique string identifier. */
+  getById(moduleId: string): ModuleRef | undefined;
+  /** Returns all registered modules. */
+  getAll(): readonly ModuleRef[];
+  /** Produces a serializable snapshot of the entire module graph for introspection. */
+  snapshot(): readonly ModuleSnapshot[];
 }
 //#endregion
-//#region src/desktop/renderer-registry.d.ts
+//#region src/signals/relay.d.ts
 /**
- * Maps Electron `webContentsId` values to {@link RendererSession} instances.
+ * Callback invoked by {@link PublicationRelay} whenever a signal is published.
  *
- * Used by the bridge layer to look up which renderer process is making an IPC request
- * and determine what channels and signals it is allowed to access. View definitions are
- * registered at bootstrap time; sessions are created lazily when a renderer first
- * communicates.
+ * Typically used by the renderer registry to forward signals from the main process
+ * to renderer processes that have opted in via `@View({ signals: [...] })`.
+ */
+type SignalPublishListener = (signalId: string, payload: unknown) => void;
+//#endregion
+//#region src/signals/context.d.ts
+/**
+ * Metadata object passed to {@link ContextualSignalHandler} callbacks when a signal is published.
  *
- * @internal
+ * Provides contextual information about the publication event. Handlers that need
+ * access to this metadata should declare two parameters (context, payload) so the
+ * {@link SignalBus} treats them as contextual handlers.
  */
-declare class RendererRegistry {
-  private readonly sessions;
-  private readonly viewDefinitions;
-  /** Store a view definition so that sessions can be created for it later. */
-  registerView(viewDef: ViewDefinition): void;
-  /**
-   * Return the existing session for a `webContentsId`, or create one if this is
-   * the first request from that renderer.
-   *
-   * @throws {BridgeError} If the `viewId` does not match any registered view definition.
-   */
-  getOrCreateSession(webContentsId: number, viewId: string): RendererSession;
-  /** Look up an existing session by its `webContentsId`, or `undefined` if none exists. */
-  getSession(webContentsId: number): RendererSession | undefined;
-  /** Remove a session when its renderer process is destroyed. */
-  removeSession(webContentsId: number): void;
-  /** Return all active renderer sessions. */
-  getAllSessions(): readonly RendererSession[];
+declare class SignalContext {
+  /** Epoch timestamp (milliseconds) captured at the moment the signal was dispatched to this handler. */
+  readonly timestamp: number;
 }
 //#endregion
-//#region src/desktop/view-manager.d.ts
+//#region src/signals/bus.d.ts
 /**
- * Framework-internal registry that tracks all `@View()` providers in the application.
+ * A callback that receives only the signal payload.
  *
- * Handles registration (including injecting the source URL into the base class)
- * and provides lookup by view ID. Consumers typically interact with views through
- * their {@link ViewProvider} subclass rather than this manager directly.
+ * Use this form when the handler does not need access to the {@link SignalContext}.
+ */
+type SignalListener<T = unknown> = (payload: T) => void | Promise<void>;
+/**
+ * A callback that receives both a {@link SignalContext} and the signal payload.
  *
- * @internal
+ * Use this form when the handler needs metadata about the publication (e.g. timestamp).
  */
-declare class ViewManager {
-  private readonly views;
+type ContextualSignalHandler<T = unknown> = (context: SignalContext, payload: T) => void | Promise<void>;
+/**
+ * Union of the two supported handler signatures for {@link SignalBus.subscribe}.
+ *
+ * The bus distinguishes between the two forms by arity: handlers with two or more
+ * parameters are treated as {@link ContextualSignalHandler}, all others as {@link SignalListener}.
+ */
+type SignalHandler<T = unknown> = SignalListener<T> | ContextualSignalHandler<T>;
+/**
+ * Fire-and-forget publish/subscribe signal bus for decoupled inter-module communication.
+ *
+ * Handlers are dispatched asynchronously via `queueMicrotask`, so `publish()` never blocks
+ * the caller. Each handler runs inside the dependency-injection context that was active at
+ * the time `subscribe()` was called, which means `inject()` works correctly inside handlers.
+ *
+ * @example
+ * ```ts
+ * // Subscribe to a signal (returns an unsubscribe function)
+ * const unsub = signalBus.subscribe('user:login', (payload) => {
+ *     console.log('User logged in:', payload.userId);
+ * });
+ *
+ * // Publish a signal — all handlers run asynchronously
+ * signalBus.publish('user:login', { userId: '42' });
+ *
+ * // Unsubscribe when no longer needed
+ * unsub();
+ * ```
+ *
+ * @example
+ * ```ts
+ * // Contextual handler with access to SignalContext
+ * signalBus.subscribe('data:sync', (context, payload) => {
+ *     console.log('Signal published at:', context.timestamp);
+ * });
+ * ```
+ */
+declare class SignalBus {
+  private readonly handlers;
+  private readonly relay;
   /**
-   * Register a view provider and apply its `@View()` source URL.
+   * Register a handler for the given signal.
    *
-   * @remarks Silently skips providers that do not have view metadata.
+   * The handler is bound to the current injection context at call time, so
+   * `inject()` resolves correctly even though the handler runs asynchronously.
+   *
+   * @returns A dispose function that removes the subscription.
    */
-  register(providerRef: ProviderRef): void;
-  /** Look up a registered view provider by its view ID. */
-  get(viewId: string): ProviderRef | undefined;
-  /** Return all registered view providers. */
-  list(): readonly ProviderRef[];
-  /** Clear the registry. Does not destroy any underlying web contents. */
-  dispose(): Promise<void>;
+  subscribe<T>(signalId: string, handler: SignalListener<T>): () => void;
+  subscribe<T>(signalId: string, handler: ContextualSignalHandler<T>): () => void;
+  /**
+   * Publish a signal to all registered handlers.
+   *
+   * Handlers are invoked asynchronously via `queueMicrotask` and their errors are
+   * logged but never propagated to the publisher. The signal is also forwarded to
+   * any connected {@link PublicationRelay} listeners (e.g. renderer processes).
+   *
+   * @remarks Payload is optional for signals that carry no data (`SignalBus.publish<void>('app:ready')`).
+   */
+  publish<T = void>(signalId: string, payload?: T): void;
+  /** @internal Connect a relay listener (used by renderer registry). */
+  connectRelay(listener: SignalPublishListener): () => void;
 }
 //#endregion
-//#region src/desktop/view-provider.d.ts
-declare const VIEW_STATE: unique symbol;
-interface ViewAuthoringSurface {
-  readonly contentView: WebContentsView | undefined;
-  readonly webContents: WebContents | undefined;
-  load(): Promise<void>;
-  setBounds(bounds: Rectangle): void;
-  setBackgroundColor(color: string): void;
-  focus(): void;
-  setWindowButtonVisibility(visible: boolean): void;
+//#region src/contracts/authoring.d.ts
+/**
+ * Codegen contract types for `@electrojs/runtime`.
+ *
+ * These interfaces and types are used by `@electrojs/codegen` to generate
+ * type-safe authoring APIs. The codegen augments the empty registry interfaces
+ * via `declare module "@electro"` to populate them with app-specific types.
+ *
+ * @module contracts/authoring
+ */
+/** Maps `"moduleId:methodId"` to the method's type reference. Augmented by codegen. */
+interface ModuleMethodMap {}
+/** Maps module IDs to their method type objects. Augmented by codegen. */
+interface ModuleApiRegistry {}
+/** Maps signal keys to their payload types. Augmented by codegen. */
+interface ModuleSignalPayloadMap {}
+/** Maps module IDs to their job ID unions. Augmented by codegen. */
+interface ModuleJobRegistry {}
+/** Maps injectable class names to their class types. Augmented by codegen. */
+interface InjectableClassRegistry {}
+/** Maps window IDs to their `@Window()` class types. Augmented by codegen. */
+interface WindowClassRegistry {}
+/** Maps view IDs to their `@View()` class types. Augmented by codegen. */
+interface ViewClassRegistry {}
+/** Union of all registered module IDs. Derived from `ModuleApiRegistry` keys. */
+type ModuleRegistryId = keyof ModuleApiRegistry;
+type JobIdFor<TModuleId extends ModuleRegistryId> = Extract<ModuleJobRegistry[TModuleId], string>;
+type SignalId = Extract<keyof ModuleSignalPayloadMap, string>;
+type VoidSignalId = { [TKey in SignalId]: ModuleSignalPayloadMap[TKey] extends void ? TKey : never }[SignalId];
+type NonVoidSignalId = Exclude<SignalId, VoidSignalId>;
+/** A class decorated with `@Module()`. Used in generated registry arrays. */
+type ModuleClass = Constructor;
+/** A class decorated with `@View()`. Used in generated registry arrays. */
+type ViewClass = Constructor;
+/** A class decorated with `@Window()`. Used in generated registry arrays. */
+type WindowClass = Constructor;
+/**
+ * Shape of the static kernel definition object generated by codegen.
+ *
+ * Used by the generated `electroAppDefinition` constant which can be
+ * passed to `AppKernel.create()` for fully typed bootstrapping.
+ */
+interface AppKernelDefinition {
+  readonly root: Constructor;
+  readonly modules: readonly Constructor[];
+  readonly windows: readonly Constructor[];
+  readonly views: readonly Constructor[];
+}
+interface TypedSignalBus {
+  publish<TSignalId extends VoidSignalId>(signalId: TSignalId): void;
+  publish<TSignalId extends NonVoidSignalId>(signalId: TSignalId, payload: ModuleSignalPayloadMap[TSignalId]): void;
+  subscribe<TSignalId extends SignalId>(signalId: TSignalId, handler: SignalListener<ModuleSignalPayloadMap[TSignalId]>): () => void;
+  subscribe<TSignalId extends SignalId>(signalId: TSignalId, handler: ContextualSignalHandler<ModuleSignalPayloadMap[TSignalId]>): () => void;
+}
+interface TypedJobRegistry<TJobId extends string = string> {
+  ensure(jobId: TJobId): void;
+  start(jobId: TJobId): void;
+  run(jobId: TJobId, ...args: unknown[]): Promise<unknown>;
+  stop(jobId: TJobId): Promise<void>;
+  cancel(jobId: TJobId): void;
+  getStatus(jobId: TJobId): JobRuntimeState | undefined;
+  list(): readonly JobRuntimeState[];
 }
 /**
- * Abstract base class for view providers decorated with `@View()`.
+ * Base type augmented onto module and provider classes by codegen.
  *
- * Extend this class to define a renderable view in your application. The framework
- * injects the source URL from the `@View()` decorator, and your subclass gains access
- * to methods for loading content, positioning, and styling.
+ * Codegen generates `interface MyModule extends ModuleAuthoringApi<"myModuleId"> {}`
+ * which gives the class access to typed methods based on the module's registered
+ * commands, queries, signals, and jobs.
  *
- * Views are created with strict security defaults: `sandbox: true`,
- * `contextIsolation: true`, and `nodeIntegration: false`.
+ */
+interface ModuleAuthoringApi<TModuleId extends ModuleRegistryId> {
+  readonly moduleId: TModuleId;
+  readonly api: ModuleApiRegistry[TModuleId];
+  readonly signals: TypedSignalBus;
+  readonly jobs: TypedJobRegistry<JobIdFor<TModuleId>>;
+  readonly modules: ModuleRegistry;
+  readonly windows: WindowManager;
+  readonly views: ViewManager;
+  readonly logger: ElectroLogger;
+}
+/**
+ * Base type augmented onto `@Window()` classes by codegen.
  *
- * @remarks The `WebContentsView` is lazily created on the first call to {@link load}.
+ * Provides typed window management capabilities when extended by codegen-generated
+ * interface augmentations.
+ */
+interface WindowAuthoringApi extends WindowAuthoringSurface {
+  readonly logger: ElectroLogger;
+}
+/**
+ * Base type augmented onto `@View()` classes by codegen.
+ *
+ * Provides typed view management capabilities when extended by codegen-generated
+ * interface augmentations.
+ */
+interface ViewAuthoringApi extends ViewAuthoringSurface {
+  readonly logger: ElectroLogger;
+}
+//#endregion
+//#region src/container/inject.d.ts
+/**
+ * Resolve a dependency from the current injection context.
+ *
+ * This is the primary way framework-managed classes obtain their dependencies.
+ * It reads the active {@link Injector} from `AsyncLocalStorage` and delegates to
+ * {@link Injector.get}.
+ *
+ * @remarks
+ * `inject()` is only available inside a framework-managed execution scope:
+ * - **Construction** -- property initializers of `@Injectable()`, `@Module()`, `@View()`, or `@Window()` classes
+ * - **Lifecycle hooks** -- `onInit`, `onStart`, `onReady`, `onShutdown`, `onDispose`
+ * - **Capability handlers** -- methods decorated with `@command`, `@query`, `@signal`, or `@job`
+ *
+ * Calling it anywhere else (e.g. in a `setTimeout` callback or a plain function)
+ * throws {@link DIError} with code `ELECTRO_DI_NO_INJECTION_CONTEXT`.
  *
  * @example
  * ```ts
- * @View({ source: 'view:main', access: ['app:getVersion'] })
- * class MainView extends ViewProvider {
- *     async onReady() {
- *         await this.load();
- *         this.setBounds({ x: 0, y: 0, width: 800, height: 600 });
- *     }
+ * @Injectable()
+ * class MyService {
+ *   private readonly config = inject(AppConfig);
  * }
  * ```
+ *
+ * @throws {@link DIError} if no injection context is active or the token cannot be resolved.
  */
-declare abstract class ViewProvider {
-  private [VIEW_STATE];
-  /** The underlying Electron `WebContentsView`, or `undefined` if not yet created. */
-  get contentView(): WebContentsView | undefined;
-  /** The `WebContents` associated with this view, or `undefined` if not yet created. */
-  get webContents(): WebContents | undefined;
-  /**
-   * Create the underlying `WebContentsView` (if needed) and load the configured source URL.
-   *
-   * The view is lazily created on the first call. Subsequent calls reload the source.
-   * If the previous view was destroyed (e.g. parent window closed), a new one is created.
-   * No-ops if no source URL has been configured.
-   */
-  load(): Promise<void>;
-  /** Set the position and size of this view within its parent window. */
-  setBounds(bounds: Rectangle): void;
-  /** Set the background color of the view (e.g. `"#ffffff"` or `"transparent"`). */
-  setBackgroundColor(color: string): void;
-  /** Give keyboard focus to this view's web contents. */
-  focus(): void;
-  /** Show or hide the native window traffic-light buttons for this view (macOS). */
-  setWindowButtonVisibility(visible: boolean): void;
-  private createView;
-  private static resolveSource;
-  /** @internal Called by the framework to set the view source from @View metadata. */
-  static __setSource(instance: ViewProvider, source: string): void;
-  /** @internal Called by the framework to set web preferences from @View metadata. */
-  static __setWebPreferences(instance: ViewProvider, webPreferences: WebPreferences): void;
-}
+declare function inject<T>(token: InjectionToken<T>): T extends SignalBus ? TypedSignalBus : T;
 //#endregion
-//#region src/desktop/window-manager.d.ts
+//#region src/container/injection-context.d.ts
 /**
- * Framework-internal registry that tracks all `@Window()` providers in the application.
+ * Ambient injection context backed by `AsyncLocalStorage`.
  *
- * Handles registration (including injecting `@Window()` configuration into the base class)
- * and provides lookup by window ID. Consumers typically interact with windows through
- * their {@link WindowProvider} subclass rather than this manager directly.
+ * The framework uses `InjectionContext` to make the current {@link Injector} available
+ * to {@link inject} calls without requiring explicit injector references. It is set
+ * automatically during provider construction, lifecycle hooks, and capability handlers.
+ *
+ * @remarks
+ * This is a framework-internal API. Application code should use {@link inject} instead
+ * of interacting with `InjectionContext` directly.
  *
  * @internal
  */
-declare class WindowManager {
-  private readonly windows;
+declare const InjectionContext: {
   /**
-   * Register a window provider and apply its `@Window()` configuration.
-   *
-   * @remarks Silently skips providers that do not have window metadata.
+   * Execute `fn` within the scope of the given injector.
+   * Any {@link inject} call made synchronously inside `fn` will resolve from this injector.
    */
-  register(providerRef: ProviderRef): void;
-  /** Look up a registered window provider by its window ID. */
-  get(windowId: string): ProviderRef | undefined;
-  /** Return all registered window providers. */
-  list(): readonly ProviderRef[];
-  /** Close all managed windows and clear the registry. */
-  dispose(): Promise<void>;
-}
+  readonly run: <T>(injector: Injector, fn: () => T) => T;
+  /**
+   * Execute `fn` within the scope of the given injector, additionally tracking `owner`
+   * as the object currently being constructed or invoked.
+   */
+  readonly runOwned: <T>(injector: Injector, owner: object, fn: () => T) => T; /** Return the injector for the current execution context, or `undefined` if none is active. */
+  readonly current: () => Injector | undefined; /** Return the owner object of the current execution context, or `undefined` if not set. */
+  readonly currentOwner: () => object | undefined; /** Whether a framework-managed injection context is currently active. */
+  readonly isActive: () => boolean;
+};
 //#endregion
-//#region src/desktop/window-provider.d.ts
-declare const WINDOW_STATE: unique symbol;
-interface WindowAuthoringSurface {
-  readonly window: BaseWindow | undefined;
-  create(): void;
-  mount(view: Pick<ViewProvider, "contentView">): void;
-  show(): void;
-  hide(): void;
-  focus(): void;
-  close(): void;
-  getBounds(): Rectangle | undefined;
-}
+//#region src/modules/validator.d.ts
 /**
- * Abstract base class for window providers decorated with `@Window()`.
+ * Validates a scanned {@link AppDefinition} for structural correctness before bootstrap.
  *
- * Extend this class to define a window in your application. The framework injects
- * configuration from the `@Window()` decorator metadata, and your subclass gains
- * access to lifecycle methods like {@link create}, {@link show}, {@link mount}, and {@link close}.
+ * Checks performed:
+ * - Unique module IDs
+ * - Exports reference declared providers
+ * - No cyclic module imports
+ * - Unique view/window IDs
+ * - Unique bridge channel names
+ * - Unique job IDs
+ * - Provider role exclusivity (a class cannot be both a view and a window)
+ * - View access references point to existing bridge channels
  *
- * @remarks The native `BaseWindow` instance is only available after calling {@link create}.
- * Calling lifecycle methods before `create()` is safe (they no-op) but the window
- * will not exist on screen.
+ * @throws {BootstrapError} On the first validation failure encountered.
+ */
+declare function validateAppDefinition(definition: AppDefinition): void;
+//#endregion
+//#region src/desktop/renderer-session.d.ts
+/**
+ * Tracks the capabilities of a single renderer process (identified by `webContentsId`).
  *
- * @example
- * ```ts
- * @Window({ width: 800, height: 600, show: false })
- * class MainWindow extends WindowProvider {
- *     async onReady() {
- *         this.create();
- *         this.mount(this.mainView);
- *         this.show();
- *     }
- * }
- * ```
+ * Each session records which bridge channels the renderer may invoke and which signals
+ * it is allowed to receive, as declared in the `@View()` decorator metadata. The
+ * {@link BridgeAccessGuard} and signal relay use this information to enforce per-view
+ * access control.
+ *
+ * @internal Created and managed by {@link RendererRegistry}.
  */
-declare abstract class WindowProvider {
-  private [WINDOW_STATE];
-  /** The underlying Electron `BaseWindow` instance, or `undefined` if not yet created. */
-  get window(): BaseWindow | undefined;
-  /** Create the native `BaseWindow` using configuration from the `@Window()` decorator. */
-  create(): void;
+declare class RendererSession {
+  /** The Electron `webContents.id` that uniquely identifies this renderer process. */
+  readonly rendererId: number;
+  /** The view ID this renderer is associated with. */
+  readonly viewId: string;
+  /** Set of bridge channel names this renderer is allowed to invoke. */
+  readonly access: ReadonlySet<string>;
+  /** Set of signal IDs this renderer is allowed to receive. */
+  readonly allowedSignals: ReadonlySet<string>;
+  constructor(/** The Electron `webContents.id` that uniquely identifies this renderer process. */
+
+  rendererId: number, viewDef: ViewDefinition);
+  /** Check whether this renderer has access to the given bridge channel. */
+  hasAccess(channel: string): boolean;
+  /** Check whether this renderer is allowed to receive the given signal. */
+  canReceiveSignal(signalId: string): boolean;
+}
+//#endregion
+//#region src/desktop/renderer-registry.d.ts
+/**
+ * Maps Electron `webContentsId` values to {@link RendererSession} instances.
+ *
+ * Used by the bridge layer to look up which renderer process is making an IPC request
+ * and determine what channels and signals it is allowed to access. View definitions are
+ * registered at bootstrap time; sessions are created lazily when a renderer first
+ * communicates.
+ *
+ * @internal
+ */
+declare class RendererRegistry {
+  private readonly sessions;
+  private readonly viewDefinitions;
+  /** Store a view definition so that sessions can be created for it later. */
+  registerView(viewDef: ViewDefinition): void;
   /**
-   * Attach a view's content to this window.
+   * Return the existing session for a `webContentsId`, or create one if this is
+   * the first request from that renderer.
    *
-   * The view's `WebContentsView` is added as a child view of the window's content area.
-   * No-ops silently if the window or view has not been created yet.
+   * @throws {BridgeError} If the `viewId` does not match any registered view definition.
    */
-  mount(view: ViewProvider): void;
-  /** Show the window. No-ops if the window has not been created. */
-  show(): void;
-  /** Hide the window without destroying it. */
-  hide(): void;
-  /** Bring the window to the front and give it focus. */
-  focus(): void;
-  /** Close and destroy the native window, releasing its resources. */
-  close(): void;
-  /** Return the window's current screen bounds, or `undefined` if not created. */
-  getBounds(): Rectangle | undefined;
-  /** @internal Called by the framework to set the window configuration from @Window metadata. */
-  static __setConfiguration(instance: WindowProvider, configuration?: BaseWindowConstructorOptions): void;
+  getOrCreateSession(webContentsId: number, viewId: string): RendererSession;
+  /** Look up an existing session by its `webContentsId`, or `undefined` if none exists. */
+  getSession(webContentsId: number): RendererSession | undefined;
+  /** Remove a session when its renderer process is destroyed. */
+  removeSession(webContentsId: number): void;
+  /** Return all active renderer sessions. */
+  getAllSessions(): readonly RendererSession[];
 }
 //#endregion
 //#region src/bridge/access-guard.d.ts
@@ -1062,7 +1185,7 @@ declare abstract class WindowProvider {
  * Enforces access control for bridge IPC calls.
  *
  * Checks two conditions before a bridge request is allowed through:
- * 1. The application kernel must be in the `"started"` state.
+ * 1. The application kernel must be in the `"starting"` or `"started"` state.
  * 2. The requesting renderer's {@link RendererSession} must have the target channel
  *    in its access set (as declared in `@View({ access: [...] })`).
  *
@@ -1073,7 +1196,7 @@ declare class BridgeAccessGuard {
   /** Update the tracked kernel state. Called by the kernel during lifecycle transitions. */
   setKernelState(state: KernelState): void;
   /**
-   * Assert that the kernel is in the `"started"` state.
+   * Assert that the kernel is in a state where bridge calls are allowed.
    *
    * @throws {BridgeError} If the kernel is not ready to handle requests.
    */
@@ -1147,7 +1270,8 @@ interface BridgeResponse {
 /**
  * Routes IPC requests from renderer processes to the appropriate {@link BridgeHandler}.
  *
- * For each incoming request the dispatcher verifies that the kernel is ready,
+ * For each incoming request the dispatcher verifies that the kernel currently
+ * accepts bridge calls,
  * that the requesting renderer has an active session, and that the session grants
  * access to the requested channel. If all checks pass the corresponding handler
  * is invoked; otherwise a serialized error is returned. Errors never propagate as
@@ -1165,7 +1289,7 @@ declare class BridgeDispatcher {
   /**
    * Process an IPC request from a renderer identified by its `webContentsId`.
    *
-   * Performs kernel-readiness, session-existence, and channel-access checks before
+   * Performs kernel bridge-readiness, session-existence, and channel-access checks before
    * delegating to the registered handler. All errors are caught and returned as
    * serialized error objects in the response.
    */
@@ -1278,7 +1402,7 @@ declare class BridgeError extends RuntimeError {
    * The original error is attached as {@link Error.cause}.
    */
   static handlerFailed(channel: string, cause: unknown): BridgeError;
-  /** A bridge call arrived before the kernel finished starting or after it began shutting down. */
+  /** A bridge call arrived before startup entered the `starting` phase or after shutdown began. */
   static kernelNotReady(): BridgeError;
   /** A bridge request came from a `webContents` that is not associated with any known view. */
   static unknownRenderer(webContentsId: number): BridgeError;
@@ -1310,7 +1434,7 @@ declare class DIError extends RuntimeError {
    *
    * @remarks
    * `inject()` is only available during construction (property initializers),
-   * lifecycle hooks (`onInit`/`onReady`/`onShutdown`/`onDispose`),
+   * lifecycle hooks (`onInit`/`onStart`/`onReady`/`onShutdown`/`onDispose`),
    * and capability handlers (`@command`, `@query`, `@signal`, `@job`).
    */
   static noInjectionContext(): DIError;
@@ -1346,7 +1470,7 @@ declare class JobError extends RuntimeError {
 declare class LifecycleError extends RuntimeError {
   private constructor();
   /**
-   * A lifecycle hook (`onInit`, `onReady`, etc.) threw during the startup sequence.
+   * A lifecycle hook (`onInit`, `onStart`, `onReady`, etc.) threw during the startup sequence.
    *
    * @remarks
    * The original error is attached as {@link Error.cause}.
@@ -1374,103 +1498,4 @@ declare class SignalError extends RuntimeError {
   static invalidSignalId(signalId: unknown): SignalError;
 }
 //#endregion
-//#region src/contracts/authoring.d.ts
-/**
- * Codegen contract types for `@electrojs/runtime`.
- *
- * These interfaces and types are used by `@electrojs/codegen` to generate
- * type-safe authoring APIs. The codegen augments the empty registry interfaces
- * via `declare module "@electro"` to populate them with app-specific types.
- *
- * @module contracts/authoring
- */
-/** Maps `"moduleId:methodId"` to the method's type reference. Augmented by codegen. */
-interface ModuleMethodMap {}
-/** Maps module IDs to their method type objects. Augmented by codegen. */
-interface ModuleApiRegistry {}
-/** Maps signal keys to their payload types. Augmented by codegen. */
-interface ModuleSignalPayloadMap {}
-/** Maps module IDs to their job ID unions. Augmented by codegen. */
-interface ModuleJobRegistry {}
-/** Maps injectable class names to their class types. Augmented by codegen. */
-interface InjectableClassRegistry {}
-/** Maps window IDs to their `@Window()` class types. Augmented by codegen. */
-interface WindowClassRegistry {}
-/** Maps view IDs to their `@View()` class types. Augmented by codegen. */
-interface ViewClassRegistry {}
-/** Union of all registered module IDs. Derived from `ModuleApiRegistry` keys. */
-type ModuleRegistryId = keyof ModuleApiRegistry;
-type JobIdFor<TModuleId extends ModuleRegistryId> = Extract<ModuleJobRegistry[TModuleId], string>;
-type SignalId = Extract<keyof ModuleSignalPayloadMap, string>;
-type VoidSignalId = { [TKey in SignalId]: ModuleSignalPayloadMap[TKey] extends void ? TKey : never }[SignalId];
-type NonVoidSignalId = Exclude<SignalId, VoidSignalId>;
-/** A class decorated with `@Module()`. Used in generated registry arrays. */
-type ModuleClass = Constructor;
-/** A class decorated with `@View()`. Used in generated registry arrays. */
-type ViewClass = Constructor;
-/** A class decorated with `@Window()`. Used in generated registry arrays. */
-type WindowClass = Constructor;
-/**
- * Shape of the static kernel definition object generated by codegen.
- *
- * Used by the generated `electroAppDefinition` constant which can be
- * passed to `AppKernel.create()` for fully typed bootstrapping.
- */
-interface AppKernelDefinition {
-  readonly root: Constructor;
-  readonly modules: readonly Constructor[];
-  readonly windows: readonly Constructor[];
-  readonly views: readonly Constructor[];
-}
-interface TypedSignalBus {
-  publish<TSignalId extends VoidSignalId>(signalId: TSignalId): void;
-  publish<TSignalId extends NonVoidSignalId>(signalId: TSignalId, payload: ModuleSignalPayloadMap[TSignalId]): void;
-  subscribe<TSignalId extends SignalId>(signalId: TSignalId, handler: SignalHandler<ModuleSignalPayloadMap[TSignalId]>): () => void;
-}
-interface TypedJobRegistry<TJobId extends string = string> {
-  ensure(jobId: TJobId): void;
-  start(jobId: TJobId): void;
-  run(jobId: TJobId, ...args: unknown[]): Promise<unknown>;
-  stop(jobId: TJobId): Promise<void>;
-  cancel(jobId: TJobId): void;
-  getStatus(jobId: TJobId): JobRuntimeState | undefined;
-  list(): readonly JobRuntimeState[];
-}
-/**
- * Base type augmented onto module and provider classes by codegen.
- *
- * Codegen generates `interface MyModule extends ModuleAuthoringApi<"myModuleId"> {}`
- * which gives the class access to typed methods based on the module's registered
- * commands, queries, signals, and jobs.
- *
- */
-interface ModuleAuthoringApi<TModuleId extends ModuleRegistryId> {
-  readonly moduleId: TModuleId;
-  readonly api: ModuleApiRegistry[TModuleId];
-  readonly signals: TypedSignalBus;
-  readonly jobs: TypedJobRegistry<JobIdFor<TModuleId>>;
-  readonly modules: ModuleRegistry;
-  readonly windows: WindowManager;
-  readonly views: ViewManager;
-  readonly logger: ElectroLogger;
-}
-/**
- * Base type augmented onto `@Window()` classes by codegen.
- *
- * Provides typed window management capabilities when extended by codegen-generated
- * interface augmentations.
- */
-interface WindowAuthoringApi extends WindowAuthoringSurface {
-  readonly logger: ElectroLogger;
-}
-/**
- * Base type augmented onto `@View()` classes by codegen.
- *
- * Provides typed view management capabilities when extended by codegen-generated
- * interface augmentations.
- */
-interface ViewAuthoringApi extends ViewAuthoringSurface {
-  readonly logger: ElectroLogger;
-}
-//#endregion
 export { type AppDefinition, AppKernel, type AppKernelDefinition, type AppKernelOptions, BootstrapError, BridgeAccessGuard, type BridgeClientConfig, BridgeDispatcher, BridgeError, BridgeHandler, type BridgeMethodDefinition, type BridgeMethodKind, type BridgeRequest, type BridgeResponse, type ContextualSignalHandler, DIError, type ElectroIpcRenderer, type ElectroLogBindings, type ElectroLogContext, type ElectroLogLevel, type ElectroLogger, IPC_CHANNELS, type InjectableClassRegistry, InjectionContext, Injector, JobContext, type JobDefinition, JobError, JobRegistry, type JobRuntimeState, type JobStatus, type KernelState, LifecycleError, type LifecycleTarget, type ModuleApiRegistry, type ModuleAuthoringApi, type ModuleClass, type ModuleDefinition, type ModuleJobRegistry, type ModuleMethodMap, ModuleRef, ModuleRegistry, type ModuleRegistryId, type ModuleSignalPayloadMap, type ModuleSnapshot, type ModuleStatus, type PreloadBridgeApi, type ProviderDefinition, type ProviderKind, ProviderRef, type ProviderSnapshot, RendererRegistry, RendererSession, RuntimeError, SignalBus, SignalContext, SignalError, type SignalHandler, type SignalHandlerDefinition, type SignalListener, type TypedJobRegistry, type TypedSignalBus, type ViewAuthoringApi, type ViewClass, type ViewClassRegistry, type ViewDefinition, ViewManager, ViewProvider, type WindowAuthoringApi, type WindowClass, type WindowClassRegistry, type WindowDefinition, WindowManager, WindowProvider, createBridgeClient, createConsoleLogger, inject, scanModules, serializeBridgeError, validateAppDefinition };