@jskit-ai/kernel 0.1.245 → 0.1.247

package/client/appConfig.js

@@ -1,4 +1,5 @@
-import { isRecord, normalizeMobileConfig } from "../shared/support/normalize.js";
+import { isRecord } from "../shared/support/normalize.js";
+import { normalizeMobileConfig } from "../shared/support/mobileConfig.js";
 
 const CLIENT_APP_CONFIG_GLOBAL_KEY = "__JSKIT_CLIENT_APP_CONFIG__";
 const EMPTY_CLIENT_APP_CONFIG = Object.freeze({});

package/client/asyncModuleRecovery.js

@@ -1,3 +1,5 @@
+import { isRecord } from "../shared/support/normalize.js";
+
 const DYNAMIC_IMPORT_ERROR_PATTERNS = Object.freeze([
   /ChunkLoadError/iu,
   /Failed to fetch dynamically imported module/iu,
@@ -7,10 +9,6 @@ const DYNAMIC_IMPORT_ERROR_PATTERNS = Object.freeze([
   /Unable to preload CSS/iu
 ]);
 
-function isRecord(value) {
-  return Boolean(value && typeof value === "object" && !Array.isArray(value));
-}
-
 function errorText(error = null) {
   return String(error?.message || error || "").trim();
 }

package/client/index.d.ts

@@ -6,85 +6,13 @@ export type ClientLogger = {
   isDebugEnabled?: boolean;
 };
 
-export type AsyncModuleRecoveryState = {
-  attempt: number;
-  error: any;
-  label: string;
-  message: string;
-  retry: (() => any) | null;
-  stale: boolean;
-  visible: boolean;
-};
-
-export function createAsyncModuleRecoveryState(options?: {
-  label?: string;
-  message?: string;
-  retry?: (() => any) | null;
-}): AsyncModuleRecoveryState;
-
-export function isDynamicImportError(error?: any): boolean;
-
-export function dynamicImportErrorMessage(error?: any, options?: {
-  label?: string;
-  stale?: boolean;
-}): string;
-
-export function notifyAsyncModuleLoadError(
-  state: AsyncModuleRecoveryState,
-  error?: any,
-  options?: {
-    label?: string;
-    message?: string;
-    retry?: (() => any) | null;
-    stale?: boolean;
-  }
-): AsyncModuleRecoveryState;
-
-export function dismissAsyncModuleRecovery(state: AsyncModuleRecoveryState): boolean;
-
-export function guardedReloadApp(options?: {
-  browserWindow?: any;
-  fetchFn?: ((input: string, init?: Record<string, any>) => Promise<any>) | null;
-  state?: AsyncModuleRecoveryState | null;
-  label?: string;
-  message?: string;
-}): Promise<boolean>;
+export * from "./asyncModuleRecovery";
 
-export function installAsyncModuleRecoveryHandlers(options?: {
-  router?: any;
-  state: AsyncModuleRecoveryState;
-  label?: string;
-  onNotify?: (state: AsyncModuleRecoveryState) => void;
-  windowObject?: any;
-}): Readonly<{
-  dispose: () => void;
-}>;
+export const DEFAULT_GUARD_EVALUATOR_KEY: "__JSKIT_WEB_SHELL_GUARD_EVALUATOR__";
 
 export function getClientAppConfig(): Readonly<Record<string, any>>;
 export function resolveMobileConfig(appConfig?: Record<string, any>): Readonly<Record<string, any>>;
 export function resolveClientAssetMode(appConfig?: Record<string, any>): string;
-export function normalizeIncomingAppUrl(
-  url?: string,
-  mobileConfig?: Record<string, any>,
-  options?: {
-    currentOrigin?: string;
-    allowedHttpOrigins?: string[];
-  }
-): string;
-export function registerMobileLaunchRouting(options?: {
-  router: any;
-  mobileConfig?: Record<string, any>;
-  getInitialLaunchUrl?: () => Promise<string> | string;
-  subscribeToLaunchUrls?: (handler: (url: string) => void) => (() => void) | void;
-  currentOrigin?: string;
-  allowedHttpOrigins?: string[];
-  logger?: ClientLogger;
-}): Readonly<{
-  initialize: () => Promise<string>;
-  dispose: () => void;
-  applyIncomingUrl: (url?: string, reason?: string) => Promise<string>;
-}>;
-
 export function resolveClientBootstrapDebugEnabled(options?: {
   env?: Record<string, any>;
   debugEnabled?: boolean;
@@ -101,7 +29,15 @@ export function createShellRouter(options?: {
   surfaceMode?: string;
   fallbackRoute?: any;
   notFoundComponent?: any;
-  guard?: false | ((to: any) => any) | Record<string, any>;
+  guard?:
+    | false
+    | ((to: any) => any)
+    | {
+        webRootAllowed?: "yes" | "no";
+        guardEvaluatorKey?: string;
+        authenticatedPolicy?: string;
+        publicPolicy?: string;
+      };
   /** Defaults to shellScrollBehavior; pass your own function, or false for none. */
   scrollBehavior?: false | ((to: any, from: any, savedPosition: any) => any);
 }): Readonly<{
@@ -116,6 +52,7 @@ export function bootstrapClientShellApp(options?: {
   appConfig?: Record<string, any>;
   appPlugins?: any[];
   pinia?: any;
+  queryClient?: any;
   router: any;
   bootClientModules: (context: any) => Promise<any>;
   surfaceRuntime: any;
@@ -123,6 +60,7 @@ export function bootstrapClientShellApp(options?: {
   env?: Record<string, any>;
   fallbackRoute?: any;
   logger?: ClientLogger;
+  /** Its isDebugEnabled decides whether bootstrap builds debug payloads; without it, a debug method means enabled. */
   createBootstrapLogger?: (options: {
     env?: Record<string, any>;
     logger?: ClientLogger;

package/client/index.js

@@ -8,11 +8,11 @@ export {
   isDynamicImportError,
   notifyAsyncModuleLoadError
 } from "./asyncModuleRecovery.js";
-export { normalizeIncomingAppUrl, registerMobileLaunchRouting } from "./mobileLaunchRouting.js";
 export {
   resolveClientBootstrapDebugEnabled,
   createSurfaceShellRouter as createShellRouter,
   shellScrollBehavior,
   bootstrapClientShellApp
 } from "./shellBootstrap.js";
+export { DEFAULT_GUARD_EVALUATOR_KEY } from "./shellRouting.js";
 export { createComponentInteractionEmitter } from "./componentInteraction.js";

package/client/logging.js

@@ -1,12 +1,17 @@
 import { isRecord } from "../shared/support/normalize.js";
 
+// isDebugEnabled tells callers whether debug output goes anywhere, so they
+// can skip building debug payloads. A logger may state it; otherwise it is
+// true exactly when the logger has its own debug method.
 function createStructuredLogger(logger = console) {
   if (isRecord(logger)) {
+    const hasDebug = typeof logger.debug === "function";
     return Object.freeze({
       info: typeof logger.info === "function" ? logger.info.bind(logger) : console.info.bind(console),
       warn: typeof logger.warn === "function" ? logger.warn.bind(logger) : console.warn.bind(console),
       error: typeof logger.error === "function" ? logger.error.bind(logger) : console.error.bind(console),
-      debug: typeof logger.debug === "function" ? logger.debug.bind(logger) : () => {}
+      debug: hasDebug ? logger.debug.bind(logger) : () => {},
+      isDebugEnabled: typeof logger.isDebugEnabled === "boolean" ? logger.isDebugEnabled : hasDebug
     });
   }
 
@@ -14,7 +19,8 @@ function createStructuredLogger(logger = console) {
     info: console.info.bind(console),
     warn: console.warn.bind(console),
     error: console.error.bind(console),
-    debug: () => {}
+    debug: () => {},
+    isDebugEnabled: false
   });
 }
 

package/client/moduleBootstrap.js

@@ -136,16 +136,18 @@ function registerClientModuleRoutes({
     surfaceMode
   });
   const log = createStructuredLogger(logger);
-  log.debug(
-    {
-      packageId: normalizedPackageId,
-      source,
-      surfaceMode: String(surfaceMode || "").trim(),
-      declaredRoutes: normalizedRoutes.map(toRouteSnapshot),
-      activeRoutes: activeRoutes.map(toRouteSnapshot)
-    },
-    "Client route registration analysis."
-  );
+  if (log.isDebugEnabled) {
+    log.debug(
+      {
+        packageId: normalizedPackageId,
+        source,
+        surfaceMode: String(surfaceMode || "").trim(),
+        declaredRoutes: normalizedRoutes.map(toRouteSnapshot),
+        activeRoutes: activeRoutes.map(toRouteSnapshot)
+      },
+      "Client route registration analysis."
+    );
+  }
 
   const declaredPaths = normalizedRoutes.map((route) => route.path);
   const activePaths = activeRoutes.map((route) => route.path);
@@ -167,14 +169,16 @@ function registerClientModuleRoutes({
 
     seenRoutePaths.add(normalizedPath);
     router.addRoute(toVueRouteRecord(route));
-    log.debug(
-      {
-        packageId: normalizedPackageId,
-        source,
-        route: toRouteSnapshot(route)
-      },
-      "Added client route to router."
-    );
+    if (log.isDebugEnabled) {
+      log.debug(
+        {
+          packageId: normalizedPackageId,
+          source,
+          route: toRouteSnapshot(route)
+        },
+        "Added client route to router."
+      );
+    }
     registeredCount += 1;
   }
 
@@ -560,14 +564,16 @@ async function bootClientModules({
       },
       "Registered client module routes."
     );
-    log.debug(
-      {
-        packageId,
-        source,
-        routerRoutes: summarizeRouterRoutes(router)
-      },
-      "Router route table after client route registration."
-    );
+    if (log.isDebugEnabled) {
+      log.debug(
+        {
+          packageId,
+          source,
+          routerRoutes: summarizeRouterRoutes(router)
+        },
+        "Router route table after client route registration."
+      );
+    }
     routeResults.push(result);
     return result;
   };
@@ -599,13 +605,15 @@ async function bootClientModules({
       },
       "Booted JSKIT client modules."
     );
-    log.debug(
-      {
-        routerRoutes: summarizeRouterRoutes(router),
-        currentPath: typeof window !== "undefined" ? String(window.location?.pathname || "") : ""
-      },
-      "JSKIT client bootstrap final route table."
-    );
+    if (log.isDebugEnabled) {
+      log.debug(
+        {
+          routerRoutes: summarizeRouterRoutes(router),
+          currentPath: typeof window !== "undefined" ? String(window.location?.pathname || "") : ""
+        },
+        "JSKIT client bootstrap final route table."
+      );
+    }
   }
 
   return Object.freeze({

package/client/moduleBootstrap.test.js

@@ -433,3 +433,38 @@ test("bootClientModules throws when packageMetadataClientProviders export is mis
     /packageMetadata provider export "MissingProvider" must be a capability provider/
   );
 });
+
+test("bootClientModules builds route debug payloads only when the logger's debug is enabled", async () => {
+  const surfaceRuntime = createSurfaceRuntimeFixture();
+  const clientModules = [
+    {
+      packageId: "@example/auth",
+      packageMetadataUiRoutes: [{ id: "auth.login", path: "/auth/login", scope: "global", autoRegister: false }],
+      module: {
+        clientRoutes: [{ id: "auth.login", name: "auth-login", path: "/auth/login", scope: "global", component: {} }]
+      }
+    }
+  ];
+
+  for (const isDebugEnabled of [false, true]) {
+    const router = createRouterStub();
+    let routeTableReads = 0;
+    router.getRoutes = () => {
+      routeTableReads += 1;
+      return [...router.routes];
+    };
+    const messages = [];
+    await bootClientModules({
+      clientModules,
+      router,
+      surfaceRuntime,
+      surfaceMode: "all",
+      logger: { info() {}, warn() {}, error() {}, debug: (_payload, message) => messages.push(message), isDebugEnabled }
+    });
+
+    assert.equal(router.routes.length, 1);
+    assert.equal(routeTableReads > 0, isDebugEnabled);
+    assert.equal(messages.includes("Added client route to router."), isDebugEnabled);
+    assert.equal(messages.includes("JSKIT client bootstrap final route table."), isDebugEnabled);
+  }
+});

package/client/shellBootstrap.js

@@ -204,14 +204,7 @@ async function bootstrapClientShellApp({
     logger: bootstrapLogger
   });
 
-  const isDebugEnabled =
-    typeof resolvedLogger?.isDebugEnabled === "boolean"
-      ? resolvedLogger.isDebugEnabled
-      : resolveClientBootstrapDebugEnabled({
-          env,
-          debugEnabled,
-          debugEnvKey
-        });
+  const { isDebugEnabled } = bootstrapLogger;
   if (isDebugEnabled) {
     bootstrapLogger.info(
       {

package/client/shellBootstrap.test.js

@@ -53,11 +53,6 @@ test("createSurfaceShellRouter builds active routes and installs a guard", () =>
     surfaceMode: "app",
     notFoundComponent: {},
     guard: {
-      surfaceDefinitions: {
-        app: { id: "app", pagesRoot: "app", requiresAuth: false },
-        admin: { id: "admin", pagesRoot: "admin", requiresAuth: false }
-      },
-      defaultSurfaceId: "app",
       webRootAllowed: "yes"
     }
   });
@@ -132,6 +127,38 @@ test("createClientBootstrapLogger enables debug from env flag", () => {
   assert.equal(logger.isDebugEnabled, true);
 });
 
+test("bootstrapClientShellApp hands hooks and modules one logger that carries its debug flag", async () => {
+  for (const debugEnabled of [false, true]) {
+    let routeTableReads = 0;
+    const seenLoggers = [];
+    const router = {
+      addRoute() {},
+      getRoutes() {
+        routeTableReads += 1;
+        return [];
+      },
+      async isReady() {}
+    };
+    const result = await bootstrapClientShellApp({
+      createApp: () => ({ use() {}, mount() {} }),
+      router,
+      surfaceRuntime: createSurfaceRuntimeFixture(),
+      logger: { info() {}, warn() {}, error() {} },
+      debugEnabled,
+      bootClientModules: async ({ logger }) => {
+        seenLoggers.push(logger);
+        return {};
+      },
+      onAfterRouterReady: ({ logger }) => seenLoggers.push(logger)
+    });
+
+    assert.equal(result.debugEnabled, debugEnabled);
+    assert.equal(result.logger.isDebugEnabled, debugEnabled);
+    assert.deepEqual(seenLoggers, [result.logger, result.logger]);
+    assert.equal(routeTableReads > 0, debugEnabled);
+  }
+});
+
 test("bootstrapClientShellApp boots modules, reinstalls fallback route, and mounts app", async () => {
   const calls = [];
   const logs = [];

package/client/shellRouting.js

@@ -1,4 +1,3 @@
-import { deriveSurfaceRouteBaseFromPagesRoot } from "../shared/surface/index.js";
 import { filterRoutesBySurface } from "../shared/surface/runtime.js";
 import { isExternalLinkTarget } from "../shared/support/linkPath.js";
 import { AUTH_POLICY_AUTHENTICATED, AUTH_POLICY_PUBLIC } from "../shared/support/policies.js";
@@ -101,20 +100,6 @@ function resolveSearchFromFullPath(fullPath) {
   return hashStart < 0 ? rawFullPath.slice(queryStart) : rawFullPath.slice(queryStart, hashStart);
 }
 
-function resolveSurfaceDefinition(surfaceDefinitions, surfaceId) {
-  const normalizedSurfaceId = String(surfaceId || "")
-    .trim()
-    .toLowerCase();
-  if (!normalizedSurfaceId) {
-    return null;
-  }
-  const definition = surfaceDefinitions[normalizedSurfaceId];
-  if (!definition || typeof definition !== "object") {
-    return null;
-  }
-  return definition;
-}
-
 function normalizeWebRootAllowed(value) {
   const normalizedValue = String(value || "")
     .trim()
@@ -125,27 +110,7 @@ function normalizeWebRootAllowed(value) {
   return WEB_ROOT_ALLOW_YES;
 }
 
-function resolveDefaultSurfaceRootPath({ surfaceDefinitions, defaultSurfaceId }) {
-  const defaultSurface = resolveSurfaceDefinition(surfaceDefinitions, defaultSurfaceId);
-  return String(
-    defaultSurface?.routeBase || deriveSurfaceRouteBaseFromPagesRoot(defaultSurface?.pagesRoot || "")
-  ).trim() || "/";
-}
-
-function resolveSurfaceRequiresAuth({ pathname, surfaceRuntime, surfaceDefinitions }) {
-  const normalizedPathname = String(pathname || "/").trim() || "/";
-  const surfaceId = surfaceRuntime.resolveSurfaceFromPathname(normalizedPathname);
-  const surfaceDefinition = resolveSurfaceDefinition(surfaceDefinitions, surfaceId);
-  return Boolean(surfaceDefinition?.requiresAuth);
-}
-
-function resolveEffectiveRouteGuard({
-  to,
-  surfaceRuntime,
-  surfaceDefinitions,
-  authenticatedPolicy = AUTH_POLICY_AUTHENTICATED,
-  publicPolicy = AUTH_POLICY_PUBLIC
-}) {
+function resolveEffectiveRouteGuard({ to, surfaceRuntime, authenticatedPolicy, publicPolicy }) {
   const routeGuard = resolveRouteGuard(to);
   const routePolicy = normalizeGuardPolicy(routeGuard?.policy);
   if (routePolicy) {
@@ -154,13 +119,8 @@ function resolveEffectiveRouteGuard({
     };
   }
 
-  if (
-    resolveSurfaceRequiresAuth({
-      pathname: to?.path || "/",
-      surfaceRuntime,
-      surfaceDefinitions
-    })
-  ) {
+  const surfaceId = surfaceRuntime.resolveSurfaceFromPathname(String(to?.path || "/").trim() || "/");
+  if (surfaceRuntime.getSurfaceDefinition(surfaceId)?.requiresAuth) {
     return {
       policy: authenticatedPolicy
     };
@@ -245,31 +205,27 @@ function evaluateShellGuard({ guard, to, guardEvaluatorKey }) {
 
 function createShellBeforeEachGuard({
   surfaceRuntime,
-  surfaceDefinitions,
-  defaultSurfaceId,
   webRootAllowed = WEB_ROOT_ALLOW_YES,
   guardEvaluatorKey = DEFAULT_GUARD_EVALUATOR_KEY,
   authenticatedPolicy = AUTH_POLICY_AUTHENTICATED,
   publicPolicy = AUTH_POLICY_PUBLIC
 } = {}) {
-  if (!surfaceRuntime || typeof surfaceRuntime.resolveSurfaceFromPathname !== "function") {
-    throw new TypeError("createShellBeforeEachGuard requires surfaceRuntime.resolveSurfaceFromPathname().");
-  }
-  if (!surfaceDefinitions || typeof surfaceDefinitions !== "object" || Array.isArray(surfaceDefinitions)) {
-    throw new TypeError("createShellBeforeEachGuard requires a surfaceDefinitions object.");
+  if (
+    !surfaceRuntime ||
+    typeof surfaceRuntime.resolveSurfaceFromPathname !== "function" ||
+    typeof surfaceRuntime.getSurfaceDefinition !== "function"
+  ) {
+    throw new TypeError(
+      "createShellBeforeEachGuard requires surfaceRuntime.resolveSurfaceFromPathname() and getSurfaceDefinition()."
+    );
   }
 
+  const defaultSurfaceRootPath =
+    surfaceRuntime.getSurfaceDefinition(surfaceRuntime.DEFAULT_SURFACE_ID)?.routeBase || "/";
+  const redirectWebRoot = normalizeWebRootAllowed(webRootAllowed) === WEB_ROOT_ALLOW_NO && defaultSurfaceRootPath !== "/";
+
   return (to) => {
-    const normalizedWebRootAllowed = normalizeWebRootAllowed(webRootAllowed);
-    const defaultSurfaceRootPath = resolveDefaultSurfaceRootPath({
-      surfaceDefinitions,
-      defaultSurfaceId
-    });
-    if (
-      normalizedWebRootAllowed === WEB_ROOT_ALLOW_NO &&
-      String(to?.path || "/").trim() === "/" &&
-      defaultSurfaceRootPath !== "/"
-    ) {
+    if (redirectWebRoot && String(to?.path || "/").trim() === "/") {
       const search = resolveSearchFromFullPath(to?.fullPath || "");
       const hash = String(to?.hash || "").trim();
       return `${defaultSurfaceRootPath}${search}${hash}`;
@@ -278,7 +234,6 @@ function createShellBeforeEachGuard({
     const guard = resolveEffectiveRouteGuard({
       to,
       surfaceRuntime,
-      surfaceDefinitions,
       authenticatedPolicy,
       publicPolicy
     });

package/client/shellRouting.test.js

@@ -1,7 +1,7 @@
 import assert from "node:assert/strict";
 import test from "node:test";
 import { createSurfaceRuntime } from "../shared/surface/runtime.js";
-import { buildSurfaceAwareRoutes } from "./shellRouting.js";
+import { DEFAULT_GUARD_EVALUATOR_KEY, buildSurfaceAwareRoutes, createShellBeforeEachGuard } from "./shellRouting.js";
 
 test("buildSurfaceAwareRoutes keeps declared route paths and filters by surface mode", () => {
   const surfaceRuntime = createSurfaceRuntime({
@@ -111,3 +111,32 @@ test("buildSurfaceAwareRoutes preserves parent path when nested descendants are
   const routePaths = routes.map((route) => route.path);
   assert.equal(routePaths.includes("/account"), true);
 });
+
+test("createShellBeforeEachGuard reads surfaces and the default root from the surface runtime", () => {
+  const surfaceRuntime = createSurfaceRuntime({
+    defaultSurfaceId: "app",
+    surfaces: {
+      home: { pagesRoot: "" },
+      app: { pagesRoot: "w/app", requiresAuth: true }
+    }
+  });
+  const evaluations = [];
+  const previousEvaluator = globalThis[DEFAULT_GUARD_EVALUATOR_KEY];
+  globalThis[DEFAULT_GUARD_EVALUATOR_KEY] = ({ guard, context }) => {
+    evaluations.push({ policy: guard.policy, pathname: context.location.pathname });
+    return { allow: false, redirectTo: "/auth/login" };
+  };
+
+  try {
+    const guard = createShellBeforeEachGuard({ surfaceRuntime, webRootAllowed: "no" });
+    assert.equal(guard({ path: "/", fullPath: "/?next=1#top", hash: "#top" }), "/w/app?next=1#top");
+    assert.equal(guard({ path: "/about", fullPath: "/about", matched: [] }), true);
+    assert.equal(guard({ path: "/w/app/projects", fullPath: "/w/app/projects", matched: [] }), "/auth/login");
+    assert.deepEqual(evaluations, [{ policy: "authenticated", pathname: "/w/app/projects" }]);
+
+    const openGuard = createShellBeforeEachGuard({ surfaceRuntime });
+    assert.equal(openGuard({ path: "/", fullPath: "/", matched: [] }), true);
+  } finally {
+    globalThis[DEFAULT_GUARD_EVALUATOR_KEY] = previousEvaluator;
+  }
+});

package/client/vite/clientBootstrapPlugin.js

@@ -234,11 +234,6 @@ function resolveInstalledViteProxyEntries(installedPackages = [], { proxyTarget
   return proxyEntries;
 }
 
-async function resolveInstalledClientPackageIds(options) {
-  const modules = await resolveInstalledClientModules(options);
-  return Object.freeze(modules.map((entry) => entry.packageId));
-}
-
 async function resolveLocalScopePackageIds({ appRoot }) {
   const appPackageJson = await readJsonFile(path.resolve(appRoot, "package.json"), {});
   return Object.freeze(
@@ -487,7 +482,6 @@ export {
   resolveCanonicalLocalPackageId,
   resolveLocalPackageForSpecifier,
   resolveLocalPackageSources,
-  resolveInstalledClientPackageIds,
   resolveLocalScopePackageIds,
   resolveInstalledClientModules,
   resolveInstalledViteProxyEntries,

package/client/vite/clientBootstrapPlugin.test.js

@@ -14,7 +14,6 @@ import {
   resolveClientOptimizeIncludeSpecifiers,
   resolveClientOptimizeExcludeSpecifiers,
   resolveLocalScopePackageIds,
-  resolveInstalledClientPackageIds,
   resolveInstalledClientModules,
   resolveInstalledViteProxyEntries
 } from "./clientBootstrapPlugin.js";
@@ -260,7 +259,7 @@ test("resolveClientOptimizeIncludeSpecifiers omits excluded package clients", ()
   assert.deepEqual(include, ["@c/pkg/client"]);
 });
 
-test("resolveInstalledClientPackageIds returns only installed packages with a client export", async () => {
+test("resolveInstalledClientModules returns only installed packages with a client export", async () => {
   const tempRoot = await mkdtemp(path.join(os.tmpdir(), "jskit-client-bootstrap-"));
   const appRoot = tempRoot;
 
@@ -289,7 +288,7 @@ test("resolveInstalledClientPackageIds returns only installed packages with a cl
     }
   });
 
-  const packageIds = await resolveInstalledClientPackageIds({ appRoot });
+  const packageIds = (await resolveInstalledClientModules({ appRoot })).map((entry) => entry.packageId);
 
   assert.deepEqual(packageIds, ["@example/has-client"]);
 });