@cordy/electro 1.0.0

package/dist/index.mjs

@@ -0,0 +1,1592 @@
+import { createRequire } from "node:module";
+import { join } from "node:path";
+import { Cron } from "croner";
+
+//#region \0rolldown/runtime.js
+var __require = /* @__PURE__ */ createRequire(import.meta.url);
+
+//#endregion
+//#region src/config/define-config.ts
+function defineConfig(input) {
+	const windows = input.windows ?? [];
+	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);
+	}
+	return {
+		runtime: input.runtime,
+		windows
+	};
+}
+
+//#endregion
+//#region src/config/caller.ts
+/** Resolve the file path of the caller (skipping electro config internals). */
+function getCallerPath() {
+	const stack = (/* @__PURE__ */ new Error()).stack;
+	if (!stack) return void 0;
+	const lines = stack.split("\n");
+	for (const line of lines) {
+		const match = line.match(/(?:at\s+.*\()?((?:file:\/\/)?[^\s)]+):\d+:\d+\)?/);
+		if (!match) continue;
+		const rawPath = match[1];
+		if (rawPath.includes("/src/config/") || rawPath.includes("/dist/config") || rawPath.includes("@cordy/electro") || rawPath.includes("/packages/electro/dist/")) continue;
+		if (rawPath.startsWith("file://")) try {
+			return decodeURIComponent(new URL(rawPath).pathname);
+		} catch {
+			return rawPath;
+		}
+		return rawPath;
+	}
+}
+
+//#endregion
+//#region src/config/define-runtime.ts
+function defineRuntime(input) {
+	if (!input.entry || input.entry.trim().length === 0) throw new Error("[electro] defineRuntime: entry must be a non-empty string");
+	return {
+		entry: input.entry,
+		vite: input.vite,
+		__source: getCallerPath() ?? ""
+	};
+}
+
+//#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\".");
+	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,
+		__source: getCallerPath() ?? ""
+	};
+}
+
+//#endregion
+//#region src/core/event-bus/accessor.ts
+/**
+* Scoped event access per feature.
+*
+* - `publish("name", payload)` -> publishes as `"ownerId:name"`
+* - `on("dep:name", handler)` -> validates `dep` is a declared dependency
+* - `on("name", handler)` -> subscribes to own `"ownerId:name"`
+*/
+var EventAccessor = class {
+	constructor(bus, ownerId, declaredDeps) {
+		this.bus = bus;
+		this.ownerId = ownerId;
+		this.declaredDeps = declaredDeps;
+	}
+	publish(event, payload) {
+		this.bus.publish(`${this.ownerId}:${event}`, payload);
+	}
+	on(event, handler) {
+		const colonIdx = event.indexOf(":");
+		if (colonIdx === -1) return this.bus.subscribe(`${this.ownerId}:${event}`, handler, this.ownerId);
+		const depId = event.slice(0, colonIdx);
+		if (!this.declaredDeps.has(depId)) throw new Error(`Feature "${this.ownerId}" cannot subscribe to "${event}": "${depId}" is not a declared dependency`);
+		return this.bus.subscribe(event, handler, this.ownerId);
+	}
+};
+
+//#endregion
+//#region src/core/event-bus/helpers.ts
+function createEvent(id, defaults) {
+	if (!id || id.trim().length === 0) throw new Error("createEvent: id is required");
+	return {
+		id,
+		defaults,
+		payload() {
+			throw new Error("phantom method — not callable");
+		}
+	};
+}
+
+//#endregion
+//#region src/core/feature/enums.ts
+let FeatureStatus = /* @__PURE__ */ function(FeatureStatus) {
+	FeatureStatus["NONE"] = "none";
+	FeatureStatus["REGISTERED"] = "registered";
+	FeatureStatus["INITIALIZING"] = "initializing";
+	FeatureStatus["READY"] = "ready";
+	FeatureStatus["ACTIVATING"] = "activating";
+	FeatureStatus["ACTIVATED"] = "activated";
+	FeatureStatus["DEACTIVATING"] = "deactivating";
+	FeatureStatus["DEACTIVATED"] = "deactivated";
+	FeatureStatus["DESTROYING"] = "destroying";
+	FeatureStatus["DESTROYED"] = "destroyed";
+	FeatureStatus["ERROR"] = "error";
+	return FeatureStatus;
+}({});
+
+//#endregion
+//#region src/core/feature/helpers.ts
+/**
+* Method for creating a feature
+* @param config - The configuration object for the feature
+* @returns The feature configuration object
+*/
+function createFeature(config) {
+	if (!config.id) throw new Error("Feature must have an id");
+	return config;
+}
+
+//#endregion
+//#region src/core/runtime/enums.ts
+let RuntimeState = /* @__PURE__ */ function(RuntimeState) {
+	RuntimeState["CREATED"] = "created";
+	RuntimeState["STARTING"] = "starting";
+	RuntimeState["RUNNING"] = "running";
+	RuntimeState["STOPPING"] = "stopping";
+	RuntimeState["STOPPED"] = "stopped";
+	RuntimeState["FAILED"] = "failed";
+	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 {
+	subscriptions = /* @__PURE__ */ new Map();
+	publish(channel, payload) {
+		const subs = this.subscriptions.get(channel);
+		if (!subs) return;
+		for (const sub of subs) sub.handler(payload);
+	}
+	subscribe(channel, handler, ownerId) {
+		const sub = {
+			channel,
+			handler,
+			ownerId
+		};
+		let channelSubs = this.subscriptions.get(channel);
+		if (!channelSubs) {
+			channelSubs = /* @__PURE__ */ new Set();
+			this.subscriptions.set(channel, channelSubs);
+		}
+		channelSubs.add(sub);
+		return () => {
+			channelSubs.delete(sub);
+			if (channelSubs.size === 0) this.subscriptions.delete(channel);
+		};
+	}
+	removeByOwner(ownerId) {
+		for (const [channel, subs] of this.subscriptions) {
+			for (const sub of subs) if (sub.ownerId === ownerId) subs.delete(sub);
+			if (subs.size === 0) this.subscriptions.delete(channel);
+		}
+	}
+};
+
+//#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) {
+	ServiceScope["PRIVATE"] = "private";
+	ServiceScope["INTERNAL"] = "internal";
+	ServiceScope["EXPOSED"] = "exposed";
+	return ServiceScope;
+}({});
+let ServiceStatus = /* @__PURE__ */ function(ServiceStatus) {
+	ServiceStatus["REGISTERED"] = "registered";
+	ServiceStatus["ACTIVE"] = "active";
+	ServiceStatus["DESTROYED"] = "destroyed";
+	return ServiceStatus;
+}({});
+
+//#endregion
+//#region src/core/service/accessor.ts
+/**
+* Implements `ctx.getService(name)` with scope-aware access control.
+*
+* - `"serviceId"` — own-feature lookup, all scopes visible, returns API directly.
+* - `"featureId:serviceId"` — cross-feature lookup, only INTERNAL + EXPOSED visible.
+*/
+var ServiceAccessor = class {
+	constructor(own, deps) {
+		this.own = own;
+		this.deps = deps;
+	}
+	/**
+	* Resolve a service by name.
+	*
+	* @param name Either `"serviceId"` (own feature) or `"featureId:serviceId"` (cross-feature).
+	* @returns The service API directly.
+	* @throws If the service or feature is not found, or scope is not accessible.
+	*/
+	get(name) {
+		const colonIdx = name.indexOf(":");
+		if (colonIdx === -1) return this.resolveOwn(name);
+		const featureId = name.slice(0, colonIdx);
+		const serviceId = name.slice(colonIdx + 1);
+		return this.resolveDep(featureId, serviceId);
+	}
+	resolveOwn(serviceId) {
+		const result = this.own.get(serviceId);
+		if (!result) throw new Error(`Service "${serviceId}" not found in own feature`);
+		return result.api;
+	}
+	resolveDep(featureId, serviceId) {
+		const manager = this.deps.get(featureId);
+		if (!manager) throw new Error(`Feature "${featureId}" is not a declared dependency`);
+		const result = manager.get(serviceId);
+		if (!result) throw new Error(`Service "${serviceId}" not found in feature "${featureId}"`);
+		if (result.scope === ServiceScope.PRIVATE) throw new Error(`Service "${serviceId}" in feature "${featureId}" is private and not accessible cross-feature`);
+		return result.api;
+	}
+};
+
+//#endregion
+//#region src/core/service/manager.ts
+/**
+* Per-feature registry and lifecycle coordinator for {@link Service} instances.
+*
+* One service per id — `get()` returns `{ api, scope }` directly.
+*/
+var ServiceManager = class {
+	/** Primary storage: `id` → Service */
+	services = /* @__PURE__ */ new Map();
+	_isShutdown = false;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/** Add a service to the registry. Throws on duplicate id. */
+	register(service) {
+		if (this.services.has(service.id)) throw new Error(`Duplicate service: "${service.id}"`);
+		this.services.set(service.id, service);
+	}
+	/** Remove a service by id. Destroys it before removing. */
+	unregister(serviceId) {
+		const service = this.services.get(serviceId);
+		if (!service) return;
+		service.destroy();
+		this.services.delete(serviceId);
+	}
+	/** Build all registered services. No-op after shutdown. */
+	startup() {
+		if (this._isShutdown) return;
+		for (const service of this.services.values()) service.build(this.ctx);
+	}
+	/** Destroy all registered services. Marks manager as shut down. */
+	shutdown() {
+		this._isShutdown = true;
+		for (const service of this.services.values()) service.destroy();
+	}
+	/**
+	* Get a service by id, returning its API and scope.
+	*
+	* @returns `{ api, scope }` or `null` if service id is unknown or not yet built
+	*/
+	get(serviceId) {
+		const service = this.services.get(serviceId);
+		if (!service) return null;
+		const api = service.api();
+		if (api == null) return null;
+		return {
+			api,
+			scope: service.scope
+		};
+	}
+	/** Return status for a given service id. Throws if unknown. */
+	status(serviceId) {
+		const service = this.services.get(serviceId);
+		if (!service) throw new Error(`Service "${serviceId}" not found`);
+		return service.status();
+	}
+	/** Return status for all registered services. */
+	list() {
+		return Array.from(this.services.values()).map((s) => s.status());
+	}
+};
+
+//#endregion
+//#region src/core/state-machine/state-machine.ts
+var StateMachine = class {
+	_current;
+	_transitions;
+	_name;
+	_listeners = /* @__PURE__ */ new Set();
+	constructor(config) {
+		this._current = config.initial;
+		this._transitions = config.transitions;
+		this._name = config.name ?? "StateMachine";
+	}
+	get current() {
+		return this._current;
+	}
+	transition(target) {
+		const allowed = this._transitions[this._current];
+		if (!allowed || !allowed.includes(target)) throw new Error(`Illegal transition: "${this._current}" \u2192 "${target}" for "${this._name}"`);
+		const from = this._current;
+		this._current = target;
+		for (const listener of this._listeners) listener(from, target);
+	}
+	canTransition(target) {
+		const allowed = this._transitions[this._current];
+		return !!allowed && allowed.includes(target);
+	}
+	assertState(...allowed) {
+		if (!allowed.includes(this._current)) {
+			const list = allowed.map((s) => `"${s}"`).join(", ");
+			throw new Error(`"${this._name}" expected state ${list}, but current is "${this._current}"`);
+		}
+	}
+	onTransition(cb) {
+		this._listeners.add(cb);
+		return () => {
+			this._listeners.delete(cb);
+		};
+	}
+};
+
+//#endregion
+//#region src/core/task/handle.ts
+/**
+* Ergonomic handle for a single {@link Task}.
+*
+* Provides per-task control: start, queue, stop, enable, disable, clear, status.
+* Created by Feature and bound to `ctx.getTask(name)`.
+*/
+var TaskHandle = class {
+	constructor(task, ctx = void 0) {
+		this.task = task;
+		this.ctx = ctx;
+	}
+	/** Execute immediately (respects overlap policy). */
+	async start(payload) {
+		await this.task.start(payload);
+	}
+	/** Push payload to FIFO queue, processes sequentially. */
+	queue(payload) {
+		this.task.queue(payload);
+	}
+	/** Abort current execution. Queue continues processing. */
+	stop() {
+		this.task.stop();
+	}
+	/** Re-enable the task (cron, ready for start/queue). */
+	enable() {
+		if (this.ctx) this.task.enable(this.ctx);
+	}
+	/** Abort current + clear queue + stop cron. */
+	disable(mode) {
+		this.task.disable(mode);
+	}
+	/** Clear the FIFO queue without stopping current execution. */
+	clear() {
+		this.task.clear();
+	}
+	/** Snapshot of the task's current state. */
+	status() {
+		return this.task.status();
+	}
+};
+
+//#endregion
+//#region src/core/task/manager.ts
+/**
+* Registry and lifecycle coordinator for {@link Task} instances.
+*
+* Manages a flat collection of tasks: registration, bulk startup/shutdown,
+* individual enable/disable, manual execution, and status queries.
+*
+* Does **not** own scheduling or retry — those belong to {@link Task}.
+*/
+var TaskManager = class {
+	tasks = /* @__PURE__ */ new Map();
+	_isShutdown = false;
+	constructor(ctx) {
+		this.ctx = ctx;
+	}
+	/** Add a task to the registry. Throws on duplicate `task.id`. */
+	register(task) {
+		if (this.tasks.has(task.id)) throw new Error(`Duplicate task id: "${task.id}"`);
+		this.tasks.set(task.id, task);
+	}
+	/** Remove a task, force-disabling it first. No-op for unknown ids. */
+	unregister(taskId) {
+		const task = this.tasks.get(taskId);
+		if (!task) return;
+		task.disable("force");
+		this.tasks.delete(taskId);
+	}
+	/** Enable all registered tasks. No-op after {@link shutdown}. */
+	startup() {
+		if (this._isShutdown) return;
+		for (const task of this.tasks.values()) task.enable(this.ctx);
+	}
+	/** Disable all registered tasks. Marks the manager as shut down (startup becomes a no-op). */
+	shutdown(mode = "graceful") {
+		this._isShutdown = true;
+		for (const task of this.tasks.values()) task.disable(mode);
+	}
+	/** Enable a single task by id. Throws if the task is not registered. */
+	enable(taskId) {
+		this.getTaskInstance(taskId).enable(this.ctx);
+	}
+	/** Disable a single task by id. Throws if the task is not registered. */
+	disable(taskId, mode = "graceful") {
+		this.getTaskInstance(taskId).disable(mode);
+	}
+	/** Trigger a manual execution of the task. Throws if the task is not registered. */
+	async start(taskId, payload) {
+		await this.getTaskInstance(taskId).start(payload);
+	}
+	/** Return the current status snapshot for a single task. */
+	status(taskId) {
+		return this.getTaskInstance(taskId).status();
+	}
+	/** Return status snapshots for all registered tasks. */
+	list() {
+		return Array.from(this.tasks.values()).map((t) => t.status());
+	}
+	/** Return the raw Task instance. Throws if not registered. */
+	getTaskInstance(taskId) {
+		const task = this.tasks.get(taskId);
+		if (!task) throw new Error(`Task "${taskId}" not found`);
+		return task;
+	}
+};
+
+//#endregion
+//#region src/core/feature/handle.ts
+/**
+* Ergonomic handle for a declared dependency Feature.
+*
+* Provides per-feature control: status, enable, disable.
+* Created by Feature and bound to `ctx.getFeature(name)`.
+*/
+var FeatureHandle = class {
+	constructor(feature, manager) {
+		this.feature = feature;
+		this.manager = manager;
+	}
+	/** Current lifecycle state. */
+	status() {
+		return this.feature.status;
+	}
+	/** Re-activate the feature (from DEACTIVATED or ERROR). */
+	async enable() {
+		await this.manager.enable(this.feature.id);
+	}
+	/** Deactivate the feature. */
+	async disable() {
+		await this.manager.disable(this.feature.id);
+	}
+};
+
+//#endregion
+//#region src/core/feature/feature.ts
+/** Allowed state transitions for the Feature FSM. */
+const TRANSITIONS = {
+	[FeatureStatus.NONE]: [FeatureStatus.REGISTERED],
+	[FeatureStatus.REGISTERED]: [FeatureStatus.INITIALIZING],
+	[FeatureStatus.INITIALIZING]: [FeatureStatus.READY, FeatureStatus.ERROR],
+	[FeatureStatus.READY]: [FeatureStatus.ACTIVATING],
+	[FeatureStatus.ACTIVATING]: [FeatureStatus.ACTIVATED, FeatureStatus.ERROR],
+	[FeatureStatus.ACTIVATED]: [FeatureStatus.DEACTIVATING],
+	[FeatureStatus.DEACTIVATING]: [FeatureStatus.DEACTIVATED, FeatureStatus.ERROR],
+	[FeatureStatus.DEACTIVATED]: [FeatureStatus.ACTIVATING, FeatureStatus.DESTROYING],
+	[FeatureStatus.DESTROYING]: [FeatureStatus.DESTROYED, FeatureStatus.ERROR],
+	[FeatureStatus.DESTROYED]: [],
+	[FeatureStatus.ERROR]: [FeatureStatus.ACTIVATING, FeatureStatus.DESTROYING]
+};
+var Feature = class {
+	state;
+	controller = new AbortController();
+	context;
+	serviceManager = null;
+	taskManager = null;
+	eventBus = null;
+	constructor(config, logger) {
+		this.config = config;
+		this.logger = logger;
+		this.state = new StateMachine({
+			transitions: TRANSITIONS,
+			initial: FeatureStatus.NONE,
+			name: `feature "${config.id}"`
+		});
+		this.context = {
+			getService: () => {
+				throw new Error("Services not yet initialized");
+			},
+			getTask: () => {
+				throw new Error("Tasks not yet initialized");
+			},
+			getFeature: () => {
+				throw new Error("Features not yet initialized");
+			},
+			events: {
+				publish: () => {
+					throw new Error("Events not yet initialized");
+				},
+				on: () => {
+					throw new Error("Events not yet initialized");
+				}
+			},
+			createWindow: () => {
+				throw new Error("Window manager not available");
+			},
+			getWindow: () => {
+				throw new Error("Window manager not available");
+			},
+			logger: this.logger,
+			signal: this.controller.signal
+		};
+	}
+	get id() {
+		return this.config.id;
+	}
+	get status() {
+		return this.state.current;
+	}
+	/**
+	* Validate and apply an FSM transition.
+	* @throws If the transition is not allowed from the current state.
+	*/
+	transition(target) {
+		this.state.transition(target);
+	}
+	async initialize(features, manager, eventBus, windowManager) {
+		this.buildContext(features, manager, eventBus, windowManager);
+		await this.config.onInitialize?.(this.context);
+	}
+	async activate() {
+		await this.config.onActivate?.(this.context);
+		this.taskManager?.startup();
+	}
+	async deactivate() {
+		if (this.eventBus) this.eventBus.removeByOwner(this.id);
+		this.taskManager?.shutdown();
+		if (this.serviceManager) this.serviceManager.shutdown();
+		await this.config.onDeactivate?.(this.context);
+	}
+	async destroy() {
+		await this.config.onDestroy?.(this.context);
+	}
+	buildContext(features, manager, eventBus, windowManager) {
+		this.context.signal = this.controller.signal;
+		this.context.logger = this.logger;
+		this.serviceManager = new ServiceManager(this.context);
+		for (const service of this.config.services ?? []) this.serviceManager.register(service);
+		this.serviceManager.startup();
+		const deps = /* @__PURE__ */ new Map();
+		for (const dep of features) if (dep.serviceManager) deps.set(dep.id, dep.serviceManager);
+		const accessor = new ServiceAccessor(this.serviceManager, deps);
+		this.context.getService = ((name) => accessor.get(name));
+		this.taskManager = new TaskManager(this.context);
+		for (const task of this.config.tasks ?? []) this.taskManager.register(task);
+		this.context.getTask = ((name) => {
+			return new TaskHandle(this.taskManager.getTaskInstance(name), this.context);
+		});
+		const declaredDeps = new Set(this.config.dependencies ?? []);
+		this.context.getFeature = ((name) => {
+			if (!declaredDeps.has(name)) throw new Error(`Feature "${name}" is not a declared dependency of "${this.id}"`);
+			const dep = features.find((f) => f.id === name);
+			if (!dep) throw new Error(`Feature "${name}" not found`);
+			return new FeatureHandle(dep, manager);
+		});
+		if (eventBus) {
+			this.eventBus = eventBus;
+			const eventAccessor = new EventAccessor(eventBus, this.id, declaredDeps);
+			const eventDefaults = /* @__PURE__ */ new Map();
+			for (const evt of this.config.events ?? []) if (evt.defaults !== void 0) eventDefaults.set(evt.id, evt.defaults);
+			this.context.events = {
+				publish: (event, payload) => {
+					const resolved = payload ?? eventDefaults.get(event);
+					eventAccessor.publish(event, resolved);
+				},
+				on: (event, handler) => {
+					return eventAccessor.on(event, handler);
+				}
+			};
+		}
+		if (windowManager) {
+			const windowAccessor = new WindowAccessor(windowManager);
+			this.context.createWindow = (name) => windowAccessor.createWindow(name);
+			this.context.getWindow = (name) => windowAccessor.getWindow(name);
+		}
+	}
+};
+
+//#endregion
+//#region src/core/feature/manager.ts
+var FeatureManager = class {
+	registry = /* @__PURE__ */ new Map();
+	/** Global service ownership: serviceId → featureId. */
+	serviceOwners = /* @__PURE__ */ new Map();
+	/** Global task ownership: taskId → featureId. */
+	taskOwners = /* @__PURE__ */ new Map();
+	windowManager = null;
+	constructor(logger, eventBus = void 0) {
+		this.logger = logger;
+		this.eventBus = eventBus;
+	}
+	/** @internal Set the window manager (called by Electron layer before bootstrap). */
+	setWindowManager(windowManager) {
+		this.windowManager = windowManager;
+	}
+	/**
+	* 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.
+	* @throws If a service or task ID is already owned by another feature.
+	*/
+	register(features) {
+		const list = Array.isArray(features) ? features : [features];
+		for (const item of list) {
+			if (this.registry.has(item.id)) {
+				this.logger.warn("FeatureManager", `Feature "${item.id}" is already registered. Skipping.`);
+				continue;
+			}
+			const seenSvcIds = /* @__PURE__ */ new Set();
+			for (const svc of item.services ?? []) {
+				if (seenSvcIds.has(svc.id)) throw new Error(`Duplicate service "${svc.id}" within feature "${item.id}" — one service per ID.`);
+				seenSvcIds.add(svc.id);
+				const owner = this.serviceOwners.get(svc.id);
+				if (owner !== void 0) throw new Error(`Service "${svc.id}" is already registered by feature "${owner}". Feature "${item.id}" cannot claim it — service IDs must be globally unique.`);
+			}
+			for (const task of item.tasks ?? []) {
+				const owner = this.taskOwners.get(task.id);
+				if (owner !== void 0) throw new Error(`Task "${task.id}" is already registered by feature "${owner}". Feature "${item.id}" cannot claim it — task IDs must be globally unique.`);
+			}
+			for (const svc of item.services ?? []) this.serviceOwners.set(svc.id, item.id);
+			for (const task of item.tasks ?? []) this.taskOwners.set(task.id, item.id);
+			const feature = new Feature(item, this.logger);
+			this.registry.set(feature.id, feature);
+			feature.transition(FeatureStatus.REGISTERED);
+		}
+	}
+	get(id) {
+		return this.registry.get(id);
+	}
+	/** Returns all registered features. */
+	list() {
+		return [...this.registry.values()];
+	}
+	/**
+	* Bootstrap all features in dependency order.
+	* Calls initialize -> activate on each feature.
+	* The feature receives a context built externally (by Runtime).
+	*/
+	async bootstrap() {
+		const order = this.reorder();
+		for (const id of order) await this.initialize(id);
+		for (const id of order) await this.activate(id);
+	}
+	/**
+	* Initialize a feature.
+	* Initializes the feature and sets its state to "ready" or "error".
+	*/
+	async initialize(id) {
+		const feature = this.registry.get(id);
+		if (feature?.status !== FeatureStatus.REGISTERED) return;
+		feature.transition(FeatureStatus.INITIALIZING);
+		try {
+			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);
+			feature.transition(FeatureStatus.READY);
+		} catch (err) {
+			feature.transition(FeatureStatus.ERROR);
+			this.logger.error(id, `initialize failed`, { error: err instanceof Error ? err.message : String(err) });
+			if (feature.config.critical) throw new Error(`Critical feature "${id}" failed to initialize`);
+		}
+	}
+	/**
+	* Activate a feature.
+	* @param id The ID of the feature to activate.
+	* @param allowRetry When true, ERROR state features can be retried (used by enable()).
+	*/
+	async activate(id, allowRetry = false) {
+		const feature = this.registry.get(id);
+		if (!(allowRetry ? [
+			FeatureStatus.READY,
+			FeatureStatus.DEACTIVATED,
+			FeatureStatus.ERROR
+		] : [FeatureStatus.READY, FeatureStatus.DEACTIVATED]).includes(feature.status)) return;
+		for (const depId of feature.config.dependencies ?? []) if (this.registry.get(depId)?.status === FeatureStatus.ERROR) {
+			this.logger.error(id, `cannot activate — dependency "${depId}" is in error state`);
+			return;
+		}
+		feature.transition(FeatureStatus.ACTIVATING);
+		try {
+			await feature.activate();
+			feature.transition(FeatureStatus.ACTIVATED);
+		} catch (err) {
+			feature.transition(FeatureStatus.ERROR);
+			this.logger.error(id, `activate failed`, { error: err instanceof Error ? err.message : String(err) });
+			if (feature.config.critical) throw new Error(`Critical feature "${id}" failed to activate`);
+		}
+	}
+	/**
+	* Deactivate a feature.
+	* @param id The ID of the feature to deactivate.
+	*/
+	async deactivate(id) {
+		const feature = this.registry.get(id);
+		if (![FeatureStatus.ACTIVATED].includes(feature.status)) return;
+		feature.transition(FeatureStatus.DEACTIVATING);
+		try {
+			await feature.deactivate();
+			feature.transition(FeatureStatus.DEACTIVATED);
+		} catch (err) {
+			feature.transition(FeatureStatus.ERROR);
+			this.logger.error(id, `deactivate failed`, { error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	async destroy(id) {
+		const feature = this.registry.get(id);
+		if (![FeatureStatus.DEACTIVATED, FeatureStatus.ERROR].includes(feature.status)) return;
+		feature.transition(FeatureStatus.DESTROYING);
+		try {
+			await feature.destroy();
+			feature.transition(FeatureStatus.DESTROYED);
+		} catch (err) {
+			feature.transition(FeatureStatus.ERROR);
+			this.logger.error(id, `destroy failed`, { error: err instanceof Error ? err.message : String(err) });
+		}
+	}
+	/** Public: re-activate a DEACTIVATED or ERROR feature. */
+	async enable(id) {
+		if (!this.registry.get(id)) throw new Error(`Feature "${id}" not found`);
+		await this.activate(id, true);
+	}
+	/** Public: deactivate an ACTIVATED feature. */
+	async disable(id) {
+		if (!this.registry.get(id)) throw new Error(`Feature "${id}" not found`);
+		await this.deactivate(id);
+	}
+	async shutdown() {
+		const order = [...this.reorder()].reverse();
+		for (const id of order) await this.deactivate(id);
+		for (const id of order) await this.destroy(id);
+	}
+	reorder() {
+		const sorted = [];
+		const visited = /* @__PURE__ */ new Set();
+		const visiting = /* @__PURE__ */ new Set();
+		const visit = (id) => {
+			if (visiting.has(id)) throw new Error(`Circular dependency detected: Feature "${id}" depends on itself!`);
+			if (visited.has(id)) return;
+			visiting.add(id);
+			const feature = this.registry.get(id);
+			if (!feature) throw new Error(`Missing dependency: Feature "${id}" is not registered.`);
+			for (const depId of feature.config.dependencies ?? []) visit(depId);
+			visiting.delete(id);
+			visited.add(id);
+			sorted.push(id);
+		};
+		for (const id of this.registry.keys()) visit(id);
+		return sorted;
+	}
+};
+
+//#endregion
+//#region src/core/logger/console-handler.ts
+const dim = "\x1B[90m";
+const cyan = "\x1B[36m";
+const green = "\x1B[32m";
+const yellow = "\x1B[33m";
+const magenta = "\x1B[35m";
+const reset = "\x1B[0m";
+function formatTime(ts) {
+	const d = new Date(ts);
+	return `${String(d.getHours()).padStart(2, "0")}:${String(d.getMinutes()).padStart(2, "0")}:${String(d.getSeconds()).padStart(2, "0")}`;
+}
+function colorizeValue(value) {
+	if (value === null) return `${magenta}null${reset}`;
+	if (value === void 0) return `${dim}undefined${reset}`;
+	if (typeof value === "string") return `${green}"${value}"${reset}`;
+	if (typeof value === "number") return `${yellow}${value}${reset}`;
+	if (typeof value === "boolean") return `${yellow}${value}${reset}`;
+	if (Array.isArray(value)) {
+		if (value.length === 0) return "[]";
+		return `[${value.map(colorizeValue).join(`${dim},${reset} `)}]`;
+	}
+	if (typeof value === "object") {
+		const entries = Object.entries(value);
+		if (entries.length === 0) return "{}";
+		return `${dim}{${reset} ${entries.map(([k, v]) => `${cyan}${k}${reset}${dim}:${reset} ${colorizeValue(v)}`).join(`${dim},${reset} `)} ${dim}}${reset}`;
+	}
+	return String(value);
+}
+function createConsoleHandler() {
+	return (entry) => {
+		const time = formatTime(entry.timestamp);
+		const tag = entry.level === "debug" ? "electro" : entry.level;
+		const detailsPart = entry.details ? ` ${colorizeValue(entry.details)}` : "";
+		const line = `${time} [${tag}] ${entry.code} \u2192 ${entry.message}${detailsPart}`;
+		if (entry.level === "error") console.error(line);
+		else if (entry.level === "warn") console.warn(line);
+		else console.log(line);
+	};
+}
+
+//#endregion
+//#region src/core/logger/logger.ts
+var Logger = class {
+	handlers = /* @__PURE__ */ new Set();
+	addHandler(handler) {
+		this.handlers.add(handler);
+	}
+	removeHandler(handler) {
+		this.handlers.delete(handler);
+	}
+	debug(code, message, details) {
+		this.emit("debug", code, message, details);
+	}
+	warn(code, message, details) {
+		this.emit("warn", code, message, details);
+	}
+	error(code, message, details) {
+		this.emit("error", code, message, details);
+	}
+	emit(level, code, message, details) {
+		const entry = {
+			level,
+			code,
+			message,
+			details,
+			timestamp: Date.now()
+		};
+		for (const handler of this.handlers) handler(entry);
+	}
+};
+
+//#endregion
+//#region src/core/runtime/runtime.ts
+const RUNTIME_TRANSITIONS = {
+	[RuntimeState.CREATED]: [RuntimeState.STARTING],
+	[RuntimeState.STARTING]: [RuntimeState.RUNNING, RuntimeState.FAILED],
+	[RuntimeState.RUNNING]: [RuntimeState.STOPPING],
+	[RuntimeState.STOPPING]: [RuntimeState.STOPPED],
+	[RuntimeState.STOPPED]: [],
+	[RuntimeState.FAILED]: []
+};
+var Runtime = class {
+	state;
+	logger;
+	featureManager;
+	eventBus;
+	windowManager = null;
+	constructor(config) {
+		this.state = new StateMachine({
+			transitions: RUNTIME_TRANSITIONS,
+			initial: RuntimeState.CREATED,
+			name: "Runtime"
+		});
+		this.logger = new Logger();
+		this.eventBus = new EventBus();
+		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);
+		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();
+			this.state.transition(RuntimeState.RUNNING);
+		} catch (err) {
+			this.state.transition(RuntimeState.FAILED);
+			throw err;
+		}
+	}
+	async shutdown() {
+		this.state.assertState(RuntimeState.RUNNING);
+		this.state.transition(RuntimeState.STOPPING);
+		await this.featureManager.shutdown();
+		this.windowManager?.destroyAll();
+		this.state.transition(RuntimeState.STOPPED);
+	}
+	async enable(id) {
+		this.state.assertState(RuntimeState.RUNNING);
+		await this.featureManager.enable(id);
+	}
+	async disable(id) {
+		this.state.assertState(RuntimeState.RUNNING);
+		await this.featureManager.disable(id);
+	}
+	isDegraded() {
+		this.state.assertState(RuntimeState.RUNNING);
+		return this.featureManager.list().some((f) => f.status === FeatureStatus.ERROR);
+	}
+};
+
+//#endregion
+//#region src/core/runtime/helpers.ts
+function createRuntime(config) {
+	return new Runtime(config);
+}
+
+//#endregion
+//#region src/core/service/service.ts
+/**
+* Single service unit: one id, one scope, one factory.
+*
+* Lifecycle: Registered → Active (after build) → Destroyed (after destroy).
+* `build()` is idempotent — calling it when already Active is a no-op.
+*/
+var Service = class {
+	_status = ServiceStatus.REGISTERED;
+	_api = null;
+	constructor(config) {
+		this.config = config;
+	}
+	get id() {
+		return this.config.id;
+	}
+	get scope() {
+		return this.config.scope ?? ServiceScope.PRIVATE;
+	}
+	/** Invoke the factory and store the result. Idempotent — no-op if already Active. */
+	build(ctx) {
+		if (this._status === ServiceStatus.ACTIVE) return;
+		if (this._status === ServiceStatus.DESTROYED) throw new Error(`Service "${this.id}" (${this.scope}) is destroyed and cannot be rebuilt`);
+		this._api = this.config.api(ctx);
+		this._status = ServiceStatus.ACTIVE;
+	}
+	/** Clear the factory result and mark as Destroyed. Idempotent. */
+	destroy() {
+		this._api = null;
+		this._status = ServiceStatus.DESTROYED;
+	}
+	/** Return the factory result, or null if not yet built / destroyed. */
+	api() {
+		return this._api;
+	}
+	/** Snapshot of the service's current state. */
+	status() {
+		return {
+			serviceId: this.id,
+			scope: this.scope,
+			state: this._status
+		};
+	}
+};
+
+//#endregion
+//#region src/core/service/helpers.ts
+/**
+* Creates a {@link Service} instance from a configuration object.
+*
+* @param config - Service configuration with `id`, `scope`, and `api`.
+* @returns A new `Service` instance ready for registration.
+* @throws If `config.id` is empty.
+*/
+function createService(config) {
+	if (!config.id) throw new Error("Service must have an id");
+	return new Service(config);
+}
+
+//#endregion
+//#region src/core/task/enums.ts
+let TaskOverlapStrategy = /* @__PURE__ */ function(TaskOverlapStrategy) {
+	TaskOverlapStrategy["Skip"] = "skip";
+	TaskOverlapStrategy["Queue"] = "queue";
+	TaskOverlapStrategy["Parallel"] = "parallel";
+	return TaskOverlapStrategy;
+}({});
+let TaskStatus = /* @__PURE__ */ function(TaskStatus) {
+	TaskStatus["Registered"] = "registered";
+	TaskStatus["Scheduled"] = "scheduled";
+	TaskStatus["Running"] = "running";
+	TaskStatus["Stopped"] = "stopped";
+	TaskStatus["Failed"] = "failed";
+	return TaskStatus;
+}({});
+let TaskRetryStrategy = /* @__PURE__ */ function(TaskRetryStrategy) {
+	TaskRetryStrategy["Fixed"] = "fixed";
+	TaskRetryStrategy["Exponential"] = "exponential";
+	return TaskRetryStrategy;
+}({});
+let TaskTriggerKind = /* @__PURE__ */ function(TaskTriggerKind) {
+	TaskTriggerKind["Cron"] = "cron";
+	TaskTriggerKind["Manual"] = "manual";
+	return TaskTriggerKind;
+}({});
+
+//#endregion
+//#region ../../node_modules/.bun/es-toolkit@github+MyraxByte+es-toolkit+f71db7c/node_modules/es-toolkit/src/error/AbortError.ts
+/**
+* An error class representing an aborted operation.
+* @augments Error
+*/
+var AbortError = class extends Error {
+	constructor(message = "The operation was aborted") {
+		super(message);
+		this.name = "AbortError";
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/es-toolkit@github+MyraxByte+es-toolkit+f71db7c/node_modules/es-toolkit/src/error/TimeoutError.ts
+/**
+* An error class representing an timeout operation.
+* @augments Error
+*/
+var TimeoutError = class extends Error {
+	constructor(message = "The operation was timed out") {
+		super(message);
+		this.name = "TimeoutError";
+	}
+};
+
+//#endregion
+//#region ../../node_modules/.bun/es-toolkit@github+MyraxByte+es-toolkit+f71db7c/node_modules/es-toolkit/src/promise/delay.ts
+/**
+* Delays the execution of code for a specified number of milliseconds.
+*
+* This function returns a Promise that resolves after the specified delay, allowing you to use it
+* with async/await to pause execution.
+*
+* @param {number} ms - The number of milliseconds to delay.
+* @param {DelayOptions} options - The options object.
+* @param {AbortSignal} options.signal - An optional AbortSignal to cancel the delay.
+* @returns {Promise<void>} A Promise that resolves after the specified delay.
+*
+* @example
+* async function foo() {
+*   console.log('Start');
+*   await delay(1000); // Delays execution for 1 second
+*   console.log('End');
+* }
+*
+* foo();
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const { signal } = controller;
+*
+* setTimeout(() => controller.abort(), 50); // Will cancel the delay after 50ms
+* try {
+*   await delay(100, { signal });
+*  } catch (error) {
+*   console.error(error); // Will log 'AbortError'
+*  }
+* }
+*/
+function delay(ms, { signal } = {}) {
+	return new Promise((resolve, reject) => {
+		const abortError = () => {
+			reject(new AbortError());
+		};
+		const abortHandler = () => {
+			clearTimeout(timeoutId);
+			abortError();
+		};
+		if (signal?.aborted) return abortError();
+		const timeoutId = setTimeout(() => {
+			signal?.removeEventListener("abort", abortHandler);
+			resolve();
+		}, ms);
+		signal?.addEventListener("abort", abortHandler, { once: true });
+	});
+}
+
+//#endregion
+//#region ../../node_modules/.bun/es-toolkit@github+MyraxByte+es-toolkit+f71db7c/node_modules/es-toolkit/src/promise/timeout.ts
+/**
+* Returns a promise that rejects with a `TimeoutError` after a specified delay.
+*
+* @param {number} ms - The delay duration in milliseconds.
+* @param {TimeoutOptions} options - The options object.
+* @param {AbortSignal} options.signal - An optional AbortSignal to cancel the timeout.
+* @returns {Promise<never>} A promise that rejects with a `TimeoutError` after the specified delay.
+* @throws {TimeoutError} Throws a `TimeoutError` after the specified delay.
+*
+* @example
+* try {
+*   await timeout(1000); // Timeout exception after 1 second
+* } catch (error) {
+*   console.error(error); // Will log 'The operation was timed out'
+* }
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const { signal } = controller;
+* setTimeout(() => controller.abort(), 50);
+* try {
+*   await timeout(1000, { signal }); // Will be aborted after 50ms
+* } catch (error) {
+*   console.error(error); // Will log 'The operation was aborted'
+* }
+*/
+async function timeout(ms, { signal } = {}) {
+	await delay(ms, { signal });
+	throw new TimeoutError();
+}
+
+//#endregion
+//#region ../../node_modules/.bun/es-toolkit@github+MyraxByte+es-toolkit+f71db7c/node_modules/es-toolkit/src/promise/withTimeout.ts
+/**
+* Executes an async function and enforces a timeout.
+*
+* If the promise does not resolve within the specified time,
+* the timeout will trigger and the returned promise will be rejected.
+*
+* @template T
+* @param {() => Promise<T>} run - A function that returns a promise to be executed.
+* @param {number} ms - The timeout duration in milliseconds.
+* @param {WithTimeoutOptions} options - The options object.
+* @param {AbortSignal} options.signal - An optional AbortSignal to cancel the operation.
+* @returns {Promise<T>} A promise that resolves with the result of the `run` function or rejects if the timeout is reached.
+*
+* @example
+* async function fetchData() {
+*   const response = await fetch('https://example.com/data');
+*   return response.json();
+* }
+*
+* try {
+*   const data = await withTimeout(fetchData, 1000);
+*   console.log(data); // Logs the fetched data if resolved within 1 second.
+* } catch (error) {
+*   console.error(error); // Will log 'TimeoutError' if not resolved within 1 second.
+* }
+*
+* // With AbortSignal
+* const controller = new AbortController();
+* const { signal } = controller;
+* const data = await withTimeout(async () => {
+*   const response = await fetch('https://example.com/data', { signal });
+*   return response.json();
+* }, 5000, { signal });
+*/
+async function withTimeout(run, ms, { signal } = {}) {
+	return Promise.race([run(), timeout(ms, { signal })]);
+}
+
+//#endregion
+//#region src/core/task/task.ts
+const noop = () => {};
+/**
+* Single executable unit within the Electro task system.
+*
+* Supports overlap strategies (skip / queue / parallel), per-payload deduplication,
+* configurable retry with fixed or exponential backoff, timeouts with abort propagation,
+* and cron-based scheduling via `croner`.
+*
+* State machine: `Registered → Scheduled → Running → Scheduled | Failed | Stopped`
+*/
+var Task = class {
+	_status = TaskStatus.Registered;
+	_runningCount = 0;
+	_lastRunAt = null;
+	_lastSuccessAt = null;
+	_lastErrorAt = null;
+	_lastError = null;
+	_queue = [];
+	_stopping = false;
+	_enabled = false;
+	_abortControllers = /* @__PURE__ */ new Set();
+	_cronJob = null;
+	_ctx = null;
+	_activeDedupeKeys = /* @__PURE__ */ new Set();
+	constructor(config) {
+		this.config = config;
+	}
+	get id() {
+		return this.config.id;
+	}
+	/** Activate the task within a feature context. Idempotent. */
+	enable(ctx) {
+		if (this._enabled) return;
+		this._ctx = ctx;
+		this._enabled = true;
+		this._status = TaskStatus.Scheduled;
+		const autoStart = this.config.autoStart !== false;
+		if (this.config.cron && autoStart) this.scheduleCron();
+		else if (!this.config.cron && autoStart) this.execute(TaskTriggerKind.Manual, void 0).catch(noop);
+	}
+	/** Deactivate the task. `"graceful"` lets running executions finish; `"force"` aborts them. */
+	disable(mode = "graceful") {
+		this._enabled = false;
+		this.clear();
+		if (this._cronJob) {
+			this._cronJob.stop();
+			this._cronJob = null;
+		}
+		if (mode === "force") for (const ac of this._abortControllers) ac.abort();
+		if (this._runningCount === 0) this._status = TaskStatus.Stopped;
+	}
+	/** Trigger a manual execution. No-op when the task is not enabled. */
+	async start(payload) {
+		await this.execute(TaskTriggerKind.Manual, payload);
+	}
+	/** Push payload to FIFO queue. Starts processing if idle. */
+	queue(payload) {
+		if (!this._enabled || !this._ctx) return;
+		if (this._runningCount > 0) {
+			this._queue.push(payload);
+			return;
+		}
+		this.execute(TaskTriggerKind.Manual, payload).catch(noop);
+	}
+	/** Abort current execution. Queue continues processing next item. */
+	stop() {
+		this._stopping = true;
+		for (const ac of this._abortControllers) ac.abort();
+	}
+	/** Clear the FIFO queue without stopping current execution. */
+	clear() {
+		this._queue = [];
+	}
+	/** Snapshot of the task's current state and run history. */
+	status() {
+		return {
+			taskId: this.id,
+			state: this._status,
+			running: this._runningCount > 0,
+			queueSize: this._queue.length,
+			lastRunAt: this._lastRunAt,
+			lastSuccessAt: this._lastSuccessAt,
+			lastErrorAt: this._lastErrorAt,
+			lastError: this._lastError
+		};
+	}
+	async execute(trigger, payload) {
+		if (!this._enabled || !this._ctx) return;
+		const ctx = this._ctx;
+		this._stopping = false;
+		if (this.shouldSkipExecution(payload)) return;
+		const dedupeKey = this.acquireDedupeKey(payload);
+		this._runningCount++;
+		this._status = TaskStatus.Running;
+		let lastError = null;
+		try {
+			lastError = await this.executeWithRetry(ctx, payload);
+		} finally {
+			this._runningCount--;
+			if (dedupeKey) this._activeDedupeKeys.delete(dedupeKey);
+			this.resolveStatus(lastError);
+		}
+		if (lastError) {
+			if (this._stopping) {
+				this._stopping = false;
+				this.drainQueue(trigger);
+			} else {
+				this._queue = [];
+				throw lastError;
+			}
+			return;
+		}
+		this.drainQueue(trigger);
+	}
+	resolveStatus(lastError) {
+		if (this._runningCount > 0) return;
+		if (lastError) this._status = TaskStatus.Failed;
+		else if (this._enabled) this._status = TaskStatus.Scheduled;
+		else this._status = TaskStatus.Stopped;
+	}
+	shouldSkipExecution(payload) {
+		if (this._runningCount === 0) return false;
+		const overlap = this.config.overlap ?? TaskOverlapStrategy.Skip;
+		if (overlap === TaskOverlapStrategy.Skip) return true;
+		if (overlap === TaskOverlapStrategy.Queue) {
+			this._queue.push(payload);
+			return true;
+		}
+		if (this.config.dedupeKey) return this._activeDedupeKeys.has(this.config.dedupeKey(payload));
+		return false;
+	}
+	acquireDedupeKey(payload) {
+		if (!this.config.dedupeKey) return void 0;
+		const key = this.config.dedupeKey(payload);
+		this._activeDedupeKeys.add(key);
+		return key;
+	}
+	async executeWithRetry(ctx, payload) {
+		const retryConfig = this.config.retry;
+		const maxAttempts = retryConfig ? retryConfig.attempts : 1;
+		let lastError = null;
+		for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+			if (!this._enabled) break;
+			const ac = new AbortController();
+			this._abortControllers.add(ac);
+			this._lastRunAt = Date.now();
+			try {
+				const execCtx = {
+					signal: ac.signal,
+					attempt
+				};
+				const promise = Promise.resolve(this.config.execute(ctx, payload, execCtx));
+				if (this.config.timeoutMs && this.config.timeoutMs > 0) await this.executeWithTimeout(promise, this.config.timeoutMs, ac);
+				else await promise;
+				this._lastSuccessAt = Date.now();
+				this._lastError = null;
+				return null;
+			} catch (err) {
+				const error = err instanceof Error ? err : new Error(String(err));
+				lastError = error;
+				this._lastErrorAt = Date.now();
+				this._lastError = error;
+				if (attempt < maxAttempts && retryConfig) await delay(this.computeRetryDelay(retryConfig.strategy, retryConfig.delayMs, attempt));
+			} finally {
+				this._abortControllers.delete(ac);
+			}
+		}
+		return lastError;
+	}
+	drainQueue(trigger) {
+		if (this._queue.length === 0 || !this._enabled) return;
+		const payload = this._queue.shift();
+		this.execute(trigger, payload).catch(noop);
+	}
+	scheduleCron() {
+		this._cronJob = new Cron(this.config.cron, () => {
+			this.execute(TaskTriggerKind.Cron, void 0).catch(noop);
+		});
+	}
+	async executeWithTimeout(promise, timeoutMs, ac) {
+		try {
+			await withTimeout(() => promise, timeoutMs);
+		} catch (err) {
+			if (err instanceof TimeoutError) {
+				ac.abort();
+				throw new Error(`Task "${this.id}" timed out after ${timeoutMs}ms`);
+			}
+			throw err;
+		}
+	}
+	computeRetryDelay(strategy, baseMs, attempt) {
+		if (strategy === TaskRetryStrategy.Exponential) return baseMs * 2 ** (attempt - 1);
+		return baseMs;
+	}
+};
+
+//#endregion
+//#region src/core/task/helpers.ts
+/** Create a {@link Task} from a config object. Throws if `id` is empty. */
+function createTask(config) {
+	if (!config.id || config.id.trim().length === 0) throw new Error("createTask: id is required");
+	return new Task(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";
+	return PolicyDecision;
+}({});
+
+//#endregion
+//#region src/policy/engine.ts
+/**
+* Deny-by-default policy engine for window–feature access control.
+*
+* A window's renderer can only access exposed services of features
+* listed in its `features: []` config. Everything else is denied.
+*
+* Used at:
+* - **Build time** (codegen): generate preload stubs only for allowed features
+* - **Runtime** (IPC routing): gate incoming calls from renderer
+*/
+var PolicyEngine = class {
+	policies = /* @__PURE__ */ new Map();
+	constructor(windows) {
+		for (const win of windows) this.policies.set(win.name, new Set(win.features ?? []));
+	}
+	/** Full policy check with decision code and context. */
+	check(windowName, featureId) {
+		const allowed = this.policies.get(windowName);
+		if (!allowed) return {
+			decision: PolicyDecision.WINDOW_NOT_FOUND,
+			windowName,
+			featureId
+		};
+		return {
+			decision: allowed.has(featureId) ? PolicyDecision.ALLOWED : PolicyDecision.ACCESS_DENIED,
+			windowName,
+			featureId
+		};
+	}
+	/** Convenience: returns true only when access is ALLOWED. */
+	canAccess(windowName, featureId) {
+		return this.check(windowName, 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`);
+		return [...allowed];
+	}
+	/** Returns all registered window names. */
+	getWindowNames() {
+		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 };