@jskit-ai/kernel 0.1.17 → 0.1.19

package/client/moduleBootstrap.js

@@ -4,14 +4,6 @@ import { isRecord } from "../shared/support/normalize.js";
 import { normalizeDescriptorClientProviders, normalizeDescriptorUiRoutes } from "./descriptorSections.js";
 import { createStructuredLogger, summarizeRouterRoutes } from "./logging.js";
 
-const CLIENT_MODULE_RUNTIME_APP_TOKEN = Symbol.for("jskit.client.runtime.app");
-const CLIENT_MODULE_ROUTER_TOKEN = Symbol.for("jskit.client.router");
-const CLIENT_MODULE_VUE_APP_TOKEN = Symbol.for("jskit.client.vue.app");
-const CLIENT_MODULE_ENV_TOKEN = Symbol.for("jskit.client.env");
-const CLIENT_MODULE_SURFACE_RUNTIME_TOKEN = Symbol.for("jskit.client.surface.runtime");
-const CLIENT_MODULE_SURFACE_MODE_TOKEN = Symbol.for("jskit.client.surface.mode");
-const CLIENT_MODULE_LOGGER_TOKEN = Symbol.for("jskit.client.logger");
-
 function normalizePackageId(value) {
   return String(value || "").trim();
 }
@@ -501,13 +493,13 @@ function createClientRuntimeApp({
     strict: true
   });
 
-  runtimeApp.instance(CLIENT_MODULE_RUNTIME_APP_TOKEN, runtimeApp);
-  runtimeApp.instance(CLIENT_MODULE_ROUTER_TOKEN, router || null);
-  runtimeApp.instance(CLIENT_MODULE_VUE_APP_TOKEN, app || null);
-  runtimeApp.instance(CLIENT_MODULE_ENV_TOKEN, isRecord(env) ? { ...env } : {});
-  runtimeApp.instance(CLIENT_MODULE_SURFACE_RUNTIME_TOKEN, surfaceRuntime || null);
-  runtimeApp.instance(CLIENT_MODULE_SURFACE_MODE_TOKEN, String(surfaceMode || "").trim());
-  runtimeApp.instance(CLIENT_MODULE_LOGGER_TOKEN, logger);
+  runtimeApp.instance("jskit.client.runtime.app", runtimeApp);
+  runtimeApp.instance("jskit.client.router", router || null);
+  runtimeApp.instance("jskit.client.vue.app", app || null);
+  runtimeApp.instance("jskit.client.env", isRecord(env) ? { ...env } : {});
+  runtimeApp.instance("jskit.client.surface.runtime", surfaceRuntime || null);
+  runtimeApp.instance("jskit.client.surface.mode", String(surfaceMode || "").trim());
+  runtimeApp.instance("jskit.client.logger", logger);
 
   return runtimeApp;
 }
@@ -661,10 +653,4 @@ async function bootClientModules({
   });
 }
 
-export {
-  CLIENT_MODULE_ROUTER_TOKEN,
-  CLIENT_MODULE_VUE_APP_TOKEN,
-  CLIENT_MODULE_ENV_TOKEN,
-  CLIENT_MODULE_SURFACE_RUNTIME_TOKEN,
-  bootClientModules
-};
+export { bootClientModules };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/kernel",
-  "version": "0.1.17",
+  "version": "0.1.19",
   "type": "module",
   "dependencies": {
     "typebox": "^1.0.81"
@@ -30,6 +30,7 @@
     "./shared/validators": "./shared/validators/index.js",
     "./shared/validators/inputNormalization": "./shared/validators/inputNormalization.js",
     "./shared/support": "./shared/support/index.js",
+    "./shared/support/stringCase": "./shared/support/stringCase.js",
     "./shared/support/tokens": "./shared/support/tokens.js",
     "./shared/support/normalize": "./shared/support/normalize.js",
     "./shared/support/permissions": "./shared/support/permissions.js",

package/server/actions/ActionRuntimeServiceProvider.js

@@ -4,8 +4,8 @@ import { createNoopIdempotencyAdapter } from "../../shared/actions/idempotency.j
 import { createNoopObservabilityAdapter } from "../../shared/actions/observability.js";
 import { createActionRegistry } from "../../shared/actions/registry.js";
 import { createSurfaceRuntime } from "../../shared/surface/runtime.js";
+import { isContainerToken } from "../../shared/support/containerToken.js";
 import { normalizeObject } from "../../shared/support/normalize.js";
-import { KERNEL_TOKENS, isContainerToken } from "../../shared/support/tokens.js";
 import { installServiceRegistrationApi } from "../registries/serviceRegistrationRegistry.js";
 import {
   ensureActionSurfaceSourceRegistry,
@@ -24,9 +24,6 @@ const ACTION_RUNTIME_API = Object.freeze({
   createNoopAuditAdapter,
   createNoopObservabilityAdapter
 });
-const ACTION_RUNTIME_CONTRIBUTOR_TAG = Symbol.for("jskit.runtime.actions.contributors");
-const ACTION_CONTEXT_CONTRIBUTOR_TAG = Symbol.for("jskit.runtime.actions.contextContributors");
-const LOGGER_TOKEN = Symbol.for("jskit.logger");
 let ACTION_RUNTIME_CONTRIBUTOR_INDEX = 0;
 
 function createSurfaceRuntimeFromAppConfig(scope) {
@@ -36,7 +33,7 @@ function createSurfaceRuntimeFromAppConfig(scope) {
 
   if (!scope.has("appConfig")) {
     throw new Error(
-      "ActionRuntimeServiceProvider requires appConfig.surfaceDefinitions when KERNEL_TOKENS.SurfaceRuntime is not registered."
+      "ActionRuntimeServiceProvider requires appConfig.surfaceDefinitions when jskit.surface.runtime is not registered."
     );
   }
 
@@ -44,7 +41,7 @@ function createSurfaceRuntimeFromAppConfig(scope) {
   const surfaceDefinitions = normalizeObject(appConfig.surfaceDefinitions);
   if (Object.keys(surfaceDefinitions).length < 1) {
     throw new Error(
-      "ActionRuntimeServiceProvider requires appConfig.surfaceDefinitions when KERNEL_TOKENS.SurfaceRuntime is not registered."
+      "ActionRuntimeServiceProvider requires appConfig.surfaceDefinitions when jskit.surface.runtime is not registered."
     );
   }
 
@@ -74,13 +71,13 @@ function normalizeDependencyMap(value, { context = "action dependencies" } = {})
 }
 
 function resolveActionContributors(scope) {
-  return resolveRegistryTaggedEntries(scope, ACTION_RUNTIME_CONTRIBUTOR_TAG).filter(
+  return resolveRegistryTaggedEntries(scope, "jskit.runtime.actions.contributors").filter(
     (entry) => entry && typeof entry === "object" && !Array.isArray(entry)
   );
 }
 
 function resolveActionContextContributors(scope) {
-  return resolveRegistryTaggedEntries(scope, ACTION_CONTEXT_CONTRIBUTOR_TAG)
+  return resolveRegistryTaggedEntries(scope, "jskit.runtime.actions.contextContributors")
     .map((entry) => normalizeContributorEntry(entry))
     .filter(Boolean);
 }
@@ -187,7 +184,7 @@ function registerActionDefinition(app, actionSpec, { context = "app.action" } =
         actions: Object.freeze([action])
       };
     },
-    ACTION_RUNTIME_CONTRIBUTOR_TAG,
+    "jskit.runtime.actions.contributors",
     { context }
   );
 }
@@ -256,7 +253,7 @@ function registerActionContextContributor(app, token, factory) {
     app,
     token,
     factory,
-    ACTION_CONTEXT_CONTRIBUTOR_TAG,
+    "jskit.runtime.actions.contextContributors",
     { context: "registerActionContextContributor" }
   );
 }
@@ -273,8 +270,8 @@ class ActionRuntimeServiceProvider {
     ensureActionSurfaceSourceRegistry(app);
     installServiceRegistrationApi(app);
 
-    if (!app.has(KERNEL_TOKENS.SurfaceRuntime)) {
-      app.singleton(KERNEL_TOKENS.SurfaceRuntime, (scope) => createSurfaceRuntimeFromAppConfig(scope));
+    if (!app.has("jskit.surface.runtime")) {
+      app.singleton("jskit.surface.runtime", (scope) => createSurfaceRuntimeFromAppConfig(scope));
     }
 
     app.singleton("runtime.actions", () => ACTION_RUNTIME_API);
@@ -286,7 +283,7 @@ class ActionRuntimeServiceProvider {
           idempotencyAdapter: createNoopIdempotencyAdapter(),
           auditAdapter: createNoopAuditAdapter(),
           observabilityAdapter: createNoopObservabilityAdapter(),
-          logger: scope.has(LOGGER_TOKEN) ? scope.make(LOGGER_TOKEN) : console
+          logger: scope.has("jskit.logger") ? scope.make("jskit.logger") : console
         });
       });
     }
