@jskit-ai/kernel 0.1.37 → 0.1.39

package/client/index.d.ts

@@ -34,6 +34,7 @@ export function bootstrapClientShellApp(options?: {
   rootComponent: any;
   appConfig?: Record<string, any>;
   appPlugins?: any[];
+  pinia?: any;
   router: any;
   bootClientModules: (context: any) => Promise<any>;
   surfaceRuntime: any;

package/client/moduleBootstrap.js

@@ -482,6 +482,7 @@ function normalizeClientModuleEntries(clientModules) {
 function createClientRuntimeApp({
   profile = "client",
   app,
+  pinia = null,
   router,
   env,
   logger,
@@ -496,6 +497,7 @@ function createClientRuntimeApp({
   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.pinia", pinia);
   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());
@@ -507,6 +509,7 @@ function createClientRuntimeApp({
 async function bootClientModules({
   clientModules = [],
   app,
+  pinia = null,
   router,
   surfaceRuntime,
   surfaceMode,
@@ -525,6 +528,7 @@ async function bootClientModules({
   const runtimeApp = createClientRuntimeApp({
     profile: String(surfaceRuntime.normalizeSurfaceMode(surfaceMode) || "client"),
     app,
+    pinia,
     router,
     env,
     logger: log,

package/client/moduleBootstrap.test.js

@@ -112,11 +112,14 @@ test("bootClientModules registers descriptor and clientRoutes with providers onl
   const surfaceRuntime = createSurfaceRuntimeFixture();
   const events = [];
   const loginComponent = {};
+  const pinia = { id: "pinia-instance" };
+  const implicitPinia = { id: "implicit-vue-global-pinia" };
   class ExampleClientProvider {
     static id = "example.client";
     register(app) {
       events.push("register");
       app.instance("example.value", 42);
+      app.instance("example.pinia", app.make("jskit.client.pinia"));
     }
     boot() {
       events.push("boot");
@@ -179,6 +182,14 @@ test("bootClientModules registers descriptor and clientRoutes with providers onl
         }
       }
     ],
+    app: {
+      config: {
+        globalProperties: {
+          $pinia: implicitPinia
+        }
+      }
+    },
+    pinia,
     router,
     surfaceRuntime,
     surfaceMode: "all",
@@ -194,6 +205,8 @@ test("bootClientModules registers descriptor and clientRoutes with providers onl
   assert.equal(router.routes[1].path, "/auth/login");
   assert.equal(router.routes[1].component, loginComponent);
   assert.equal(result.runtimeApp.make("example.value"), 42);
+  assert.equal(result.runtimeApp.make("example.pinia"), pinia);
+  assert.notEqual(result.runtimeApp.make("example.pinia"), implicitPinia);
 });
 
 test("bootClientModules does not auto-discover providers from module exports", async () => {

package/client/shellBootstrap.js

@@ -108,6 +108,7 @@ async function bootstrapClientShellApp({
   rootComponent,
   appConfig = {},
   appPlugins = [],
+  pinia = null,
   router,
   bootClientModules,
   surfaceRuntime,
@@ -158,6 +159,7 @@ async function bootstrapClientShellApp({
 
   const clientBootstrap = await bootClientModules({
     app,
+    pinia,
     router,
     surfaceRuntime,
     surfaceMode,

package/client/shellBootstrap.test.js

@@ -85,6 +85,7 @@ test("bootstrapClientShellApp boots modules, reinstalls fallback route, and moun
   const logs = [];
   const surfaceRuntime = createSurfaceRuntimeFixture();
   const plugin = { name: "vuetify-like-plugin" };
+  const pinia = { id: "pinia-instance" };
   const fallbackRoute = {
     name: "not-found",
     path: "/:pathMatch(.*)*",
@@ -140,10 +141,12 @@ test("bootstrapClientShellApp boots modules, reinstalls fallback route, and moun
       }
     },
     appPlugins: [plugin],
+    pinia,
     router,
     bootClientModules: async (context) => {
       calls.push("bootClientModules");
       assert.equal(context.app, app);
+      assert.equal(context.pinia, pinia);
       assert.equal(context.router, router);
       assert.equal(typeof context.logger.debug, "function");
       return {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/kernel",
-  "version": "0.1.37",
+  "version": "0.1.39",
   "type": "module",
   "dependencies": {
     "typebox": "^1.0.81"
@@ -19,6 +19,7 @@
     "./server/actions": "./server/actions/index.js",
     "./server/http": "./server/http/index.js",
     "./server/platform": "./server/platform/index.js",
+    "./server/registries": "./server/registries/index.js",
     "./server/runtime": "./server/runtime/index.js",
     "./server/runtime/errors": "./server/runtime/errors.js",
     "./server/runtime/requestUrl": "./server/runtime/requestUrl.js",

package/server/registries/bootstrapPayloadContributorRegistry.js

@@ -9,8 +9,21 @@ function registerBootstrapPayloadContributor(app, token, factory) {
 
 function resolveBootstrapPayloadContributors(scope) {
   return resolveTaggedEntries(scope, "jskit.runtime.bootstrap.payloadContributors")
-    .map((entry) => normalizeContributorEntry(entry))
-    .filter(Boolean);
+    .map((entry, index) => ({
+      contributor: normalizeContributorEntry(entry),
+      index
+    }))
+    .filter((entry) => Boolean(entry.contributor))
+    .sort((left, right) => {
+      const leftOrder = Number.isFinite(left.contributor?.order) ? Number(left.contributor.order) : 0;
+      const rightOrder = Number.isFinite(right.contributor?.order) ? Number(right.contributor.order) : 0;
+      if (leftOrder !== rightOrder) {
+        return leftOrder - rightOrder;
+      }
+
+      return left.index - right.index;
+    })
+    .map((entry) => entry.contributor);
 }
 
 async function resolveBootstrapPayload(scope, context = {}) {

package/server/runtime/bootstrapContributors.test.js

@@ -87,6 +87,58 @@ test("resolveBootstrapPayload applies contributors in deterministic token order"
   });
 });
 
+test("resolveBootstrapPayload honors explicit contributor order before token order", async () => {
+  const app = createContainer();
+  const calls = [];
+
+  registerBootstrapPayloadContributor(app, "test.bootstrap.alpha", () => ({
+    contributorId: "alpha",
+    order: 200,
+    contribute({ payload }) {
+      calls.push({
+        contributorId: "alpha",
+        payload
+      });
+      return {
+        alpha: true
+      };
+    }
+  }));
+
+  registerBootstrapPayloadContributor(app, "test.bootstrap.zeta", () => ({
+    contributorId: "zeta",
+    order: 100,
+    contribute({ payload }) {
+      calls.push({
+        contributorId: "zeta",
+        payload
+      });
+      return {
+        zeta: true
+      };
+    }
+  }));
+
+  const payload = await resolveBootstrapPayload(app);
+
+  assert.deepEqual(calls, [
+    {
+      contributorId: "zeta",
+      payload: {}
+    },
+    {
+      contributorId: "alpha",
+      payload: {
+        zeta: true
+      }
+    }
+  ]);
+  assert.deepEqual(payload, {
+    zeta: true,
+    alpha: true
+  });
+});
+
 test("resolveBootstrapPayload ignores non-object contributions", async () => {
   const app = createContainer();
 

package/shared/support/visibility.js

@@ -3,6 +3,15 @@ import { ROUTE_VISIBILITY_PUBLIC, ROUTE_VISIBILITY_USER } from "./policies.js";
 
 const ROUTE_VISIBILITY_LEVELS = Object.freeze([ROUTE_VISIBILITY_PUBLIC, ROUTE_VISIBILITY_USER]);
 const ROUTE_VISIBILITY_LEVEL_SET = new Set(ROUTE_VISIBILITY_LEVELS);
+const ROUTE_VISIBILITY_WORKSPACE = "workspace";
+const ROUTE_VISIBILITY_WORKSPACE_USER = "workspace_user";
+const ROUTE_VISIBILITY_TOKENS = Object.freeze([
+  ROUTE_VISIBILITY_PUBLIC,
+  ROUTE_VISIBILITY_USER,
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER
+]);
+const ROUTE_VISIBILITY_TOKEN_SET = new Set(ROUTE_VISIBILITY_TOKENS);
 
 function normalizeRouteVisibilityToken(value, { fallback = ROUTE_VISIBILITY_PUBLIC } = {}) {
   const normalized = normalizeText(value).toLowerCase();
@@ -34,6 +43,22 @@ function normalizeRouteVisibility(value, { fallback = ROUTE_VISIBILITY_PUBLIC }
   return ROUTE_VISIBILITY_PUBLIC;
 }
 
+function checkRouteVisibility(value, { context = "checkRouteVisibility" } = {}) {
+  const normalized = normalizeRouteVisibilityToken(value);
+  if (ROUTE_VISIBILITY_TOKEN_SET.has(normalized)) {
+    return normalized;
+  }
+
+  throw new TypeError(`${context} must be one of: ${ROUTE_VISIBILITY_TOKENS.join(", ")}.`);
+}
+
+function isWorkspaceRouteVisibility(value = "") {
+  const normalized = checkRouteVisibility(value, {
+    context: "isWorkspaceRouteVisibility visibility"
+  });
+  return normalized === ROUTE_VISIBILITY_WORKSPACE || normalized === ROUTE_VISIBILITY_WORKSPACE_USER;
+}
+
 function normalizeVisibilityScopeKind(value) {
   const normalized = normalizeText(value).toLowerCase();
   return normalized || null;
@@ -53,4 +78,16 @@ function normalizeVisibilityContext(value = {}) {
   });
 }
 
-export { ROUTE_VISIBILITY_LEVELS, normalizeRouteVisibilityToken, normalizeRouteVisibility, normalizeVisibilityContext };
+export {
+  ROUTE_VISIBILITY_LEVELS,
+  ROUTE_VISIBILITY_PUBLIC,
+  ROUTE_VISIBILITY_USER,
+  ROUTE_VISIBILITY_WORKSPACE,
+  ROUTE_VISIBILITY_WORKSPACE_USER,
+  ROUTE_VISIBILITY_TOKENS,
+  normalizeRouteVisibilityToken,
+  normalizeRouteVisibility,
+  checkRouteVisibility,
+  isWorkspaceRouteVisibility,
+  normalizeVisibilityContext
+};

package/shared/support/visibility.test.js

@@ -1,6 +1,12 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import { normalizeRouteVisibilityToken, normalizeRouteVisibility, normalizeVisibilityContext } from "./visibility.js";
+import {
+  checkRouteVisibility,
+  isWorkspaceRouteVisibility,
+  normalizeRouteVisibilityToken,
+  normalizeRouteVisibility,
+  normalizeVisibilityContext
+} from "./visibility.js";
 
 test("normalizeRouteVisibility keeps kernel core visibility contract", () => {
   assert.equal(normalizeRouteVisibility("PUBLIC"), "public");
@@ -18,6 +24,18 @@ test("normalizeRouteVisibilityToken normalizes visibility tokens for module-leve
   assert.equal(normalizeRouteVisibilityToken("", { fallback: "workspace" }), "workspace");
 });
 
+test("checkRouteVisibility accepts workspace visibility tokens", () => {
+  assert.equal(checkRouteVisibility("workspace"), "workspace");
+  assert.equal(checkRouteVisibility("workspace_user"), "workspace_user");
+  assert.throws(() => checkRouteVisibility("invalid"), /must be one of/);
+});
+
+test("isWorkspaceRouteVisibility matches only workspace-scoped tokens", () => {
+  assert.equal(isWorkspaceRouteVisibility("workspace"), true);
+  assert.equal(isWorkspaceRouteVisibility("workspace_user"), true);
+  assert.equal(isWorkspaceRouteVisibility("public"), false);
+});
+
 test("normalizeVisibilityContext normalizes mode and owner identifiers", () => {
   assert.deepEqual(normalizeVisibilityContext({ visibility: "user", userId: "7" }), {
     visibility: "user",

package/shared/surface/apiPaths.js

@@ -7,6 +7,76 @@ const API_DOCS_PATH = `${API_PREFIX}/docs`;
 const API_REALTIME_PATH = `${API_PREFIX}/realtime`;
 const VERSIONED_API_PATH_PATTERN = /^\/api\/v[0-9]+(?:$|\/)/;
 
+function normalizeRouteTemplateParams(params = null) {
+  if (!params || typeof params !== "object" || Array.isArray(params)) {
+    return {};
+  }
+  return params;
+}
+
+function materializeRouteTemplate(routeTemplate = "/", { params = {}, strictParams = true, context = "materializeRouteTemplate" } = {}) {
+  const normalizedTemplate = normalizePathname(routeTemplate);
+  const normalizedParams = normalizeRouteTemplateParams(params);
+  const missingParams = new Set();
+  const outputPath = String(normalizedTemplate || "/").replace(/:([A-Za-z0-9_]+)/g, (_full, rawName) => {
+    const paramName = String(rawName || "").trim();
+    const rawValue = normalizedParams[paramName];
+    const paramValue = String(Array.isArray(rawValue) ? rawValue[0] : rawValue ?? "").trim();
+    if (!paramValue) {
+      missingParams.add(paramName);
+      return `:${paramName}`;
+    }
+    return encodeURIComponent(paramValue);
+  });
+
+  if (strictParams && missingParams.size > 0) {
+    throw new Error(`${context} missing required route params: ${[...missingParams].sort().join(", ")}.`);
+  }
+
+  return outputPath;
+}
+
+function resolveScopedRouteBase(routeBase = "/") {
+  const normalizedRouteBase = normalizePathname(routeBase);
+  const segments = normalizedRouteBase.split("/").filter(Boolean);
+  let lastDynamicIndex = -1;
+
+  for (let index = 0; index < segments.length; index += 1) {
+    const segment = segments[index];
+    if (segment.startsWith(":") && segment.length > 1) {
+      lastDynamicIndex = index;
+    }
+  }
+
+  if (lastDynamicIndex < 0) {
+    return "/";
+  }
+
+  return `/${segments.slice(0, lastDynamicIndex + 1).join("/")}`;
+}
+
+function resolveScopedApiBasePath({
+  routeBase = "/",
+  relativePath = "/",
+  params = {},
+  strictParams = true
+} = {}) {
+  const scopedRouteBase = resolveScopedRouteBase(routeBase);
+  const materializedScopeBase = materializeRouteTemplate(scopedRouteBase, {
+    params,
+    strictParams,
+    context: "resolveScopedApiBasePath"
+  });
+  const basePath = materializedScopeBase === "/" ? API_BASE_PATH : `${API_BASE_PATH}${materializedScopeBase}`;
+  const normalizedRelativePath = normalizePathname(relativePath || "/");
+
+  if (normalizedRelativePath === "/") {
+    return basePath;
+  }
+
+  return `${basePath}${normalizedRelativePath}`;
+}
+
 function isApiPath(pathname) {
   return matchesPathPrefix(pathname, API_BASE_PATH);
 }
@@ -74,11 +144,14 @@ export {
   API_PREFIX_SLASH,
   API_DOCS_PATH,
   API_REALTIME_PATH,
+  materializeRouteTemplate,
   normalizePathname,
   isApiPath,
   isVersionedApiPath,
   toVersionedApiPath,
   toVersionedApiPrefix,
   buildVersionedApiPath,
-  isVersionedApiPrefixMatch
+  isVersionedApiPrefixMatch,
+  resolveScopedRouteBase,
+  resolveScopedApiBasePath
 };

package/shared/surface/apiPaths.test.js

@@ -0,0 +1,31 @@
+import test from "node:test";
+import assert from "node:assert/strict";
+import { resolveScopedApiBasePath, resolveScopedRouteBase } from "./apiPaths.js";
+
+test("resolveScopedRouteBase keeps the route prefix through the last dynamic segment", () => {
+  assert.equal(resolveScopedRouteBase("/"), "/");
+  assert.equal(resolveScopedRouteBase("/home"), "/");
+  assert.equal(resolveScopedRouteBase("/w/:workspaceSlug"), "/w/:workspaceSlug");
+  assert.equal(resolveScopedRouteBase("/w/:workspaceSlug/admin"), "/w/:workspaceSlug");
+  assert.equal(resolveScopedRouteBase("/org/:orgId/team/:teamId/admin"), "/org/:orgId/team/:teamId");
+});
+
+test("resolveScopedApiBasePath materializes scoped API paths from route templates", () => {
+  assert.equal(resolveScopedApiBasePath({ routeBase: "/home", relativePath: "/settings" }), "/api/settings");
+  assert.equal(
+    resolveScopedApiBasePath({
+      routeBase: "/w/:workspaceSlug/admin",
+      relativePath: "/members",
+      params: { workspaceSlug: "acme" }
+    }),
+    "/api/w/acme/members"
+  );
+  assert.throws(
+    () =>
+      resolveScopedApiBasePath({
+        routeBase: "/w/:workspaceSlug/admin",
+        relativePath: "/members"
+      }),
+    /missing required route params/
+  );
+});

package/shared/surface/index.js

@@ -4,3 +4,7 @@ export {
   deriveSurfaceRouteBaseFromPagesRoot
 } from "./registry.js";
 export { createSurfacePathHelpers } from "./paths.js";
+export {
+  resolveScopedRouteBase,
+  resolveScopedApiBasePath
+} from "./apiPaths.js";