@jskit-ai/kernel 0.1.32 → 0.1.34

package/shared/support/shellLayoutTargets.test.js

@@ -18,9 +18,13 @@ test("normalizeShellOutletTargetId validates host:position tokens", () => {
 test("discoverShellOutletTargetsFromVueSource resolves legal targets and one default", () => {
   const source = `
     <template>
-      <ShellOutlet host="shell-layout" position="top-left" />
-      <ShellOutlet host="shell-layout" position="primary-menu" default />
-      <ShellOutlet host="shell-layout" position="secondary-menu" />
+      <ShellOutlet target="shell-layout:top-left" />
+      <ShellOutlet
+        target="shell-layout:primary-menu"
+        default
+        default-link-component-token="local.main.ui.surface-aware-menu-link-item"
+      />
+      <ShellOutlet target="shell-layout:secondary-menu" />
     </template>
   `;
 
@@ -33,6 +37,7 @@ test("discoverShellOutletTargetsFromVueSource resolves legal targets and one def
     discovered.targets.map((entry) => entry.id),
     ["shell-layout:top-left", "shell-layout:primary-menu", "shell-layout:secondary-menu"]
   );
+  assert.equal(discovered.targets[1].defaultLinkComponentToken, "local.main.ui.surface-aware-menu-link-item");
   assert.equal(
     describeShellOutletTargets(discovered.targets),
     "shell-layout:top-left, shell-layout:primary-menu, shell-layout:secondary-menu"
@@ -46,8 +51,8 @@ test("discoverShellOutletTargetsFromVueSource resolves legal targets and one def
 test("discoverShellOutletTargetsFromVueSource throws for duplicate targets", () => {
   const source = `
     <template>
-      <ShellOutlet host="shell-layout" position="top-right" />
-      <ShellOutlet host="shell-layout" position="top-right" />
+      <ShellOutlet target="shell-layout:top-right" />
+      <ShellOutlet target="shell-layout:top-right" />
     </template>
   `;
 
@@ -60,8 +65,8 @@ test("discoverShellOutletTargetsFromVueSource throws for duplicate targets", ()
 test("discoverShellOutletTargetsFromVueSource throws for multiple defaults", () => {
   const source = `
     <template>
-      <ShellOutlet host="shell-layout" position="primary-menu" default />
-      <ShellOutlet host="shell-layout" position="secondary-menu" default />
+      <ShellOutlet target="shell-layout:primary-menu" default />
+      <ShellOutlet target="shell-layout:secondary-menu" default />
     </template>
   `;
 
@@ -74,11 +79,24 @@ test("discoverShellOutletTargetsFromVueSource throws for multiple defaults", ()
 test("discoverShellOutletTargetsFromVueSource ignores disabled default markers", () => {
   const source = `
     <template>
-      <ShellOutlet host="shell-layout" position="primary-menu" default="false" />
-      <ShellOutlet host="shell-layout" position="secondary-menu" />
+      <ShellOutlet target="shell-layout:primary-menu" default="false" />
+      <ShellOutlet target="shell-layout:secondary-menu" />
     </template>
   `;
 
   const discovered = discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" });
   assert.equal(discovered.defaultTargetId, "");
 });
+
+test("discoverShellOutletTargetsFromVueSource rejects legacy split outlet attributes", () => {
+  const source = `
+    <template>
+      <ShellOutlet target="shell-layout:primary-menu" host="other-host" position="primary-menu" />
+    </template>
+  `;
+
+  assert.throws(
+    () => discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" }),
+    /must declare ShellOutlet targets with "target" only/
+  );
+});

package/shared/support/visibility.js

@@ -49,7 +49,7 @@ function normalizeVisibilityContext(value = {}) {
     scopeKind: normalizedScopeKind,
     requiresActorScope: source.requiresActorScope === true,
     scopeOwnerId: normalizeOpaqueId(source.scopeOwnerId),
-    userOwnerId: normalizeOpaqueId(source.userOwnerId)
+    userId: normalizeOpaqueId(source.userId)
   });
 }
 

package/shared/support/visibility.test.js

@@ -19,20 +19,20 @@ test("normalizeRouteVisibilityToken normalizes visibility tokens for module-leve
 });
 
 test("normalizeVisibilityContext normalizes mode and owner identifiers", () => {
-  assert.deepEqual(normalizeVisibilityContext({ visibility: "user", userOwnerId: "7" }), {
+  assert.deepEqual(normalizeVisibilityContext({ visibility: "user", userId: "7" }), {
     visibility: "user",
     scopeKind: null,
     requiresActorScope: false,
     scopeOwnerId: null,
-    userOwnerId: "7"
+    userId: "7"
   });
 
-  assert.deepEqual(normalizeVisibilityContext({ visibility: "workspace_user", scopeOwnerId: "4", userOwnerId: 9 }), {
+  assert.deepEqual(normalizeVisibilityContext({ visibility: "workspace_user", scopeOwnerId: "4", userId: 9 }), {
     visibility: "workspace_user",
     scopeKind: null,
     requiresActorScope: false,
     scopeOwnerId: "4",
-    userOwnerId: 9
+    userId: "9"
   });
 
   assert.deepEqual(normalizeVisibilityContext({ visibility: "workspace", scopeOwnerId: "0" }), {
@@ -40,6 +40,6 @@ test("normalizeVisibilityContext normalizes mode and owner identifiers", () => {
     scopeKind: null,
     requiresActorScope: false,
     scopeOwnerId: "0",
-    userOwnerId: null
+    userId: null
   });
 });

package/shared/validators/cursorPaginationQueryValidator.js

@@ -1,14 +1,13 @@
 import { Type } from "typebox";
-import { normalizeText } from "../support/normalize.js";
 import { normalizeObjectInput } from "./inputNormalization.js";
-import { positiveIntegerValidator } from "./recordIdParamsValidator.js";
+import { positiveIntegerValidator, recordIdInputSchema, recordIdValidator } from "./recordIdParamsValidator.js";
 
 function normalizeCursorPaginationQuery(input = {}) {
   const source = normalizeObjectInput(input);
   const normalized = {};
 
   if (Object.hasOwn(source, "cursor")) {
-    normalized.cursor = normalizeText(source.cursor);
+    normalized.cursor = recordIdValidator.normalize(source.cursor);
   }
 
   if (Object.hasOwn(source, "limit")) {
@@ -21,7 +20,7 @@ function normalizeCursorPaginationQuery(input = {}) {
 const cursorPaginationQueryValidator = Object.freeze({
   schema: Type.Object(
     {
-      cursor: Type.Optional(positiveIntegerValidator.schema),
+      cursor: Type.Optional(recordIdInputSchema),
       limit: Type.Optional(positiveIntegerValidator.schema)
     },
     { additionalProperties: false }

package/shared/validators/cursorPaginationQueryValidator.test.js

@@ -11,9 +11,8 @@ test("cursorPaginationQueryValidator normalizes numeric strings as cursor text",
 
 test("cursorPaginationQueryValidator schema rejects opaque cursor strings", () => {
   assert.equal(
-    cursorPaginationQueryValidator.schema.properties.cursor.anyOf.some(
-      (entry) => entry.type === "string" && entry.pattern === "^[1-9][0-9]*$"
-    ),
+    cursorPaginationQueryValidator.schema.properties.cursor.type === "string" &&
+      cursorPaginationQueryValidator.schema.properties.cursor.pattern === "^[1-9][0-9]*$",
     true
   );
 });

package/shared/validators/index.js

@@ -8,7 +8,17 @@ export {
 export { mergeObjectSchemas } from "./mergeObjectSchemas.js";
 export { mergeValidators } from "./mergeValidators.js";
 export { nestValidator } from "./nestValidator.js";
-export { recordIdParamsValidator, positiveIntegerValidator } from "./recordIdParamsValidator.js";
+export {
+  RECORD_ID_PATTERN,
+  recordIdSchema,
+  recordIdInputSchema,
+  nullableRecordIdSchema,
+  nullableRecordIdInputSchema,
+  recordIdValidator,
+  nullableRecordIdValidator,
+  recordIdParamsValidator,
+  positiveIntegerValidator
+} from "./recordIdParamsValidator.js";
 export { normalizeSettingsFieldInput, normalizeSettingsFieldOutput } from "./settingsFieldNormalization.js";
 export {
   normalizeRequiredFieldList,

package/shared/validators/recordIdParamsValidator.js

@@ -1,23 +1,51 @@
 import { Type } from "typebox";
 import { normalizeObjectInput } from "./inputNormalization.js";
-import { normalizePositiveInteger, normalizeText } from "../support/normalize.js";
+import { normalizePositiveInteger, normalizeRecordId } from "../support/normalize.js";
 
-function normalizeRecordId(value) {
-  return normalizePositiveInteger(normalizeText(value));
-}
+const RECORD_ID_PATTERN = "^[1-9][0-9]*$";
+
+const recordIdSchema = Type.String({
+  minLength: 1,
+  pattern: RECORD_ID_PATTERN
+});
+
+const recordIdInputSchema = recordIdSchema;
+
+const nullableRecordIdSchema = Type.Union([recordIdSchema, Type.Null()]);
+const nullableRecordIdInputSchema = Type.Union([recordIdInputSchema, Type.Null()]);
 
 const positiveIntegerValidator = Object.freeze({
   schema: Type.Union([
     Type.Integer({ minimum: 1 }),
-    Type.String({ minLength: 1, pattern: "^[1-9][0-9]*$" })
+    Type.String({ minLength: 1, pattern: RECORD_ID_PATTERN })
   ]),
-  normalize: normalizeRecordId
+  normalize(value) {
+    return normalizePositiveInteger(value);
+  }
+});
+
+const recordIdValidator = Object.freeze({
+  schema: recordIdInputSchema,
+  normalize(value) {
+    return normalizeRecordId(value, {
+      fallback: ""
+    });
+  }
+});
+
+const nullableRecordIdValidator = Object.freeze({
+  schema: nullableRecordIdInputSchema,
+  normalize(value) {
+    return normalizeRecordId(value, {
+      fallback: null
+    });
+  }
 });
 
 const recordIdParamsValidator = Object.freeze({
   schema: Type.Object(
     {
-      recordId: Type.Optional(positiveIntegerValidator.schema)
+      recordId: Type.Optional(recordIdInputSchema)
     },
     { additionalProperties: false }
   ),
@@ -26,11 +54,21 @@ const recordIdParamsValidator = Object.freeze({
     const normalized = {};
 
     if (Object.hasOwn(source, "recordId")) {
-      normalized.recordId = normalizeRecordId(source.recordId);
+      normalized.recordId = recordIdValidator.normalize(source.recordId);
     }
 
     return normalized;
   }
 });
 
-export { recordIdParamsValidator, positiveIntegerValidator };
+export {
+  RECORD_ID_PATTERN,
+  recordIdSchema,
+  recordIdInputSchema,
+  nullableRecordIdSchema,
+  nullableRecordIdInputSchema,
+  recordIdValidator,
+  nullableRecordIdValidator,
+  recordIdParamsValidator,
+  positiveIntegerValidator
+};

package/shared/validators/recordIdParamsValidator.test.js

@@ -3,15 +3,18 @@ import assert from "node:assert/strict";
 
 import { recordIdParamsValidator } from "./recordIdParamsValidator.js";
 
-test("recordIdParamsValidator normalizes string id to positive integer", () => {
+test("recordIdParamsValidator normalizes canonical string ids", () => {
   assert.deepEqual(recordIdParamsValidator.normalize({ recordId: "42" }), {
-    recordId: 42
+    recordId: "42"
   });
 });
 
-test("recordIdParamsValidator normalizes invalid id to 0", () => {
+test("recordIdParamsValidator rejects invalid ids", () => {
   assert.deepEqual(recordIdParamsValidator.normalize({ recordId: "nope" }), {
-    recordId: 0
+    recordId: ""
+  });
+  assert.deepEqual(recordIdParamsValidator.normalize({ recordId: 42 }), {
+    recordId: ""
   });
 });
 

package/README.md

@@ -1,24 +0,0 @@
-# kernel
-
-Internal JSKIT framework runtime package.
-
-This package contains the merged runtime internals:
-- container
-- kernel
-- http fastify bridge
-- server runtime primitives
-- support primitives
-- surface routing primitives
-- platform runtime bootstrap
-
-## Historical note
-
-kernel was assembled moving code from these legacy packages and then deleting them:
-
-  - @jskit-ai/container-core
-  - @jskit-ai/http-fastify-core
-  - @jskit-ai/kernel
-  - @jskit-ai/platform-server-runtime
-  - @jskit-ai/server-runtime-core
-  - @jskit-ai/support-core
-  - @jskit-ai/surface-routing