@jskit-ai/kernel 0.1.32 → 0.1.34

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/kernel",
-  "version": "0.1.32",
+  "version": "0.1.34",
   "type": "module",
   "dependencies": {
     "typebox": "^1.0.81"
@@ -37,6 +37,7 @@
     "./shared/support/crudLookup": "./shared/support/crudLookup.js",
     "./shared/support/deepFreeze": "./shared/support/deepFreeze.js",
     "./shared/support/listenerSet": "./shared/support/listenerSet.js",
+    "./shared/support/shellLayoutTargets": "./shared/support/shellLayoutTargets.js",
     "./shared/support/providerLogger": "./shared/support/providerLogger.js",
     "./shared/support/returnToPath": "./shared/support/returnToPath.js",
     "./shared/support/visibility": "./shared/support/visibility.js",

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

@@ -236,7 +236,7 @@ test("registerRoutes attaches visibilityContext from route visibility resolvers"
       }
 
       return {
-        userOwnerId: context?.actor?.id,
+        userId: context?.actor?.id,
         requiresActorScope: true
       };
     }
@@ -281,7 +281,7 @@ test("registerRoutes attaches visibilityContext from route visibility resolvers"
     scopeKind: null,
     requiresActorScope: true,
     scopeOwnerId: null,
-    userOwnerId: 23
+    userId: "23"
   });
   assert.deepEqual(observed[0].context.requestMeta.visibilityContext, observed[0].context.visibilityContext);
   assert.equal(observed[0].context.requestMeta.routeVisibility, "user");
@@ -309,7 +309,7 @@ test("registerRoutes keeps actor scope requirement for core user visibility with
       }
 
       return {
-        userOwnerId: context?.actor?.id
+        userId: context?.actor?.id
       };
     }
   }));
@@ -353,7 +353,7 @@ test("registerRoutes keeps actor scope requirement for core user visibility with
     scopeKind: null,
     requiresActorScope: true,
     scopeOwnerId: null,
-    userOwnerId: 23
+    userId: "23"
   });
   assert.equal(observed[0].context.requestMeta.routeVisibility, "user");
 });
@@ -399,7 +399,7 @@ test("registerRoutes does not infer actor scope from non-core route visibility t
     scopeKind: null,
     requiresActorScope: false,
     scopeOwnerId: null,
-    userOwnerId: null
+    userId: null
   });
   assert.equal(observed[0].context.requestMeta.routeVisibility, "workspace_user");
 });

package/server/runtime/entityChangeEvents.js

@@ -43,10 +43,10 @@ function resolveVisibilityScope(visibilityContext = {}, runtimeContext = {}) {
   const visibility = normalizeText(visibilityContext.visibility).toLowerCase();
   const scopeKind = normalizeText(visibilityContext.scopeKind || visibility).toLowerCase();
   const scopeOwnerId = normalizeOpaqueId(visibilityContext.scopeOwnerId);
-  const userOwnerId = normalizeOpaqueId(visibilityContext.userOwnerId);
+  const userId = normalizeOpaqueId(visibilityContext.userId);
   const requiresActorScope = visibilityContext.requiresActorScope === true;
 
-  if (requiresActorScope && userOwnerId == null) {
+  if (requiresActorScope && userId == null) {
     return null;
   }
 
@@ -57,7 +57,7 @@ function resolveVisibilityScope(visibilityContext = {}, runtimeContext = {}) {
     };
     if (requiresActorScope) {
       scope.scopeId = scopeOwnerId;
-      scope.userId = userOwnerId;
+      scope.userId = userId;
     }
     return scope;
   }
@@ -72,10 +72,10 @@ function resolveVisibilityScope(visibilityContext = {}, runtimeContext = {}) {
     };
   }
 
-  if (scopeKind === "user" && userOwnerId != null) {
+  if (scopeKind === "user" && userId != null) {
     return {
       kind: "user",
-      id: userOwnerId
+      id: userId
     };
   }
 

package/server/runtime/entityChangeEvents.test.js

@@ -33,9 +33,9 @@ test("entity change publisher emits normalized event payload", async () => {
   });
 
   assert.equal(payload?.operation, "created");
-  assert.equal(payload?.entityId, 5);
-  assert.deepEqual(payload?.scope, { kind: "scope", id: 23 });
-  assert.equal(payload?.actorId, 17);
+  assert.equal(payload?.entityId, "5");
+  assert.deepEqual(payload?.scope, { kind: "scope", id: "23" });
+  assert.equal(payload?.actorId, "17");
   assert.equal(payload?.commandId, "cmd-1");
   assert.equal(payload?.sourceClientId, "client-a");
   assert.equal(payload?.meta?.service?.token, "crud.customers");
@@ -111,7 +111,7 @@ test("entity change publisher infers scoped owner from service context when visi
     }
   );
 
