@jskit-ai/kernel 0.1.245 → 0.1.246

package/shared/surface/runtime.test.js

@@ -317,3 +317,60 @@ test("filterRoutesBySurface hoists cross-surface nested route wrappers to top-le
     ["", "members"]
   );
 });
+
+test("createSurfaceRuntime reads every definition from its one surface registry", () => {
+  const runtime = createSurfaceRuntime({
+    defaultSurfaceId: "APP",
+    surfaces: {
+      app: { pagesRoot: "", requiresAuth: false },
+      admin: { pagesRoot: "w/[workspaceSlug]/admin", requiresAuth: true },
+      console: { pagesRoot: "console", enabled: false }
+    }
+  });
+
+  const admin = runtime.getSurfaceDefinition(" Admin ");
+  assert.equal(admin.routeBase, "/w/:workspaceSlug/admin");
+  assert.equal(admin.enabled, true);
+  assert.equal(admin.requiresAuth, true);
+  assert.equal(Object.isFrozen(admin), true);
+  assert.equal(runtime.getSurfaceDefinition("console").enabled, false);
+  assert.equal(runtime.DEFAULT_SURFACE, runtime.getSurfaceDefinition("app"));
+  assert.deepEqual(runtime.SURFACE_IDS, ["app", "admin", "console"]);
+  assert.deepEqual(runtime.listSurfaceDefinitions().map((entry) => entry.id), ["app", "admin", "console"]);
+  assert.throws(
+    () => createSurfaceRuntime({ surfaces: { app: {} } }),
+    /Surface "app" requires pagesRoot/
+  );
+});
+
+test("createSurfaceRuntime resolves API pathnames by the surface-relative path", () => {
+  const runtime = createSurfaceRuntime({
+    defaultSurfaceId: "app",
+    surfaces: {
+      app: { pagesRoot: "" },
+      admin: { pagesRoot: "admin" }
+    }
+  });
+
+  assert.equal(runtime.resolveSurfaceFromPathname("/api/admin/users?x=1"), "admin");
+  assert.equal(runtime.resolveSurfaceFromPathname("/api/v2/admin/users"), "admin");
+  assert.equal(runtime.resolveSurfaceFromPathname("/api"), "app");
+  assert.equal(runtime.resolveSurfaceFromPathname("/apiary/admin"), "app");
+});
+
+test("filterRoutesBySurface keeps optional route params when hoisting a surface boundary", () => {
+  const runtime = createSurfaceRuntime({
+    defaultSurfaceId: "app",
+    surfaces: {
+      app: { pagesRoot: "" },
+      admin: { pagesRoot: "admin" }
+    }
+  });
+
+  const routes = filterRoutesBySurface(
+    [{ path: "/", children: [{ path: "admin/users/:id?", meta: { jskit: { surface: "admin" } } }] }],
+    { surfaceRuntime: runtime, surfaceMode: "all" }
+  );
+
+  assert.deepEqual(routes.map((route) => route.path), ["/", "/admin/users/:id?"]);
+});

package/shared/validators/index.js

@@ -8,12 +8,11 @@ export {
   NULLABLE_HTML_TIME_STRING_SCHEMA
 } from "./htmlTimeSchemas.js";
 export { mergeObjectSchemas } from "./mergeObjectSchemas.js";
