@cordy/electro 1.0.8 → 1.1.0

package/dist/index.d.mts

@@ -1,16 +1,10 @@
-import { BaseWindow } from "electron";
+import { BaseWindow, WebContentsView } from "electron";
 import { UserConfig } from "vite";
 
 //#region src/config/types.d.ts
 declare const RUNTIME_BRAND: unique symbol;
-declare const WINDOW_BRAND: unique symbol;
+declare const VIEW_BRAND: unique symbol;
 declare const CONFIG_BRAND: unique symbol;
-type WindowLifecycle = "singleton" | "multi";
-type WindowCloseBehavior = "hide" | "destroy";
-type WindowType = "base-window" | "browser-window";
-interface WindowBehavior {
-  close: WindowCloseBehavior;
-}
 interface RuntimeDefinition {
   readonly [RUNTIME_BRAND]: true;
   readonly entry: string;
@@ -18,45 +12,37 @@ interface RuntimeDefinition {
   /** @internal Caller path captured by defineRuntime(). */
   readonly __source: string;
 }
-interface WindowDefinition {
-  readonly [WINDOW_BRAND]: true;
+interface ViewDefinition {
+  readonly [VIEW_BRAND]: true;
   readonly name: string;
   readonly entry: string;
-  readonly type?: WindowType;
   readonly features?: readonly string[];
   readonly vite?: UserConfig;
   readonly preload?: string;
-  readonly lifecycle?: WindowLifecycle;
-  readonly autoShow?: boolean;
-  readonly behavior?: WindowBehavior;
-  readonly window?: Record<string, unknown>;
-  /** @internal Caller path captured by defineWindow(). */
+  readonly webPreferences?: Record<string, unknown>;
+  /** @internal Caller path captured by defineView(). */
   readonly __source: string;
 }
 interface ElectroConfig {
   readonly [CONFIG_BRAND]: true;
   readonly runtime: RuntimeDefinition;
-  readonly windows?: readonly WindowDefinition[];
+  readonly views?: readonly ViewDefinition[];
 }
 interface DefineRuntimeInput {
   entry: string;
   vite?: UserConfig;
 }
-interface DefineWindowInput {
+interface DefineViewInput {
   name: string;
   entry: string;
-  type?: WindowType;
   features?: readonly string[];
   vite?: UserConfig;
   preload?: string;
-  lifecycle?: WindowLifecycle;
-  autoShow?: boolean;
-  behavior?: WindowBehavior;
-  window?: Record<string, unknown>;
+  webPreferences?: Record<string, unknown>;
 }
 interface DefineConfigInput {
   runtime: RuntimeDefinition;
-  windows?: readonly WindowDefinition[];
+  views?: readonly ViewDefinition[];
 }
 //#endregion
 //#region src/config/define-config.d.ts
@@ -65,8 +51,8 @@ declare function defineConfig(input: DefineConfigInput): ElectroConfig;
 //#region src/config/define-runtime.d.ts
 declare function defineRuntime(input: DefineRuntimeInput): RuntimeDefinition;
 //#endregion
-//#region src/config/define-window.d.ts
-declare function defineWindow(input: DefineWindowInput): WindowDefinition;
+//#region src/config/define-view.d.ts
+declare function defineView(input: DefineViewInput): ViewDefinition;
 //#endregion
 //#region src/core/event-bus/types.d.ts
 type EventHandler = (payload: unknown) => void;
@@ -146,60 +132,96 @@ declare enum FeatureStatus {
   ERROR = "error"
 }
 //#endregion
-//#region src/window/types.d.ts
-/** A window with an auto-loading `load()` method that resolves dev/prod URLs. */
-type ElectroWindow<T extends BaseWindow = BaseWindow> = T & {
+//#region src/core/view/types.d.ts
+type ViewId = string;
+/** Config for renderer-linked views (built by Vite). */
+interface RendererViewConfig {
+  id: ViewId;
+  /** Link to a defineView() name. `true` = use `id` as the renderer name. */
+  renderer: true | string;
+  webPreferences?: Record<string, unknown>;
+}
+/** Config for dynamic views (no renderer entry, programmatic). */
+interface DynamicViewConfig {
+  id: ViewId;
+  webPreferences?: Record<string, unknown>;
+}
+type ViewConfig = RendererViewConfig | DynamicViewConfig;
+/** A WebContentsView augmented with `load()` for renderer-linked views. */
+type ElectroView = WebContentsView & {
   load(): Promise<void>;
 };
-/** Factory interface for creating platform windows from definitions. */
-interface WindowFactory {
-  create(definition: WindowDefinition): BaseWindow;
+/** Public interface — hides the View class. */
+interface CreatedView {
+  readonly id: ViewId;
+  /** Create the WebContentsView. Idempotent: returns existing if alive. */
+  create(): ElectroView;
+  /** Return the live ElectroView, or null if not yet created / destroyed. */
+  view(): ElectroView | null;
+  /** Destroy the WebContentsView and clear refs. */
+  destroy(): void;
 }
-/** Snapshot of a tracked window. */
-interface WindowInfo {
-  name: string;
-  windowId: number;
-  destroyed: boolean;
+/** Type-erased interface for managers. */
+interface ViewInstance {
+  readonly id: ViewId;
+  create(): ElectroView;
+  view(): ElectroView | null;
+  destroy(): void;
+}
+//#endregion
+//#region src/core/view/manager.d.ts
+/**
+* ViewManager — global registry for view instances.
+*
+* Views are registered at runtime startup and accessible from any feature.
+* Views are idempotent: `get(id).create()` returns the same instance if alive.
+*/
+declare class ViewManager {
+  private readonly instances;
+  register(view: ViewInstance): void;
+  get(id: ViewId): ViewInstance | null;
+  destroyAll(): void;
+}
+//#endregion
+//#region src/core/window/types.d.ts
+type WindowId = string;
+interface WindowConfig<TApi = void> {
+  id: WindowId;
+  options?: Record<string, unknown>;
+  api?: (window: BaseWindow) => TApi;
+}
+/** Public interface — hides the Window class. */
+interface CreatedWindow<TApi = void> {
+  readonly id: WindowId;
+  /** Create the BaseWindow. Idempotent: returns existing if alive. */
+  create(): BaseWindow;
+  /** The live BaseWindow, or null if not yet created / destroyed. */
+  readonly window: BaseWindow | null;
+  /** The typed API, or null if not yet created / destroyed. */
+  readonly api: TApi | null;
+  /** Destroy the BaseWindow and clear refs. */
+  destroy(): void;
+}
+/** Type-erased interface for managers. */
+interface WindowInstance {
+  readonly id: WindowId;
+  create(): BaseWindow;
+  readonly window: BaseWindow | null;
+  readonly api: unknown;
+  destroy(): void;
 }
 //#endregion
-//#region src/window/manager.d.ts
+//#region src/core/window/manager.d.ts
 /**
-* WindowManager — registry, creation, and lifecycle coordinator for windows.
+* WindowManager — global registry for window instances.
 *
-* Manages window definitions and their instances through a WindowFactory
-* abstraction. Enforces singleton/multi lifecycle semantics and provides
-* querying and bulk destruction capabilities.
+* Windows are registered at runtime startup and accessible from any feature.
 */
 declare class WindowManager {
-  private readonly factory;
-  private readonly definitions;
   private readonly instances;
-  constructor(factory: WindowFactory);
-  /** Register a window definition. Throws on duplicate name. */
-  registerDefinition(definition: WindowDefinition): void;
-  /** Check whether a definition is registered for the given name. */
-  hasDefinition(name: string): boolean;
-  /**
-  * Create a window from a registered definition.
-  *
-  * - Throws if no definition exists for `name`.
-  * - For singleton lifecycle (the default), throws if a live instance already exists.
-  * - For multi lifecycle, always creates a new instance.
-  */
-  createWindow(name: string): ElectroWindow;
-  /**
-  * Get the first alive window for the given name, or null.
-  * Cleans up destroyed instances as a side effect.
-  */
-  getWindow(name: string): ElectroWindow | null;
-  /** Destroy all instances for the given name. No-op if name is unknown. */
-  destroyWindow(name: string): void;
-  /** Destroy all tracked windows across all names. */
+  register(window: WindowInstance): void;
+  get(id: WindowId): WindowInstance | null;
   destroyAll(): void;
-  /** Returns a snapshot of all tracked windows (including destroyed ones). */
-  list(): WindowInfo[];
-  /** Return alive (non-destroyed) instances for a given name. */
-  private getAliveInstances;
 }
 //#endregion
 //#region src/core/task/enums.d.ts
@@ -331,14 +353,17 @@ interface FeatureMap {}
 interface ServiceOwnerMap {}
 /** Maps task ID → owning feature ID. Populated by codegen. */
 interface TaskOwnerMap {}
-/** Declaration-merging registry for window types. Codegen populates this. */
-interface WindowMap {}
+/** Declaration-merging registry for view types. Codegen populates this. */
+interface ViewMap {}
+/** Declaration-merging registry for window API types. Codegen populates this. */
+interface WindowApiMap {}
 /** Resolve the owning feature ID for a service. Falls back to `string` (→ BaseContext). */
 type _ServiceOwner<TId extends string> = TId extends keyof ServiceOwnerMap ? ServiceOwnerMap[TId] : string;
 /** Resolve the owning feature ID for a task. Falls back to `string` (→ BaseContext). */
 type _TaskOwner<TId extends string> = TId extends keyof TaskOwnerMap ? TaskOwnerMap[TId] : string;
-type _SuggestWindowKeys = (keyof WindowMap & string) | (string & {});
-type _ResolveWindow<K extends string> = K extends keyof WindowMap ? ElectroWindow<WindowMap[K]> : ElectroWindow;
+type _SuggestViewKeys = (keyof ViewMap & string) | (string & {});
+type _SuggestWindowKeys = (keyof WindowApiMap & string) | (string & {});
+type _ResolveWindowApi<K extends string> = K extends keyof WindowApiMap ? WindowApiMap[K] : unknown;
 /** Extract the dependency IDs union for a feature. */
 type _DepIds<FId> = FId extends keyof FeatureMap ? FeatureMap[FId]["dependencies"] : never;
 /** Own service keys for a feature. */
@@ -395,8 +420,9 @@ type TypedContext<FId extends keyof FeatureMap, ExcludeSvc extends string = neve
     publish<K extends _OwnEventKeys<FId>>(event: K, ...args: undefined extends _ResolveOwnEvent<FId, K> ? [payload?: _ResolveOwnEvent<FId, K>] : [payload: _ResolveOwnEvent<FId, K>]): void;
     on<K extends _OwnEventKeys<FId> | _DepEventKeys<FId>>(event: K, handler: (payload: _ResolveEvent<FId, K>) => void): () => void;
   };
-  createWindow: <K extends _SuggestWindowKeys>(name: K) => _ResolveWindow<K & string>;
-  getWindow: <K extends _SuggestWindowKeys>(name: K) => _ResolveWindow<K & string> | null;
+  getWindow: <K extends _SuggestWindowKeys>(id: K) => CreatedWindow<_ResolveWindowApi<K & string>> | null;
+  createView: <K extends _SuggestViewKeys>(id: K) => ElectroView;
+  getView: <K extends _SuggestViewKeys>(id: K) => ElectroView | null;
 };
 /** Unscoped context — flat suggestions from all features. */
 type BaseContext = {
@@ -409,8 +435,9 @@ type BaseContext = {
     publish(event: _SuggestAllEvent, payload?: unknown): void;
     on(event: string, handler: (payload: unknown) => void): () => void;
   };
-  createWindow: <K extends _SuggestWindowKeys>(name: K) => _ResolveWindow<K & string>;
-  getWindow: <K extends _SuggestWindowKeys>(name: K) => _ResolveWindow<K & string> | null;
+  getWindow: <K extends _SuggestWindowKeys>(id: K) => CreatedWindow<_ResolveWindowApi<K & string>> | null;
+  createView: <K extends _SuggestViewKeys>(id: K) => ElectroView;
+  getView: <K extends _SuggestViewKeys>(id: K) => ElectroView | null;
 };
 interface LoggerContext {
   debug(code: string, message: string, details?: Record<string, unknown>): void;
@@ -580,9 +607,12 @@ declare class FeatureManager {
   /** Global task ownership: taskId → featureId. */
   private readonly taskOwners;
   private windowManager;
+  private viewManager;
   constructor(logger: LoggerContext, eventBus?: EventBus | undefined);
-  /** @internal Set the window manager (called by Electron layer before bootstrap). */
+  /** @internal Set the window manager (called by Runtime before bootstrap). */
   setWindowManager(windowManager: WindowManager): void;
+  /** @internal Set the view manager (called by Runtime before bootstrap). */
+  setViewManager(viewManager: ViewManager): void;
   /**
   * Register a feature or a list of features.
   * If a feature with the same ID is already registered, a warning is logged and the feature is skipped.
@@ -641,7 +671,7 @@ declare class Feature<FId extends FeatureId> {
   * @throws If the transition is not allowed from the current state.
   */
   transition(target: FeatureStatus): void;
-  initialize(features: Feature<FeatureId>[], manager: FeatureManager, eventBus?: EventBus, windowManager?: WindowManager): Promise<void>;
+  initialize(features: Feature<FeatureId>[], manager: FeatureManager, eventBus?: EventBus, windowManager?: WindowManager, viewManager?: ViewManager): Promise<void>;
   activate(): Promise<void>;
   deactivate(): Promise<void>;
   destroy(): Promise<void>;
@@ -710,6 +740,8 @@ declare class Logger implements LoggerContext {
 //#region src/core/runtime/types.d.ts
 type RuntimeConfig = {
   features?: FeatureConfig<any>[];
+  windows?: WindowInstance[];
+  views?: ViewInstance[];
   logger?: {
     handlers?: LogHandler[];
   };
@@ -721,10 +753,9 @@ declare class Runtime {
   readonly logger: Logger;
   private readonly featureManager;
   private readonly eventBus;
-  private windowManager;
+  private readonly windowManager;
+  private readonly viewManager;
   constructor(config?: RuntimeConfig);
-  /** @internal Inject window manager (called by Electron layer before start). */
-  _injectWindowManager(windowManager: WindowManager): void;
   register(features: FeatureConfig<any> | FeatureConfig<any>[]): void;
   start(): Promise<void>;
   shutdown(): Promise<void>;
@@ -750,25 +781,45 @@ declare function createService<Scope extends ServiceScope, TApi, TId extends Ser
 /** Create a {@link Task} from a config object. Throws if `id` is empty. */
 declare function createTask<TId extends TaskId, TPayload = void>(config: TaskConfig<TId, TPayload>): CreatedTask<TId, TPayload>;
 //#endregion
+//#region src/core/window/helpers.d.ts
+/**
+* Creates a {@link Window} instance from a configuration object.
+*
+* @param config - Window configuration with `id`, optional `options`, and optional `api`.
+* @returns A new `Window` instance ready for registration.
+* @throws If `config.id` is empty.
+*/
+declare function createWindow<TApi = void>(config: WindowConfig<TApi>): CreatedWindow<TApi>;
+//#endregion
+//#region src/core/view/helpers.d.ts
+/**
+* Creates a {@link View} instance from a configuration object.
+*
+* @param config - View configuration with `id`, and either `renderer` (for Vite-built views) or `webPreferences` (for dynamic views).
+* @returns A new `View` instance ready for registration.
+* @throws If `config.id` is empty.
+*/
+declare function createView(config: ViewConfig): CreatedView;
+//#endregion
 //#region src/policy/types.d.ts
 /** Outcome of a policy check. */
 declare enum PolicyDecision {
   ALLOWED = "ALLOWED",
   ACCESS_DENIED = "ACCESS_DENIED",
-  WINDOW_NOT_FOUND = "WINDOW_NOT_FOUND"
+  VIEW_NOT_FOUND = "VIEW_NOT_FOUND"
 }
 /** Result of a policy check with context. */
 interface PolicyResult {
   readonly decision: PolicyDecision;
-  readonly windowName: string;
+  readonly viewName: string;
   readonly featureId: string;
 }
 //#endregion
 //#region src/policy/engine.d.ts
 /**
-* Deny-by-default policy engine for window–feature access control.
+* Deny-by-default policy engine for view–feature access control.
 *
-* A window's renderer can only access exposed services of features
+* A view's renderer can only access exposed services of features
 * listed in its `features: []` config. Everything else is denied.
 *
 * Used at:
@@ -777,15 +828,15 @@ interface PolicyResult {
 */
 declare class PolicyEngine {
   private readonly policies;
-  constructor(windows: readonly WindowDefinition[]);
+  constructor(views: readonly ViewDefinition[]);
   /** Full policy check with decision code and context. */
-  check(windowName: string, featureId: string): PolicyResult;
+  check(viewName: string, featureId: string): PolicyResult;
   /** Convenience: returns true only when access is ALLOWED. */
-  canAccess(windowName: string, featureId: string): boolean;
-  /** Returns the allowed feature IDs for a window. Throws if window unknown. */
-  getAllowedFeatures(windowName: string): readonly string[];
-  /** Returns all registered window names. */
-  getWindowNames(): string[];
+  canAccess(viewName: string, featureId: string): boolean;
+  /** Returns the allowed feature IDs for a view. Throws if view unknown. */
+  getAllowedFeatures(viewName: string): readonly string[];
+  /** Returns all registered view names. */
+  getViewNames(): string[];
 }
 //#endregion
-export { type BaseContext, type CreatedEvent, type CreatedService, type CreatedTask, type DefineConfigInput, type DefineRuntimeInput, type DefineWindowInput, type ElectroConfig, type ElectroWindow, EventAccessor, type EventHandler, type EventId, type EventInstance, type EventSubscription, type FeatureConfig, type FeatureContext, type FeatureHandle, type FeatureId, type FeatureMap, FeatureStatus, type LogEntry, type LogHandler, type LoggerContext, PolicyDecision, PolicyEngine, type PolicyResult, Runtime, type RuntimeConfig, type RuntimeDefinition, RuntimeState, type ServiceConfig, type ServiceId, type ServiceInfo, type ServiceOwnerMap, ServiceScope, ServiceStatus, type StopMode, type TaskConfig, type TaskExecutionContext, type TaskHandle, type TaskId, TaskOverlapStrategy, type TaskOwnerMap, TaskRetryStrategy, TaskStatus, type TaskStatusInfo, type TypedContext, type WindowBehavior, type WindowCloseBehavior, type WindowDefinition, type WindowFactory, type WindowInfo, type WindowLifecycle, type WindowMap, type WindowType, createEvent, createFeature, createRuntime, createService, createTask, defineConfig, defineRuntime, defineWindow };
+export { type BaseContext, type CreatedEvent, type CreatedService, type CreatedTask, type CreatedView, type CreatedWindow, type DefineConfigInput, type DefineRuntimeInput, type DefineViewInput, type ElectroConfig, type ElectroView, EventAccessor, type EventHandler, type EventId, type EventInstance, type EventSubscription, type FeatureConfig, type FeatureContext, type FeatureHandle, type FeatureId, type FeatureMap, FeatureStatus, type LogEntry, type LogHandler, type LoggerContext, PolicyDecision, PolicyEngine, type PolicyResult, Runtime, type RuntimeConfig, type RuntimeDefinition, RuntimeState, type ServiceConfig, type ServiceId, type ServiceInfo, type ServiceOwnerMap, ServiceScope, ServiceStatus, type StopMode, type TaskConfig, type TaskExecutionContext, type TaskHandle, type TaskId, TaskOverlapStrategy, type TaskOwnerMap, TaskRetryStrategy, TaskStatus, type TaskStatusInfo, type TypedContext, type ViewConfig, type ViewDefinition, type ViewId, type ViewInstance, type ViewMap, type WindowApiMap, type WindowConfig, type WindowId, type WindowInstance, createEvent, createFeature, createRuntime, createService, createTask, createView, createWindow, defineConfig, defineRuntime, defineView };

package/dist/index.mjs

@@ -1,6 +1,6 @@
 import { createRequire } from "node:module";
-import { join } from "node:path";
 import { Cron } from "croner";
+import { join } from "node:path";
 
 //#region \0rolldown/runtime.js
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
@@ -8,15 +8,15 @@ var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
 //#region src/config/define-config.ts
 function defineConfig(input) {
-	const windows = input.windows ?? [];
+	const views = input.views ?? [];
 	const seen = /* @__PURE__ */ new Set();
-	for (const win of windows) {
-		if (seen.has(win.name)) throw new Error(`[electro] defineConfig: duplicate window name "${win.name}"`);
-		seen.add(win.name);
+	for (const view of views) {
+		if (seen.has(view.name)) throw new Error(`[electro] defineConfig: duplicate view name "${view.name}"`);
+		seen.add(view.name);
 	}
 	return {
 		runtime: input.runtime,
-		windows
+		views
 	};
 }
 
@@ -53,26 +53,19 @@ function defineRuntime(input) {
 }
 
 //#endregion
-//#region src/config/define-window.ts
-const WINDOW_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
-function defineWindow(input) {
-	if (!input.name || input.name.trim().length === 0) throw new Error("[electro] defineWindow: name must be a non-empty string");
-	if (!WINDOW_NAME_PATTERN.test(input.name)) throw new Error(`[electro] defineWindow: name "${input.name}" is invalid. Must match ${WINDOW_NAME_PATTERN.toString()}`);
-	if (!input.entry || input.entry.trim().length === 0) throw new Error("[electro] defineWindow: entry must be a non-empty string");
-	const lifecycle = input.lifecycle ?? "singleton";
-	const close = input.behavior?.close ?? (lifecycle === "multi" ? "destroy" : "hide");
-	if (lifecycle === "multi" && close === "hide") throw new Error("[electro] defineWindow: behavior.close \"hide\" is only allowed with lifecycle \"singleton\". Multi-instance windows must use \"destroy\".");
+//#region src/config/define-view.ts
+const VIEW_NAME_PATTERN = /^[a-zA-Z0-9][a-zA-Z0-9_-]*$/;
+function defineView(input) {
+	if (!input.name || input.name.trim().length === 0) throw new Error("[electro] defineView: name must be a non-empty string");
+	if (!VIEW_NAME_PATTERN.test(input.name)) throw new Error(`[electro] defineView: name "${input.name}" is invalid. Must match ${VIEW_NAME_PATTERN.toString()}`);
+	if (!input.entry || input.entry.trim().length === 0) throw new Error("[electro] defineView: entry must be a non-empty string");
 	return {
 		name: input.name,
 		entry: input.entry,
-		type: input.type,
 		features: input.features,
 		vite: input.vite,
 		preload: input.preload,
-		lifecycle,
-		autoShow: input.autoShow ?? false,
-		behavior: { close },
-		window: input.window,
+		webPreferences: input.webPreferences,
 		__source: getCallerPath() ?? ""
 	};
 }
@@ -158,125 +151,6 @@ let RuntimeState = /* @__PURE__ */ function(RuntimeState) {
 	return RuntimeState;
 }({});
 
-//#endregion
-//#region src/window/default-factory.ts
-/**
-* Default WindowFactory — creates Electron BrowserWindow or BaseWindow
-* from a WindowDefinition at runtime.
-*/
-function createDefaultWindowFactory() {
-	return { create(definition) {
-		if (definition.type === "browser-window") {
-			const { BrowserWindow } = __require("electron");
-			return new BrowserWindow({
-				show: definition.autoShow ?? false,
-				...definition.window ?? {}
-			});
-		}
-		const { BaseWindow: BW } = __require("electron");
-		return new BW({
-			show: definition.autoShow ?? false,
-			...definition.window ?? {}
-		});
-	} };
-}
-
-//#endregion
-//#region src/window/manager.ts
-/**
-* WindowManager — registry, creation, and lifecycle coordinator for windows.
-*
-* Manages window definitions and their instances through a WindowFactory
-* abstraction. Enforces singleton/multi lifecycle semantics and provides
-* querying and bulk destruction capabilities.
-*/
-var WindowManager = class {
-	factory;
-	definitions = /* @__PURE__ */ new Map();
-	instances = /* @__PURE__ */ new Map();
-	constructor(factory) {
-		this.factory = factory;
-	}
-	/** Register a window definition. Throws on duplicate name. */
-	registerDefinition(definition) {
-		if (this.definitions.has(definition.name)) throw new Error(`Window definition duplicate: "${definition.name}" is already registered`);
-		this.definitions.set(definition.name, definition);
-	}
-	/** Check whether a definition is registered for the given name. */
-	hasDefinition(name) {
-		return this.definitions.has(name);
-	}
-	/**
-	* Create a window from a registered definition.
-	*
-	* - Throws if no definition exists for `name`.
-	* - For singleton lifecycle (the default), throws if a live instance already exists.
-	* - For multi lifecycle, always creates a new instance.
-	*/
-	createWindow(name) {
-		const definition = this.definitions.get(name);
-		if (!definition) throw new Error(`Cannot create window: no definition found for "${name}"`);
-		if ((definition.lifecycle ?? "singleton") === "singleton") {
-			if (this.getAliveInstances(name).length > 0) throw new Error(`Cannot create window "${name}": singleton instance already exists`);
-		}
-		const window = this.factory.create(definition);
-		const electrified = window;
-		electrified.load = async () => {
-			if (typeof window.loadURL !== "function") throw new Error(`Cannot load window "${name}": BaseWindow does not support loadURL/loadFile. Set type: "browser-window" in your window definition.`);
-			const bw = window;
-			const devUrl = process.env[`ELECTRO_DEV_URL_${name}`];
-			if (devUrl) {
-				await bw.loadURL(devUrl);
-				return;
-			}
-			const { app } = await import("electron");
-			await bw.loadFile(join(app.getAppPath(), ".electro", "out", "renderer", name, "index.html"));
-		};
-		const list = this.instances.get(name);
-		if (list) list.push(electrified);
-		else this.instances.set(name, [electrified]);
-		return electrified;
-	}
-	/**
-	* Get the first alive window for the given name, or null.
-	* Cleans up destroyed instances as a side effect.
-	*/
-	getWindow(name) {
-		const list = this.instances.get(name);
-		if (!list) return null;
-		const alive = list.filter((w) => !w.isDestroyed());
-		this.instances.set(name, alive);
-		return alive.length > 0 ? alive[0] : null;
-	}
-	/** Destroy all instances for the given name. No-op if name is unknown. */
-	destroyWindow(name) {
-		const list = this.instances.get(name);
-		if (!list) return;
-		for (const window of list) if (!window.isDestroyed()) window.destroy();
-		this.instances.set(name, []);
-	}
-	/** Destroy all tracked windows across all names. */
-	destroyAll() {
-		for (const [name] of this.instances) this.destroyWindow(name);
-	}
-	/** Returns a snapshot of all tracked windows (including destroyed ones). */
-	list() {
-		const result = [];
-		for (const [name, windows] of this.instances) for (const window of windows) result.push({
-			name,
-			windowId: window.id,
-			destroyed: window.isDestroyed()
-		});
-		return result;
-	}
-	/** Return alive (non-destroyed) instances for a given name. */
-	getAliveInstances(name) {
-		const list = this.instances.get(name);
-		if (!list) return [];
-		return list.filter((w) => !w.isDestroyed());
-	}
-};
-
 //#endregion
 //#region src/core/event-bus/event-bus.ts
 var EventBus = class {
@@ -311,26 +185,6 @@ var EventBus = class {
 	}
 };
 
-//#endregion
-//#region src/window/accessor.ts
-/**
-* Thin accessor bound to FeatureContext.
-*
-* Provides `createWindow(name)` and `getWindow(name)` for features.
-* Delegates all work to WindowManager.
-*/
-var WindowAccessor = class {
-	constructor(manager) {
-		this.manager = manager;
-	}
-	createWindow(name) {
-		return this.manager.createWindow(name);
-	}
-	getWindow(name) {
-		return this.manager.getWindow(name);
-	}
-};
-
 //#endregion
 //#region src/core/service/enums.ts
 let ServiceScope = /* @__PURE__ */ function(ServiceScope) {
@@ -676,12 +530,15 @@ var Feature = class {
 					throw new Error("Events not yet initialized");
 				}
 			},
-			createWindow: () => {
-				throw new Error("Window manager not available");
-			},
 			getWindow: () => {
 				throw new Error("Window manager not available");
 			},
+			createView: () => {
+				throw new Error("View manager not available");
+			},
+			getView: () => {
+				throw new Error("View manager not available");
+			},
 			logger: this.logger,
 			signal: this.controller.signal
 		};
@@ -699,8 +556,8 @@ var Feature = class {
 	transition(target) {
 		this.state.transition(target);
 	}
-	async initialize(features, manager, eventBus, windowManager) {
-		this.buildContext(features, manager, eventBus, windowManager);
+	async initialize(features, manager, eventBus, windowManager, viewManager) {
+		this.buildContext(features, manager, eventBus, windowManager, viewManager);
 		await this.config.onInitialize?.(this.context);
 	}
 	async activate() {
@@ -716,7 +573,7 @@ var Feature = class {
 	async destroy() {
 		await this.config.onDestroy?.(this.context);
 	}
-	buildContext(features, manager, eventBus, windowManager) {
+	buildContext(features, manager, eventBus, windowManager, viewManager) {
 		this.context.signal = this.controller.signal;
 		this.context.logger = this.logger;
 		this.serviceManager = new ServiceManager(this.context);
@@ -753,10 +610,20 @@ var Feature = class {
 				}
 			};
 		}
-		if (windowManager) {
-			const windowAccessor = new WindowAccessor(windowManager);
-			this.context.createWindow = (name) => windowAccessor.createWindow(name);
-			this.context.getWindow = (name) => windowAccessor.getWindow(name);
+		if (windowManager) this.context.getWindow = (id) => {
+			return windowManager.get(id);
+		};
+		if (viewManager) {
+			this.context.createView = (id) => {
+				const inst = viewManager.get(id);
+				if (!inst) throw new Error(`View "${id}" not registered`);
+				return inst.create();
+			};
+			this.context.getView = (id) => {
+				const inst = viewManager.get(id);
+				if (!inst) return null;
+				return inst.view();
+			};
 		}
 	}
 };
@@ -770,14 +637,19 @@ var FeatureManager = class {
 	/** Global task ownership: taskId → featureId. */
 	taskOwners = /* @__PURE__ */ new Map();
 	windowManager = null;
+	viewManager = null;
 	constructor(logger, eventBus = void 0) {
 		this.logger = logger;
 		this.eventBus = eventBus;
 	}
-	/** @internal Set the window manager (called by Electron layer before bootstrap). */
+	/** @internal Set the window manager (called by Runtime before bootstrap). */
 	setWindowManager(windowManager) {
 		this.windowManager = windowManager;
 	}
+	/** @internal Set the view manager (called by Runtime before bootstrap). */
+	setViewManager(viewManager) {
+		this.viewManager = viewManager;
+	}
 	/**
 	* Register a feature or a list of features.
 	* If a feature with the same ID is already registered, a warning is logged and the feature is skipped.
@@ -837,7 +709,7 @@ var FeatureManager = class {
 			const features = [];
 			const deps = feature.config.dependencies ?? [];
 			for (const dep of deps) features.push(this.registry.get(dep));
-			await feature.initialize(features, this, this.eventBus, this.windowManager ?? void 0);
+			await feature.initialize(features, this, this.eventBus, this.windowManager ?? void 0, this.viewManager ?? void 0);
 			feature.transition(FeatureStatus.READY);
 		} catch (err) {
 			feature.transition(FeatureStatus.ERROR);
@@ -1006,6 +878,49 @@ var Logger = class {
 	}
 };
 
+//#endregion
+//#region src/core/view/manager.ts
+/**
+* ViewManager — global registry for view instances.
+*
+* Views are registered at runtime startup and accessible from any feature.
+* Views are idempotent: `get(id).create()` returns the same instance if alive.
+*/
+var ViewManager = class {
+	instances = /* @__PURE__ */ new Map();
+	register(view) {
+		if (this.instances.has(view.id)) throw new Error(`View "${view.id}" is already registered`);
+		this.instances.set(view.id, view);
+	}
+	get(id) {
+		return this.instances.get(id) ?? null;
+	}
+	destroyAll() {
+		for (const inst of this.instances.values()) inst.destroy();
+	}
+};
+
+//#endregion
+//#region src/core/window/manager.ts
+/**
+* WindowManager — global registry for window instances.
+*
+* Windows are registered at runtime startup and accessible from any feature.
+*/
+var WindowManager = class {
+	instances = /* @__PURE__ */ new Map();
+	register(window) {
+		if (this.instances.has(window.id)) throw new Error(`Window "${window.id}" is already registered`);
+		this.instances.set(window.id, window);
+	}
+	get(id) {
+		return this.instances.get(id) ?? null;
+	}
+	destroyAll() {
+		for (const inst of this.instances.values()) inst.destroy();
+	}
+};
+
 //#endregion
 //#region src/core/runtime/runtime.ts
 const RUNTIME_TRANSITIONS = {
@@ -1021,7 +936,8 @@ var Runtime = class {
 	logger;
 	featureManager;
 	eventBus;
-	windowManager = null;
+	windowManager;
+	viewManager;
 	constructor(config) {
 		this.state = new StateMachine({
 			transitions: RUNTIME_TRANSITIONS,
@@ -1033,24 +949,19 @@ var Runtime = class {
 		this.featureManager = new FeatureManager(this.logger, this.eventBus);
 		this.logger.addHandler(createConsoleHandler());
 		if (config?.logger?.handlers) for (const handler of config.logger.handlers) this.logger.addHandler(handler);
+		this.windowManager = new WindowManager();
+		for (const win of config?.windows ?? []) this.windowManager.register(win);
+		this.viewManager = new ViewManager();
+		for (const view of config?.views ?? []) this.viewManager.register(view);
+		this.featureManager.setWindowManager(this.windowManager);
+		this.featureManager.setViewManager(this.viewManager);
 		if (config?.features) this.featureManager.register(config.features);
 	}
-	/** @internal Inject window manager (called by Electron layer before start). */
-	_injectWindowManager(windowManager) {
-		this.state.assertState(RuntimeState.CREATED);
-		this.windowManager = windowManager;
-		this.featureManager.setWindowManager(windowManager);
-	}
 	register(features) {
 		this.state.assertState(RuntimeState.CREATED);
 		this.featureManager.register(features);
 	}
 	async start() {
-		if (!this.windowManager && typeof __ELECTRO_WINDOW_DEFINITIONS__ !== "undefined") {
-			const wm = new WindowManager(createDefaultWindowFactory());
-			for (const def of __ELECTRO_WINDOW_DEFINITIONS__) wm.registerDefinition(def);
-			this._injectWindowManager(wm);
-		}
 		this.state.transition(RuntimeState.STARTING);
 		try {
 			await this.featureManager.bootstrap();
@@ -1064,7 +975,8 @@ var Runtime = class {
 		this.state.assertState(RuntimeState.RUNNING);
 		this.state.transition(RuntimeState.STOPPING);
 		await this.featureManager.shutdown();
-		this.windowManager?.destroyAll();
+		this.viewManager.destroyAll();
+		this.windowManager.destroyAll();
 		this.state.transition(RuntimeState.STOPPED);
 	}
 	async enable(id) {
@@ -1531,22 +1443,154 @@ function createTask(config) {
 	return new Task(config);
 }
 
+//#endregion
+//#region src/core/window/window.ts
+/**
+* Window — manages a single BaseWindow instance with an optional typed API.
+*
+* `create()` is idempotent: calling it while an alive window exists returns
+* the existing instance. After the window is destroyed (user close, etc.),
+* calling `create()` again spawns a fresh one.
+*/
+var Window = class {
+	_window = null;
+	_api = null;
+	constructor(config) {
+		this.config = config;
+	}
+	get id() {
+		return this.config.id;
+	}
+	create() {
+		if (this._window && !this._window.isDestroyed()) return this._window;
+		const { BaseWindow: BW } = __require("electron");
+		this._window = new BW({
+			show: false,
+			...this.config.options ?? {}
+		});
+		if (this.config.api) this._api = this.config.api(this._window);
+		return this._window;
+	}
+	get window() {
+		if (this._window?.isDestroyed()) {
+			this._window = null;
+			this._api = null;
+		}
+		return this._window;
+	}
+	get api() {
+		if (this._window?.isDestroyed()) {
+			this._window = null;
+			this._api = null;
+		}
+		return this._api;
+	}
+	destroy() {
+		if (this._window && !this._window.isDestroyed()) this._window.destroy();
+		this._window = null;
+		this._api = null;
+	}
+};
+
+//#endregion
+//#region src/core/window/helpers.ts
+/**
+* Creates a {@link Window} instance from a configuration object.
+*
+* @param config - Window configuration with `id`, optional `options`, and optional `api`.
+* @returns A new `Window` instance ready for registration.
+* @throws If `config.id` is empty.
+*/
+function createWindow(config) {
+	if (!config.id) throw new Error("Window must have an id");
+	return new Window(config);
+}
+
+//#endregion
+//#region src/core/view/view.ts
+function isRendererConfig(config) {
+	return "renderer" in config;
+}
+function resolveRendererName(config) {
+	return config.renderer === true ? config.id : config.renderer;
+}
+/**
+* View — manages a single WebContentsView instance.
+*
+* `create()` is idempotent: calling it while an alive view exists returns
+* the existing instance. After the view is destroyed, calling `create()`
+* spawns a fresh one.
+*
+* For renderer-linked views, `load()` resolves the dev URL or production
+* file path automatically.
+*/
+var View = class {
+	_view = null;
+	constructor(config) {
+		this.config = config;
+	}
+	get id() {
+		return this.config.id;
+	}
+	create() {
+		if (this._view && !this._view.webContents.isDestroyed()) return this._view;
+		const { WebContentsView: WCV } = __require("electron");
+		const view = new WCV({ webPreferences: { ...this.config.webPreferences ?? {} } });
+		if (isRendererConfig(this.config)) {
+			const rendererName = resolveRendererName(this.config);
+			view.load = async () => {
+				const devUrl = process.env[`ELECTRO_DEV_URL_${rendererName}`];
+				if (devUrl) {
+					await view.webContents.loadURL(devUrl);
+					return;
+				}
+				const { app } = await import("electron");
+				await view.webContents.loadFile(join(app.getAppPath(), ".electro", "out", "renderer", rendererName, "index.html"));
+			};
+		} else view.load = async () => {};
+		this._view = view;
+		return view;
+	}
+	view() {
+		if (this._view?.webContents.isDestroyed()) this._view = null;
+		return this._view;
+	}
+	destroy() {
+		if (this._view && !this._view.webContents.isDestroyed()) this._view.webContents.close();
+		this._view = null;
+	}
+};
+
+//#endregion
+//#region src/core/view/helpers.ts
+/**
+* Creates a {@link View} instance from a configuration object.
+*
+* @param config - View configuration with `id`, and either `renderer` (for Vite-built views) or `webPreferences` (for dynamic views).
+* @returns A new `View` instance ready for registration.
+* @throws If `config.id` is empty.
+*/
+function createView(config) {
+	if (!config.id) throw new Error("View must have an id");
+	return new View(config);
+}
+
 //#endregion
 //#region src/policy/types.ts
 /** Outcome of a policy check. */
 let PolicyDecision = /* @__PURE__ */ function(PolicyDecision) {
 	PolicyDecision["ALLOWED"] = "ALLOWED";
 	PolicyDecision["ACCESS_DENIED"] = "ACCESS_DENIED";
-	PolicyDecision["WINDOW_NOT_FOUND"] = "WINDOW_NOT_FOUND";
+	PolicyDecision["VIEW_NOT_FOUND"] = "VIEW_NOT_FOUND";
 	return PolicyDecision;
 }({});
 
 //#endregion
 //#region src/policy/engine.ts
 /**
-* Deny-by-default policy engine for window–feature access control.
+* Deny-by-default policy engine for view–feature access control.
 *
-* A window's renderer can only access exposed services of features
+* A view's renderer can only access exposed services of features
 * listed in its `features: []` config. Everything else is denied.
 *
 * Used at:
@@ -1555,38 +1599,38 @@ let PolicyDecision = /* @__PURE__ */ function(PolicyDecision) {
 */
 var PolicyEngine = class {
 	policies = /* @__PURE__ */ new Map();
-	constructor(windows) {
-		for (const win of windows) this.policies.set(win.name, new Set(win.features ?? []));
+	constructor(views) {
+		for (const view of views) this.policies.set(view.name, new Set(view.features ?? []));
 	}
 	/** Full policy check with decision code and context. */
-	check(windowName, featureId) {
-		const allowed = this.policies.get(windowName);
+	check(viewName, featureId) {
+		const allowed = this.policies.get(viewName);
 		if (!allowed) return {
-			decision: PolicyDecision.WINDOW_NOT_FOUND,
-			windowName,
+			decision: PolicyDecision.VIEW_NOT_FOUND,
+			viewName,
 			featureId
 		};
 		return {
 			decision: allowed.has(featureId) ? PolicyDecision.ALLOWED : PolicyDecision.ACCESS_DENIED,
-			windowName,
+			viewName,
 			featureId
 		};
 	}
 	/** Convenience: returns true only when access is ALLOWED. */
-	canAccess(windowName, featureId) {
-		return this.check(windowName, featureId).decision === PolicyDecision.ALLOWED;
+	canAccess(viewName, featureId) {
+		return this.check(viewName, featureId).decision === PolicyDecision.ALLOWED;
 	}
-	/** Returns the allowed feature IDs for a window. Throws if window unknown. */
-	getAllowedFeatures(windowName) {
-		const allowed = this.policies.get(windowName);
-		if (!allowed) throw new Error(`Window "${windowName}" is not registered in the policy engine`);
+	/** Returns the allowed feature IDs for a view. Throws if view unknown. */
+	getAllowedFeatures(viewName) {
+		const allowed = this.policies.get(viewName);
+		if (!allowed) throw new Error(`View "${viewName}" is not registered in the policy engine`);
 		return [...allowed];
 	}
-	/** Returns all registered window names. */
-	getWindowNames() {
+	/** Returns all registered view names. */
+	getViewNames() {
 		return [...this.policies.keys()];
 	}
 };
 
 //#endregion
-export { EventAccessor, FeatureStatus, PolicyDecision, PolicyEngine, Runtime, RuntimeState, ServiceScope, ServiceStatus, TaskOverlapStrategy, TaskRetryStrategy, TaskStatus, createEvent, createFeature, createRuntime, createService, createTask, defineConfig, defineRuntime, defineWindow };
+export { EventAccessor, FeatureStatus, PolicyDecision, PolicyEngine, Runtime, RuntimeState, ServiceScope, ServiceStatus, TaskOverlapStrategy, TaskRetryStrategy, TaskStatus, createEvent, createFeature, createRuntime, createService, createTask, createView, createWindow, defineConfig, defineRuntime, defineView };

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@cordy/electro",
-    "version": "1.0.8",
+    "version": "1.1.0",
     "description": "Electron framework — feature-first runtime, codegen, and Vite-based build system",
     "license": "MIT",
     "type": "module",