lifecycleion 0.0.12 → 0.0.14

package/dist/lib/lifecycle-manager/index.d.cts

@@ -158,7 +158,7 @@ interface RestartComponentOptions {
 /**
  * Stable, machine-readable failure codes for individual component operations
  */
-type ComponentOperationFailureCode = 'component_not_found' | 'component_already_running' | 'component_already_starting' | 'component_already_stopping' | 'component_not_running' | 'component_stalled' | 'missing_dependency' | 'dependency_not_running' | 'has_running_dependents' | 'startup_in_progress' | 'shutdown_in_progress' | 'component_startup_timeout' | 'component_shutdown_timeout' | 'restart_stop_failed' | 'restart_start_failed' | 'unknown_error';
+type ComponentOperationFailureCode = 'component_not_found' | 'component_already_running' | 'component_already_starting' | 'component_already_stopping' | 'component_not_running' | 'component_stalled' | 'missing_dependency' | 'dependency_not_running' | 'has_running_dependents' | 'startup_in_progress' | 'shutdown_in_progress' | 'component_unexpected_stop' | 'component_startup_timeout' | 'component_shutdown_timeout' | 'restart_stop_failed' | 'restart_start_failed' | 'unknown_error';
 /**
  * Failure codes for unregister operations
  */
@@ -202,7 +202,7 @@ interface StartupResult {
     /** Reason for failure (when success is false) */
     reason?: string;
     /** Error code (when success is false) */
-    code?: 'already_in_progress' | 'shutdown_in_progress' | 'dependency_cycle' | 'no_components_registered' | 'stalled_components_exist' | 'partial_state' | 'required_component_failed' | 'startup_timeout' | 'unknown_error';
+    code?: 'already_in_progress' | 'component_unexpected_stop' | 'shutdown_in_progress' | 'dependency_cycle' | 'no_components_registered' | 'stalled_components_exist' | 'partial_state' | 'required_component_failed' | 'startup_timeout' | 'unknown_error';
     /** Error object (when success is false due to dependency cycle or unknown error) */
     error?: Error;
     /** Total startup duration in milliseconds */
@@ -471,6 +471,7 @@ interface LifecycleCommon extends EventEmitterSurface {
     attachSignals(): void;
     detachSignals(): void;
     getSignalStatus(): LifecycleSignalStatus;
+    getShutdownEscalationStatus(): ShutdownEscalationStatus;
     triggerReload(): Promise<SignalBroadcastResult>;
     triggerInfo(): Promise<SignalBroadcastResult>;
     triggerDebug(): Promise<SignalBroadcastResult>;
@@ -681,6 +682,163 @@ interface LifecycleSignalStatus extends ProcessSignalManagerStatus {
     /** How shutdown was triggered (null if not shut down) */
     shutdownMethod: ShutdownMethod | null;
 }
+interface ShutdownEscalationStatusDisabled {
+    /** Whether repeated shutdown escalation is configured */
+    configured: false;
+    /** Whether a shutdown is currently in progress */
+    isShuttingDown: boolean;
+    /** Escalation cannot be armed when the policy is disabled */
+    isArmed: false;
+    /** Config fields are unavailable while the policy is disabled */
+    forceAfterCount: null;
+    withinMS: null;
+    armedAfterFailureMS: null;
+    armedAfterFailureMSSource: null;
+    /** Runtime counters remain empty while the policy is disabled */
+    requestCount: 0;
+    firstMethod: null;
+    latestMethod: null;
+    firstRequestAt: null;
+    latestRequestAt: null;
+    repeatedWindowStartedAt: null;
+    armedUntil: null;
+    hasTriggeredForceShutdown: false;
+}
+interface ShutdownEscalationStatusEnabled {
+    /** Whether repeated shutdown escalation is configured */
+    configured: true;
+    /** Whether a shutdown is currently in progress */
+    isShuttingDown: boolean;
+    /** Whether escalation remains armed after an unsuccessful shutdown */
+    isArmed: boolean;
+    /** Configured force threshold when policy is enabled */
+    forceAfterCount: number;
+    /** Configured escalation window when policy is enabled */
+    withinMS: number;
+    /** Effective post-failure armed duration in ms when policy is enabled */
+    armedAfterFailureMS: number;
+    /** Whether the effective armed duration was explicitly configured or derived from defaults */
+    armedAfterFailureMSSource: 'explicit' | 'derived';
+    /** Whether manual stopAllComponents() retries continue the armed escalation state */
+    countManualRetriesTowardEscalation: boolean;
+    /**
+     * Number of follow-up shutdown requests counted in the current escalation
+     * window (resets when a new window starts). This is a window-local count,
+     * not a cumulative total of all requests since shutdown began.
+     */
+    requestCount: number;
+    /** Method that started the current/most recent shutdown escalation cycle */
+    firstMethod: ShutdownMethod | null;
+    /** Most recent shutdown request method seen by escalation tracking */
+    latestMethod: ShutdownMethod | null;
+    /** Timestamp of the first shutdown request that seeded this escalation state */
+    firstRequestAt: number | null;
+    /** Timestamp of the most recent shutdown request counted by escalation tracking */
+    latestRequestAt: number | null;
+    /** Timestamp when the current post-start escalation window began */
+    repeatedWindowStartedAt: number | null;
+    /** Timestamp when armed-after-failure escalation will expire */
+    armedUntil: number | null;
+    /** Whether onForceShutdown() has already been dispatched for this shutdown cycle */
+    hasTriggeredForceShutdown: boolean;
+}
+/**
+ * Read-only snapshot of repeated shutdown escalation configuration and runtime state.
+ */
+type ShutdownEscalationStatus = ShutdownEscalationStatusDisabled | ShutdownEscalationStatusEnabled;
+/**
+ * Context passed to repeated shutdown force handlers.
+ *
+ * The first request starts graceful shutdown. If additional shutdown requests
+ * arrive within the configured time window and the threshold is reached, the
+ * LifecycleManager invokes `onForceShutdown()` with this snapshot.
+ */
+interface ForceShutdownContext {
+    /** Number of escalation requests counted after shutdown had already started */
+    requestCount: number;
+    /** Method that started the current shutdown cycle */
+    firstMethod: ShutdownMethod;
+    /** Most recent shutdown request method */
+    latestMethod: ShutdownMethod;
+    /** Unix timestamp in ms for the request that started the current shutdown cycle */
+    firstRequestAt: number;
+    /** Unix timestamp in ms for the most recent request in the current window */
+    latestRequestAt: number;
+    /**
+     * Whether shutdown is still actively running when the force callback fires.
+     *
+     * This is `true` when escalation fires during an active shutdown (the normal
+     * path: operator pressed the shutdown signal multiple times while
+     * `stopAllComponents()` was still running).
+     *
+     * This is `false` when escalation fires from the post-failure armed window
+     * (i.e. a previous shutdown attempt already returned unsuccessfully and the
+     * manager kept escalation armed briefly). In that path the force callback
+     * fires before the follow-up `stopAllComponents()` call is issued, so no
+     * shutdown is actively in progress at the moment the callback runs.
+     *
+     * Check `wasArmedAfterFailure` to distinguish the two cases.
+     */
+    isShuttingDown: boolean;
+    /**
+     * Whether this force-shutdown was triggered from the post-failure armed
+     * state rather than during an active shutdown.
+     *
+     * `true`  — a previous shutdown attempt returned unsuccessfully, the manager
+     *           kept escalation armed, and the force threshold was crossed while
+     *           that armed window was still open (no shutdown running yet).
+     *
+     * `false` — the force threshold was crossed while `stopAllComponents()` was
+     *           actively in progress (the common path).
+     *
+     * Use this to decide whether your force handler needs to start or re-trigger
+     * shutdown, or whether it can assume a shutdown run is already underway.
+     */
+    wasArmedAfterFailure: boolean;
+}
+/**
+ * Optional policy for escalating repeated shutdown requests during an already
+ * running shutdown.
+ */
+interface RepeatedShutdownRequestPolicy {
+    /**
+     * Number of shutdown requests required before force escalation runs.
+     * Only escalation requests received after shutdown has already started count
+     * toward this threshold. The initial request that starts graceful shutdown
+     * does not count.
+     * @default 3
+     */
+    forceAfterCount?: number;
+    /**
+     * Time window in ms for counting follow-up escalation requests received
+     * after shutdown has already started.
+     * Requests outside the window start a new escalation window.
+     * @default 2000
+     */
+    withinMS?: number;
+    /**
+     * How long escalation should remain armed after an unsuccessful shutdown
+     * returns. When omitted, the manager derives it as `withinMS * forceAfterCount`.
+     * Set to `0` to disable post-failure arming entirely — the escalation window
+     * will not persist once a shutdown attempt returns, and each new request will
+     * start a fresh escalation cycle. (Note: `withinMS = 0` is a separate option
+     * that controls the width of the active-shutdown escalation window, not this.)
+     */
+    armedAfterFailureMS?: number;
+    /**
+     * If true, manual `stopAllComponents()` retries that happen while the
+     * post-failure armed window is still open continue the same escalation state.
+     * When false, manual retries always start a fresh escalation cycle.
+     * @default false
+     */
+    countManualRetriesTowardEscalation?: boolean;
+    /**
+     * Invoked once per shutdown cycle when repeated requests reach the threshold.
+     * Typical uses: final logging, telemetry flush, `logger.exit()`, or
+     * `process.exit()` by the application.
+     */
+    onForceShutdown: (context: ForceShutdownContext) => void | Promise<void>;
+}
 /**
  * Configuration options for LifecycleManager
  */
@@ -711,6 +869,11 @@ interface LifecycleManagerOptions {
     onInfoRequested?: (broadcastInfo: () => Promise<SignalBroadcastResult>) => void | Promise<void>;
     /** Custom debug signal handler (called instead of default broadcast, receives broadcast function you can optionally call) */
     onDebugRequested?: (broadcastDebug: () => Promise<SignalBroadcastResult>) => void | Promise<void>;
+    /**
+     * Optional policy for escalating repeated shutdown requests received while a
+     * graceful shutdown is already in progress.
+     */
+    repeatedShutdownRequestPolicy?: RepeatedShutdownRequestPolicy;
 }
 
 /**
@@ -793,6 +956,10 @@ declare abstract class BaseComponent {
     protected name: string;
     /** Reference to component-scoped lifecycle (set by manager when registered) */
     protected lifecycle: ComponentLifecycleRef;
+    /** @internal Set by LifecycleManager while the component is running. */
+    private _unexpectedStopHandler?;
+    /** @internal Incremented whenever the unexpected-stop handler is re-armed or cleared. */
+    private _unexpectedStopGeneration;
     /**
      * Create a new component
      *
@@ -801,6 +968,10 @@ declare abstract class BaseComponent {
      * @throws {InvalidComponentNameError} If name doesn't match kebab-case pattern
      */
     constructor(rootLogger: Logger, options: ComponentOptions);
+    /** @internal Called by LifecycleManager after a successful start. */
+    _setUnexpectedStopHandler(handler: (error?: Error) => boolean): void;
+    /** @internal Called by LifecycleManager when stop begins or component is unregistered. */
+    _clearUnexpectedStopHandler(): void;
     /**
      * Start the component
      *
@@ -983,6 +1154,28 @@ declare abstract class BaseComponent {
      * Check if component is optional
      */
     isOptional(): boolean;
+    /**
+     * Run-scoped unexpected-stop callback. Rebound by LifecycleManager on each
+     * successful start so captured references from older runs go stale.
+     */
+    protected reportUnexpectedStop: (error?: Error) => boolean;
+    /**
+     * Get this component's own status from the manager's perspective.
+     *
+     * Equivalent to `this.lifecycle.getComponentStatus(this.getName())` but without
+     * needing to pass the name. Returns `undefined` if the component is not registered.
+     *
+     * Check `status?.state === 'running'` to test whether the component is currently running.
+     */
+    protected getSelfStatus(): ComponentStatus | undefined;
+    /**
+     * Capture a run-scoped unexpected-stop reporter for async listeners created during start().
+     *
+     * Unlike calling `this.reportUnexpectedStop()` later, the returned callback becomes a no-op
+     * once the component is stopped, unregistered, or restarted. This prevents stale listeners
+     * from a previous run from stopping a newer run of the same component instance.
+     */
+    protected getUnexpectedStopReporter(): (error?: Error) => boolean;
 }
 
 /**
@@ -1008,6 +1201,7 @@ declare class LifecycleManager extends EventEmitterProtected implements Lifecycl
     private readonly attachSignalsBeforeStartup;
     private readonly attachSignalsOnStart;
     private readonly detachSignalsOnStop;
+    private readonly repeatedShutdownRequestPolicy?;
     private components;
     private runningComponents;
     private componentStates;
@@ -1015,13 +1209,19 @@ declare class LifecycleManager extends EventEmitterProtected implements Lifecycl
     private componentTimestamps;
     private componentErrors;
     private componentStartAttemptTokens;
+    private componentStopAttemptTokens;
+    private pendingForceStopWaiters;
+    private unexpectedStopsDuringStartup;
     private isStarting;
+    private autoAttachedSignalsDuringStartup;
     private isStarted;
     private isShuttingDown;
     private shutdownToken;
     private pendingLoggerExitResolve;
     private shutdownMethod;
     private lastShutdownResult;
+    private repeatedShutdownExpiryTimer;
+    private repeatedShutdownRequestState;
     private processSignalManager;
     private readonly onReloadRequested?;
     private readonly onInfoRequested?;
@@ -1214,6 +1414,10 @@ declare class LifecycleManager extends EventEmitterProtected implements Lifecycl
      * Get status information about signal handling.
      */
     getSignalStatus(): LifecycleSignalStatus;
+    /**
+     * Get status information about repeated shutdown escalation configuration and runtime state.
+     */
+    getShutdownEscalationStatus(): ShutdownEscalationStatus;
     /**
      * Enable Logger exit hook integration
      *
@@ -1422,6 +1626,45 @@ declare class LifecycleManager extends EventEmitterProtected implements Lifecycl
     private autoAttachSignals;
     private autoDetachSignalsIfIdle;
     private monitorLateStartupCompletion;
+    private consumeUnexpectedStopsDuringStartup;
+    /**
+     * Issues and returns a unique stop attempt token for a component.
+     *
+     * Each stop attempt (graceful or force-retry) gets a unique token.
+     * The late-resolution handler captures this token in its closure so it can
+     * skip any stall entries that were created by a *later* stop attempt — e.g. a
+     * force-retry that also timed out after the original graceful promise floated
+     * in the background.
+     */
+    private issueStopAttemptToken;
+    private createPendingForceStopWaiter;
+    private resolvePendingForceStopWaiters;
+    /**
+     * Called when a stop promise eventually resolves after its timeout path already fired.
+     *
+     * Usually this means a previously stalled component's original stop() or
+     * onShutdownForce() promise finally resolved, so the manager can clear the
+     * stall and transition the component to stopped without a manual retry.
+     *
+     * There is one extra overlap case for graceful stop(): stop() can resolve
+     * after the graceful timeout but before onShutdownForce() itself times out.
+     * In that window no stall entry exists yet, but the component still finished
+     * stopping cleanly, so we finalize it here and let the later force-timeout
+     * path observe the already-stopped state and no-op. This overlap fix is
+     * scoped to the same stop token and will not cross a later retry attempt.
+     *
+     * Two guards prevent stale floating promises from incorrectly clearing state:
+     *
+     * 1. token guard — if a newer stop attempt (e.g. a retryStalled
+     *    force-retry) has started since this promise was launched, its token
+     *    won't match and we bail out immediately.
+     *
+     * 2. state/stall guard — if the component was unregistered, restarted, or
+     *    already cleared by another path, there will be neither a matching stall
+     *    entry nor the force-phase overlap state, so we bail out.
+     */
+    private handleLateStopResolution;
+    private handleComponentUnexpectedStop;
     /**
      * Safe emit wrapper - prevents event handler errors from breaking lifecycle
      */
@@ -1470,40 +1713,100 @@ declare class LifecycleManager extends EventEmitterProtected implements Lifecycl
     private findAllCircularCycles;
     /**
      * Handle shutdown signal - initiates stopAllComponents().
-     * Double signal protection: if already shutting down, log warning and ignore.
-     */
-    private handleShutdownRequest;
-    /**
-     * Handle reload request - calls custom callback or broadcasts to components.
      *
-     * When called from signal handlers (source='signal'), the Promise is started
-     * but not awaited due to Node.js signal handler constraints. Components are
-     * still notified and the work completes, but return values are not accessible.
+     * Four cases depending on the current shutdown state:
      *
-     * When called from manual triggers (source='trigger'), the Promise is awaited
-     * and results are returned for programmatic use.
+     * 1. **Active shutdown** (`isShuttingDown = true`): escalate through the
+     *    repeated-shutdown policy if configured, otherwise log and discard.
+     *    Emits `signal:shutdown` with `isAlreadyShuttingDown: true` and returns
+     *    without starting another shutdown.
+     *
+     * 2. **Armed post-failure** (previous shutdown finished, armed window still
+     *    open): count the request toward the escalation window, emit
+     *    `signal:shutdown` with `isAlreadyShuttingDown: false`, then start a
+     *    new `stopAllComponents()` run to retry.
+     *
+     * 3. **Armed post-failure expired** (armed window opened but has since
+     *    elapsed): expire the stale state, treat the request as a fresh
+     *    shutdown (falls through to case 4).
+     *
+     * 4. **Fresh shutdown** (no prior shutdown state): seed escalation tracking
+     *    if policy is configured, emit `signal:shutdown` with
+     *    `isAlreadyShuttingDown: false`, and start `stopAllComponents()`.
      *
-     * @param source - Whether triggered from signal manager or manual trigger
+     * In all cases `signal:shutdown` is emitted exactly once.
      */
-    private handleReloadRequest;
+    private handleShutdownRequest;
     /**
-     * Handle info request - calls custom callback or broadcasts to components.
+     * Tracks repeated shutdown requests during an active shutdown and optionally
+     * invokes the configured force shutdown callback when the threshold is reached.
      *
-     * When called from signal handlers, the Promise executes but return values
-     * are not accessible due to Node.js signal handler constraints.
+     * @returns true when the request was consumed as part of the repeated-shutdown
+     * escalation flow, false when the caller should treat it as a fresh shutdown request
+     */
+    private handleRepeatedShutdownRequest;
+    /**
+     * Clears repeated shutdown request tracking so a new shutdown cycle starts fresh.
+     */
+    private resetRepeatedShutdownRequestState;
+    /**
+     * Clear any pending expiration timer for the post-failure escalation window.
+     */
+    private clearRepeatedShutdownExpiryTimer;
+    /**
+     * Returns whether post-failure escalation remains armed after first
+     * normalizing any stale timer-backed state.
      *
-     * @param source - Whether triggered from signal manager or manual trigger
+     * The method can expire old armed windows as a side effect because the timer
+     * callback may not have run yet on a delayed event loop. Callers use this
+     * when they need the effective runtime truth, not just the last timer write.
      */
-    private handleInfoRequest;
+    private normalizeRepeatedShutdownRequestStateArmedStatus;
     /**
-     * Handle debug request - calls custom callback or broadcasts to components.
+     * Transition armed post-failure escalation state into its expired/reset state.
+     */
+    private expireRepeatedShutdownRequestState;
+    /**
+     * Arms or refreshes the post-failure escalation window and its expiration timer.
+     */
+    private refreshRepeatedShutdownArmedWindow;
+    /**
+     * Seeds shutdown escalation tracking for a new shutdown cycle.
      *
-     * When called from signal handlers, the Promise executes but return values
-     * are not accessible due to Node.js signal handler constraints.
+     * The first shutdown trigger starts graceful shutdown and arms escalation with
+     * an effective post-start count of 0. Later shutdown requests can then count
+     * toward the configured force threshold regardless of whether the shutdown
+     * started from a signal, keyboard shortcut, or direct API call.
+     */
+    private seedRepeatedShutdownRequestState;
+    /**
+     * Preserves a short-lived post-failure escalation window after shutdown
+     * returns unsuccessfully so operators can keep pressing shutdown without
+     * losing the existing force count the moment the graceful attempt finishes.
+     */
+    private armRepeatedShutdownAfterFailure;
+    /**
+     * Shared dispatch path for reload/info/debug requests. Logs the dispatch,
+     * emits the signal event, then either invokes the user-supplied callback
+     * (passing the broadcast function so the user controls when/whether to
+     * broadcast) or broadcasts directly when no callback is configured.
      *
-     * @param source - Whether triggered from signal manager or manual trigger
+     * When called from signal handlers (source='signal'), the Promise is started
+     * but not awaited — Node.js signal handlers cannot return values, so results
+     * are not accessible. Components are still notified and the work completes.
+     * When called from manual triggers (source='trigger'), the Promise is awaited
+     * and results are returned for programmatic use.
      */
+    private handleSignalRequest;
+    private handleReloadRequest;
+    private handleInfoRequest;
     private handleDebugRequest;
+    /**
+     * Shared signal broadcast pipeline used by reload/info/debug.
+     * Iterates running components, runs the picked handler with timeout, and
+     * aggregates per-component results into a SignalBroadcastResult.
+     */
+    private runSignalBroadcast;
     /**
      * Broadcast reload signal to all running components.
      * Calls onReload() on components that implement it.
@@ -1637,6 +1940,28 @@ interface LifecycleManagerEventMap {
         method: ShutdownMethod;
         duringStartup: boolean;
     };
+    /** Failed/timed-out shutdown left escalation armed briefly for follow-up force presses. */
+    'lifecycle-manager:shutdown-escalation-armed': {
+        firstMethod: ShutdownMethod;
+        requestCount: number;
+        armedUntil: number;
+    };
+    /** Armed escalation window expired and the manager cleared that old escalation state. */
+    'lifecycle-manager:shutdown-escalation-expired': {
+        firstMethod: ShutdownMethod;
+        latestMethod: ShutdownMethod | null;
+        requestCount: number;
+        armedUntil: number;
+    };
+    /** Repeated shutdown requests crossed the force threshold and onForceShutdown() was invoked. */
+    'lifecycle-manager:shutdown-escalation-forced': {
+        firstMethod: ShutdownMethod;
+        latestMethod: ShutdownMethod;
+        requestCount: number;
+        firstRequestAt: number;
+        latestRequestAt: number;
+        wasArmedAfterFailure: boolean;
+    };
     'component:starting': {
         name: string;
     };
@@ -1701,6 +2026,15 @@ interface LifecycleManagerEventMap {
         reason?: string;
         code?: string;
     };
+    'component:stalled-resolved': {
+        name: string;
+        stallInfo: ComponentStallInfo;
+        stalledDurationMS: number;
+    };
+    'component:unexpected-stop': {
+        name: string;
+        error?: Error;
+    };
     'component:shutdown-force-completed': {
         name: string;
     };
@@ -1713,6 +2047,7 @@ interface LifecycleManagerEventMap {
     };
     'signal:shutdown': {
         method: ShutdownSignal;
+        isAlreadyShuttingDown: boolean;
     };
     'signal:reload': undefined;
     'signal:info': undefined;
@@ -1827,6 +2162,25 @@ declare class LifecycleManagerEvents {
         method: ShutdownMethod;
         duringStartup: boolean;
     }): void;
+    lifecycleManagerShutdownEscalationArmed(input: {
+        firstMethod: ShutdownMethod;
+        requestCount: number;
+        armedUntil: number;
+    }): void;
+    lifecycleManagerShutdownEscalationExpired(input: {
+        firstMethod: ShutdownMethod;
+        latestMethod: ShutdownMethod | null;
+        requestCount: number;
+        armedUntil: number;
+    }): void;
+    lifecycleManagerShutdownEscalationForced(input: {
+        firstMethod: ShutdownMethod;
+        latestMethod: ShutdownMethod;
+        requestCount: number;
+        firstRequestAt: number;
+        latestRequestAt: number;
+        wasArmedAfterFailure: boolean;
+    }): void;
     componentStarting(name: string): void;
     componentStarted(name: string, status?: ComponentStatus): void;
     componentStartTimeout(name: string, error: Error, info?: {
@@ -1859,10 +2213,12 @@ declare class LifecycleManagerEvents {
         reason?: string;
         code?: string;
     }): void;
+    componentStalledResolved(name: string, stallInfo: ComponentStallInfo, stalledDurationMS: number): void;
+    componentUnexpectedStop(name: string, error?: Error): void;
     componentShutdownForceCompleted(name: string): void;
     componentShutdownForceTimeout(name: string, timeoutMS: number): void;
     componentStartupRollback(name: string): void;
-    signalShutdown(method: ShutdownSignal): void;
+    signalShutdown(method: ShutdownSignal, isAlreadyShuttingDown?: boolean): void;
     signalReload(): void;
     signalInfo(): void;
     signalDebug(): void;
@@ -2048,4 +2404,4 @@ declare const lifecycleManagerErrCodes: {
     readonly StopTimeout: "StopTimeout";
 };
 
-export { BaseComponent, type BaseOperationResult, type BroadcastOptions, type BroadcastResult, type ComponentHealthResult, ComponentNotFoundError, type ComponentOperationFailureCode, type ComponentOperationResult, type ComponentOptions, ComponentRegistrationError, type ComponentSignalResult, type ComponentStallInfo, ComponentStartTimeoutError, ComponentStartupError, type ComponentState, type ComponentStatus, ComponentStopTimeoutError, type ComponentValueResult, DependencyCycleError, type DependencyValidationResult, type GetValueOptions, type HealthCheckResult, type HealthReport, type InsertComponentAtResult, type InsertPosition, InvalidComponentNameError, LifecycleManager, type LifecycleManagerEmit, type LifecycleManagerEventMap, type LifecycleManagerEventName, LifecycleManagerEvents, type LifecycleManagerOptions, type LifecycleManagerStatus, type MessageResult, MissingDependencyError, type RegisterComponentResult, type RegisterOptions, type RegistrationFailureCode, type RestartComponentOptions, type RestartResult, type SendMessageOptions, type ShutdownMethod, type ShutdownResult, type SignalBroadcastResult, type StartComponentOptions, type StartupOptions, type StartupOrderFailureCode, type StartupOrderResult, type StartupResult, StartupTimeoutError, type StopAllOptions, type StopComponentOptions, type SystemState, type UnregisterComponentResult, type UnregisterFailureCode, type UnregisterOptions, type ValueResult, lifecycleManagerErrCodes, lifecycleManagerErrPrefix, lifecycleManagerErrTypes };
+export { BaseComponent, type BaseOperationResult, type BroadcastOptions, type BroadcastResult, type ComponentHealthResult, ComponentNotFoundError, type ComponentOperationFailureCode, type ComponentOperationResult, type ComponentOptions, ComponentRegistrationError, type ComponentSignalResult, type ComponentStallInfo, ComponentStartTimeoutError, ComponentStartupError, type ComponentState, type ComponentStatus, ComponentStopTimeoutError, type ComponentValueResult, DependencyCycleError, type DependencyValidationResult, type ForceShutdownContext, type GetValueOptions, type HealthCheckResult, type HealthReport, type InsertComponentAtResult, type InsertPosition, InvalidComponentNameError, LifecycleManager, type LifecycleManagerEmit, type LifecycleManagerEventMap, type LifecycleManagerEventName, LifecycleManagerEvents, type LifecycleManagerOptions, type LifecycleManagerStatus, type MessageResult, MissingDependencyError, type RegisterComponentResult, type RegisterOptions, type RegistrationFailureCode, type RepeatedShutdownRequestPolicy, type RestartComponentOptions, type RestartResult, type SendMessageOptions, type ShutdownEscalationStatus, type ShutdownMethod, type ShutdownResult, type SignalBroadcastResult, type StartComponentOptions, type StartupOptions, type StartupOrderFailureCode, type StartupOrderResult, type StartupResult, StartupTimeoutError, type StopAllOptions, type StopComponentOptions, type SystemState, type UnregisterComponentResult, type UnregisterFailureCode, type UnregisterOptions, type ValueResult, lifecycleManagerErrCodes, lifecycleManagerErrPrefix, lifecycleManagerErrTypes };