@jskit-ai/kernel 0.1.117 → 0.1.119

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/kernel",
-  "version": "0.1.117",
+  "version": "0.1.119",
   "type": "module",
   "dependencies": {
     "json-rest-schema": "1.x.x"

package/shared/runtime/application.js

@@ -22,6 +22,19 @@ function nowMilliseconds() {
   return Date.now();
 }
 
+function createProviderLifecycleError(providerId, phase, cause) {
+  const message = `Provider \"${providerId}\" failed during ${phase}().`;
+  const causeMessage = String(cause?.message || cause || "").trim();
+  return new ProviderLifecycleError(
+    causeMessage ? `${message} ${causeMessage}` : message,
+    {
+      providerId,
+      phase,
+      cause
+    }
+  );
+}
+
 class Application {
   constructor({ profile = "", strict = true, container = null } = {}) {
     this.profile = normalizeText(profile);
@@ -196,11 +209,7 @@ class Application {
           await entry.provider.register(this);
         }
       } catch (error) {
-        throw new ProviderLifecycleError(`Provider \"${entry.id}\" failed during register().`, {
-          providerId: entry.id,
-          phase: "register",
-          cause: error
-        });
+        throw createProviderLifecycleError(entry.id, "register", error);
       } finally {
         this.diagnostics.timings.register[entry.id] = nowMilliseconds() - startedAt;
       }
@@ -222,11 +231,7 @@ class Application {
           await entry.provider.boot(this);
         }
       } catch (error) {
-        throw new ProviderLifecycleError(`Provider \"${entry.id}\" failed during boot().`, {
-          providerId: entry.id,
-          phase: "boot",
-          cause: error
-        });
+        throw createProviderLifecycleError(entry.id, "boot", error);
       } finally {
         this.diagnostics.timings.boot[entry.id] = nowMilliseconds() - startedAt;
       }
@@ -255,11 +260,7 @@ class Application {
           await entry.provider.shutdown(this);
         }
       } catch (error) {
-        throw new ProviderLifecycleError(`Provider \"${entry.id}\" failed during shutdown().`, {
-          providerId: entry.id,
-          phase: "shutdown",
-          cause: error
-        });
+        throw createProviderLifecycleError(entry.id, "shutdown", error);
       } finally {
         this.diagnostics.timings.shutdown[entry.id] = nowMilliseconds() - startedAt;
       }

package/shared/runtime/kernelErrors.js

@@ -1,8 +1,13 @@
 class KernelError extends Error {
   constructor(message, details = {}) {
-    super(String(message || "Kernel error."));
+    const normalizedDetails = details && typeof details === "object" ? { ...details } : {};
+    const hasCause = Object.prototype.hasOwnProperty.call(normalizedDetails, "cause");
+    super(
+      String(message || "Kernel error."),
+      hasCause ? { cause: normalizedDetails.cause } : undefined
+    );
     this.name = this.constructor.name;
-    this.details = details && typeof details === "object" ? { ...details } : {};
+    this.details = normalizedDetails;
   }
 }
 

package/shared/runtime/kernelErrors.test.js

@@ -0,0 +1,56 @@
+import assert from "node:assert/strict";
+import { spawnSync } from "node:child_process";
+import { mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import process from "node:process";
+import test from "node:test";
+import { fileURLToPath } from "node:url";
+import { KernelError } from "./kernelErrors.js";
+
+const APPLICATION_PATH = fileURLToPath(new URL("./application.js", import.meta.url));
+
+test("KernelError preserves structured details while exposing the standard cause", () => {
+  const cause = new Error("underlying failure");
+  const error = new KernelError("outer failure", {
+    cause,
+    providerId: "example.provider"
+  });
+
+  assert.equal(error.cause, cause);
+  assert.equal(error.details.cause, cause);
+  assert.equal(error.details.providerId, "example.provider");
+});
+
+test("provider lifecycle failures expose their cause in Node test output", async (context) => {
+  const fixtureRoot = await mkdtemp(path.join(tmpdir(), "jskit-kernel-error-"));
+  context.after(() => rm(fixtureRoot, { recursive: true, force: true }));
+  const fixturePath = path.join(fixtureRoot, "provider-lifecycle-failure.test.mjs");
+  const source = `
+import { Application } from ${JSON.stringify(APPLICATION_PATH)};
+import test from "node:test";
+
+test("generated server starts", async () => {
+  const app = new Application();
+  app.configureProviders([{
+    id: "json-rest-api.core",
+    async boot() {
+      throw new Error("DB_CLIENT is required. Use mysql2 or pg.");
+    }
+  }]);
+  await app.bootProviders();
+});
+`;
+  await writeFile(fixturePath, source, "utf8");
+  const childEnvironment = { ...process.env };
+  delete childEnvironment.NODE_TEST_CONTEXT;
+  const result = spawnSync(process.execPath, ["--test", fixturePath], {
+    encoding: "utf8",
+    env: childEnvironment
+  });
+  const output = `${String(result.stdout || "")}\n${String(result.stderr || "")}`;
+
+  assert.equal(result.status, 1, output);
+  assert.match(output, /Provider "json-rest-api\.core" failed during boot\(\)\./u);
+  assert.match(output, /DB_CLIENT is required\. Use mysql2 or pg\./u);
+});