+export { isJsonRestSchemaInstance } from "./jsonRestSchemaSupport.js";
 export {
   hasJsonRestSchemaDefinition,
   normalizeSingleSchemaDefinition,
-  normalizeSchemaDefinition,
   resolveSchemaTransportSchemaDefinition,
-  resolveStructuredSchemaTransportSchema,
   executeJsonRestSchemaDefinition
 } from "./schemaDefinitions.js";
 export {
@@ -23,9 +22,7 @@ export {
 export {
   RECORD_ID_PATTERN,
   recordIdSchema,
-  recordIdInputSchema,
   nullableRecordIdSchema,
-  nullableRecordIdInputSchema,
   recordIdParamsValidator
 } from "./recordIdParamsValidator.js";
 export {

package/shared/validators/jsonRestSchemaSupport.js

@@ -64,14 +64,6 @@ function resolveSchemaDefinitionTransportSchema(schemaDefinition = null, options
   return schema.toJsonSchema({ mode });
 }
 
-function executeSchemaDefinition(schemaDefinition = null, payload, options = {}) {
-  const schema = requireJsonRestSchemaInstance(schemaDefinition, {
-    context: `${options?.context || "schema definition"}.schema`
-  });
-  const mode = resolveSchemaDefinitionMode(schemaDefinition, options);
-  return schema[mode](payload);
-}
-
 function resolveJsonRestSchemaFieldMessages(schemaDefinition = null, fieldName = "") {
   const normalizedFieldName = normalizeText(fieldName);
   if (!normalizedFieldName) {
@@ -147,6 +139,5 @@ export {
   isJsonRestSchemaInstance,
   resolveSchemaDefinitionMode,
   resolveSchemaDefinitionTransportSchema,
-  executeSchemaDefinition,
   normalizeJsonRestSchemaFieldErrors
 };

package/shared/validators/recordIdParamsValidator.js

@@ -9,15 +9,11 @@ const recordIdSchema = deepFreeze({
   pattern: RECORD_ID_PATTERN
 });
 
-const recordIdInputSchema = recordIdSchema;
-
 const nullableRecordIdSchema = deepFreeze({
   ...recordIdSchema,
   nullable: true
 });
 
-const nullableRecordIdInputSchema = nullableRecordIdSchema;
-
 const recordIdParamsValidator = deepFreeze({
   schema: createSchema({
     recordId: {
@@ -34,8 +30,6 @@ const recordIdParamsValidator = deepFreeze({
 export {
   RECORD_ID_PATTERN,
   recordIdSchema,
-  recordIdInputSchema,
   nullableRecordIdSchema,
-  nullableRecordIdInputSchema,
   recordIdParamsValidator
 };

package/shared/validators/schemaDefinitions.js

@@ -1,6 +1,5 @@
 import { normalizeObject, normalizeText } from "../support/normalize.js";
 import {
-  executeSchemaDefinition,
   isJsonRestSchemaInstance,
   normalizeJsonRestSchemaFieldErrors,
   resolveSchemaDefinitionMode,
@@ -49,21 +48,11 @@ function normalizeSingleSchemaDefinition(value, { context = "schema definition",
   return Object.freeze(normalized);
 }
 
-function normalizeSchemaDefinition(value, {
-  context = "schema definition",
-  defaultMode = ""
-} = {}) {
-  return normalizeSingleSchemaDefinition(value, {
-    context,
-    defaultMode
-  });
-}
-
 function resolveSchemaTransportSchemaDefinition(value, {
   context = "schema definition",
   defaultMode = ""
 } = {}) {
-  const normalized = normalizeSchemaDefinition(value, {
+  const normalized = normalizeSingleSchemaDefinition(value, {
     context,
     defaultMode
   });
@@ -78,19 +67,9 @@ function resolveSchemaTransportSchemaDefinition(value, {
   });
 }
 
-function resolveStructuredSchemaTransportSchema(value, {
-  context = "schema definition",
-  defaultMode = ""
-} = {}) {
-  return resolveSchemaTransportSchemaDefinition(value, {
-    context,
-    defaultMode
-  });
-}
-
 function hasJsonRestSchemaDefinition(value) {
   try {
-    return Boolean(normalizeSchemaDefinition(value));
+    return Boolean(normalizeSingleSchemaDefinition(value));
   } catch {
     return false;
   }
@@ -100,7 +79,7 @@ function executeJsonRestSchemaDefinition(value, payload, {
   context = "schema definition",
   defaultMode = ""
 } = {}) {
-  const normalized = normalizeSchemaDefinition(value, {
+  const normalized = normalizeSingleSchemaDefinition(value, {
     context,
     defaultMode
   });
@@ -109,18 +88,13 @@ function executeJsonRestSchemaDefinition(value, payload, {
     return null;
   }
 
-  return executeSchemaDefinition(normalized, payload, {
-    defaultMode: defaultMode || "patch",
-    context: `${context}.mode`
-  });
+  return normalized.schema[normalized.mode](payload);
 }
 
 export {
   hasJsonRestSchemaDefinition,
   normalizeSingleSchemaDefinition,
-  normalizeSchemaDefinition,
   resolveSchemaTransportSchemaDefinition,
-  resolveStructuredSchemaTransportSchema,
   executeJsonRestSchemaDefinition,
   normalizeJsonRestSchemaFieldErrors
 };

package/shared/validators/schemaPayloadValidation.js

@@ -44,11 +44,7 @@ function validateSchemaPayload(schemaDefinition, payload, {
     context
   });
 
-  if (!result) {
-    throw new TypeError(`${context}.schema must be a json-rest-schema schema instance.`);
-  }
-
-  const fieldErrors = normalizeJsonRestSchemaFieldErrors(result?.errors, schemaDefinition);
+  const fieldErrors = normalizeJsonRestSchemaFieldErrors(result.errors, schemaDefinition);
   if (Object.keys(fieldErrors).length > 0) {
     throw buildSchemaValidationError({
       fieldErrors,
@@ -56,7 +52,7 @@ function validateSchemaPayload(schemaDefinition, payload, {
     });
   }
 
-  return result?.validatedObject ?? payload;
+  return result.validatedObject ?? payload;
 }
 
 export {

package/test/barrelExposure.test.js

@@ -27,6 +27,7 @@ const BARREL_EXPECTATIONS = Object.freeze([
   Object.freeze({
     filePath: path.join(REPO_ROOT, "packages", "kernel", "shared", "capabilities", "index.js"),
     expectedExports: Object.freeze([
+      "ARCHITECTURE_ID_PATTERN",
       "createCapabilityRuntime",
       "defineProvider"
     ])
@@ -61,7 +62,6 @@ const BARREL_EXPECTATIONS = Object.freeze([
       "normalizePermissionList",
       "normalizeReturnToPath",
       "pickOwnProperties",
-      "resolveAllowedOriginsFromPlacementContext",
       "splitPathQueryAndHash",
       "toCamelCase",
       "toSnakeCase",
@@ -84,18 +84,15 @@ const BARREL_EXPECTATIONS = Object.freeze([
       "deriveResourceRequiredMetadata",
       "executeJsonRestSchemaDefinition",
       "hasJsonRestSchemaDefinition",
+      "isJsonRestSchemaInstance",
       "mergeObjectSchemas",
       "normalizeObjectInput",
       "normalizeRequiredFieldList",
-      "normalizeSchemaDefinition",
       "normalizeSingleSchemaDefinition",
-      "nullableRecordIdInputSchema",
       "nullableRecordIdSchema",
-      "recordIdInputSchema",
       "recordIdParamsValidator",
       "recordIdSchema",
       "resolveSchemaTransportSchemaDefinition",
-      "resolveStructuredSchemaTransportSchema",
       "validateSchemaPayload"
     ])
   }),
@@ -106,6 +103,7 @@ const BARREL_EXPECTATIONS = Object.freeze([
       "createComponentInteractionEmitter",
       "createAsyncModuleRecoveryState",
       "createShellRouter",
+      "DEFAULT_GUARD_EVALUATOR_KEY",
       "dismissAsyncModuleRecovery",
       "dynamicImportErrorMessage",
       "resolveClientAssetMode",
@@ -113,9 +111,7 @@ const BARREL_EXPECTATIONS = Object.freeze([
       "getClientAppConfig",
       "installAsyncModuleRecoveryHandlers",
       "isDynamicImportError",
-      "normalizeIncomingAppUrl",
       "notifyAsyncModuleLoadError",
-      "registerMobileLaunchRouting",
       "resolveMobileConfig",
       "resolveClientBootstrapDebugEnabled",
       "shellScrollBehavior"

package/test/exportsContract.test.js

@@ -30,9 +30,7 @@ const EXPORTED_UNUSED_ALLOWLIST = new Set([
   // defineFeature(), while infrastructure providers use it directly.
   "./shared/capabilities",
   // Public HTTP composition provider used when assembling a server runtime.
-  "./server/http",
-  // Public helper API for packages that publish entity-change realtime events.
-  "./server/runtime/entityChangeEvents"
+  "./server/http"
 ]);
 
 function normalizeSlash(value) {

package/client/mobileLaunchRouting.js

@@ -1,231 +0,0 @@
-import { normalizePathname } from "../shared/surface/paths.js";
-import { normalizeText } from "../shared/support/normalize.js";
-import { resolveMobileConfig } from "./appConfig.js";
-
-function buildNormalizedRoutePath(pathname = "/", search = "", hash = "") {
-  const normalizedPathname = normalizePathname(pathname);
-  const normalizedSearch = String(search || "").trim().replace(/^\?+/, "");
-  const normalizedHash = String(hash || "").trim();
-
-  return `${normalizedPathname}${normalizedSearch ? `?${normalizedSearch}` : ""}${normalizedHash}`;
-}
-
-function normalizeResolvedRoutePath(value = "", fallback = "") {
-  const normalizedValue = normalizeText(value);
-  if (!normalizedValue) {
-    return fallback;
-  }
-
-  try {
-    const parsed = new URL(normalizedValue, "https://jskit.invalid");
-    return buildNormalizedRoutePath(parsed.pathname, parsed.search, parsed.hash);
-  } catch {
-    return fallback;
-  }
-}
-
-function normalizeAllowedHttpOrigins({ mobileConfig = {}, currentOrigin = "", allowedHttpOrigins = [] } = {}) {
-  const origins = new Set();
-
-  const maybeAddOrigin = (value = "") => {
-    const normalizedValue = normalizeText(value);
-    if (!normalizedValue) {
-      return;
-    }
-
-    try {
-      const parsed = new URL(normalizedValue);
-      const protocol = String(parsed.protocol || "").toLowerCase();
-      if (protocol !== "http:" && protocol !== "https:") {
-        return;
-      }
-      origins.add(String(parsed.origin || "").trim().toLowerCase());
-    } catch {}
-  };
-
-  maybeAddOrigin(currentOrigin);
-
-  const explicitOrigins = Array.isArray(allowedHttpOrigins) ? allowedHttpOrigins : [allowedHttpOrigins];
-  for (const entry of explicitOrigins) {
-    maybeAddOrigin(entry);
-  }
-
-  const appLinkDomains = Array.isArray(mobileConfig?.auth?.appLinkDomains) ? mobileConfig.auth.appLinkDomains : [];
-  for (const domain of appLinkDomains) {
-    const normalizedDomain = normalizeText(domain).toLowerCase();
-    if (!normalizedDomain) {
-      continue;
-    }
-    maybeAddOrigin(`https://${normalizedDomain}`);
-  }
-
-  return origins;
-}
-
-function normalizeCustomSchemeRoutePath(parsedUrl) {
-  const host = normalizeText(parsedUrl?.host);
-  const pathname = normalizePathname(parsedUrl?.pathname || "/");
-
-  if (!host) {
-    return pathname;
-  }
-
-  if (pathname === "/") {
-    return `/${host}`;
-  }
-
-  return normalizePathname(`/${host}${pathname}`);
-}
-
-function normalizeIncomingAppUrl(url = "", mobileConfig = {}, { currentOrigin = "", allowedHttpOrigins = [] } = {}) {
-  const normalizedUrl = normalizeText(url);
-  if (!normalizedUrl) {
-    return "";
-  }
-
-  if (normalizedUrl.startsWith("/")) {
-    try {
-      const parsed = new URL(normalizedUrl, "https://jskit.invalid");
-      return buildNormalizedRoutePath(parsed.pathname, parsed.search, parsed.hash);
-    } catch {
-      return "";
-    }
-  }
-
-  let parsedUrl;
-  try {
-    parsedUrl = new URL(normalizedUrl);
-  } catch {
-    return "";
-  }
-
-  const resolvedMobileConfig = resolveMobileConfig({
-    mobile: mobileConfig
-  });
-  const allowedOrigins = normalizeAllowedHttpOrigins({
-    mobileConfig: resolvedMobileConfig,
-    currentOrigin,
-    allowedHttpOrigins
-  });
-  const protocol = String(parsedUrl.protocol || "").toLowerCase();
-  const customScheme = normalizeText(resolvedMobileConfig.auth.customScheme).toLowerCase();
-
-  if (customScheme && protocol === `${customScheme}:`) {
-    return buildNormalizedRoutePath(
-      normalizeCustomSchemeRoutePath(parsedUrl),
-      parsedUrl.search,
-      parsedUrl.hash
-    );
-  }
-
-  if ((protocol === "http:" || protocol === "https:") && allowedOrigins.has(String(parsedUrl.origin || "").toLowerCase())) {
-    return buildNormalizedRoutePath(parsedUrl.pathname, parsedUrl.search, parsedUrl.hash);
-  }
-
-  return "";
-}
-
-function registerMobileLaunchRouting({
-  router,
-  mobileConfig = {},
-  getInitialLaunchUrl = async () => "",
-  subscribeToLaunchUrls = () => () => {},
-  resolveTargetPath = null,
-  currentOrigin = typeof window === "object" && window?.location ? String(window.location.origin || "") : "",
-  allowedHttpOrigins = [],
-  logger = null
-} = {}) {
-  if (!router || typeof router.replace !== "function") {
-    throw new TypeError("registerMobileLaunchRouting requires router.replace().");
-  }
-
-  const resolvedMobileConfig = resolveMobileConfig({
-    mobile: mobileConfig
-  });
-  const runtimeLogger =
-    logger && typeof logger === "object"
-      ? logger
-      : {
-          info() {},
-          warn() {},
-          error() {}
-        };
-
-  async function applyIncomingUrl(url = "", reason = "manual") {
-    const normalizedTargetPath = normalizeIncomingAppUrl(url, resolvedMobileConfig, {
-      currentOrigin,
-      allowedHttpOrigins
-    });
-    if (!normalizedTargetPath) {
-      return "";
-    }
-
-    let resolvedTargetPath = normalizedTargetPath;
-    if (typeof resolveTargetPath === "function") {
-      const nextTargetPath = await resolveTargetPath(
-        Object.freeze({
-          originalUrl: String(url || ""),
-          normalizedTargetPath,
-          reason,
-          mobileConfig: resolvedMobileConfig,
-          router
-        })
-      );
-      resolvedTargetPath = normalizeResolvedRoutePath(nextTargetPath, normalizedTargetPath);
-    }
-
-    const currentFullPath = String(router.currentRoute?.value?.fullPath || "").trim();
-    if (currentFullPath === resolvedTargetPath) {
-      return resolvedTargetPath;
-    }
-
-    await router.replace(resolvedTargetPath);
-    if (typeof runtimeLogger.info === "function") {
-      runtimeLogger.info(
-        {
-          reason,
-          targetPath: resolvedTargetPath
-        },
-        "Mobile launch routing applied incoming app URL."
-      );
-    }
-    return resolvedTargetPath;
-  }
-
-  async function initialize() {
-    if (resolvedMobileConfig.enabled !== true) {
-      return "";
-    }
-
-    const initialLaunchUrl = await getInitialLaunchUrl();
-    return applyIncomingUrl(initialLaunchUrl, "initial-launch");
-  }
-
-  const unsubscribe =
-    resolvedMobileConfig.enabled === true
-      ? subscribeToLaunchUrls((nextUrl) => {
-          Promise.resolve(applyIncomingUrl(nextUrl, "launch-event")).catch((error) => {
-            if (typeof runtimeLogger.warn === "function") {
-              runtimeLogger.warn(
-                {
-                  error: String(error?.message || error || "unknown error")
-                },
-                "Mobile launch routing failed to apply incoming app URL."
-              );
-            }
-          });
-        })
-      : () => {};
-
-  return Object.freeze({
-    initialize,
-    dispose() {
-      if (typeof unsubscribe === "function") {
-        unsubscribe();
-      }
-    },
-    applyIncomingUrl
-  });
-}
-
-export { normalizeIncomingAppUrl, registerMobileLaunchRouting };