-  assert.deepEqual(payload?.scope, { kind: "workspace", id: 23 });
+  assert.deepEqual(payload?.scope, { kind: "workspace", id: "23" });
   assert.equal(published.length, 1);
 });
 
@@ -133,7 +133,7 @@ test("entity change publisher supports opaque actor and scope identifiers", asyn
       visibilityContext: {
         scopeKind: "workspace_user",
         scopeOwnerId: "workspace_23",
-        userOwnerId: "user_17",
+        userId: "user_17",
         requiresActorScope: true
       }
     }

package/server/runtime/serviceAuthorization.test.js

@@ -24,7 +24,7 @@ test("requireAuth accepts actor context", () => {
     }
   });
 
-  assert.equal(actor.id, 7);
+  assert.equal(actor.id, "7");
 });
 
 test("requireAuth accepts non-numeric actor ids", () => {

package/server/support/importFreshModuleFromAbsolutePath.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+import { pathToFileURL } from "node:url";
+
+let freshImportCounter = 0;
+
+function nextFreshImportToken() {
+  freshImportCounter += 1;
+  return String(freshImportCounter);
+}
+
+async function importFreshModuleFromAbsolutePath(absolutePath) {
+  const normalizedPath = String(absolutePath || "").trim();
+  if (!normalizedPath || !path.isAbsolute(normalizedPath)) {
+    throw new Error("importFreshModuleFromAbsolutePath requires an absolute path.");
+  }
+
+  const resolvedPath = path.resolve(normalizedPath);
+  const moduleUrl = pathToFileURL(resolvedPath);
+  moduleUrl.searchParams.set("jskit_fresh", nextFreshImportToken());
+  return import(moduleUrl.href);
+}
+
+export { importFreshModuleFromAbsolutePath };

package/server/support/importFreshModuleFromAbsolutePath.test.js

@@ -0,0 +1,36 @@
+import assert from "node:assert/strict";
+import { mkdtemp, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+import test from "node:test";
+import { importFreshModuleFromAbsolutePath } from "./importFreshModuleFromAbsolutePath.js";
+
+test("importFreshModuleFromAbsolutePath requires an absolute path", async () => {
+  await assert.rejects(
+    () => importFreshModuleFromAbsolutePath("relative/module.js"),
+    /requires an absolute path/
+  );
+});
+
+test("importFreshModuleFromAbsolutePath re-evaluates a module on each call", async () => {
+  const tempRoot = await mkdtemp(path.join(tmpdir(), "jskit-import-fresh-module-"));
+  const modulePath = path.join(tempRoot, "counter.mjs");
+  const counterKey = "__jskitKernelImportFreshCounter";
+  delete globalThis[counterKey];
+
+  await writeFile(
+    modulePath,
+    `globalThis.${counterKey} = Number(globalThis.${counterKey} || 0) + 1;
+export const loadCount = globalThis.${counterKey};
+`,
+    "utf8"
+  );
+
+  const first = await importFreshModuleFromAbsolutePath(modulePath);
+  const second = await importFreshModuleFromAbsolutePath(modulePath);
+
+  assert.equal(first.loadCount, 1);
+  assert.equal(second.loadCount, 2);
+
+  delete globalThis[counterKey];
+});

package/server/support/index.js

@@ -1,6 +1,7 @@
 export { symlinkSafeRequire } from "./symlinkSafeRequire.js";
 export { resolveAppConfig } from "./appConfig.js";
 export { loadAppConfigFromModuleUrl } from "./appConfigFiles.js";
+export { importFreshModuleFromAbsolutePath } from "./importFreshModuleFromAbsolutePath.js";
 export { resolveRequiredAppRoot, toPosixPath } from "./path.js";
 export {
   DEFAULT_PAGE_LINK_COMPONENT_TOKEN,

package/server/support/pageTargets.js

@@ -16,8 +16,9 @@ import {
 } from "../../shared/support/shellLayoutTargets.js";
 import { resolveShellOutletPlacementTargetFromApp } from "./shellOutlets.js";
 import { resolveRequiredAppRoot, toPosixPath } from "./path.js";
+import { loadAppConfigFromModuleUrl } from "./appConfigFiles.js";
 
-const DEFAULT_PAGE_LINK_COMPONENT_TOKEN = "users.web.shell.surface-aware-menu-link-item";
+const DEFAULT_PAGE_LINK_COMPONENT_TOKEN = "local.main.ui.surface-aware-menu-link-item";
 const DEFAULT_SUBPAGE_LINK_COMPONENT_TOKEN = "local.main.ui.tab-link-item";
 const PAGE_ROOT_PREFIX = "src/pages/";
 const ROUTER_VIEW_TAG_PATTERN = /<RouterView\b/i;
@@ -64,17 +65,17 @@ function resolvePagesRelativeAppPath(
   if (isAbsolutePathInput(normalizedValue)) {
     throw new Error(`${context} ${label} must be relative to src/pages/: ${normalizedValue}.`);
   }
-  if (
-    normalizedValue === "src/pages" ||
-    normalizedValue.startsWith(PAGE_ROOT_PREFIX)
-  ) {
+  if (normalizedValue === "src/pages" || normalizedValue === PAGE_ROOT_PREFIX) {
     throw new Error(
-      `${context} ${label} must be relative to src/pages/, without the src/pages/ prefix: ${normalizedValue}.`
+      `${context} ${label} must include a path under src/pages/: ${normalizedValue}.`
     );
   }
+  if (normalizedValue.startsWith(PAGE_ROOT_PREFIX)) {
+    return normalizedValue;
+  }
   if (normalizedValue.startsWith("src/")) {
     throw new Error(
-      `${context} ${label} must be relative to src/pages/, without a leading src/ segment: ${normalizedValue}.`
+      `${context} ${label} must be relative to src/pages/ or start with src/pages/: ${normalizedValue}.`
     );
   }
 
@@ -174,38 +175,46 @@ function humanizePageSegment(value = "", fallback = "Page") {
 
 async function loadPublicConfig(appRoot = "", { context = "page target" } = {}) {
   const resolvedAppRoot = resolveRequiredAppRoot(appRoot, { context });
-  const configPath = path.join(resolvedAppRoot, "config", "public.js");
-
-  try {
-    await readFile(configPath, "utf8");
-  } catch {
-    throw new Error(`${context} requires app config at config/public.js.`);
-  }
-
-  let moduleNamespace = null;
   try {
-    moduleNamespace = await import(pathToFileURL(configPath).href);
+    const config = normalizeObject(
+      await loadAppConfigFromModuleUrl({
+        moduleUrl: pathToFileURL(path.join(resolvedAppRoot, "config", "public.js")).href
+      })
+    );
+    if (Object.keys(config).length < 1) {
+      throw new Error("requires exported config in config/public.js.");
+    }
+    return config;
   } catch (error) {
     throw new Error(
       `${context} could not load config/public.js: ${String(error?.message || error || "unknown error")}`
     );
   }
+}
 
-  const config = normalizeObject(
-    moduleNamespace?.config ||
-    moduleNamespace?.default?.config ||
-    moduleNamespace?.default
-  );
-  if (Object.keys(config).length < 1) {
-    throw new Error(`${context} requires exported config in config/public.js.`);
+function normalizeSurfaceAccessPolicyId(value = "") {
+  return normalizeText(value).toLowerCase();
+}
+
+function resolveSurfaceRequiresAuth(surfaceDefinition = {}, surfaceAccessPolicies = {}) {
+  const normalizedDefinition = normalizeObject(surfaceDefinition);
+  const normalizedPolicies = normalizeObject(surfaceAccessPolicies);
+  const accessPolicyId = normalizeSurfaceAccessPolicyId(normalizedDefinition.accessPolicyId);
+  const configuredPolicy = accessPolicyId
+    ? normalizeObject(normalizedPolicies[accessPolicyId])
+    : {};
+
+  if (Object.hasOwn(configuredPolicy, "requireAuth")) {
+    return configuredPolicy.requireAuth === true;
   }
 
-  return config;
+  return normalizedDefinition.requiresAuth === true;
 }
 
 async function listSurfacePageRoots(appRoot = "", { context = "page target" } = {}) {
   const config = await loadPublicConfig(appRoot, { context });
   const surfaceDefinitions = normalizeObject(config.surfaceDefinitions);
+  const surfaceAccessPolicies = normalizeObject(config.surfaceAccessPolicies);
 
   return Object.freeze(
     Object.entries(surfaceDefinitions)
@@ -218,7 +227,8 @@ async function listSurfacePageRoots(appRoot = "", { context = "page target" } =
 
         return Object.freeze({
           id: surfaceId,
-          pagesRoot: normalizeSurfacePagesRoot(definition.pagesRoot)
+          pagesRoot: normalizeSurfacePagesRoot(definition.pagesRoot),
+          requiresAuth: resolveSurfaceRequiresAuth(definition, surfaceAccessPolicies)
         });
       })
       .filter(Boolean)
@@ -239,6 +249,7 @@ function deriveSurfaceMatchesFromPageFile(relativePath = "", surfacePageRoots =
         return Object.freeze({
           surfaceId: normalizeSurfaceId(surface?.id),
           pagesRoot,
+          requiresAuth: surface?.requiresAuth === true,
           surfaceRelativeFilePath: pagePathWithinPagesRoot
         });
       }
@@ -251,6 +262,7 @@ function deriveSurfaceMatchesFromPageFile(relativePath = "", surfacePageRoots =
       return Object.freeze({
         surfaceId: normalizeSurfaceId(surface?.id),
         pagesRoot,
+        requiresAuth: surface?.requiresAuth === true,
         surfaceRelativeFilePath: pagePathWithinPagesRoot.slice(requiredPrefix.length)
       });
     })
@@ -433,9 +445,7 @@ function resolveSubpagesHostTargetFromPageSource(source = "") {
   }
 
   return Object.freeze({
-    id: target.id,
-    host: target.host,
-    position: target.position
+    id: target.id
   });
 }
 
@@ -468,6 +478,7 @@ async function resolvePageTargetDetails({
     }),
     surfaceId: surfaceMatch.surfaceId,
     surfacePagesRoot: surfaceMatch.pagesRoot,
+    surfaceRequiresAuth: surfaceMatch.requiresAuth === true,
     surfaceRelativeFilePath: surfaceMatch.surfaceRelativeFilePath,
     ...routeInfo
   });
@@ -530,12 +541,7 @@ async function resolveNearestParentSubpagesHost({
 }
 
 function normalizePlacementTargetId(target = {}) {
-  const host = normalizeText(target?.host);
-  const position = normalizeText(target?.position);
-  if (!host || !position) {
-    return "";
-  }
-  return normalizeShellOutletTargetId(`${host}:${position}`);
+  return normalizeShellOutletTargetId(target?.id || target?.target || target);
 }
 
 function resolveRelativeLinkToFromParent(pageTarget = {}, parentHost = null) {
@@ -616,6 +622,11 @@ function resolveInferredPageLinkComponentToken({
     return normalizedExplicitToken;
   }
 
+  const normalizedPlacementTargetDefaultToken = normalizeText(placementTarget?.defaultLinkComponentToken);
+  if (normalizedPlacementTargetDefaultToken) {
+    return normalizedPlacementTargetDefaultToken;
+  }
+
   const parentTargetId = normalizePlacementTargetId(parentHost);
   const placementTargetId = normalizePlacementTargetId(placementTarget);
   if (parentTargetId && parentTargetId === placementTargetId) {
@@ -625,6 +636,14 @@ function resolveInferredPageLinkComponentToken({
   return normalizeText(defaultComponentToken) || DEFAULT_PAGE_LINK_COMPONENT_TOKEN;
 }
 
+function renderPageLinkWhenLine(pageTarget = {}) {
+  if (pageTarget?.surfaceRequiresAuth !== true) {
+    return "";
+  }
+
+  return "    when: ({ auth }) => Boolean(auth?.authenticated)\n";
+}
+
 async function resolvePageLinkTargetDetails({
   appRoot,
   targetFile = "",
@@ -663,6 +682,7 @@ async function resolvePageLinkTargetDetails({
       defaultComponentToken,
       subpageComponentToken
     }),
+    whenLine: renderPageLinkWhenLine(resolvedPageTarget),
     linkTo: resolveInferredPageLinkTo({
       explicitLinkTo: linkTo,
       pageTarget: resolvedPageTarget,

package/server/support/pageTargets.test.js

@@ -36,8 +36,12 @@ async function writeShellLayout(appRoot, source = "") {
     source ||
       `<template>
   <div>
-    <ShellOutlet host="shell-layout" position="top-right" />
-    <ShellOutlet host="shell-layout" position="primary-menu" default />
+    <ShellOutlet target="shell-layout:top-right" />
+    <ShellOutlet
+      target="shell-layout:primary-menu"
+      default
+      default-link-component-token="local.main.ui.surface-aware-menu-link-item"
+    />
   </div>
 </template>
 `
@@ -128,6 +132,41 @@ test("resolvePageTargetDetails chooses the most specific matching surface pagesR
   });
 });
 
+test("resolvePageTargetDetails derives surface auth requirement from surface access policy", async () => {
+  await withTempApp(async (appRoot) => {
+    await writeConfig(
+      appRoot,
+      `export const config = {
+  surfaceAccessPolicies: {
+    public: {},
+    authenticated: {
+      requireAuth: true
+    }
+  },
+  surfaceDefinitions: {
+    home: { id: "home", pagesRoot: "home", enabled: true, accessPolicyId: "public" },
+    app: { id: "app", pagesRoot: "app", enabled: true, accessPolicyId: "authenticated" }
+  }
+};
+`
+    );
+
+    const publicPageTarget = await resolvePageTargetDetails({
+      appRoot,
+      targetFile: "home/index.vue",
+      context: "page target"
+    });
+    const authenticatedPageTarget = await resolvePageTargetDetails({
+      appRoot,
+      targetFile: "app/index.vue",
+      context: "page target"
+    });
+
+    assert.equal(publicPageTarget.surfaceRequiresAuth, false);
+    assert.equal(authenticatedPageTarget.surfaceRequiresAuth, true);
+  });
+});
+
 test("resolvePageTargetDetails rejects duplicate matching surface pagesRoot definitions", async () => {
   await withTempApp(async (appRoot) => {
     await writeConfig(
@@ -153,7 +192,7 @@ test("resolvePageTargetDetails rejects duplicate matching surface pagesRoot defi
   });
 });
 
-test("resolvePageTargetDetails rejects target files with a src/pages prefix", async () => {
+test("resolvePageTargetDetails accepts target files with a src/pages prefix", async () => {
   await withTempApp(async (appRoot) => {
     await writeConfig(
       appRoot,
@@ -165,26 +204,25 @@ test("resolvePageTargetDetails rejects target files with a src/pages prefix", as
 `
     );
 
-    await assert.rejects(
-      () =>
-        resolvePageTargetDetails({
-          appRoot,
-          targetFile: "src/pages/admin/reports/index.vue",
-          context: "page target"
-        }),
-      /must be relative to src\/pages\/, without the src\/pages\/ prefix/
-    );
+    const details = await resolvePageTargetDetails({
+      appRoot,
+      targetFile: "src/pages/admin/reports/index.vue",
+      context: "page target"
+    });
+
+    assert.equal(details.targetFilePath.relativePath, "src/pages/admin/reports/index.vue");
+    assert.equal(details.surfaceId, "admin");
+    assert.equal(details.routeUrlSuffix, "/reports");
   });
 });
 
-test("normalizePagesRelativeTargetRoot rejects route roots with a src/pages prefix", () => {
-  assert.throws(
-    () =>
-      normalizePagesRelativeTargetRoot("src/pages/admin/customers", {
-        context: "crud-ui-generator",
-        label: 'option "target-root"'
-      }),
-    /must be relative to src\/pages\/, without the src\/pages\/ prefix/
+test("normalizePagesRelativeTargetRoot accepts route roots with a src/pages prefix", () => {
+  assert.equal(
+    normalizePagesRelativeTargetRoot("src/pages/admin/customers", {
+      context: "crud-ui-generator",
+      label: 'option "target-root"'
+    }),
+    "src/pages/admin/customers"
   );
 });
 
@@ -208,10 +246,77 @@ test("resolvePageLinkTargetDetails falls back to the app default placement targe
     });
 
     assert.equal(details.pageTarget.surfaceId, "admin");
-    assert.equal(details.placementTarget.host, "shell-layout");
-    assert.equal(details.placementTarget.position, "primary-menu");
-    assert.equal(details.componentToken, "users.web.shell.surface-aware-menu-link-item");
+    assert.equal(details.placementTarget.id, "shell-layout:primary-menu");
+    assert.equal(details.componentToken, "local.main.ui.surface-aware-menu-link-item");
     assert.equal(details.linkTo, "");
+    assert.equal(details.whenLine, "");
+  });
+});
+
+test("resolvePageLinkTargetDetails emits an auth guard when the surface policy requires auth", async () => {
+  await withTempApp(async (appRoot) => {
+    await writeConfig(
+      appRoot,
+      `export const config = {
+  surfaceAccessPolicies: {
+    authenticated: {
+      requireAuth: true
+    }
+  },
+  surfaceDefinitions: {
+    app: { id: "app", pagesRoot: "app", enabled: true, accessPolicyId: "authenticated" }
+  }
+};
+`
+    );
+    await writeShellLayout(appRoot);
+
+    const details = await resolvePageLinkTargetDetails({
+      appRoot,
+      targetFile: "app/reports/index.vue",
+      context: "page target"
+    });
+
+    assert.equal(details.whenLine, "    when: ({ auth }) => Boolean(auth?.authenticated)\n");
+  });
+});
+
+test("resolvePageLinkTargetDetails prefers an outlet-declared default link token over subpage heuristics", async () => {
+  await withTempApp(async (appRoot) => {
+    await writeConfig(
+      appRoot,
+      `export const config = {
+  surfaceDefinitions: {
+    home: { id: "home", pagesRoot: "home", enabled: true }
+  }
+};
+`
+    );
+    await writeFileInApp(
+      appRoot,
+      "src/pages/home/settings.vue",
+      `<template>
+  <section>
+    <ShellOutlet
+      target="home-settings:primary-menu"
+      default-link-component-token="local.main.ui.surface-aware-menu-link-item"
+    />
+    <RouterView />
+  </section>
+</template>
+`
+    );
+
+    const details = await resolvePageLinkTargetDetails({
+      appRoot,
+      targetFile: "home/settings/pollen-types/index.vue",
+      context: "page target"
+    });
+
+    assert.equal(details.parentHost?.id, "home-settings:primary-menu");
+    assert.equal(details.placementTarget.id, "home-settings:primary-menu");
+    assert.equal(details.componentToken, "local.main.ui.surface-aware-menu-link-item");
+    assert.equal(details.linkTo, "./pollen-types");
   });
 });
 
@@ -233,7 +338,7 @@ test("resolvePageLinkTargetDetails inherits a file-route parent subpages host",
       `<template>
   <SectionContainerShell>
     <template #tabs>
-      <ShellOutlet host="contact-view" position="sub-pages" />
+      <ShellOutlet target="contact-view:sub-pages" />
     </template>
     <RouterView />
   </SectionContainerShell>
@@ -248,8 +353,7 @@ test("resolvePageLinkTargetDetails inherits a file-route parent subpages host",
     });
 
     assert.equal(details.parentHost?.id, "contact-view:sub-pages");
-    assert.equal(details.placementTarget.host, "contact-view");
-    assert.equal(details.placementTarget.position, "sub-pages");
+    assert.equal(details.placementTarget.id, "contact-view:sub-pages");
     assert.equal(details.componentToken, "local.main.ui.tab-link-item");
     assert.equal(details.linkTo, "./notes");
   });
@@ -277,8 +381,7 @@ test("resolvePageLinkTargetDetails honors explicit placement and link overrides"
       context: "page target"
     });
 
-    assert.equal(details.placementTarget.host, "shell-layout");
-    assert.equal(details.placementTarget.position, "top-right");
+    assert.equal(details.placementTarget.id, "shell-layout:top-right");
     assert.equal(details.componentToken, "custom.link-item");
     assert.equal(details.linkTo, "./assistant-notes");
   });
@@ -302,7 +405,7 @@ test("resolvePageLinkTargetDetails inherits an index-route parent subpages host
       `<template>
   <SectionContainerShell>
     <template #tabs>
-      <ShellOutlet host="customer-view" position="sub-pages" />
+      <ShellOutlet target="customer-view:sub-pages" />
     </template>
     <RouterView />
   </SectionContainerShell>
@@ -318,8 +421,7 @@ test("resolvePageLinkTargetDetails inherits an index-route parent subpages host
 
     assert.equal(details.parentHost?.id, "customer-view:sub-pages");
     assert.equal(details.parentHost?.pageFile, "src/pages/admin/customers/[customerId]/index.vue");
-    assert.equal(details.placementTarget.host, "customer-view");
-    assert.equal(details.placementTarget.position, "sub-pages");
+    assert.equal(details.placementTarget.id, "customer-view:sub-pages");
     assert.equal(details.componentToken, "local.main.ui.tab-link-item");
     assert.equal(details.linkTo, "./pets");
   });