@zudojs/lifecycle 0.1.0 → 1.1.0

package/dist/lifecycleManager/lifecycleManager.shutdown.js

@@ -6,27 +6,58 @@
 import { LifecyclePhase, LifecycleState } from "@zudojs/constants";
 import { buildExecutionPlan } from "../lifecyclePlan/lifecyclePlan.core.js";
 import { createLifecycleContext } from "../lifecycleContext/lifecycleContext.type.js";
-import { transitionComponent } from "./lifecycleManager.context.js";
+import { emitComponentFailed, recordResult, transitionComponent, wasAttempted, } from "./lifecycleManager.context.js";
 /** Shutdown phases in execution order. */
-const SHUTDOWN_PHASES = ["stop", "dispose"];
+const SHUTDOWN_PHASES = [LifecyclePhase.STOP, LifecyclePhase.DISPOSE];
 /**
  * Performs the full shutdown sequence: stop → dispose.
- * Idempotent — safe to call multiple times.
+ *
+ * Idempotent and single-flight: concurrent callers (a signal handler
+ * and a failing startup, say) all await the SAME teardown rather than
+ * running overlapping ones.
  */
-export async function performShutdown(ctx) {
+export function performShutdown(ctx) {
+    ctx.shutdownPromise ??= runShutdown(ctx);
+    return ctx.shutdownPromise;
+}
+async function runShutdown(ctx) {
     if (ctx.state.state === LifecycleState.DISPOSED)
         return;
+    // Shutdown must always be possible, including mid-startup. A plain
+    // transition() threw LifecycleStateError when shutdown() was called
+    // while the application was still INITIALIZING or STARTING, so a
+    // signal arriving during startup crashed instead of tearing down.
     if (ctx.state.state !== LifecycleState.STOPPING &&
         ctx.state.state !== LifecycleState.FAILED) {
-        ctx.state.transition(LifecycleState.STOPPING);
+        if (ctx.state.canTransition(LifecycleState.STOPPING)) {
+            ctx.state.transition(LifecycleState.STOPPING);
+        }
+        else {
+            ctx.state.forceState(LifecycleState.STOPPING);
+        }
     }
     ctx.events.emit("application:stopping", {});
     const deadline = Date.now() + ctx.shutdownTimeout;
+    // A startup stage still executing must settle before its components
+    // are stopped, otherwise `stop()` overlaps the component's own
+    // `start()`. Startup itself refuses to launch further stages once
+    // `shutdownPromise` is set, so this wait is bounded by one stage.
+    if (ctx.inFlight !== undefined) {
+        await raceDeadline(ctx, ctx.inFlight.then(() => undefined, () => undefined), Math.max(deadline - Date.now(), 1));
+    }
+    // The shutdown deadline used to be checked only BETWEEN the two
+    // phases, so a single hook that never settled hung shutdown (and the
+    // process) forever. Race the whole phase against the remaining
+    // budget and abort the run's signal when it expires, so hooks that
+    // honour cancellation stop and the rest are abandoned.
     for (const phase of SHUTDOWN_PHASES) {
-        if (deadline - Date.now() <= 0)
+        const remaining = deadline - Date.now();
+        if (remaining <= 0) {
+            ctx.controller.abort(new Error(`Lifecycle shutdown exceeded its ${ctx.shutdownTimeout}ms deadline.`));
             break;
+        }
         try {
-            await executeShutdownPhase(ctx, phase);
+            await raceDeadline(ctx, executeShutdownPhase(ctx, phase), remaining);
         }
         catch {
             // Shutdown must continue even if individual components fail.
@@ -36,24 +67,102 @@ export async function performShutdown(ctx) {
     ctx.events.emit("application:stopped", {
         duration: Date.now() - ctx.startTime,
     });
+    ctx.events.emit("application:disposed", {
+        duration: Date.now() - ctx.startTime,
+    });
 }
-/** Executes a single shutdown phase across all registered components. */
+/**
+ * Resolves when the phase finishes or the shutdown budget runs out.
+ *
+ * On expiry the run's AbortController is aborted so in-flight hooks
+ * observing `context.signal` unwind, and the timer is always cleared
+ * so it can never hold the event loop open.
+ */
+async function raceDeadline(ctx, phase, remainingMs) {
+    let timer;
+    const expiry = new Promise((resolve) => {
+        timer = setTimeout(() => {
+            ctx.controller.abort(new Error(`Lifecycle shutdown exceeded its ${ctx.shutdownTimeout}ms deadline.`));
+            resolve();
+        }, remainingMs);
+    });
+    try {
+        await Promise.race([phase, expiry]);
+    }
+    finally {
+        if (timer !== undefined) {
+            clearTimeout(timer);
+        }
+    }
+    // The abandoned phase promise must never surface as an unhandled
+    // rejection once the race has been decided.
+    void phase.catch(() => { });
+}
+/**
+ * Executes a single shutdown phase across all registered components.
+ *
+ * A hook only runs for components that reached the matching startup
+ * phase: `stop()` when `start` ran, `dispose()` when `initialize` ran.
+ * Rollback after an early failure — and `shutdown()` on a manager that
+ * was never started — used to call `stop()` on components that had
+ * never started; a real server's `close()` throws in that situation
+ * and the phantom failure was then recorded against the component.
+ */
 async function executeShutdownPhase(ctx, phase) {
     const plan = buildExecutionPlan(ctx.registry.getAll(), phase);
-    const context = createLifecycleContext(phase, ctx.startTime);
+    const context = createLifecycleContext(phase, ctx.startTime, ctx.controller.signal);
+    const isStop = phase === LifecyclePhase.STOP;
+    const prerequisite = isStop
+        ? LifecyclePhase.START
+        : LifecyclePhase.INITIALIZE;
+    const successState = isStop
+        ? LifecycleState.STOPPED
+        : LifecycleState.DISPOSED;
     for (const stage of plan.stages) {
         const stageRegs = stage.components
             .map((id) => ctx.registry.get(id))
             .filter((r) => r !== undefined);
         if (stageRegs.length === 0)
             continue;
+        const runnable = [];
         for (const reg of stageRegs) {
-            transitionComponent(ctx, reg.id, LifecycleState.STOPPING);
+            if (!wasAttempted(ctx, reg.id, prerequisite)) {
+                // Never reached the phase this hook undoes. It still ends up
+                // DISPOSED so status reflects the teardown.
+                if (!isStop) {
+                    transitionComponent(ctx, reg.id, LifecycleState.DISPOSED);
+                }
+                continue;
+            }
+            runnable.push(reg);
+            // Only the stop phase moves a component into STOPPING; dispose
+            // runs from STOPPED (or FAILED) and transitions straight to
+            // DISPOSED.
+            if (isStop) {
+                transitionComponent(ctx, reg.id, LifecycleState.STOPPING);
+            }
+            ctx.events.emit("component:stopping", {
+                component: { componentId: reg.id },
+            });
         }
-        await ctx.executor.executeStage(stageRegs, phase, context, ctx.concurrency);
-        const targetState = phase === "stop" ? LifecycleState.STOPPED : LifecycleState.DISPOSED;
-        for (const reg of stageRegs) {
-            transitionComponent(ctx, reg.id, targetState);
+        if (runnable.length === 0)
+            continue;
+        const results = await ctx.executor.executeStage(runnable, phase, context, ctx.concurrency);
+        // Shutdown results used to be discarded entirely: a component whose
+        // stop() or dispose() threw was still reported as cleanly STOPPED,
+        // its failure never reached getStatus() or the event stream, and
+        // operators had no way to learn a resource had leaked.
+        for (const result of results) {
+            recordResult(ctx, result);
+            if (result.success) {
+                transitionComponent(ctx, result.id, successState);
+                ctx.events.emit("component:stopped", {
+                    component: { componentId: result.id, duration: result.duration },
+                });
+                continue;
+            }
+            transitionComponent(ctx, result.id, LifecycleState.FAILED);
+            emitComponentFailed(ctx, result);
         }
     }
 }

package/dist/lifecycleManager/lifecycleManager.startup.d.ts

@@ -6,6 +6,12 @@
 import type { LifecycleManagerContext } from "./lifecycleManager.context.js";
 /**
  * Performs the full startup sequence: initialize → start → ready.
+ *
+ * When a CRITICAL component fails, the application is rolled back
+ * (stop → dispose) and this function REJECTS with a LifecycleStartError.
+ * It previously resolved normally after rolling everything back, so
+ * `await manager.start()` reported success for an application that had
+ * just been torn down.
  */
 export declare function performStartup(ctx: LifecycleManagerContext): Promise<void>;
 //# sourceMappingURL=lifecycleManager.startup.d.ts.map

package/dist/lifecycleManager/lifecycleManager.startup.js

@@ -4,97 +4,226 @@
  * Startup orchestration — initializes, starts, and readies components.
  */
 import { LifecyclePhase, LifecycleState } from "@zudojs/constants";
+import { LifecycleComponentError, LifecycleStartError } from "@zudojs/errors";
 import { buildExecutionPlan } from "../lifecyclePlan/lifecyclePlan.core.js";
 import { createLifecycleContext } from "../lifecycleContext/lifecycleContext.type.js";
-import { transitionComponent, transitionComponentBatch, emitComponentFailed, } from "./lifecycleManager.context.js";
+import { transitionComponent, transitionComponentBatch, emitComponentFailed, failComponent, markAttempted, recordResult, } from "./lifecycleManager.context.js";
 import { performShutdown } from "./lifecycleManager.shutdown.js";
 /** Maps startup phases to their target component state after success. */
 const SUCCESS_STATE = {
-    initialize: LifecycleState.INITIALIZED,
-    start: LifecycleState.STARTED,
-    ready: LifecycleState.READY,
+    [LifecyclePhase.INITIALIZE]: LifecycleState.INITIALIZED,
+    [LifecyclePhase.START]: LifecycleState.STARTED,
+    [LifecyclePhase.READY]: LifecycleState.READY,
 };
 /** Maps startup phases to their component state during execution. */
 const EXECUTING_STATE = {
-    initialize: LifecycleState.INITIALIZING,
-    start: LifecycleState.STARTING,
-    ready: LifecycleState.STARTED,
+    [LifecyclePhase.INITIALIZE]: LifecycleState.INITIALIZING,
+    [LifecyclePhase.START]: LifecycleState.STARTING,
+    [LifecyclePhase.READY]: LifecycleState.STARTED,
+};
+/**
+ * Per-phase component events.
+ *
+ * Every one of these event types was declared by LifecycleEventType
+ * from the first release, but startup only ever emitted the generic
+ * "component:starting"/"component:started" pair — and the "starting"
+ * event carried a comma-joined list of ids in the `componentId` field
+ * instead of a real component id.
+ */
+const PHASE_EVENTS = {
+    [LifecyclePhase.INITIALIZE]: {
+        begin: "component:initializing",
+        end: "component:initialized",
+    },
+    [LifecyclePhase.START]: {
+        begin: "component:starting",
+        end: "component:started",
+    },
+    [LifecyclePhase.READY]: {
+        begin: "component:starting",
+        end: "component:ready",
+    },
+};
+/** Application-level event emitted when a startup phase begins. */
+const PHASE_APPLICATION_EVENT = {
+    [LifecyclePhase.INITIALIZE]: "application:initializing",
+    [LifecyclePhase.START]: "application:starting",
+    [LifecyclePhase.READY]: "application:starting",
 };
 /**
  * Performs the full startup sequence: initialize → start → ready.
+ *
+ * When a CRITICAL component fails, the application is rolled back
+ * (stop → dispose) and this function REJECTS with a LifecycleStartError.
+ * It previously resolved normally after rolling everything back, so
+ * `await manager.start()` reported success for an application that had
+ * just been torn down.
  */
 export async function performStartup(ctx) {
     ctx.startTime = Date.now();
     ctx.state.transition(LifecycleState.INITIALIZING);
-    ctx.events.emit("application:initializing", {});
     try {
         ctx.registry.freeze();
-        const initOk = await executePhase(ctx, "initialize");
-        if (!initOk) {
-            await performShutdown(ctx);
-            return;
+        const failedInit = await executePhase(ctx, LifecyclePhase.INITIALIZE);
+        if (failedInit) {
+            throw new LifecycleStartError(failedInit.id, failedInit.error);
         }
+        assertNotShuttingDown(ctx, LifecyclePhase.INITIALIZE);
         ctx.state.transition(LifecycleState.INITIALIZED);
+        ctx.events.emit("application:initialized", {
+            duration: Date.now() - ctx.startTime,
+        });
         ctx.state.transition(LifecycleState.STARTING);
-        const startOk = await executePhase(ctx, "start");
-        if (!startOk) {
-            await performShutdown(ctx);
-            return;
+        const failedStart = await executePhase(ctx, LifecyclePhase.START);
+        if (failedStart) {
+            throw new LifecycleStartError(failedStart.id, failedStart.error);
         }
+        assertNotShuttingDown(ctx, LifecyclePhase.START);
         ctx.state.transition(LifecycleState.STARTED);
-        const readyOk = await executePhase(ctx, "ready");
-        if (readyOk) {
-            ctx.state.transition(LifecycleState.READY);
-            ctx.events.emit("application:ready", {
-                duration: Date.now() - ctx.startTime,
-            });
+        // A failing `ready` hook on a critical component used to be
+        // ignored completely: no state change, no rollback, and start()
+        // resolved with the application stuck in STARTED.
+        const failedReady = await executePhase(ctx, LifecyclePhase.READY);
+        if (failedReady) {
+            throw new LifecycleStartError(failedReady.id, failedReady.error);
         }
+        assertNotShuttingDown(ctx, LifecyclePhase.READY);
+        ctx.state.transition(LifecycleState.READY);
+        ctx.events.emit("application:ready", {
+            duration: Date.now() - ctx.startTime,
+        });
     }
     catch (error) {
-        if (ctx.state.state !== LifecycleState.FAILED) {
+        // Rollback happens on exactly one path, so a completed teardown is
+        // never re-entered and its DISPOSED state is never overwritten
+        // with FAILED.
+        // When the failure IS a requested shutdown, the teardown already
+        // owns the application state.
+        if (ctx.shutdownPromise === undefined &&
+            ctx.state.state !== LifecycleState.FAILED &&
+            ctx.state.state !== LifecycleState.DISPOSED) {
             ctx.state.forceState(LifecycleState.FAILED);
         }
         await performShutdown(ctx);
         throw error;
     }
 }
+/**
+ * Throws when a shutdown has been requested while startup is running.
+ *
+ * Startup used to keep launching later stages after `shutdown()` had
+ * already torn everything down: a component started that way was
+ * never stopped, and the eventual failure was an opaque
+ * LifecycleStateError from the DISPOSED → INITIALIZED transition.
+ */
+function assertNotShuttingDown(ctx, phase) {
+    if (ctx.shutdownPromise !== undefined) {
+        throw new LifecycleStartError("application", new LifecycleComponentError("application", phase, new Error("Startup was cancelled because shutdown was requested while the application was starting.")));
+    }
+}
 /**
  * Executes a single startup phase across all registered components.
- * Returns false if a critical component failed.
+ * Returns the failure of the first critical component, or undefined.
+ *
+ * Two bookkeeping rules apply to every stage:
+ *
+ * - A component that FAILED an earlier phase, or whose dependency has
+ *   failed, does not enter this phase. It used to have `start()` and
+ *   `ready()` invoked after its own `initialize()` had thrown, and its
+ *   dependents were started as if the dependency were healthy —
+ *   silently voiding the `dependsOn` contract. A skipped dependent is
+ *   recorded as FAILED with a LifecycleComponentError naming the
+ *   failed dependency, and its own `critical` flag decides whether
+ *   startup aborts.
+ *
+ * - Every result of a stage is recorded, transitioned and announced
+ *   before a critical failure aborts the phase. Returning on the first
+ *   failed result dropped the results of siblings in the same stage,
+ *   which were then left in INITIALIZING / STARTING forever (no
+ *   transition leads out of those states except to their success or
+ *   FAILED) even after rollback had disposed them.
  */
 async function executePhase(ctx, phase) {
     const plan = buildExecutionPlan(ctx.registry.getAll(), phase);
-    const context = createLifecycleContext(phase, ctx.startTime);
+    const context = createLifecycleContext(phase, ctx.startTime, ctx.controller.signal);
+    const events = PHASE_EVENTS[phase];
+    ctx.events.emit(PHASE_APPLICATION_EVENT[phase], {});
     for (const stage of plan.stages) {
         const stageRegs = stage.components
             .map((id) => ctx.registry.get(id))
             .filter((r) => r !== undefined);
         if (stageRegs.length === 0)
             continue;
-        transitionComponentBatch(ctx, stageRegs.map((r) => r.id), EXECUTING_STATE[phase]);
-        ctx.events.emit("component:starting", {
-            component: { componentId: stage.components.join(",") },
-        });
-        const results = await ctx.executor.executeStage(stageRegs, phase, context, ctx.concurrency);
+        assertNotShuttingDown(ctx, phase);
+        const runnable = [];
+        let criticalFailure;
+        for (const reg of stageRegs) {
+            if (ctx.componentStates.get(reg.id)?.state === LifecycleState.FAILED) {
+                // Already failed in an earlier phase; nothing more to run.
+                continue;
+            }
+            const failedDependency = reg.dependsOn.find((dep) => ctx.componentStates.get(dep)?.state === LifecycleState.FAILED);
+            if (failedDependency === undefined) {
+                runnable.push(reg);
+                continue;
+            }
+            const skipped = {
+                id: reg.id,
+                phase,
+                duration: 0,
+                success: false,
+                error: new LifecycleComponentError(reg.id, phase, new Error(`Component "${reg.id}" was not started because its dependency "${failedDependency}" failed.`)),
+            };
+            recordResult(ctx, skipped);
+            failComponent(ctx, reg.id);
+            emitComponentFailed(ctx, skipped);
+            if (reg.critical) {
+                criticalFailure ??= { id: reg.id, error: skipped.error };
+            }
+        }
+        if (criticalFailure) {
+            ctx.state.forceState(LifecycleState.FAILED);
+            return criticalFailure;
+        }
+        if (runnable.length === 0)
+            continue;
+        transitionComponentBatch(ctx, runnable.map((r) => r.id), EXECUTING_STATE[phase]);
+        for (const reg of runnable) {
+            markAttempted(ctx, reg.id, phase);
+            ctx.events.emit(events.begin, {
+                component: { componentId: reg.id },
+            });
+        }
+        const pending = ctx.executor.executeStage(runnable, phase, context, ctx.concurrency);
+        ctx.inFlight = pending;
+        let results;
+        try {
+            results = await pending;
+        }
+        finally {
+            ctx.inFlight = undefined;
+        }
         for (const result of results) {
-            const existing = ctx.results.get(result.id) ?? [];
-            ctx.results.set(result.id, [...existing, result]);
+            recordResult(ctx, result);
             if (!result.success) {
                 transitionComponent(ctx, result.id, LifecycleState.FAILED);
                 emitComponentFailed(ctx, result);
                 if (ctx.registry.get(result.id)?.critical) {
-                    ctx.state.forceState(LifecycleState.FAILED);
-                    return false;
+                    criticalFailure ??= { id: result.id, error: result.error };
                 }
             }
             else {
                 transitionComponent(ctx, result.id, SUCCESS_STATE[phase]);
-                ctx.events.emit("component:started", {
+                ctx.events.emit(events.end, {
                     component: { componentId: result.id, duration: result.duration },
                 });
             }
         }
+        if (criticalFailure) {
+            ctx.state.forceState(LifecycleState.FAILED);
+            return criticalFailure;
+        }
     }
-    return true;
+    return undefined;
 }
 //# sourceMappingURL=lifecycleManager.startup.js.map

package/dist/lifecyclePhase/lifecyclePhase.core.d.ts

@@ -13,7 +13,13 @@ export declare const SHUTDOWN_PHASES: readonly LifecyclePhase[];
  */
 export declare function getPhaseHookName(phase: LifecyclePhase): string;
 /**
- * Returns the on-prefixed hook name for a component method.
+ * Returns the name of the LifecycleComponent method a phase invokes.
+ *
+ * This is the same mapping as {@link getPhaseHookName}; the two names
+ * exist for readability at the call site. The doc comment previously
+ * claimed an "on-prefixed" name, which this function has never
+ * returned — component hooks are `initialize`, `start`, `ready`,
+ * `stop` and `dispose`.
  */
 export declare function getComponentMethod(phase: LifecyclePhase): string;
 //# sourceMappingURL=lifecyclePhase.core.d.ts.map

package/dist/lifecyclePhase/lifecyclePhase.core.js

@@ -33,20 +33,15 @@ export function getPhaseHookName(phase) {
     }
 }
 /**
- * Returns the on-prefixed hook name for a component method.
+ * Returns the name of the LifecycleComponent method a phase invokes.
+ *
+ * This is the same mapping as {@link getPhaseHookName}; the two names
+ * exist for readability at the call site. The doc comment previously
+ * claimed an "on-prefixed" name, which this function has never
+ * returned — component hooks are `initialize`, `start`, `ready`,
+ * `stop` and `dispose`.
  */
 export function getComponentMethod(phase) {
-    switch (phase) {
-        case LifecyclePhase.INITIALIZE:
-            return "initialize";
-        case LifecyclePhase.START:
-            return "start";
-        case LifecyclePhase.READY:
-            return "ready";
-        case LifecyclePhase.STOP:
-            return "stop";
-        case LifecyclePhase.DISPOSE:
-            return "dispose";
-    }
+    return getPhaseHookName(phase);
 }
 //# sourceMappingURL=lifecyclePhase.core.js.map

package/dist/lifecyclePlan/lifecyclePlan.core.js

@@ -12,7 +12,7 @@ export function buildExecutionPlan(registrations, phase) {
     for (const reg of registrations) {
         priorities.set(reg.id, reg.priority);
     }
-    const graph = buildGraphForPhase(registrations, phase);
+    const graph = buildGraphForPhase(registrations);
     const isShutdown = phase === "stop" || phase === "dispose";
     const sorted = isShutdown
         ? reverseTopologicalSort(graph, priorities)
@@ -24,9 +24,13 @@ export function buildExecutionPlan(registrations, phase) {
     return { stages, phase };
 }
 /**
- * Builds a dependency graph for a specific phase.
+ * Builds the component dependency graph.
+ *
+ * The graph is phase-independent: startup and shutdown share the same
+ * edges and differ only in traversal direction, which
+ * buildExecutionPlan applies.
  */
-function buildGraphForPhase(registrations, phase) {
+function buildGraphForPhase(registrations) {
     const graph = new DependencyGraph();
     for (const reg of registrations) {
         graph.addNode(reg.id);

package/dist/lifecycleSignal/lifecycleSignal.handler.d.ts

@@ -10,11 +10,11 @@ export interface SignalHandlerOptions {
     /** Function to call when a signal is received. */
     readonly handler: () => void;
 }
+/** Default signal configuration for graceful shutdown. */
+export declare const DEFAULT_SHUTDOWN_SIGNALS: readonly NodeJS.Signals[];
 /**
  * Installs process signal handlers that trigger lifecycle shutdown.
  * Returns a cleanup function to remove the handlers.
  */
 export declare function installSignalHandlers(options: SignalHandlerOptions): () => void;
-/** Default signal configuration for graceful shutdown. */
-export declare const DEFAULT_SHUTDOWN_SIGNALS: readonly NodeJS.Signals[];
 //# sourceMappingURL=lifecycleSignal.handler.d.ts.map

package/dist/lifecycleSignal/lifecycleSignal.handler.js

@@ -3,12 +3,17 @@
  *
  * Process signal handler — manages SIGTERM, SIGINT, SIGHUP for graceful shutdown.
  */
+/** Default signal configuration for graceful shutdown. */
+export const DEFAULT_SHUTDOWN_SIGNALS = Object.freeze(["SIGINT", "SIGTERM"]);
 /**
  * Installs process signal handlers that trigger lifecycle shutdown.
  * Returns a cleanup function to remove the handlers.
  */
 export function installSignalHandlers(options) {
-    const signals = options.signals ?? ["SIGINT", "SIGTERM"];
+    // DEFAULT_SHUTDOWN_SIGNALS was exported as the documented default
+    // while this function hard-coded its own copy of the same list, so
+    // changing the constant had no effect on the actual default.
+    const signals = options.signals ?? DEFAULT_SHUTDOWN_SIGNALS;
     const handler = options.handler;
     const installed = [];
     for (const signal of signals) {
@@ -24,6 +29,4 @@ export function installSignalHandlers(options) {
         }
     };
 }
-/** Default signal configuration for graceful shutdown. */
-export const DEFAULT_SHUTDOWN_SIGNALS = Object.freeze(["SIGINT", "SIGTERM"]);
 //# sourceMappingURL=lifecycleSignal.handler.js.map

package/package.json

@@ -1,8 +1,12 @@
 {
   "name": "@zudojs/lifecycle",
-  "version": "0.1.0",
+  "version": "1.1.0",
   "description": "Application and component lifecycle orchestration with state machine, dependency ordering, graceful shutdown, rollback, and signals.",
   "license": "MIT",
+  "author": {
+    "name": "Oluwayemi Oyinlola",
+    "url": "https://github.com/oyinlola-tech"
+  },
   "type": "module",
   "main": "./dist/index.js",
   "module": "./dist/index.js",
@@ -14,22 +18,18 @@
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "!dist/**/*.map",
+    "!dist/**/*.tsbuildinfo",
+    "!dist/.tsbuildinfo"
   ],
-  "scripts": {
-    "build": "tsc -p tsconfig.json",
-    "typecheck": "tsc -p tsconfig.json --noEmit",
-    "clean": "rm -rf dist",
-    "test": "vitest run",
-    "test:watch": "vitest"
-  },
   "dependencies": {
-    "@zudojs/errors": "0.1.0",
-    "@zudojs/constants": "0.1.0"
+    "@zudojs/errors": "1.0.1",
+    "@zudojs/constants": "1.0.1"
   },
   "devDependencies": {
     "@types/node": "^26.4.1",
-    "typescript": "^7.0.2",
+    "typescript": "7.0.2",
     "vitest": "^4.1.11"
   },
   "engines": {
@@ -46,8 +46,19 @@
     "shutdown"
   ],
   "homepage": "https://github.com/oyinlola-tech/zudo#readme",
+  "bugs": {
+    "url": "https://github.com/oyinlola-tech/zudo/issues"
+  },
   "repository": {
     "type": "git",
-    "url": "https://github.com/oyinlola-tech/zudo"
+    "url": "https://github.com/oyinlola-tech/zudo",
+    "directory": "packages/lifecycle"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "typecheck": "tsc -p tsconfig.json --noEmit && tsc -p tsconfig.test.json --noEmit",
+    "clean": "rm -rf dist",
+    "test": "vitest run",
+    "test:watch": "vitest"
   }
-}
+}

package/dist/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EACL,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AACnC,YAAY,EACV,kBAAkB,EAClB,4BAA4B,EAC5B,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,+BAA+B,CAAC;AACvC,YAAY,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAC;AACpE,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,SAAS,EACT,eAAe,GAChB,MAAM,8BAA8B,CAAC;AACtC,YAAY,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AACrE,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAC9D,YAAY,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,YAAY,EAAE,eAAe,EAAE,MAAM,8BAA8B,CAAC;AACpE,OAAO,EACL,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AACrC,YAAY,EAAE,uBAAuB,EAAE,MAAM,6BAA6B,CAAC;AAC3E,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AACnE,YAAY,EACV,kBAAkB,EAClB,uBAAuB,EACvB,yBAAyB,EACzB,cAAc,EACd,sBAAsB,GACvB,MAAM,4BAA4B,CAAC;AACpC,OAAO,EACL,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC;AACpC,YAAY,EAAE,oBAAoB,EAAE,MAAM,4BAA4B,CAAC"}

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH,OAAO,EAAE,qBAAqB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EACL,cAAc,EACd,eAAe,EACf,gBAAgB,EAChB,kBAAkB,GACnB,MAAM,2BAA2B,CAAC;AAQnC,OAAO,EAAE,sBAAsB,EAAE,MAAM,6BAA6B,CAAC;AACrE,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AACjE,OAAO,EACL,eAAe,EACf,eAAe,EACf,sBAAsB,EACtB,WAAW,EACX,SAAS,EACT,eAAe,GAChB,MAAM,8BAA8B,CAAC;AAEtC,OAAO,EAAE,kBAAkB,EAAE,MAAM,0BAA0B,CAAC;AAE9D,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAC;AAEjE,OAAO,EACL,gBAAgB,EAChB,sBAAsB,GACvB,MAAM,6BAA6B,CAAC;AAErC,OAAO,EAAE,qBAAqB,EAAE,MAAM,4BAA4B,CAAC;AAQnE,OAAO,EACL,qBAAqB,EACrB,wBAAwB,GACzB,MAAM,4BAA4B,CAAC"}

package/dist/lifecycleComponent/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/lifecycleComponent/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,YAAY,EACV,kBAAkB,EAClB,4BAA4B,EAC5B,qBAAqB,EACrB,qBAAqB,GACtB,MAAM,8BAA8B,CAAC"}

package/dist/lifecycleComponent/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/lifecycleComponent/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}

package/dist/lifecycleComponent/lifecycleComponent.type.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycleComponent.type.d.ts","sourceRoot":"","sources":["../../src/lifecycleComponent/lifecycleComponent.type.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,8CAA8C,CAAC;AAErF;;;GAGG;AACH,MAAM,WAAW,kBAAkB;IACjC,8CAA8C;IAC9C,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IAEtB,iFAAiF;IACjF,UAAU,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEtD,iEAAiE;IACjE,KAAK,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjD,uEAAuE;IACvE,KAAK,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEjD,yEAAyE;IACzE,IAAI,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;IAEhD,gEAAgE;IAChE,OAAO,CAAC,CAAC,OAAO,EAAE,gBAAgB,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;CACpD;AAED,qDAAqD;AACrD,MAAM,WAAW,4BAA4B;IAC3C,gEAAgE;IAChE,QAAQ,CAAC,EAAE,CAAC,EAAE,MAAM,CAAC;IAErB,yDAAyD;IACzD,QAAQ,CAAC,SAAS,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAEvC,gFAAgF;IAChF,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,sFAAsF;IACtF,QAAQ,CAAC,QAAQ,CAAC,EAAE,OAAO,CAAC;IAE5B,yDAAyD;IACzD,QAAQ,CAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAE1B,iDAAiD;IACjD,QAAQ,CAAC,KAAK,CAAC,EAAE,qBAAqB,CAAC;CACxC;AAED,8CAA8C;AAC9C,MAAM,WAAW,qBAAqB;IACpC,wCAAwC;IACxC,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,mCAAmC;IACnC,QAAQ,CAAC,KAAK,CAAC,EAAE,MAAM,CAAC;IAExB,2CAA2C;IAC3C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAE3B,wBAAwB;IACxB,QAAQ,CAAC,OAAO,CAAC,EAAE,OAAO,GAAG,aAAa,CAAC;CAC5C;AAED,kDAAkD;AAClD,MAAM,WAAW,qBAAqB;IACpC,iBAAiB;IACjB,QAAQ,CAAC,EAAE,EAAE,MAAM,CAAC;IAEpB,8BAA8B;IAC9B,QAAQ,CAAC,SAAS,EAAE,kBAAkB,CAAC;IAEvC,2BAA2B;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS,MAAM,EAAE,CAAC;IAEtC,6CAA6C;IAC7C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAE1B,wDAAwD;IACxD,QAAQ,CAAC,QAAQ,EAAE,OAAO,CAAC;IAE3B,+CAA+C;IAC/C,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IAEzB,2BAA2B;IAC3B,QAAQ,CAAC,KAAK,EAAE,qBAAqB,CAAC;CACvC"}

package/dist/lifecycleComponent/lifecycleComponent.type.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"lifecycleComponent.type.js","sourceRoot":"","sources":["../../src/lifecycleComponent/lifecycleComponent.type.ts"],"names":[],"mappings":"AAAA;;;;GAIG"}