@@ -300,8 +297,6 @@ class ActionRuntimeServiceProvider {
 }
 
 export {
-  ACTION_RUNTIME_CONTRIBUTOR_TAG,
-  ACTION_CONTEXT_CONTRIBUTOR_TAG,
   resolveActionContributors,
   resolveActionContextContributors,
   registerActionContextContributor,

package/server/actions/ActionRuntimeServiceProvider.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import {
   EMPTY_INPUT_VALIDATOR,
   OBJECT_INPUT_VALIDATOR
@@ -71,7 +70,7 @@ test("ActionRuntimeServiceProvider registers runtime actions api and action exec
   assert.equal(app.singletons.has("runtime.actions"), true);
   assert.equal(app.singletons.has("actionRegistry"), true);
   assert.equal(app.singletons.has("actionExecutor"), true);
-  assert.equal(app.singletons.has(KERNEL_TOKENS.SurfaceRuntime), true);
+  assert.equal(app.singletons.has("jskit.surface.runtime"), true);
   assert.equal(typeof app.action, "function");
   assert.equal(typeof app.actions, "function");
   assert.equal(typeof app.actionSurfaceSource, "function");
@@ -87,7 +86,7 @@ test("ActionRuntimeServiceProvider materializes dependencies and surfaces for ap
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
 
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["app", "admin", "console"];
     }
@@ -175,7 +174,7 @@ test("ActionRuntimeServiceProvider materializes custom surfacesFrom aliases regi
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
 
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["home", "app", "admin", "console"];
     }
@@ -247,7 +246,7 @@ test("app.actions + resolveActionContributors provide canonical contributor wiri
   const app = createSingletonApp();
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["app", "admin", "console"];
     }
@@ -300,7 +299,7 @@ test("action runtime execute merges static and per-execution dependencies", asyn
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
 
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["app"];
     }
@@ -421,7 +420,7 @@ test("EMPTY_INPUT_VALIDATOR allows empty input and rejects unexpected fields", a
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
 
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["app"];
     }
@@ -520,7 +519,7 @@ test("app.actions rejects unsupported surfacesFrom aliases", () => {
   const provider = new ActionRuntimeServiceProvider();
   provider.register(app);
 
-  app.singleton(KERNEL_TOKENS.SurfaceRuntime, () => ({
+  app.singleton("jskit.surface.runtime", () => ({
     listEnabledSurfaceIds() {
       return ["app", "admin"];
     }

package/server/actions/index.js

@@ -1,6 +1,4 @@
 export {
-  ACTION_RUNTIME_CONTRIBUTOR_TAG,
-  ACTION_CONTEXT_CONTRIBUTOR_TAG,
   resolveActionContributors,
   resolveActionContextContributors,
   registerActionContextContributor,

package/server/http/lib/httpRuntime.js

@@ -1,4 +1,3 @@
-import { KERNEL_TOKENS } from "../../../shared/support/tokens.js";
 import { normalizeObject } from "../../../shared/support/normalize.js";
 import { ensureApiErrorHandling } from "../../runtime/fastifyBootstrap.js";
 import { resolveDefaultSurfaceId } from "../../support/appConfig.js";
@@ -13,8 +12,8 @@ function registerHttpRuntime(app, options = {}) {
 
   const runtimeOptions = normalizeObject(options);
   const {
-    fastifyToken = KERNEL_TOKENS.Fastify,
-    routerToken = KERNEL_TOKENS.HttpRouter,
+    fastifyToken = "jskit.fastify",
+    routerToken = "jskit.http.router",
     autoRegisterApiErrorHandling = true,
     apiErrorHandling = {},
     ...routeRegistrationOptions
@@ -55,13 +54,13 @@ function createHttpRuntime(
   }
 
   const runtimeRouter = router || createRouter();
-  app.singleton(KERNEL_TOKENS.HttpRouter, () => runtimeRouter);
+  app.singleton("jskit.http.router", () => runtimeRouter);
 
   if (fastify) {
-    app.instance(KERNEL_TOKENS.Fastify, fastify);
+    app.instance("jskit.fastify", fastify);
     if (autoRegisterApiErrorHandling !== false) {
       ensureApiErrorHandling(app, {
-        fastifyToken: KERNEL_TOKENS.Fastify,
+        fastifyToken: "jskit.fastify",
         ...normalizeObject(apiErrorHandling)
       });
     }

package/server/http/lib/index.js

@@ -11,7 +11,6 @@ export {
   createHttpRuntime
 } from "./kernel.js";
 export {
-  ROUTE_VISIBILITY_RESOLVER_TAG,
   resolveRouteVisibilityResolvers,
   registerRouteVisibilityResolver,
   resolveRouteVisibilityContext

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

@@ -1,7 +1,5 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-
-import { KERNEL_TOKENS } from "../../../shared/support/tokens.js";
 import { registerActionContextContributor } from "../../actions/ActionRuntimeServiceProvider.js";
 import { createApplication } from "../../kernel/index.js";
 import { createRouter } from "./router.js";
@@ -59,16 +57,16 @@ test("registerRoutes attaches request scope and request context tokens", async (
         path: "/scope-check",
         middleware: [
           (request) => {
-            observed.middlewareRequest = request.scope.make(KERNEL_TOKENS.Request);
-            observed.middlewareReply = request.scope.make(KERNEL_TOKENS.Reply);
-            observed.middlewareRequestId = request.scope.make(KERNEL_TOKENS.RequestId);
-            observed.middlewareScope = request.scope.make(KERNEL_TOKENS.RequestScope);
+            observed.middlewareRequest = request.scope.make("jskit.http.request");
+            observed.middlewareReply = request.scope.make("jskit.http.reply");
+            observed.middlewareRequestId = request.scope.make("jskit.http.requestId");
+            observed.middlewareScope = request.scope.make("jskit.http.requestScope");
           }
         ],
         handler: async (request, reply) => {
           observed.handlerScope = request.scope;
-          observed.handlerRequest = request.scope.make(KERNEL_TOKENS.Request);
-          observed.handlerRequestId = request.scope.make(KERNEL_TOKENS.RequestId);
+          observed.handlerRequest = request.scope.make("jskit.http.request");
+          observed.handlerRequestId = request.scope.make("jskit.http.requestId");
           reply.code(200).send({ ok: true });
         }
       }
@@ -441,7 +439,7 @@ test("registerRoutes supports custom request scope property and requestId resolv
           assert.equal(Boolean(request.scope), false);
           assert.equal(Boolean(request.requestScope), true);
           assert.equal(request.requestScope.scopeId, "request:r-42");
-          assert.equal(request.requestScope.make(KERNEL_TOKENS.RequestId), "r-42");
+          assert.equal(request.requestScope.make("jskit.http.requestId"), "r-42");
           reply.code(200).send({ ok: true });
         }
       }
@@ -467,12 +465,12 @@ test("registerHttpRuntime passes app context so request scope is available", asy
   const router = createRouter();
 
   router.get("/runtime-scope", async (request, reply) => {
-    const requestId = request.scope.make(KERNEL_TOKENS.RequestId);
+    const requestId = request.scope.make("jskit.http.requestId");
     reply.code(200).send({ requestId });
   });
 
-  app.instance(KERNEL_TOKENS.Fastify, fastify);
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.fastify", fastify);
+  app.instance("jskit.http.router", router);
 
   const registration = registerHttpRuntime(app);
   assert.equal(registration.routeCount, 1);
@@ -492,8 +490,8 @@ test("registerHttpRuntime installs API error handling once by default", () => {
   const fastify = createFastifyStub();
   const router = createRouter();
 
-  app.instance(KERNEL_TOKENS.Fastify, fastify);
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.fastify", fastify);
+  app.instance("jskit.http.router", router);
 
   registerHttpRuntime(app);
   registerHttpRuntime(app);
@@ -507,8 +505,8 @@ test("registerHttpRuntime can disable automatic API error handling", () => {
   const fastify = createFastifyStub();
   const router = createRouter();
 
-  app.instance(KERNEL_TOKENS.Fastify, fastify);
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.fastify", fastify);
+  app.instance("jskit.http.router", router);
 
   registerHttpRuntime(app, {
     autoRegisterApiErrorHandling: false
@@ -530,8 +528,8 @@ test("registerHttpRuntime resolves request action default surface from appConfig
     reply.code(200).send({ ok: true });
   });
 
-  app.instance(KERNEL_TOKENS.Fastify, fastify);
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.fastify", fastify);
+  app.instance("jskit.http.router", router);
   app.instance("appConfig", {
     surfaceDefaultId: "home"
   });
@@ -621,8 +619,8 @@ test("registerHttpRuntime forwards middleware alias/group config to route execut
     }
   );
 
-  app.instance(KERNEL_TOKENS.Fastify, fastify);
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.fastify", fastify);
+  app.instance("jskit.http.router", router);
 
   registerHttpRuntime(app, {
     middleware: {

package/server/http/lib/requestScope.js

@@ -1,5 +1,3 @@
-import { KERNEL_TOKENS } from "../../../shared/support/tokens.js";
-
 function resolveRequestRuntimeId({ request = null, requestIdResolver = null } = {}) {
   if (typeof requestIdResolver === "function") {
     const resolvedByResolver = String(requestIdResolver(request) || "").trim();
@@ -44,10 +42,10 @@ function attachRequestScope({
     return null;
   }
 
-  scope.instance(KERNEL_TOKENS.Request, request);
-  scope.instance(KERNEL_TOKENS.Reply, reply);
-  scope.instance(KERNEL_TOKENS.RequestId, runtimeRequestId);
-  scope.instance(KERNEL_TOKENS.RequestScope, scope);
+  scope.instance("jskit.http.request", request);
+  scope.instance("jskit.http.reply", reply);
+  scope.instance("jskit.http.requestId", runtimeRequestId);
+  scope.instance("jskit.http.requestScope", scope);
 
   if (request && typeof request === "object") {
     request[normalizeRequestScopeProperty(requestScopeProperty)] = scope;

package/server/http/lib/routeValidator.js

@@ -3,7 +3,7 @@ import { mergeValidators } from "../../../shared/validators/mergeValidators.js";
 import { RouteDefinitionError } from "./errors.js";
 import { resolveRouteLabel } from "./routeSupport.js";
 
-const ROUTE_VALIDATOR_SYMBOL = Symbol.for("@jskit-ai/kernel/http/routeValidator");
+const ROUTE_VALIDATOR_SYMBOL = "@jskit-ai/kernel/http/routeValidator";
 const VALIDATOR_OPTION_KEYS = Object.freeze([
   "meta",
   "bodyValidator",

package/server/http/lib/router.js

@@ -1,4 +1,4 @@
-import { ensureNonEmptyText, normalizeArray, normalizeObject, normalizeText } from "../../../shared/support/normalize.js";
+import { ensureNonEmptyText, normalizeObject, normalizeText } from "../../../shared/support/normalize.js";
 import { RouteDefinitionError } from "./errors.js";
 import { resolveRouteValidatorOptions } from "./routeValidator.js";
 import { normalizeMiddlewareStack as normalizeSharedMiddlewareStack } from "./routeSupport.js";

package/server/platform/providerRuntime.js

@@ -2,7 +2,6 @@ import { ActionRuntimeServiceProvider } from "../actions/ActionRuntimeServicePro
 import { ServerRuntimeCoreServiceProvider } from "../runtime/ServerRuntimeCoreServiceProvider.js";
 import { createApplication } from "../kernel/index.js";
 import { createHttpRuntime } from "../http/lib/kernel.js";
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import { readLockFromApp } from "./providerRuntime/lockfile.js";
 import {
   collectGlobalUiPaths,
@@ -27,8 +26,8 @@ async function createProviderRuntimeApp({
     profile
   });
 
-  app.instance(KERNEL_TOKENS.Env, env && typeof env === "object" ? { ...env } : {});
-  app.instance(KERNEL_TOKENS.Logger, logger || console);
+  app.instance("jskit.env", env && typeof env === "object" ? { ...env } : {});
+  app.instance("jskit.logger", logger || console);
 
   let httpRuntime = null;
   if (fastify && typeof fastify.route === "function") {

package/server/registries/actionSurfaceSourceRegistry.js

@@ -1,7 +1,5 @@
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import { assertTaggableApp } from "./primitives.js";
 
-const ACTION_SURFACE_SOURCE_REGISTRY_TOKEN = Symbol.for("jskit.runtime.actions.surfaceSourceRegistry");
 const ACTION_SURFACE_SOURCE_NAME_PATTERN = /^[a-z][a-z0-9_.-]*$/;
 
 function normalizeSurfaceIdValue(value) {
@@ -22,11 +20,11 @@ function resolveSurfaceRuntime(scope) {
     throw new Error("Action definition materialization requires scope.has()/make().");
   }
 
-  if (!scope.has(KERNEL_TOKENS.SurfaceRuntime)) {
-    throw new Error("Action definition surfacesFrom requires KERNEL_TOKENS.SurfaceRuntime.");
+  if (!scope.has("jskit.surface.runtime")) {
+    throw new Error("Action definition surfacesFrom requires jskit.surface.runtime.");
   }
 
-  return scope.make(KERNEL_TOKENS.SurfaceRuntime);
+  return scope.make("jskit.surface.runtime");
 }
 
 function resolveEnabledSurfaceIds(surfaceRuntime) {
@@ -104,10 +102,10 @@ function resolveActionSurfaceSourceRegistry(scope) {
   if (!scope || typeof scope.has !== "function" || typeof scope.make !== "function") {
     throw new Error("Action surface source resolution requires scope.has()/make().");
   }
-  if (!scope.has(ACTION_SURFACE_SOURCE_REGISTRY_TOKEN)) {
+  if (!scope.has("jskit.runtime.actions.surfaceSourceRegistry")) {
     throw new Error("Action surface source registry is not registered.");
   }
-  return scope.make(ACTION_SURFACE_SOURCE_REGISTRY_TOKEN);
+  return scope.make("jskit.runtime.actions.surfaceSourceRegistry");
 }
 
 function resolveActionSurfaceSourceIds(scope, sourceName, { context = "action.surfacesFrom" } = {}) {
@@ -141,8 +139,8 @@ function ensureActionSurfaceSourceRegistry(app) {
     throw new Error("ensureActionSurfaceSourceRegistry requires app.has().");
   }
 
-  if (!app.has(ACTION_SURFACE_SOURCE_REGISTRY_TOKEN)) {
-    app.singleton(ACTION_SURFACE_SOURCE_REGISTRY_TOKEN, () => createActionSurfaceSourceRegistry());
+  if (!app.has("jskit.runtime.actions.surfaceSourceRegistry")) {
+    app.singleton("jskit.runtime.actions.surfaceSourceRegistry", () => createActionSurfaceSourceRegistry());
   }
   installActionSurfaceSourceRegistrationApi(app);
 }

package/server/registries/bootstrapPayloadContributorRegistry.js

@@ -1,16 +1,14 @@
 import { normalizeObject } from "../../shared/support/normalize.js";
 import { normalizeContributorEntry, registerTaggedSingleton, resolveTaggedEntries } from "./primitives.js";
 
-const BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TAG = Symbol.for("jskit.runtime.bootstrap.payloadContributors");
-
 function registerBootstrapPayloadContributor(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TAG, {
+  registerTaggedSingleton(app, token, factory, "jskit.runtime.bootstrap.payloadContributors", {
     context: "registerBootstrapPayloadContributor"
   });
 }
 
 function resolveBootstrapPayloadContributors(scope) {
-  return resolveTaggedEntries(scope, BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TAG)
+  return resolveTaggedEntries(scope, "jskit.runtime.bootstrap.payloadContributors")
     .map((entry) => normalizeContributorEntry(entry))
     .filter(Boolean);
 }
@@ -34,7 +32,6 @@ async function resolveBootstrapPayload(scope, context = {}) {
 }
 
 export {
-  BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TAG,
   registerBootstrapPayloadContributor,
   resolveBootstrapPayloadContributors,
   resolveBootstrapPayload

package/server/registries/domainEventListenerRegistry.js

@@ -1,8 +1,6 @@
 import { normalizeObject } from "../../shared/support/normalize.js";
 import { registerTaggedSingleton, resolveTaggedEntries } from "./primitives.js";
 
-const DOMAIN_EVENT_LISTENER_TAG = Symbol.for("jskit.runtime.domainEvent.listeners");
-
 function normalizeDomainEventListener(entry) {
   if (typeof entry === "function") {
     return {
@@ -24,13 +22,13 @@ function normalizeDomainEventListener(entry) {
 }
 
 function registerDomainEventListener(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, DOMAIN_EVENT_LISTENER_TAG, {
+  registerTaggedSingleton(app, token, factory, "jskit.runtime.domainEvent.listeners", {
     context: "registerDomainEventListener"
   });
 }
 
 function resolveDomainEventListeners(scope) {
-  return resolveTaggedEntries(scope, DOMAIN_EVENT_LISTENER_TAG)
+  return resolveTaggedEntries(scope, "jskit.runtime.domainEvent.listeners")
     .map((entry) => normalizeDomainEventListener(entry))
     .filter(Boolean);
 }
@@ -54,7 +52,6 @@ function createDomainEvents(scope) {
 }
 
 export {
-  DOMAIN_EVENT_LISTENER_TAG,
   registerDomainEventListener,
   resolveDomainEventListeners,
   createDomainEvents

package/server/registries/index.js

@@ -1,17 +1,14 @@
 export {
-  BOOTSTRAP_PAYLOAD_CONTRIBUTOR_TAG,
   registerBootstrapPayloadContributor,
   resolveBootstrapPayloadContributors,
   resolveBootstrapPayload
 } from "./bootstrapPayloadContributorRegistry.js";
 export {
-  DOMAIN_EVENT_LISTENER_TAG,
   registerDomainEventListener,
   resolveDomainEventListeners,
   createDomainEvents
 } from "./domainEventListenerRegistry.js";
 export {
-  SERVICE_REGISTRATION_TAG,
   normalizeServiceRegistration,
   materializeServiceRegistration,
   registerServiceRegistration,
@@ -19,7 +16,6 @@ export {
   installServiceRegistrationApi
 } from "./serviceRegistrationRegistry.js";
 export {
-  ROUTE_VISIBILITY_RESOLVER_TAG,
   resolveRouteVisibilityResolvers,
   registerRouteVisibilityResolver,
   resolveRouteVisibilityContext

package/server/registries/routeVisibilityResolverRegistry.js

@@ -4,8 +4,6 @@ import { ROUTE_VISIBILITY_PUBLIC } from "../../shared/support/policies.js";
 import { RouteRegistrationError } from "../http/lib/errors.js";
 import { registerTaggedSingleton, resolveTaggedEntries } from "./primitives.js";
 
-const ROUTE_VISIBILITY_RESOLVER_TAG = Symbol.for("jskit.runtime.http.visibilityResolvers");
-
 function normalizeRouteVisibilityResolver(entry) {
   if (typeof entry === "function") {
     return {
@@ -25,13 +23,13 @@ function normalizeRouteVisibilityResolver(entry) {
 }
 
 function resolveRouteVisibilityResolvers(scope) {
-  return resolveTaggedEntries(scope, ROUTE_VISIBILITY_RESOLVER_TAG)
+  return resolveTaggedEntries(scope, "jskit.runtime.http.visibilityResolvers")
     .map((entry) => normalizeRouteVisibilityResolver(entry))
     .filter(Boolean);
 }
 
 function registerRouteVisibilityResolver(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, ROUTE_VISIBILITY_RESOLVER_TAG, {
+  registerTaggedSingleton(app, token, factory, "jskit.runtime.http.visibilityResolvers", {
     context: "registerRouteVisibilityResolver",
     ErrorType: RouteRegistrationError
   });
@@ -80,7 +78,6 @@ async function resolveRouteVisibilityContext({
 }
 
 export {
-  ROUTE_VISIBILITY_RESOLVER_TAG,
   resolveRouteVisibilityResolvers,
   registerRouteVisibilityResolver,
   resolveRouteVisibilityContext

package/server/registries/serviceRegistrationRegistry.js

@@ -1,5 +1,5 @@
 import { normalizeObject, normalizePositiveInteger, normalizeText } from "../../shared/support/normalize.js";
-import { isContainerToken } from "../../shared/support/tokens.js";
+import { isContainerToken } from "../../shared/support/containerToken.js";
 import { createEntityChangePublisher } from "../runtime/entityChangeEvents.js";
 import {
   assertTaggableApp,
@@ -8,8 +8,6 @@ import {
   resolveTaggedEntries
 } from "./primitives.js";
 
-const SERVICE_REGISTRATION_TAG = Symbol.for("jskit.runtime.services.registrations");
-const ENTITY_CHANGED_EVENT_TYPE = "entity.changed";
 const DEFAULT_REALTIME_AUDIENCE = "event_scope";
 let SERVICE_REGISTRATION_INDEX = 0;
 
@@ -28,8 +26,8 @@ function createServiceRegistrationToken() {
 
 function normalizeServiceEventType(value, { context = "service event" } = {}) {
   const normalizedType = normalizeText(value).toLowerCase();
-  if (normalizedType !== ENTITY_CHANGED_EVENT_TYPE) {
-    throw new TypeError(`${context}.type must be "${ENTITY_CHANGED_EVENT_TYPE}".`);
+  if (normalizedType !== "entity.changed") {
+    throw new TypeError(`${context}.type must be "entity.changed".`);
   }
   return normalizedType;
 }
@@ -173,7 +171,7 @@ function normalizeServiceEventsForDefinition(serviceDefinition, serviceMetadata)
     for (const [index, entry] of normalizedEntries.entries()) {
       if (!entry.source || !entry.entity) {
         throw new TypeError(
-          `service metadata.events.${methodName}[${index}] requires source and entity for "${ENTITY_CHANGED_EVENT_TYPE}".`
+          `service metadata.events.${methodName}[${index}] requires source and entity for "entity.changed".`
         );
       }
     }
@@ -374,13 +372,13 @@ function normalizeServiceRegistration(value = {}) {
 }
 
 function registerServiceRegistration(app, token, factory) {
-  registerTaggedSingleton(app, token, factory, SERVICE_REGISTRATION_TAG, {
+  registerTaggedSingleton(app, token, factory, "jskit.runtime.services.registrations", {
     context: "registerServiceRegistration"
   });
 }
 
 function resolveServiceRegistrations(scope) {
-  return resolveTaggedEntries(scope, SERVICE_REGISTRATION_TAG)
+  return resolveTaggedEntries(scope, "jskit.runtime.services.registrations")
     .map((entry) => normalizeObject(entry))
     .filter((entry) => Object.keys(entry).length > 0)
     .sort((left, right) => String(left.serviceToken || "").localeCompare(String(right.serviceToken || "")));
@@ -422,7 +420,6 @@ function installServiceRegistrationApi(app) {
 }
 
 export {
-  SERVICE_REGISTRATION_TAG,
   normalizeServiceRegistration,
   materializeServiceRegistration,
   registerServiceRegistration,

package/server/runtime/ServerRuntimeCoreServiceProvider.js

@@ -17,7 +17,6 @@ import * as serviceAuthorization from "./serviceAuthorization.js";
 import * as serviceRegistration from "../registries/serviceRegistrationRegistry.js";
 import * as entityChangeEvents from "./entityChangeEvents.js";
 import * as securityAudit from "./securityAudit.js";
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 
 const SERVER_RUNTIME_CORE_API = Object.freeze({
   apiRouteRegistration: Object.freeze({ ...apiRouteRegistration }),
@@ -56,7 +55,7 @@ class ServerRuntimeCoreServiceProvider {
   }
 
   boot(app) {
-    if (app.has(KERNEL_TOKENS.HttpRouter)) {
+    if (app.has("jskit.http.router")) {
       bootstrapRoutes.bootBootstrapRoutes(app);
     }
   }

package/server/runtime/bootBootstrapRoutes.js

@@ -1,7 +1,6 @@
 import { Type } from "typebox";
 import { normalizeObjectInput } from "../../shared/validators/inputNormalization.js";
 import { AUTH_POLICY_PUBLIC } from "../../shared/support/policies.js";
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import { resolveBootstrapPayload } from "../registries/bootstrapPayloadContributorRegistry.js";
 
 const bootstrapQueryValidator = Object.freeze({
@@ -15,7 +14,7 @@ const bootstrapOutputValidator = Object.freeze({
 });
 
 function bootBootstrapRoutes(app) {
-  const router = app.make(KERNEL_TOKENS.HttpRouter);
+  const router = app.make("jskit.http.router");
 
   router.register(
     "GET",

package/server/runtime/bootBootstrapRoutes.test.js

@@ -1,7 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createContainer } from "../container/index.js";
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import { registerBootstrapPayloadContributor } from "../registries/bootstrapPayloadContributorRegistry.js";
 import { bootBootstrapRoutes, bootstrapQueryValidator } from "./bootBootstrapRoutes.js";
 
@@ -42,7 +41,7 @@ test("bootBootstrapRoutes registers GET /api/bootstrap and resolves contributors
     }
   };
 
-  app.instance(KERNEL_TOKENS.HttpRouter, router);
+  app.instance("jskit.http.router", router);
   registerBootstrapPayloadContributor(app, "test.bootstrap.payload", () => ({
     contributorId: "test.bootstrap.payload",
     contribute({ query }) {

package/server/runtime/fastifyBootstrap.js

@@ -1,11 +1,8 @@
-import { KERNEL_TOKENS } from "../../shared/support/tokens.js";
 import { ActionRuntimeError } from "../../shared/actions/actionDefinitions.js";
 import { normalizeOpaqueId } from "../../shared/support/normalize.js";
 import { isAppError } from "./errors.js";
 import { resolveDefaultSurfaceId } from "../support/appConfig.js";
 
-const API_ERROR_HANDLER_MARKER_TOKEN = "kernel.runtime.apiErrorHandlerRegistered";
-
 function resolveLoggerLevel({ configuredLevel = "", nodeEnv = "development", allowedLevels = [] } = {}) {
   const normalizedConfiguredLevel = String(configuredLevel || "")
     .trim()
@@ -228,8 +225,8 @@ function registerApiErrorHandler(
 function ensureApiErrorHandling(
   app,
   {
-    fastifyToken = KERNEL_TOKENS.Fastify,
-    markerToken = API_ERROR_HANDLER_MARKER_TOKEN,
+    fastifyToken = "jskit.fastify",
+    markerToken = "kernel.runtime.apiErrorHandlerRegistered",
     isAppError: isAppErrorOverride,
     autoRegister = true,
     ...handlerOptions
@@ -243,7 +240,7 @@ function ensureApiErrorHandling(
     return false;
   }
 
-  const normalizedMarkerToken = String(markerToken || "").trim() || API_ERROR_HANDLER_MARKER_TOKEN;
+  const normalizedMarkerToken = String(markerToken || "").trim() || "kernel.runtime.apiErrorHandlerRegistered";
   if (app.has(normalizedMarkerToken)) {
     return false;
   }

package/server/support/SupportCoreServiceProvider.js

@@ -1,11 +1,13 @@
 import * as normalize from "../../shared/support/normalize.js";
 import * as sorting from "../../shared/support/sorting.js";
-import * as tokens from "../../shared/support/tokens.js";
+import { isContainerToken } from "../../shared/support/containerToken.js";
 
 const SUPPORT_CORE_API = Object.freeze({
   normalize: Object.freeze({ ...normalize }),
   sorting: Object.freeze({ ...sorting }),
-  tokens: Object.freeze({ ...tokens })
+  tokens: Object.freeze({
+    isContainerToken
+  })
 });
 
 class SupportCoreServiceProvider {

package/shared/support/containerToken.js

@@ -0,0 +1,8 @@
+function isContainerToken(value) {
+  if (typeof value === "string") {
+    return value.trim().length > 0;
+  }
+  return typeof value === "symbol" || typeof value === "function";
+}
+
+export { isContainerToken };

package/shared/support/index.js

@@ -7,6 +7,7 @@ export {
   normalizeReturnToPath,
   resolveAllowedOriginsFromPlacementContext
 } from "./returnToPath.js";
+export { toCamelCase, toSnakeCase } from "./stringCase.js";
 export {
   isTransientQueryError,
   shouldRetryTransientQueryFailure,

package/shared/support/normalize.js

@@ -3,6 +3,47 @@ function normalizeText(value, { fallback = "" } = {}) {
   return normalized || fallback;
 }
 
+function normalizeBoolean(value) {
+  if (typeof value === "boolean") {
+    return value;
+  }
+
+  if (typeof value === "number") {
+    if (value === 1) {
+      return true;
+    }
+    if (value === 0) {
+      return false;
+    }
+  }
+
+  const normalized = normalizeText(value).toLowerCase();
+  if (normalized === "true" || normalized === "1" || normalized === "yes" || normalized === "y") {
+    return true;
+  }
+  if (normalized === "false" || normalized === "0" || normalized === "no" || normalized === "n") {
+    return false;
+  }
+
+  throw new TypeError("Boolean field must be true or false.");
+}
+
+function normalizeFiniteNumber(value) {
+  const normalized = Number(value);
+  if (!Number.isFinite(normalized)) {
+    throw new TypeError("Number field must be a valid number.");
+  }
+  return normalized;
+}
+
+function normalizeFiniteInteger(value) {
+  const normalized = normalizeFiniteNumber(value);
+  if (!Number.isInteger(normalized)) {
+    throw new TypeError("Number field must be an integer.");
+  }
+  return normalized;
+}
+
 function normalizeLowerText(value, { fallback = "" } = {}) {
   return normalizeText(value, {
     fallback
@@ -21,6 +62,50 @@ function normalizeObject(value, { fallback = {} } = {}) {
   return value;
 }
 
+function normalizeIfInSource(source, normalized, fieldName, normalizer = (value) => value) {
+  if (!isRecord(source)) {
+    return normalized;
+  }
+  if (!isRecord(normalized)) {
+    throw new TypeError("normalizeIfInSource requires target object.");
+  }
+
+  const normalizedFieldName = normalizeText(fieldName);
+  if (!normalizedFieldName) {
+    throw new TypeError("normalizeIfInSource requires fieldName.");
+  }
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeIfInSource requires normalizer function.");
+  }
+
+  if (!Object.hasOwn(source, normalizedFieldName)) {
+    return normalized;
+  }
+
+  const sourceValue = source[normalizedFieldName];
+  if (sourceValue == null) {
+    normalized[normalizedFieldName] = sourceValue;
+    return normalized;
+  }
+
+  normalized[normalizedFieldName] = normalizer(sourceValue);
+  return normalized;
+}
+
+function normalizeIfPresent(value, normalizer = (entry) => entry) {
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeIfPresent requires normalizer function.");
+  }
+  return value == null ? value : normalizer(value);
+}
+
+function normalizeOrNull(value, normalizer = (entry) => entry) {
+  if (typeof normalizer !== "function") {
+    throw new TypeError("normalizeOrNull requires normalizer function.");
+  }
+  return value == null ? null : normalizer(value);
+}
+
 function isRecord(value) {
   return Boolean(value && typeof value === "object" && !Array.isArray(value));
 }
@@ -108,9 +193,15 @@ function ensureNonEmptyText(value, label = "value") {
 
 export {
   normalizeText,
+  normalizeBoolean,
+  normalizeFiniteNumber,
+  normalizeFiniteInteger,
   normalizeLowerText,
   normalizeQueryToken,
   normalizeObject,
+  normalizeIfInSource,
+  normalizeIfPresent,
+  normalizeOrNull,
   isRecord,
   normalizeArray,
   normalizeUniqueTextList,

package/shared/support/normalize.test.js

@@ -1,10 +1,17 @@
 import test from "node:test";
 import assert from "node:assert/strict";
 import {
+  normalizeBoolean,
+  normalizeFiniteInteger,
+  normalizeFiniteNumber,
+  normalizeIfInSource,
+  normalizeIfPresent,
+  normalizeOrNull,
   normalizeOpaqueId,
   normalizePositiveInteger,
   normalizeOneOf,
   normalizeQueryToken,
+  normalizeText,
   normalizeUniqueTextList
 } from "./normalize.js";
 
@@ -39,6 +46,95 @@ test("normalizePositiveInteger normalizes valid integers and applies fallback",
   );
 });
 
+test("normalizeBoolean normalizes supported boolean-like values", () => {
+  assert.equal(normalizeBoolean(true), true);
+  assert.equal(normalizeBoolean(false), false);
+  assert.equal(normalizeBoolean(1), true);
+  assert.equal(normalizeBoolean(0), false);
+  assert.equal(normalizeBoolean(" yes "), true);
+  assert.equal(normalizeBoolean("No"), false);
+  assert.throws(() => normalizeBoolean("maybe"), /Boolean field must be true or false/);
+});
+
+test("normalizeFiniteNumber normalizes numeric values", () => {
+  assert.equal(normalizeFiniteNumber("42.5"), 42.5);
+  assert.equal(normalizeFiniteNumber("7"), 7);
+  assert.throws(() => normalizeFiniteNumber("abc"), /Number field must be a valid number/);
+});
+
+test("normalizeFiniteInteger normalizes integer values", () => {
+  assert.equal(normalizeFiniteInteger("7"), 7);
+  assert.throws(
+    () => normalizeFiniteInteger("3.2"),
+    /Number field must be an integer/
+  );
+});
+
+test("normalizeIfInSource normalizes only present source fields", () => {
+  const source = {
+    firstName: "  Ada  "
+  };
+  const normalized = {};
+
+  normalizeIfInSource(source, normalized, "firstName", normalizeText);
+  normalizeIfInSource(source, normalized, "lastName", normalizeText);
+
+  assert.deepEqual(normalized, {
+    firstName: "Ada"
+  });
+});
+
+test("normalizeIfInSource passes through nullish values without normalizer", () => {
+  const source = {
+    firstName: null,
+    lastName: undefined
+  };
+  const normalized = {};
+
+  normalizeIfInSource(source, normalized, "firstName", normalizeText);
+  normalizeIfInSource(source, normalized, "lastName", normalizeText);
+
+  assert.deepEqual(normalized, {
+    firstName: null,
+    lastName: undefined
+  });
+});
+
+test("normalizeIfInSource validates target and function arguments", () => {
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, null, "firstName", normalizeText),
+    /requires target object/
+  );
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, {}, "", normalizeText),
+    /requires fieldName/
+  );
+  assert.throws(
+    () => normalizeIfInSource({ firstName: "Ada" }, {}, "firstName", null),
+    /requires normalizer function/
+  );
+});
+
+test("normalizeIfPresent normalizes non-nullish values and preserves nullish values", () => {
+  assert.equal(normalizeIfPresent("  Ada  ", normalizeText), "Ada");
+  assert.equal(normalizeIfPresent(null, normalizeText), null);
+  assert.equal(normalizeIfPresent(undefined, normalizeText), undefined);
+  assert.throws(
+    () => normalizeIfPresent("Ada", null),
+    /requires normalizer function/
+  );
+});
+
+test("normalizeOrNull normalizes non-nullish values and coerces nullish to null", () => {
+  assert.equal(normalizeOrNull("  Ada  ", normalizeText), "Ada");
+  assert.equal(normalizeOrNull(null, normalizeText), null);
+  assert.equal(normalizeOrNull(undefined, normalizeText), null);
+  assert.throws(
+    () => normalizeOrNull("Ada", null),
+    /requires normalizer function/
+  );
+});
+
 test("normalizeOpaqueId preserves opaque identifiers", () => {
   assert.equal(normalizeOpaqueId("  user-123  "), "user-123");
   assert.equal(normalizeOpaqueId(7), 7);

package/shared/support/stringCase.js

@@ -0,0 +1,26 @@
+function toCamelCase(value = "") {
+  return String(value || "")
+    .replace(/[-_]+([a-zA-Z0-9])/g, (_, nextChar) => String(nextChar || "").toUpperCase())
+    .replace(/^[A-Z]/, (char) => char.toLowerCase())
+    .replace(/[-_]+$/g, "");
+}
+
+function toSnakeCase(value = "") {
+  const source = String(value || "");
+  if (!source) {
+    return "";
+  }
+
+  const replaced = source
+    .replace(/([A-Z0-9]+)([A-Z][a-z])/g, "$1_$2")
+    .replace(/([a-z0-9])([A-Z])/g, "$1_$2")
+    .replace(/[-\s]+/g, "_")
+    .replace(/__+/g, "_");
+
+  return replaced
+    .toLowerCase()
+    .replace(/^_+/, "")
+    .replace(/_+$/, "");
+}
+
+export { toCamelCase, toSnakeCase };

package/shared/support/tokens.js

@@ -1,23 +1 @@
-const KERNEL_TOKENS = Object.freeze({
-  Logger: Symbol.for("jskit.logger"),
-  Env: Symbol.for("jskit.env"),
-  Fastify: Symbol.for("jskit.fastify"),
-  HttpRouter: Symbol.for("jskit.http.router"),
-  Request: Symbol.for("jskit.http.request"),
-  Reply: Symbol.for("jskit.http.reply"),
-  RequestId: Symbol.for("jskit.http.requestId"),
-  RequestScope: Symbol.for("jskit.http.requestScope"),
-  Knex: Symbol.for("jskit.database.knex"),
-  TransactionManager: Symbol.for("jskit.database.transactionManager"),
-  Storage: Symbol.for("jskit.storage"),
-  SurfaceRuntime: Symbol.for("jskit.surface.runtime")
-});
-
-function isContainerToken(value) {
-  if (typeof value === "string") {
-    return value.trim().length > 0;
-  }
-  return typeof value === "symbol" || typeof value === "function";
-}
-
-export { KERNEL_TOKENS, isContainerToken };
+export { isContainerToken } from "./containerToken.js";

package/shared/support/tokens.test.js

@@ -1,10 +1,10 @@
 import test from "node:test";
 import assert from "node:assert/strict";
-import { isContainerToken } from "./tokens.js";
+import { isContainerToken } from "./containerToken.js";
 
 test("isContainerToken accepts valid container token types", () => {
   assert.equal(isContainerToken("appConfig"), true);
-  assert.equal(isContainerToken(Symbol.for("jskit.test")), true);
+  assert.equal(isContainerToken("jskit.test"), true);
   assert.equal(isContainerToken(() => {}), true);
 });
 

package/test/barrelExposure.test.js

@@ -34,6 +34,8 @@ const BARREL_EXPECTATIONS = Object.freeze([
       "pickOwnProperties",
       "resolveAllowedOriginsFromPlacementContext",
       "splitPathQueryAndHash",
+      "toCamelCase",
+      "toSnakeCase",
       "shouldRetryTransientQueryFailure",
       "transientQueryRetryDelay"
     ])

package/test/exportsContract.test.js

@@ -20,7 +20,13 @@ const SCANNED_EXTENSIONS = new Set([".js", ".mjs", ".cjs", ".ts", ".tsx", ".vue"
 const IGNORED_DIRECTORIES = new Set(["node_modules", ".git", "dist", "coverage"]);
 const EXCLUDED_USAGE_PATH_SEGMENTS = new Set(["test", "tests", "__tests__", "test-support"]);
 const TEST_FILENAME_PATTERN = /\.(test|spec)\.[A-Za-z0-9]+$/;
-const EXPORTED_UNUSED_ALLOWLIST = new Set(["./_testable"]);
+const EXPORTED_UNUSED_ALLOWLIST = new Set([
+  "./_testable",
+  // Used by generated app bootstrap code emitted from kernel client vite plugin.
+  "./client/moduleBootstrap",
+  // Intentionally retained as an explicit low-level kernel API subpath.
+  "./shared/support/tokens"
+]);
 
 function normalizeSlash(value) {
   return String(value || "").replace(/\\/g, "/");

package/test/stringCase.test.js

@@ -0,0 +1,22 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { toCamelCase, toSnakeCase } from "../shared/support/stringCase.js";
+
+test("toCamelCase converts snake and kebab to camelCase", () => {
+  assert.equal(toCamelCase("created_at"), "createdAt");
+  assert.equal(toCamelCase("user-id"), "userId");
+  assert.equal(toCamelCase("__leading__dots__"), "leadingDots");
+});
+
+test("toSnakeCase converts camelCase and PascalCase to snake_case", () => {
+  assert.equal(toSnakeCase("createdAt"), "created_at");
+  assert.equal(toSnakeCase("XMLHttpRequest"), "xml_http_request");
+  assert.equal(toSnakeCase("userID"), "user_id");
+  assert.equal(toSnakeCase("already_snake"), "already_snake");
+});
+
+test("toSnakeCase handles empty inputs gracefully", () => {
+  assert.equal(toSnakeCase(""), "");
+  assert.equal(toSnakeCase(null), "");
+  assert.equal(toSnakeCase("  "), "");
+});