@jskit-ai/kernel 0.1.57 → 0.1.58

package/package.json

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

package/server/http/lib/kernel.test.js

@@ -760,6 +760,51 @@ test("registerRoutes attaches request.input when route input transforms are conf
   assert.equal(reply.statusCode, 200);
 });
 
+test("registerRoutes strips Fastify body schemas when JSKIT runtime body validation is present", () => {
+  const fastify = createFastifyStub();
+
+  registerRoutes(fastify, {
+    routes: [
+      {
+        method: "POST",
+        path: "/body-schema-runtime-validation",
+        schema: {
+          body: {
+            type: "object",
+            properties: {
+              flag: {
+                anyOf: [{ type: "boolean" }, { type: "null" }]
+              }
+            }
+          },
+          querystring: {
+            type: "object",
+            properties: {
+              limit: { type: "integer" }
+            }
+          }
+        },
+        input: {
+          body: (body) => ({
+            flag: body?.flag ?? null
+          })
+        },
+        handler: async (_request, reply) => {
+          reply.code(200).send({ ok: true });
+        }
+      }
+    ]
+  });
+
+  assert.equal(Object.prototype.hasOwnProperty.call(fastify.routes[0].schema, "body"), false);
+  assert.deepEqual(fastify.routes[0].schema.querystring, {
+    type: "object",
+    properties: {
+      limit: { type: "integer" }
+    }
+  });
+});
+
 test("registerRoutes applies transport request transforms before route input normalization", async () => {
   const fastify = createFastifyStub();
 
@@ -979,6 +1024,116 @@ test("registerRoutes applies transport response transforms before reply serializ
   });
 });
 
