@jskit-ai/kernel 0.1.244 → 0.1.246

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

@@ -3,7 +3,7 @@ import test from "node:test";
 import { createSchema } from "json-rest-schema";
 
 import { createRouter } from "./router.js";
-import { compileRouteValidator, defineRouteValidator, resolveRouteValidatorOptions } from "./routeValidator.js";
+import { compileRouteValidator, resolveRouteValidatorOptions } from "./routeValidator.js";
 
 function stripJsonRestTransportExtensions(value) {
   if (Array.isArray(value)) {
@@ -45,7 +45,7 @@ function createMockJsonRestSchema() {
   });
 }
 
-test("defineRouteValidator compiles body/query/params and maps query schema to querystring", () => {
+test("compileRouteValidator compiles body/query/params and maps query schema to querystring", () => {
   const bodySchema = createSchema({
     name: {
       type: "string",
@@ -82,7 +82,7 @@ test("defineRouteValidator compiles body/query/params and maps query schema to q
     type: "object"
   };
 
-  const validator = defineRouteValidator({
+  const compiled = compileRouteValidator({
     meta: {
       tags: ["contacts", "intake"],
       summary: "Create contact intake"
@@ -104,8 +104,6 @@ test("defineRouteValidator compiles body/query/params and maps query schema to q
     }
   });
 
-  const compiled = validator.toRouteOptions();
-
   assert.deepEqual(compiled.schema, {
     tags: ["contacts", "intake"],
     summary: "Create contact intake",
@@ -344,7 +342,7 @@ test("resolveRouteValidatorOptions rejects validator wrapper", () => {
       method: "POST",
       path: "/contacts",
       options: {
-        validator: defineRouteValidator({}),
+        validator: {},
         middleware: ["api"]
       }
     }),
@@ -352,10 +350,10 @@ test("resolveRouteValidatorOptions rejects validator wrapper", () => {
   );
 });
 
-test("defineRouteValidator rejects unsupported advanced.jskitInput", () => {
+test("compileRouteValidator rejects unsupported advanced.jskitInput", () => {
   assert.throws(
     () =>
-      defineRouteValidator({
+      compileRouteValidator({
         advanced: {
           jskitInput: {}
         }
@@ -364,24 +362,24 @@ test("defineRouteValidator rejects unsupported advanced.jskitInput", () => {
   );
 });
 
-test("defineRouteValidator rejects unsupported top-level keys generically", () => {
+test("compileRouteValidator rejects unsupported top-level keys generically", () => {
   assert.throws(
     () =>
-      defineRouteValidator({
+      compileRouteValidator({
         unsupportedContract: {
           schema: {
             type: "object"
           }
         }
       }),
-    /defineRouteValidator\(\)\.unsupportedContract is not supported/
+    /route validator\.unsupportedContract is not supported/
   );
 });
 
-test("defineRouteValidator validates meta fields", () => {
+test("compileRouteValidator validates meta fields", () => {
   assert.throws(
     () =>
-      defineRouteValidator({
+      compileRouteValidator({
         meta: {
           tags: ["ok", ""]
         }
@@ -391,7 +389,7 @@ test("defineRouteValidator validates meta fields", () => {
 
   assert.throws(
     () =>
-      defineRouteValidator({
+      compileRouteValidator({
         meta: {
           summary: ""
         }
@@ -407,7 +405,7 @@ test("HttpRouter.register rejects validator wrapper options", () => {
       "POST",
       "/contacts",
       {
-        validator: defineRouteValidator({})
+        validator: {}
       },
       async () => {}
     ),
@@ -425,7 +423,7 @@ test("HttpRouter.register rejects compiled route option payloads", () => {
     }
   });
 
-  const validator = defineRouteValidator({
+  const compiled = compileRouteValidator({
     query: {
       schema: querySchema
     }
@@ -434,7 +432,7 @@ test("HttpRouter.register rejects compiled route option payloads", () => {
   assert.throws(
     () => router.get(
       "/contacts",
-      validator.toRouteOptions(),
+      compiled,
       async () => {}
     ),
     /uses unsupported validator options: schema, input/

package/server/http/lib/router.js

@@ -1,7 +1,7 @@
 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";
+import { normalizeMiddlewareStack as normalizeSharedMiddlewareStack, resolveRouteLabel } from "./routeSupport.js";
 import { normalizeRouteOutputTransform, normalizeRouteTransport } from "./routeTransport.js";
 
 function normalizeMethod(method) {
@@ -13,17 +13,7 @@ function normalizePath(pathname) {
   if (!value.startsWith("/")) {
     throw new RouteDefinitionError(`Route path must start with '/': ${value || "<empty>"}`);
   }
-  return value.replace(/\/+/g, "/");
-}
-
-function joinPath(left, right) {
-  const leftPath = normalizeText(left);
-  const rightPath = normalizeText(right);
-
-  const normalizedLeft = leftPath ? `/${leftPath.replace(/^\/+|\/+$/g, "")}` : "";
-  const normalizedRight = rightPath ? `/${rightPath.replace(/^\/+|\/+$/g, "")}` : "";
-  const joined = `${normalizedLeft}${normalizedRight}`.replace(/\/+/g, "/");
-  return joined || "/";
+  return value.replace(/\/+/g, "/").replace(/(.)\/$/, "$1");
 }
 
 function normalizeRouterMiddlewareStack(value, { context = "middleware" } = {}) {
@@ -40,9 +30,7 @@ function normalizeRouteInternal(value, { method = "", path = "" } = {}) {
     return false;
   }
   if (typeof value !== "boolean") {
-    throw new RouteDefinitionError(
-      `Route ${String(method || "<unknown>")} ${String(path || "<unknown>")} internal must be a boolean.`
-    );
+    throw new RouteDefinitionError(`Route ${resolveRouteLabel({ method, path })} internal must be a boolean.`);
   }
   return value;
 }
@@ -74,12 +62,8 @@ function normalizeRouteInput(method, path, optionsOrHandler, maybeHandler) {
 }
 
 class HttpRouter {
-  constructor({ routes = null, prefix = "", middleware = [] } = {}) {
-    this._routes = Array.isArray(routes) ? routes : [];
-    this._prefix = normalizeText(prefix);
-    this._middleware = normalizeRouterMiddlewareStack(middleware, {
-      context: "router middleware"
-    });
+  constructor() {
+    this._routes = [];
   }
 
   register(method, path, optionsOrHandler, maybeHandler) {
@@ -111,7 +95,7 @@ class HttpRouter {
     const route = Object.freeze({
       id: normalizeText(resolvedOptions.id),
       method: input.method,
-      path: joinPath(this._prefix, input.path),
+      path: input.path,
       schema: resolvedOptions.schema,
       input: routeInput,
       output: routeOutput,
@@ -131,7 +115,7 @@ class HttpRouter {
       ownerResolver: resolvedOptions.ownerResolver,
       csrfProtection: resolvedOptions.csrfProtection,
       bodyLimit: resolvedOptions.bodyLimit,
-      middleware: Object.freeze([...this._middleware, ...routeMiddleware]),
+      middleware: Object.freeze(routeMiddleware),
       handler: input.handler
     });
 
@@ -159,81 +143,13 @@ class HttpRouter {
     return this.register("DELETE", path, optionsOrHandler, maybeHandler);
   }
 
-  group({ prefix = "", middleware = [] } = {}, defineRoutes = null) {
-    if (typeof defineRoutes !== "function") {
-      throw new RouteDefinitionError("group() requires a callback.");
-    }
-
-    const nestedRouter = new HttpRouter({
-      routes: this._routes,
-      prefix: joinPath(this._prefix, prefix || ""),
-      middleware: [
-        ...this._middleware,
-        ...normalizeRouterMiddlewareStack(middleware, {
-          context: "group middleware"
-        })
-      ]
-    });
-
-    defineRoutes(nestedRouter);
-    return this;
-  }
-
-  resource(name, controller, options = {}) {
-    this._resource(name, controller, {
-      ...normalizeObject(options),
-      apiOnly: false
-    });
-    return this;
-  }
-
-  apiResource(name, controller, options = {}) {
-    this._resource(name, controller, {
-      ...normalizeObject(options),
-      apiOnly: true
-    });
-    return this;
-  }
-
-  _resource(name, controller, options = {}) {
-    const resourceName = ensureNonEmptyText(name, "resource name");
-    const idParam = normalizeText(options.idParam, { fallback: "id" });
-    const basePath = `/${resourceName}`;
-    const itemPath = `/${resourceName}/:${idParam}`;
-
-    const methods = normalizeObject(controller);
-    const routeOptions = {
-      ...normalizeObject(options)
-    };
-    delete routeOptions.idParam;
-    delete routeOptions.apiOnly;
-
-    const requireMethod = (methodName) => {
-      const handler = methods[methodName];
-      if (typeof handler !== "function") {
-        throw new RouteDefinitionError(`resource controller for ${resourceName} is missing method ${methodName}().`);
-      }
-      return handler;
-    };
-
-    this.get(basePath, routeOptions, requireMethod("index"));
-    if (!options.apiOnly) {
-      this.get(`${basePath}/create`, routeOptions, requireMethod("create"));
-      this.get(`${itemPath}/edit`, routeOptions, requireMethod("edit"));
-    }
-    this.post(basePath, routeOptions, requireMethod("store"));
-    this.get(itemPath, routeOptions, requireMethod("show"));
-    this.put(itemPath, routeOptions, requireMethod("update"));
-    this.delete(itemPath, routeOptions, requireMethod("destroy"));
-  }
-
   list() {
     return Object.freeze([...this._routes]);
   }
 }
 
-function createRouter(options = {}) {
-  return new HttpRouter(options);
+function createRouter() {
+  return new HttpRouter();
 }
 
-export { HttpRouter, createRouter, joinPath };
+export { HttpRouter, createRouter };

package/server/platform/providerRuntime/capabilityProviderLoader.js

@@ -1,7 +1,8 @@
 import path from "node:path";
 import { pathToFileURL } from "node:url";
 import { defineProvider } from "../../../shared/capabilities/defineProvider.js";
-import { fileExists, isIdentifier, isInsidePackageRoot } from "./helpers.js";
+import { fileExists } from "../../../internal/node/fileSystem.js";
+import { isIdentifier, isInsidePackageRoot } from "./helpers.js";
 
 function declaredProviderEntrypoints(packageEntry) {
   const runtime = packageEntry?.packageMetadata?.runtime;

package/server/platform/providerRuntime/helpers.js

@@ -1,45 +1,12 @@
 import path from "node:path";
-import { escapeRegExp } from "../../../shared/surface/escapeRegExp.js";
-import { fileExists } from "../../../internal/node/fileSystem.js";
 
 function isIdentifier(value) {
   return /^[A-Za-z_$][A-Za-z0-9_$]*$/.test(String(value || ""));
 }
 
-function createWildcardMatcher(pattern) {
-  const rawPattern = String(pattern || "").trim();
-  if (!rawPattern) {
-    return null;
-  }
-
-  const escapedPattern = escapeRegExp(rawPattern).replace(/\\\*/g, ".*");
-  return new RegExp(`^${escapedPattern}$`);
-}
-
-function normalizeRelativePath(fromPath, targetPath) {
-  const relative = path.relative(path.resolve(fromPath), path.resolve(targetPath));
-  return relative.split(path.sep).join("/");
-}
-
 function isInsidePackageRoot(packageRoot, candidatePath) {
   const relative = path.relative(path.resolve(packageRoot), path.resolve(candidatePath));
   return relative === "" || (!relative.startsWith("..") && !path.isAbsolute(relative));
 }
 
-function toAbsoluteSortedUniquePaths(values) {
-  const source = Array.isArray(values) ? values : [];
-  return Object.freeze(
-    [...new Set(source.map((entry) => path.resolve(entry)).filter(Boolean))].sort((left, right) =>
-      left.localeCompare(right)
-    )
-  );
-}
-
-export {
-  isIdentifier,
-  createWildcardMatcher,
-  normalizeRelativePath,
-  fileExists,
-  isInsidePackageRoot,
-  toAbsoluteSortedUniquePaths
-};
+export { isIdentifier, isInsidePackageRoot };

package/server/runtime/integers.js

@@ -6,8 +6,4 @@ function parsePositiveInteger(value) {
   });
 }
 
-function normalizeNullablePositiveInteger(value) {
-  return parsePositiveInteger(value);
-}
-
-export { parsePositiveInteger, normalizeNullablePositiveInteger };
+export { parsePositiveInteger };

package/server/runtime/serviceAuthorization.js

@@ -26,7 +26,7 @@ function resolveRequireMode(value) {
   return mode;
 }
 
-function normalizeRequireAuthOptions(options = {}, { context = "requireAuth options" } = {}) {
+function normalizeRequireAuthOptions(options = {}) {
   const source = normalizeObject(options);
   const mode = resolveRequireMode(source.require);
   const permissions = normalizePermissionList(source.permissions);
@@ -35,8 +35,7 @@ function normalizeRequireAuthOptions(options = {}, { context = "requireAuth opti
     require: mode,
     permissions: Object.freeze(permissions),
     message: normalizeText(source.message),
-    code: normalizeText(source.code),
-    context
+    code: normalizeText(source.code)
   });
 }
 
@@ -71,7 +70,7 @@ function requireAuth(source = {}, options = {}) {
     return actor;
   }
 
-  const requiredPermissions = normalizePermissionList(settings.permissions);
+  const requiredPermissions = settings.permissions;
   if (requiredPermissions.length < 1) {
     return actor;
   }
@@ -106,8 +105,4 @@ function requireAuth(source = {}, options = {}) {
   return actor;
 }
 
-export {
-  resolveServiceContext,
-  hasPermission,
-  requireAuth
-};
+export { requireAuth };

package/server/support/appConfig.js

@@ -1,4 +1,5 @@
-import { normalizeMobileConfig, normalizeObject, normalizeText } from "../../shared/support/normalize.js";
+import { normalizeObject, normalizeText } from "../../shared/support/normalize.js";
+import { normalizeMobileConfig } from "../../shared/support/mobileConfig.js";
 import { normalizeSurfaceId } from "../../shared/surface/registry.js";
 
 function resolveAppConfig(scope = null) {

package/server/support/appConfigFiles.js

@@ -1,5 +1,4 @@
 import path from "node:path";
-import { fileURLToPath } from "node:url";
 import { fileExists } from "../../internal/node/fileSystem.js";
 import { importFreshModuleFromAbsolutePath } from "./importFreshModuleFromAbsolutePath.js";
 
@@ -10,27 +9,6 @@ function normalizeConfigObject(value) {
   return value && typeof value === "object" && !Array.isArray(value) ? value : {};
 }
 
-async function resolveAppRootFromModuleUrl(
-  moduleUrl,
-  { publicConfigRelativePath = PUBLIC_CONFIG_RELATIVE_PATH } = {}
-) {
-  const moduleDirectory = path.dirname(fileURLToPath(moduleUrl));
-  let currentDirectory = path.resolve(moduleDirectory);
-
-  while (true) {
-    const candidateConfigPath = path.join(currentDirectory, publicConfigRelativePath);
-    if (await fileExists(candidateConfigPath)) {
-      return currentDirectory;
-    }
-
-    const parentDirectory = path.dirname(currentDirectory);
-    if (parentDirectory === currentDirectory) {
-      throw new Error(`Unable to locate app root (missing ${publicConfigRelativePath}).`);
-    }
-    currentDirectory = parentDirectory;
-  }
-}
-
 async function loadConfigModuleAtPath(absolutePath) {
   if (!(await fileExists(absolutePath))) {
     return {};
@@ -62,19 +40,4 @@ async function loadAppConfigFromAppRoot({
   });
 }
 
-async function loadAppConfigFromModuleUrl({
-  moduleUrl = import.meta.url,
-  publicConfigRelativePath = PUBLIC_CONFIG_RELATIVE_PATH,
-  serverConfigRelativePath = SERVER_CONFIG_RELATIVE_PATH
-} = {}) {
-  const appRoot = await resolveAppRootFromModuleUrl(moduleUrl, {
-    publicConfigRelativePath
-  });
-  return loadAppConfigFromAppRoot({
-    appRoot,
-    publicConfigRelativePath,
-    serverConfigRelativePath
-  });
-}
-
-export { loadAppConfigFromAppRoot, loadAppConfigFromModuleUrl };
+export { loadAppConfigFromAppRoot };

package/server/support/appConfigFiles.test.js

@@ -3,32 +3,7 @@ import { mkdtemp, mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 import os from "node:os";
 import test from "node:test";
-import { pathToFileURL } from "node:url";
-import { loadAppConfigFromAppRoot, loadAppConfigFromModuleUrl } from "./appConfigFiles.js";
-
-async function createModuleUrlAt(absolutePath) {
-  await mkdir(path.dirname(absolutePath), { recursive: true });
-  await writeFile(absolutePath, "export {};\n", "utf8");
-  return pathToFileURL(absolutePath).href;
-}
-
-test("loadAppConfigFromModuleUrl merges public and server config", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "kernel-app-config-"));
-  const appRoot = path.join(tempRoot, "app");
-  await mkdir(path.join(appRoot, "config"), { recursive: true });
-  await writeFile(path.join(appRoot, "config", "public.js"), "export const config = { a: 1, shared: 'public' };", "utf8");
-  await writeFile(path.join(appRoot, "config", "server.js"), "export const config = { b: 2, shared: 'server' };", "utf8");
-  const moduleUrl = await createModuleUrlAt(path.join(appRoot, "packages", "main", "src", "server", "MainServiceProvider.js"));
-
-  const loaded = await loadAppConfigFromModuleUrl({ moduleUrl });
-
-  assert.deepEqual(loaded, {
-    a: 1,
-    b: 2,
-    shared: "server"
-  });
-  assert.equal(Object.isFrozen(loaded), true);
-});
+import { loadAppConfigFromAppRoot } from "./appConfigFiles.js";
 
 test("loadAppConfigFromAppRoot merges public and server config", async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "kernel-app-config-"));
@@ -69,26 +44,15 @@ test("loadAppConfigFromAppRoot requires an explicit appRoot", async () => {
   );
 });
 
-test("loadAppConfigFromModuleUrl tolerates missing server config", async () => {
+test("loadAppConfigFromAppRoot tolerates missing server config", async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "kernel-app-config-"));
   const appRoot = path.join(tempRoot, "app");
   await mkdir(path.join(appRoot, "config"), { recursive: true });
   await writeFile(path.join(appRoot, "config", "public.js"), "export const config = { a: 1 };", "utf8");
-  const moduleUrl = await createModuleUrlAt(path.join(appRoot, "packages", "main", "src", "server", "MainServiceProvider.js"));
 
-  const loaded = await loadAppConfigFromModuleUrl({ moduleUrl });
+  const loaded = await loadAppConfigFromAppRoot({ appRoot });
 
   assert.deepEqual(loaded, {
     a: 1
   });
 });
-
-test("loadAppConfigFromModuleUrl throws when app root cannot be resolved", async () => {
-  const tempRoot = await mkdtemp(path.join(os.tmpdir(), "kernel-app-config-"));
-  const moduleUrl = await createModuleUrlAt(path.join(tempRoot, "missing", "packages", "main", "src", "server", "MainServiceProvider.js"));
-
-  await assert.rejects(
-    loadAppConfigFromModuleUrl({ moduleUrl }),
-    /Unable to locate app root/
-  );
-});

package/server/support/index.js

@@ -1,6 +1,6 @@
 export { symlinkSafeRequire } from "./symlinkSafeRequire.js";
 export { resolveAppConfig, resolveMobileConfig, resolveClientAssetMode, resolveMobileCallbackUrls } from "./appConfig.js";
-export { loadAppConfigFromAppRoot, loadAppConfigFromModuleUrl } from "./appConfigFiles.js";
+export { loadAppConfigFromAppRoot } from "./appConfigFiles.js";
 export { importFreshModuleFromAbsolutePath } from "./importFreshModuleFromAbsolutePath.js";
 export {
   collectPackageDependencyIds,
@@ -9,23 +9,4 @@ export {
   discoverInstalledPackages
 } from "../../internal/node/installedPackages.js";
 export { resolveRequiredAppRoot, toPosixPath } from "./path.js";
-export {
-  DEFAULT_PAGE_LINK_COMPONENT_TOKEN,
-  DEFAULT_SUBPAGE_LINK_COMPONENT_TOKEN,
-  listSurfacePageRoots,
-  normalizePagesRelativeTargetFile,
-  normalizePagesRelativeTargetRoot,
-  resolveBestSurfaceMatchFromPageFile,
-  resolvePageTargetDetails,
-  deriveDefaultSubpagesHost,
-  resolveNearestParentSubpagesHost,
-  resolvePageLinkTargetDetails
-} from "./pageTargets.js";
-export {
-  discoverPlacementTopologyFromApp,
-  discoverShellOutletSourcePathsFromApp,
-  discoverShellOutletTargetsFromApp,
-  resolveSemanticPlacementTargetFromApp,
-  resolveShellOutletPlacementTargetFromApp
-} from "./shellOutlets.js";
 export { tryAcquireExclusiveFileLock } from "./fileLock.js";

package/shared/capabilities/defineProvider.js

@@ -96,4 +96,4 @@ function defineProvider({
   });
 }
 
-export { defineProvider, normalizeArchitectureId };
+export { ARCHITECTURE_ID_PATTERN, defineProvider, normalizeArchitectureId };

package/shared/capabilities/index.js

@@ -1,2 +1,2 @@
-export { defineProvider } from "./defineProvider.js";
+export { ARCHITECTURE_ID_PATTERN, defineProvider } from "./defineProvider.js";
 export { createCapabilityRuntime } from "./runtime.js";

package/shared/index.js

@@ -1,2 +1,2 @@
 export { resolveLinkPath } from "./support/linkPath.js";
-export { normalizePathname } from "./surface/apiPaths.js";
+export { normalizePathname } from "./surface/paths.js";

package/shared/support/index.js

@@ -3,10 +3,7 @@ export { pickOwnProperties } from "./pickOwnProperties.js";
 export { formatDateTime } from "./formatDateTime.js";
 export { appendQueryString, splitPathQueryAndHash } from "./queryPath.js";
 export { normalizePermissionList, hasPermission } from "./permissions.js";
-export {
-  normalizeReturnToPath,
-  resolveAllowedOriginsFromPlacementContext
-} from "./returnToPath.js";
+export { normalizeReturnToPath } from "./returnToPath.js";
 export { toCamelCase, toSnakeCase } from "./stringCase.js";
 export {
   isTransientQueryError,

package/shared/support/mobileConfig.js

@@ -0,0 +1,99 @@
+import {
+  hasValue,
+  normalizeBoolean,
+  normalizeLowerText,
+  normalizeObject,
+  normalizePositiveInteger,
+  normalizeText,
+  normalizeUniqueTextList
+} from "./normalize.js";
+
+const MOBILE_ASSET_MODES = Object.freeze(["bundled", "dev_server"]);
+const MOBILE_STRATEGIES = Object.freeze(["capacitor"]);
+const DEFAULT_MOBILE_AUTH_CONFIG = Object.freeze({
+  callbackPath: "/auth/login",
+  customScheme: "",
+  appLinkDomains: Object.freeze([])
+});
+const DEFAULT_MOBILE_ANDROID_CONFIG = Object.freeze({
+  packageName: "",
+  minSdk: 26,
+  targetSdk: 35,
+  versionCode: 1,
+  versionName: "1.0.0"
+});
+
+function normalizeMobileStrategy(value = "", { fallback = "" } = {}) {
+  const normalized = normalizeLowerText(value);
+  return MOBILE_STRATEGIES.includes(normalized) ? normalized : normalizeLowerText(fallback);
+}
+
+function normalizeMobileAssetMode(value = "", { fallback = "bundled" } = {}) {
+  const normalized = normalizeLowerText(value);
+  if (!normalized) {
+    return normalizeLowerText(fallback, {
+      fallback: "bundled"
+    });
+  }
+  if (!MOBILE_ASSET_MODES.includes(normalized)) {
+    throw new TypeError('config.mobile.assetMode must be "bundled" or "dev_server".');
+  }
+  return normalized;
+}
+
+function normalizeMobileCallbackPath(value = "", { fallback = "/auth/login" } = {}) {
+  const normalized = normalizeText(value, {
+    fallback
+  });
+  if (!normalized) {
+    return "";
+  }
+
+  return normalized.startsWith("/") ? normalized : `/${normalized}`;
+}
+
+function normalizeMobileConfig(source = {}) {
+  const mobile = normalizeObject(source);
+  const auth = normalizeObject(mobile.auth);
+  const android = normalizeObject(mobile.android);
+
+  return Object.freeze({
+    enabled: hasValue(mobile.enabled) ? normalizeBoolean(mobile.enabled) : false,
+    strategy: normalizeMobileStrategy(mobile.strategy),
+    appId: normalizeText(mobile.appId),
+    appName: normalizeText(mobile.appName),
+    assetMode: normalizeMobileAssetMode(mobile.assetMode),
+    devServerUrl: normalizeText(mobile.devServerUrl),
+    apiBaseUrl: normalizeText(mobile.apiBaseUrl),
+    auth: Object.freeze({
+      callbackPath: normalizeMobileCallbackPath(auth.callbackPath, {
+        fallback: DEFAULT_MOBILE_AUTH_CONFIG.callbackPath
+      }),
+      customScheme: normalizeLowerText(auth.customScheme),
+      appLinkDomains: Object.freeze([
+        ...new Set(
+          normalizeUniqueTextList(auth.appLinkDomains, {
+            acceptSingle: true
+          }).map((entry) => normalizeLowerText(entry))
+        )
+      ])
+    }),
+    android: Object.freeze({
+      packageName: normalizeText(android.packageName),
+      minSdk: normalizePositiveInteger(android.minSdk, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.minSdk
+      }),
+      targetSdk: normalizePositiveInteger(android.targetSdk, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.targetSdk
+      }),
+      versionCode: normalizePositiveInteger(android.versionCode, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionCode
+      }),
+      versionName: normalizeText(android.versionName, {
+        fallback: DEFAULT_MOBILE_ANDROID_CONFIG.versionName
+      })
+    })
+  });
+}
+
+export { normalizeMobileCallbackPath, normalizeMobileConfig };