+test("registerRoutes bypasses success transport and output transforms for error replies", async () => {
+  const fastify = createFastifyStub();
+  let successTransportCalls = 0;
+  let outputTransformCalls = 0;
+
+  registerRoutes(fastify, {
+    routes: [
+      {
+        method: "GET",
+        path: "/transport-error-bypass",
+        transport: {
+          kind: "jsonapi-resource",
+          contentType: "application/vnd.api+json",
+          response() {
+            successTransportCalls += 1;
+            return {
+              data: {
+                type: "contacts",
+                id: "7",
+                attributes: {
+                  name: "Alice"
+                }
+              }
+            };
+          }
+        },
+        output() {
+          outputTransformCalls += 1;
+          return {
+            mutated: true
+          };
+        },
+        handler: async (_request, reply) => {
+          reply.code(500).send({
+            errors: [
+              {
+                status: "500",
+                code: "internal_server_error",
+                title: "Internal server error."
+              }
+            ]
+          });
+        }
+      }
+    ]
+  });
+
+  const request = {};
+  const reply = createReplyStub();
+
+  await fastify.routes[0].handler(request, reply);
+
+  assert.equal(reply.statusCode, 500);
+  assert.equal(reply.headers["Content-Type"], "application/vnd.api+json");
+  assert.equal(successTransportCalls, 0);
+  assert.equal(outputTransformCalls, 0);
+  assert.deepEqual(reply.payload, {
+    errors: [
+      {
+        status: "500",
+        code: "internal_server_error",
+        title: "Internal server error."
+      }
+    ]
+  });
+});
+
+test("registerRoutes bypasses success transport for Error payloads before status normalization", async () => {
+  const fastify = createFastifyStub();
+  let successTransportCalls = 0;
+
+  registerRoutes(fastify, {
+    routes: [
+      {
+        method: "GET",
+        path: "/transport-error-instance",
+        transport: {
+          kind: "jsonapi-resource",
+          contentType: "application/vnd.api+json",
+          response() {
+            successTransportCalls += 1;
+            return {
+              data: {
+                type: "contacts",
+                id: "7",
+                attributes: {
+                  name: "Alice"
+                }
+              }
+            };
+          }
+        },
+        handler: async (_request, reply) => {
+          reply.send(new Error("Boom"));
+        }
+      }
+    ]
+  });
+
+  const request = {};
+  const reply = createReplyStub();
+
+  await fastify.routes[0].handler(request, reply);
+
+  assert.equal(successTransportCalls, 0);
+  assert.equal(reply.headers["Content-Type"], "application/vnd.api+json");
+  assert.equal(reply.payload instanceof Error, true);
+  assert.equal(reply.payload.message, "Boom");
+});
+
 test("registerRoutes exposes full transport runtime on Fastify route config for pre-handler error serialization", () => {
   const fastify = createFastifyStub();
   const transport = {

package/server/http/lib/routeRegistration.js

@@ -17,6 +17,9 @@ const JSON_API_CONTENT_TYPE = "application/vnd.api+json";
 function toFastifyRouteOptions(route) {
   const sourceRoute = normalizeObject(route);
   const schema = cloneRouteSchema(sourceRoute.schema);
+  if (shouldStripFastifyBodySchema(sourceRoute, schema)) {
+    delete schema.body;
+  }
   const existingConfig = normalizeObject(sourceRoute.config);
   const transportKind = normalizeText(sourceRoute?.transport?.kind).toLowerCase();
   const existingTransportConfig =
@@ -48,6 +51,18 @@ function toFastifyRouteOptions(route) {
   };
 }
 
+function shouldStripFastifyBodySchema(route = null, schema = null) {
+  if (!route || !schema || typeof schema !== "object" || Array.isArray(schema)) {
+    return false;
+  }
+
+  if (!Object.prototype.hasOwnProperty.call(schema, "body")) {
+    return false;
+  }
+
+  return typeof route?.input?.body === "function";
+}
+
 function normalizeHeaderValue(value) {
   if (Array.isArray(value)) {
     return String(value[0] || "").trim();
@@ -210,6 +225,19 @@ function wrapReplySend({ reply = null, request = null, route = null, outputTrans
 
   const originalSend = reply.send.bind(reply);
   reply.send = function transformedSend(payload) {
+    const statusCode = Number(reply?.statusCode || 200);
+
+    if (payload instanceof Error || statusCode >= 400) {
+      if (
+        normalizeText(transport?.contentType) &&
+        !replyHasHeader(reply, "content-type")
+      ) {
+        reply.header("Content-Type", transport.contentType);
+      }
+
+      return originalSend(payload);
+    }
+
     let nextPayload = payload;
     if (typeof transport?.response === "function") {
       const transportedPayload = transport.response(payload, {
@@ -217,7 +245,7 @@ function wrapReplySend({ reply = null, request = null, route = null, outputTrans
         reply,
         route,
         transport,
-        statusCode: Number(reply?.statusCode || 200)
+        statusCode
       });
 
       if (transportedPayload && typeof transportedPayload.then === "function") {
@@ -235,7 +263,7 @@ function wrapReplySend({ reply = null, request = null, route = null, outputTrans
         reply,
         route,
         transport,
-        statusCode: Number(reply?.statusCode || 200)
+        statusCode
       });
 
       if (transformedPayload && typeof transformedPayload.then === "function") {
@@ -249,7 +277,7 @@ function wrapReplySend({ reply = null, request = null, route = null, outputTrans
 
     if (
       normalizeText(transport?.contentType) &&
-      Number(reply?.statusCode || 200) !== 204 &&
+      statusCode !== 204 &&
       !replyHasHeader(reply, "content-type")
     ) {
       reply.header("Content-Type", transport.contentType);

package/server/platform/providerRuntime.js

@@ -39,6 +39,18 @@ async function createProviderRuntimeApp({
 
   await app.start({ providers });
 
+  if (fastify && typeof fastify.addHook === "function") {
+    let didShutdown = false;
+    fastify.addHook("onClose", async () => {
+      if (didShutdown) {
+        return;
+      }
+
+      didShutdown = true;
+      await app.shutdown();
+    });
+  }
+
   const routeRegistration = httpRuntime ? httpRuntime.registerRoutes() : { routeCount: 0 };
   return Object.freeze({
     app,

package/server/platform/providerRuntime.test.js

@@ -215,3 +215,115 @@ test("createProviderRuntimeFromApp resolves descriptor using source.packagePath"
     await rm(appRoot, { recursive: true, force: true });
   }
 });
+
+test("createProviderRuntimeFromApp wires fastify onClose to provider shutdown exactly once", async () => {
+  const appRoot = await createTestAppRoot("kernel-provider-runtime-fastify-close-");
+  try {
+    await mkdir(path.join(appRoot, "packages", "local-example", "src", "server", "providers"), { recursive: true });
+    await writeFile(
+      path.join(appRoot, ".jskit", "lock.json"),
+      `${JSON.stringify(
+        {
+          lockVersion: 1,
+          installedPackages: {
+            "@local/example": {
+              packageId: "@local/example",
+              version: "0.1.0",
+              source: {
+                type: "local-package",
+                packagePath: "packages/local-example"
+              },
+              managed: {
+                packageJson: {
+                  dependencies: {},
+                  devDependencies: {},
+                  scripts: {}
+                },
+                text: {},
+                files: []
+              },
+              options: {},
+              installedAt: "2026-01-01T00:00:00.000Z"
+            }
+          }
+        },
+        null,
+        2
+      )}\n`,
+      "utf8"
+    );
+    await writeFile(
+      path.join(appRoot, "packages", "local-example", "package.descriptor.mjs"),
+      [
+        "export default Object.freeze({",
+        "  packageVersion: 1,",
+        "  packageId: \"@local/example\",",
+        "  version: \"0.1.0\",",
+        "  description: \"Local example package\",",
+        "  dependsOn: [],",
+        "  capabilities: {",
+        "    provides: [],",
+        "    requires: []",
+        "  },",
+        "  runtime: {",
+        "    server: {",
+        "      providers: [",
+        "        { discover: { dir: \"src/server/providers\", pattern: \"*Provider.js\" } }",
+        "      ]",
+        "    }",
+        "  }",
+        "});"
+      ].join("\n"),
+      "utf8"
+    );
+    await writeFile(
+      path.join(appRoot, "packages", "local-example", "src", "server", "providers", "CloseAwareProvider.js"),
+      [
+        "export default class CloseAwareProvider {",
+        "  static id = \"example.close-aware\";",
+        "  register(app) {",
+        "    app.instance(\"example.close.state\", { shutdownCalls: 0 });",
+        "  }",
+        "  async boot() {}",
+        "  async shutdown(app) {",
+        "    app.make(\"example.close.state\").shutdownCalls += 1;",
+        "  }",
+        "}"
+      ].join("\n"),
+      "utf8"
+    );
+
+    const hooks = [];
+    const fastify = {
+      route() {},
+      setErrorHandler() {},
+      addContentTypeParser() {},
+      hasContentTypeParser() {
+        return false;
+      },
+      getDefaultJsonParser() {
+        return (_request, body, done) => done(null, body);
+      },
+      addHook(name, handler) {
+        hooks.push({ name, handler });
+      }
+    };
+
+    const runtime = await createProviderRuntimeFromApp({
+      appRoot,
+      profile: "app",
+      fastify
+    });
+
+    const closeHook = hooks.find((entry) => entry.name === "onClose");
+    assert.ok(closeHook);
+    assert.equal(runtime.app.make("example.close.state").shutdownCalls, 0);
+
+    await closeHook.handler();
+    await closeHook.handler();
+
+    assert.equal(runtime.app.make("example.close.state").shutdownCalls, 1);
+  } finally {
+    await rm(appRoot, { recursive: true, force: true });
+  }
+});

package/server/support/pageTargets.js

@@ -19,9 +19,11 @@ import { resolveRequiredAppRoot, toPosixPath } from "./path.js";
 import { loadAppConfigFromModuleUrl } from "./appConfigFiles.js";
 
 const DEFAULT_PAGE_LINK_COMPONENT_TOKEN = "local.main.ui.surface-aware-menu-link-item";
-const DEFAULT_SUBPAGE_LINK_COMPONENT_TOKEN = "local.main.ui.tab-link-item";
+const DEFAULT_SUBPAGE_LINK_COMPONENT_TOKEN = "local.main.ui.surface-aware-menu-link-item";
 const PAGE_ROOT_PREFIX = "src/pages/";
 const ROUTER_VIEW_TAG_PATTERN = /<RouterView\b/i;
+const SECTION_CONTAINER_SHELL_TAG_PATTERN = /<SectionContainerShell\b/i;
+const TABS_SLOT_PATTERN = /<template\b[^>]*(?:#tabs|v-slot:tabs)\b[^>]*>([\s\S]*?)<\/template>/i;
 
 function normalizeRelativeFilePath(value = "") {
   return String(value || "")
@@ -430,7 +432,6 @@ function resolveSubpagesHostTargetFromPageSource(source = "") {
   if (!ROUTER_VIEW_TAG_PATTERN.test(sourceText)) {
     return null;
   }
-
   const discoveredTargets = discoverShellOutletTargetsFromVueSource(sourceText, {
     context: "subpages host"
   });
@@ -444,8 +445,25 @@ function resolveSubpagesHostTargetFromPageSource(source = "") {
     return null;
   }
 
+  let isSectionSubpagesHost = false;
+  if (SECTION_CONTAINER_SHELL_TAG_PATTERN.test(sourceText)) {
+    const tabsSlotMatch = TABS_SLOT_PATTERN.exec(sourceText);
+    if (tabsSlotMatch) {
+      const tabsTargets = discoverShellOutletTargetsFromVueSource(String(tabsSlotMatch[1] || ""), {
+        context: "subpages host tabs slot"
+      });
+      const tabTargetIds = Array.isArray(tabsTargets.targets)
+        ? tabsTargets.targets.map((entry) => normalizeShellOutletTargetId(entry?.id)).filter(Boolean)
+        : [];
+      if (tabTargetIds.length === 1 && tabTargetIds[0] === normalizeShellOutletTargetId(target.id)) {
+        isSectionSubpagesHost = true;
+      }
+    }
+  }
+
   return Object.freeze({
-    id: target.id
+    id: target.id,
+    isSectionSubpagesHost
   });
 }
 
@@ -594,16 +612,11 @@ function resolveInferredPageLinkTo({
   const parentTargetId = normalizePlacementTargetId(parentHost);
   const placementTargetId = normalizePlacementTargetId(placementTarget);
   if (parentTargetId && parentTargetId === placementTargetId) {
-    const inferredLinkTo = resolveRelativeLinkToFromParent(pageTarget, parentHost);
-    if (inferredLinkTo) {
-      return inferredLinkTo;
-    }
-  }
-
-  if (normalizeText(parentHost?.pageShape) === "index") {
-    const inferredLinkTo = resolveRelativeLinkToFromParent(pageTarget, parentHost);
-    if (inferredLinkTo) {
-      return inferredLinkTo;
+    if (parentHost?.isSectionSubpagesHost === true) {
+      const inferredLinkTo = resolveRelativeLinkToFromParent(pageTarget, parentHost);
+      if (inferredLinkTo) {
+        return inferredLinkTo;
+      }
     }
   }
 
@@ -633,7 +646,11 @@ function resolveInferredPageLinkComponentToken({
 
   const parentTargetId = normalizePlacementTargetId(parentHost);
   const placementTargetId = normalizePlacementTargetId(placementTarget);
-  if (parentTargetId && parentTargetId === placementTargetId) {
+  if (
+    parentHost?.isSectionSubpagesHost === true &&
+    parentTargetId &&
+    parentTargetId === placementTargetId
+  ) {
     return normalizeText(subpageComponentToken) || DEFAULT_SUBPAGE_LINK_COMPONENT_TOKEN;
   }
 
@@ -681,6 +698,12 @@ async function resolvePageLinkTargetDetails({
     defaultComponentToken,
     subpageComponentToken
   });
+  const parentTargetId = normalizePlacementTargetId(parentHost);
+  const placementTargetId = normalizePlacementTargetId(placementTarget);
+  const preservesRelativeSubpageLinks =
+    parentHost?.isSectionSubpagesHost === true &&
+    Boolean(parentTargetId) &&
+    parentTargetId === placementTargetId;
 
   return Object.freeze({
     pageTarget: resolvedPageTarget,
@@ -693,7 +716,9 @@ async function resolvePageLinkTargetDetails({
       pageTarget: resolvedPageTarget,
       parentHost,
       placementTarget,
-      suppressImplicitRelativeLinks: resolvedComponentToken === (normalizeText(defaultComponentToken) || DEFAULT_PAGE_LINK_COMPONENT_TOKEN)
+      suppressImplicitRelativeLinks:
+        resolvedComponentToken === (normalizeText(defaultComponentToken) || DEFAULT_PAGE_LINK_COMPONENT_TOKEN) &&
+        preservesRelativeSubpageLinks !== true
     })
   });
 }

package/server/support/pageTargets.test.js

@@ -354,7 +354,7 @@ test("resolvePageLinkTargetDetails inherits a file-route parent subpages host",
 
     assert.equal(details.parentHost?.id, "contact-view:sub-pages");
     assert.equal(details.placementTarget.id, "contact-view:sub-pages");
-    assert.equal(details.componentToken, "local.main.ui.tab-link-item");
+    assert.equal(details.componentToken, "local.main.ui.surface-aware-menu-link-item");
     assert.equal(details.linkTo, "./notes");
   });
 });
@@ -422,7 +422,7 @@ test("resolvePageLinkTargetDetails inherits an index-route parent subpages host
     assert.equal(details.parentHost?.id, "customer-view:sub-pages");
     assert.equal(details.parentHost?.pageFile, "src/pages/admin/customers/[customerId]/index.vue");
     assert.equal(details.placementTarget.id, "customer-view:sub-pages");
-    assert.equal(details.componentToken, "local.main.ui.tab-link-item");
+    assert.equal(details.componentToken, "local.main.ui.surface-aware-menu-link-item");
     assert.equal(details.linkTo, "./pets");
   });
 });