@jskit-ai/kernel 0.1.245 → 0.1.247

package/shared/support/shellLayoutTargets.test.js

@@ -1,11 +1,6 @@
 import assert from "node:assert/strict";
 import test from "node:test";
-import {
-  describeShellOutletTargets,
-  discoverShellOutletTargetsFromVueSource,
-  findShellOutletTargetById,
-  normalizeShellOutletTargetId
-} from "./shellLayoutTargets.js";
+import { normalizeShellOutletTargetId } from "./shellLayoutTargets.js";
 
 test("normalizeShellOutletTargetId validates host:position tokens", () => {
   assert.equal(normalizeShellOutletTargetId("shell-layout:primary-menu"), "shell-layout:primary-menu");
@@ -14,107 +9,3 @@ test("normalizeShellOutletTargetId validates host:position tokens", () => {
   assert.equal(normalizeShellOutletTargetId("shell-layout"), "");
   assert.equal(normalizeShellOutletTargetId("shell-layout:"), "");
 });
-
-test("discoverShellOutletTargetsFromVueSource resolves legal targets and one default", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:top-left" />
-      <ShellOutlet
-        target="shell-layout:primary-menu"
-        default
-      />
-      <ShellOutlet target="shell-layout:secondary-menu" />
-    </template>
-  `;
-
-  const discovered = discoverShellOutletTargetsFromVueSource(source, {
-    context: "ShellLayout.vue"
-  });
-
-  assert.equal(discovered.defaultTargetId, "shell-layout:primary-menu");
-  assert.deepEqual(
-    discovered.targets.map((entry) => entry.id),
-    ["shell-layout:top-left", "shell-layout:primary-menu", "shell-layout:secondary-menu"]
-  );
-  assert.equal(
-    describeShellOutletTargets(discovered.targets),
-    "shell-layout:top-left, shell-layout:primary-menu, shell-layout:secondary-menu"
-  );
-  assert.deepEqual(
-    findShellOutletTargetById(discovered.targets, " shell-layout : primary-menu "),
-    discovered.targets[1]
-  );
-});
-
-test("discoverShellOutletTargetsFromVueSource throws for duplicate targets", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:top-right" />
-      <ShellOutlet target="shell-layout:top-right" />
-    </template>
-  `;
-
-  assert.throws(
-    () => discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" }),
-    /duplicate ShellOutlet target/
-  );
-});
-
-test("discoverShellOutletTargetsFromVueSource throws for multiple defaults", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:primary-menu" default />
-      <ShellOutlet target="shell-layout:secondary-menu" default />
-    </template>
-  `;
-
-  assert.throws(
-    () => discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" }),
-    /multiple default ShellOutlet targets/
-  );
-});
-
-test("discoverShellOutletTargetsFromVueSource can collect source hints without enforcing one default", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:primary-menu" default />
-      <ShellOutlet target="shell-layout:primary-bottom-nav" default />
-    </template>
-  `;
-
-  const discovered = discoverShellOutletTargetsFromVueSource(source, {
-    context: "ShellLayout.vue",
-    enforceSingleDefault: false
-  });
-
-  assert.equal(discovered.defaultTargetId, "shell-layout:primary-menu");
-  assert.deepEqual(
-    discovered.targets.map((entry) => entry.id),
-    ["shell-layout:primary-menu", "shell-layout:primary-bottom-nav"]
-  );
-});
-
-test("discoverShellOutletTargetsFromVueSource ignores disabled default markers", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:primary-menu" default="false" />
-      <ShellOutlet target="shell-layout:secondary-menu" />
-    </template>
-  `;
-
-  const discovered = discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" });
-  assert.equal(discovered.defaultTargetId, "");
-});
-
-test("discoverShellOutletTargetsFromVueSource reads the target attribute", () => {
-  const source = `
-    <template>
-      <ShellOutlet target="shell-layout:primary-menu" host="other-host" position="primary-menu" />
-    </template>
-  `;
-
-  assert.deepEqual(
-    discoverShellOutletTargetsFromVueSource(source, { context: "ShellLayout.vue" }).targets,
-    [{ id: "shell-layout:primary-menu", default: false }]
-  );
-});

package/shared/support/sorting.js

@@ -4,12 +4,4 @@ function sortStrings(values = []) {
   );
 }
 
-function sortById(items = [], { idSelector = (item) => item?.id } = {}) {
-  return [...(Array.isArray(items) ? items : [])].sort((left, right) => {
-    const leftId = String(idSelector(left) || "").trim();
-    const rightId = String(idSelector(right) || "").trim();
-    return leftId.localeCompare(rightId);
-  });
-}
-
-export { sortStrings, sortById };
+export { sortStrings };

package/shared/surface/apiPaths.js

@@ -1,11 +1,4 @@
-import { matchesPathPrefix, normalizePathname } from "./paths.js";
-
-const API_BASE_PATH = "/api";
-const API_PREFIX = "/api";
-const API_PREFIX_SLASH = `${API_PREFIX}/`;
-const API_DOCS_PATH = `${API_PREFIX}/docs`;
-const API_REALTIME_PATH = `${API_PREFIX}/realtime`;
-const VERSIONED_API_PATH_PATTERN = /^\/api\/v[0-9]+(?:$|\/)/;
+import { API_BASE_PATH, normalizePathname } from "./paths.js";
 
 function normalizeRouteTemplateParams(params = null) {
   if (!params || typeof params !== "object" || Array.isArray(params)) {
@@ -77,81 +70,7 @@ function resolveScopedApiBasePath({
   return `${basePath}${normalizedRelativePath}`;
 }
 
-function isApiPath(pathname) {
-  return matchesPathPrefix(pathname, API_BASE_PATH);
-}
-
-function isVersionedApiPath(pathname) {
-  return VERSIONED_API_PATH_PATTERN.test(normalizePathname(pathname));
-}
-
-function toVersionedApiPath(pathname) {
-  const normalizedPathname = normalizePathname(pathname);
-  if (!isApiPath(normalizedPathname)) {
-    return normalizedPathname;
-  }
-
-  if (isVersionedApiPath(normalizedPathname)) {
-    return normalizedPathname;
-  }
-
-  if (normalizedPathname === API_BASE_PATH) {
-    return API_PREFIX;
-  }
-
-  return `${API_PREFIX}${normalizedPathname.slice(API_BASE_PATH.length)}`;
-}
-
-function toVersionedApiPrefix(pathnameOrPrefix) {
-  const versionedPath = toVersionedApiPath(pathnameOrPrefix || API_BASE_PATH);
-  if (!isApiPath(versionedPath)) {
-    return normalizePathname(versionedPath);
-  }
-
-  if (versionedPath === API_PREFIX) {
-    return API_PREFIX_SLASH;
-  }
-
-  return `${versionedPath}/`;
-}
-
-function buildVersionedApiPath(suffix) {
-  const rawSuffix = String(suffix || "").trim();
-  if (!rawSuffix || rawSuffix === "/") {
-    return API_PREFIX;
-  }
-
-  const normalizedSuffix = normalizePathname(rawSuffix.startsWith("/") ? rawSuffix : `/${rawSuffix}`);
-  if (isApiPath(normalizedSuffix)) {
-    return toVersionedApiPath(normalizedSuffix);
-  }
-
-  if (normalizedSuffix === "/") {
-    return API_PREFIX;
-  }
-
-  return `${API_PREFIX}${normalizedSuffix}`;
-}
-
-function isVersionedApiPrefixMatch(pathname) {
-  const normalizedPathname = normalizePathname(pathname);
-  return normalizedPathname === API_PREFIX || normalizedPathname.startsWith(API_PREFIX_SLASH);
-}
-
 export {
-  API_BASE_PATH,
-  API_PREFIX,
-  API_PREFIX_SLASH,
-  API_DOCS_PATH,
-  API_REALTIME_PATH,
-  materializeRouteTemplate,
-  normalizePathname,
-  isApiPath,
-  isVersionedApiPath,
-  toVersionedApiPath,
-  toVersionedApiPrefix,
-  buildVersionedApiPath,
-  isVersionedApiPrefixMatch,
   resolveScopedRouteBase,
   resolveScopedApiBasePath
 };

package/shared/surface/paths.js

@@ -1,4 +1,7 @@
 import { escapeRegExp } from "./escapeRegExp.js";
+import { normalizeSurfaceId } from "./registry.js";
+
+const API_BASE_PATH = "/api";
 
 function normalizePathname(pathname) {
   const rawValue = String(pathname || "/").trim();
@@ -73,201 +76,65 @@ function compareSurfaceRouteSpecificity(left, right) {
   return String(left.id || "").localeCompare(String(right.id || ""));
 }
 
-function createSurfacePathHelpers(options = {}) {
-  const normalizeSurfaceId = options?.normalizeSurfaceId;
-  const resolveSurfaceRouteBaseFromRegistry = options?.resolveSurfaceRouteBase;
-  const listSurfaceDefinitions = options?.listSurfaceDefinitions;
-
-  if (typeof normalizeSurfaceId !== "function") {
-    throw new Error("createSurfacePathHelpers requires normalizeSurfaceId.");
-  }
-  if (typeof resolveSurfaceRouteBaseFromRegistry !== "function") {
-    throw new Error("createSurfacePathHelpers requires resolveSurfaceRouteBase.");
-  }
-  if (typeof listSurfaceDefinitions !== "function") {
-    throw new Error("createSurfacePathHelpers requires listSurfaceDefinitions.");
-  }
-
-  const defaultSurfaceId = normalizeSurfaceId(options?.defaultSurfaceId);
-  if (!defaultSurfaceId) {
+function createSurfacePathHelpers({ defaultSurfaceId, surfaceDefinitions, apiBasePath = API_BASE_PATH } = {}) {
+  const normalizedDefaultSurfaceId = normalizeSurfaceId(defaultSurfaceId);
+  if (!normalizedDefaultSurfaceId) {
     throw new Error("createSurfacePathHelpers requires defaultSurfaceId.");
   }
-
-  const apiBasePath = normalizePathname(options?.apiBasePath || "/api");
-  const routeConfig = options?.routes && typeof options.routes === "object" && !Array.isArray(options.routes) ? options.routes : {};
-
-  function normalizeSurface(surface) {
-    return normalizeSurfaceId(surface);
-  }
-
-  function resolveSurfaceRouteBase(surface) {
-    return normalizePathname(resolveSurfaceRouteBaseFromRegistry(surface));
+  if (!Array.isArray(surfaceDefinitions)) {
+    throw new Error("createSurfacePathHelpers requires a surfaceDefinitions array.");
   }
 
-  function surfaceDefinitions() {
-    return listSurfaceDefinitions().filter(
-      (surface) => surface && typeof surface === "object" && !Array.isArray(surface)
-    );
-  }
+  const normalizedApiBasePath = normalizePathname(apiBasePath);
+  const routedSurfaces = surfaceDefinitions
+    .map((definition) => {
+      const surfaceId = normalizeSurfaceId(definition?.id);
+      if (!surfaceId) {
+        return null;
+      }
 
-  function routedSurfaceDefinitions() {
-    return surfaceDefinitions()
-      .map((definition) => {
-        const surfaceId = normalizeSurface(definition?.id);
-        if (!surfaceId) {
-          return null;
-        }
+      const matcher = compileSurfaceRouteMatcher(definition.routeBase || "/");
+      return {
+        id: surfaceId,
+        routeBase: matcher.routeBase,
+        segmentCount: matcher.segmentCount,
+        staticSegmentCount: matcher.staticSegmentCount,
+        matcher
+      };
+    })
+    .filter(Boolean)
+    .sort(compareSurfaceRouteSpecificity);
 
-        const routeBase = resolveSurfaceRouteBase(surfaceId);
-        const matcher = compileSurfaceRouteMatcher(routeBase);
-        return {
-          id: surfaceId,
-          routeBase,
-          segmentCount: matcher.segmentCount,
-          staticSegmentCount: matcher.staticSegmentCount,
-          matcher
-        };
-      })
-      .filter(Boolean)
-      .sort(compareSurfaceRouteSpecificity);
+  function matchSurface(pathname) {
+    return routedSurfaces.find((surface) => surface.matcher.test(pathname))?.id || normalizedDefaultSurfaceId;
   }
 
   function resolveApiNamespace(pathname) {
-    const normalizedPathname = normalizePathname(pathname);
-    if (!matchesPathPrefix(normalizedPathname, apiBasePath)) {
+    if (!matchesPathPrefix(pathname, normalizedApiBasePath)) {
       return "";
     }
 
-    if (normalizedPathname === apiBasePath) {
-      return apiBasePath;
-    }
-
-    const remainder = normalizedPathname.slice(apiBasePath.length);
-    if (!remainder || remainder === "/") {
-      return apiBasePath;
-    }
-
-    const versionMatch = remainder.match(/^\/v[0-9]+(?:$|\/)/);
+    const versionMatch = pathname.slice(normalizedApiBasePath.length).match(/^\/v[0-9]+(?:$|\/)/);
     if (!versionMatch) {
-      return apiBasePath;
-    }
-
-    const versionPath = String(versionMatch[0]).replace(/\/$/, "");
-    return normalizePathname(`${apiBasePath}${versionPath}`);
-  }
-
-  function resolveSurfaceFromApiPathname(pathname) {
-    const apiNamespace = resolveApiNamespace(pathname);
-    if (!apiNamespace) {
-      return "";
-    }
-
-    const normalizedPathname = normalizePathname(pathname);
-    const remainder = normalizedPathname.slice(apiNamespace.length) || "/";
-    const apiRelativePath = normalizePathname(remainder.startsWith("/") ? remainder : `/${remainder}`);
-
-    for (const surface of routedSurfaceDefinitions()) {
-      if (surface.matcher.test(apiRelativePath)) {
-        return surface.id;
-      }
+      return normalizedApiBasePath;
     }
 
-    return defaultSurfaceId;
+    return normalizePathname(`${normalizedApiBasePath}${versionMatch[0]}`);
   }
 
   function resolveSurfaceFromPathname(pathname) {
     const normalizedPathname = normalizePathname(pathname);
-    const apiSurface = resolveSurfaceFromApiPathname(normalizedPathname);
-    if (apiSurface) {
-      return apiSurface;
-    }
-
-    for (const surface of routedSurfaceDefinitions()) {
-      if (surface.matcher.test(normalizedPathname)) {
-        return surface.id;
-      }
-    }
-
-    return defaultSurfaceId;
-  }
-
-  function withSurfaceRouteBase(surface, path) {
-    const normalizedPath = normalizePathname(path);
-    const routeBase = resolveSurfaceRouteBase(surface);
-    if (normalizedPath === "/") {
-      return routeBase || "/";
-    }
-
-    if (routeBase === "/") {
-      return normalizedPath;
-    }
-    return normalizePathname(`${routeBase}${normalizedPath}`);
-  }
-
-  function normalizeOptionalRoutePath(path) {
-    const normalizedPath = String(path || "").trim();
-    if (!normalizedPath) {
-      return "";
-    }
-
-    return normalizePathname(normalizedPath);
-  }
-
-  function createSurfacePaths(surface) {
-    const normalizedSurface = normalizeSurface(surface);
-    const routeBase = resolveSurfaceRouteBase(normalizedSurface);
-
-    const rootPath = routeBase || "/";
-    const namedPaths = {};
-    for (const [routeName, routePath] of Object.entries(routeConfig)) {
-      const normalizedRouteName = String(routeName || "").trim();
-      if (!normalizedRouteName) {
-        continue;
-      }
-      const normalizedRoutePath = normalizeOptionalRoutePath(routePath);
-      if (!normalizedRoutePath) {
-        continue;
-      }
-      namedPaths[normalizedRouteName] = withSurfaceRouteBase(normalizedSurface, normalizedRoutePath);
+    const apiNamespace = resolveApiNamespace(normalizedPathname);
+    if (!apiNamespace) {
+      return matchSurface(normalizedPathname);
     }
 
-    const frozenNamedPaths = Object.freeze({
-      ...namedPaths
-    });
-
-    return {
-      surface: normalizedSurface,
-      routeBase,
-      rootPath,
-      namedPaths: frozenNamedPaths,
-      isNamedPath(routeName, pathname) {
-        const normalizedRouteName = String(routeName || "").trim();
-        if (!normalizedRouteName || !Object.hasOwn(frozenNamedPaths, normalizedRouteName)) {
-          return false;
-        }
-        return normalizePathname(pathname) === frozenNamedPaths[normalizedRouteName];
-      }
-    };
-  }
-
-  function resolveSurfacePaths(pathname) {
-    const browserPathname =
-      typeof window !== "undefined" && window?.location?.pathname ? String(window.location.pathname) : "";
-    const effectivePathname = browserPathname || pathname;
-    return createSurfacePaths(resolveSurfaceFromPathname(effectivePathname));
+    return matchSurface(normalizePathname(normalizedPathname.slice(apiNamespace.length)));
   }
 
   return Object.freeze({
-    normalizePathname,
-    matchesPathPrefix,
-    compileSurfaceRouteMatcher,
-    resolveSurfaceFromApiPathname,
-    resolveSurfaceFromPathname,
-    resolveSurfaceRouteBase,
-    withSurfaceRouteBase,
-    createSurfacePaths,
-    resolveSurfacePaths
+    resolveSurfaceFromPathname
   });
 }
 
-export { createSurfacePathHelpers, normalizePathname, matchesPathPrefix };
+export { API_BASE_PATH, createSurfacePathHelpers, normalizePathname, matchesPathPrefix };

package/shared/surface/registry.js

@@ -81,7 +81,8 @@ function createSurfaceRegistry(options = {}) {
           ...sourceDefinition,
           id: normalizedId,
           pagesRoot,
-          routeBase: deriveSurfaceRouteBaseFromPagesRoot(pagesRoot)
+          routeBase: deriveSurfaceRouteBaseFromPagesRoot(pagesRoot),
+          enabled: sourceDefinition.enabled !== false
         })
       ];
     })

package/shared/surface/runtime.js

@@ -1,41 +1,9 @@
 import { createSurfacePathHelpers } from "./paths.js";
-import {
-  createSurfaceRegistry,
-  deriveSurfaceRouteBaseFromPagesRoot,
-  normalizeSurfaceId,
-  normalizeSurfacePagesRoot
-} from "./registry.js";
+import { createSurfaceRegistry, normalizeSurfaceId } from "./registry.js";
 import { isRecord } from "../support/normalize.js";
 
-function uniqueSurfaceIds(ids) {
-  const seen = new Set();
-  const ordered = [];
-  for (const id of ids) {
-    const normalizedId = normalizeSurfaceId(id);
-    if (!normalizedId || seen.has(normalizedId)) {
-      continue;
-    }
-    seen.add(normalizedId);
-    ordered.push(normalizedId);
-  }
-  return ordered;
-}
-
-function resolveSurfaceIds({ surfaces = {} } = {}) {
-  const surfaceCandidates = [];
-  for (const [key, value] of Object.entries(isRecord(surfaces) ? surfaces : {})) {
-    const record = isRecord(value) ? value : {};
-    surfaceCandidates.push(record.id || key);
-  }
-
-  const fromSurfaces = uniqueSurfaceIds(surfaceCandidates);
-  if (fromSurfaces.length > 0) {
-    return fromSurfaces;
-  }
-
-  throw new Error("createSurfaceRuntime requires at least one surface id.");
-}
-
+// Unlike normalizePathname, this keeps "?" so vue-router optional params
+// such as "/users/:id?" survive when a route is hoisted to an absolute path.
 function normalizeRoutePath(pathLike = "") {
   const rawPath = String(pathLike || "").trim();
   if (!rawPath || rawPath === "/") {
@@ -44,9 +12,6 @@ function normalizeRoutePath(pathLike = "") {
 
   const withLeadingSlash = rawPath.startsWith("/") ? rawPath : `/${rawPath}`;
   const compacted = withLeadingSlash.replace(/\/{2,}/g, "/");
-  if (compacted === "/") {
-    return "/";
-  }
   return compacted.replace(/\/+$/, "") || "/";
 }
 
@@ -99,16 +64,7 @@ function resolveRouteSurface(route, inheritedSurfaceId = "", { surfaceRuntime, a
     return normalizedInheritedSurface;
   }
 
-  const routePath = String(route?.path || "").trim();
-  if (routePath && routePath.startsWith("/")) {
-    return surfaceRuntime.resolveSurfaceFromPathname(routePath);
-  }
-
-  if (absolutePath) {
-    return surfaceRuntime.resolveSurfaceFromPathname(absolutePath);
-  }
-
-  return surfaceRuntime.DEFAULT_SURFACE_ID;
+  return surfaceRuntime.resolveSurfaceFromPathname(absolutePath);
 }
 
 function normalizeRoutesBySurfaceBoundaries(routeList = [], { surfaceRuntime } = {}) {
@@ -186,48 +142,19 @@ function normalizeRoutesBySurfaceBoundaries(routeList = [], { surfaceRuntime } =
 
 function createSurfaceRuntime(options = {}) {
   const allMode = normalizeSurfaceId(options?.allMode || "all") || "all";
-  const sourceSurfaces = isRecord(options?.surfaces) ? options.surfaces : {};
-  const surfaceIds = resolveSurfaceIds({
-    surfaces: sourceSurfaces
-  });
-
-  const normalizedSurfaces = {};
-  for (const surfaceId of surfaceIds) {
-    const source = isRecord(sourceSurfaces[surfaceId]) ? sourceSurfaces[surfaceId] : {};
-    if (!Object.prototype.hasOwnProperty.call(source, "pagesRoot")) {
-      throw new Error(`Surface "${surfaceId}" requires pagesRoot (use "" for root).`);
-    }
-    const pagesRoot = normalizeSurfacePagesRoot(source.pagesRoot);
-    normalizedSurfaces[surfaceId] = {
-      ...source,
-      id: surfaceId,
-      pagesRoot,
-      routeBase: deriveSurfaceRouteBaseFromPagesRoot(pagesRoot),
-      enabled: source.enabled !== false
-    };
-  }
-
-  const defaultSurfaceId = normalizeSurfaceId(options?.defaultSurfaceId) || surfaceIds[0];
   const registry = createSurfaceRegistry({
-    surfaces: normalizedSurfaces,
-    defaultSurfaceId
+    surfaces: isRecord(options?.surfaces) ? options.surfaces : {},
+    defaultSurfaceId: options?.defaultSurfaceId
   });
+  const { SURFACE_REGISTRY, DEFAULT_SURFACE_ID } = registry;
+  const surfaceDefinitions = registry.listSurfaceDefinitions();
+  const surfaceIds = surfaceDefinitions.map((definition) => definition.id);
+  const enabledSurfaceIds = surfaceDefinitions.filter((definition) => definition.enabled).map((definition) => definition.id);
 
   const pathHelpers = createSurfacePathHelpers({
-    apiBasePath: String(options?.apiBasePath || "/api"),
-    defaultSurfaceId: registry.DEFAULT_SURFACE_ID,
-    normalizeSurfaceId: registry.normalizeSurfaceId,
-    resolveSurfaceRouteBase: registry.resolveSurfaceRouteBase,
-    listSurfaceDefinitions: registry.listSurfaceDefinitions,
-    routes: options?.routes
-  });
-
-  const enabledSurfaceIds = surfaceIds.filter((surfaceId) => normalizedSurfaces[surfaceId]?.enabled !== false);
-  const defaultSurfaceSource = isRecord(normalizedSurfaces[registry.DEFAULT_SURFACE_ID])
-    ? normalizedSurfaces[registry.DEFAULT_SURFACE_ID]
-    : {};
-  const defaultSurfaceDefinition = Object.freeze({
-    ...defaultSurfaceSource
+    apiBasePath: options?.apiBasePath,
+    defaultSurfaceId: DEFAULT_SURFACE_ID,
+    surfaceDefinitions
   });
 
   function normalizeSurfaceMode(value) {
@@ -236,7 +163,7 @@ function createSurfaceRuntime(options = {}) {
       return allMode;
     }
 
-    return registry.SURFACE_REGISTRY[normalized] ? normalized : allMode;
+    return SURFACE_REGISTRY[normalized] ? normalized : allMode;
   }
 
   function listEnabledSurfaceIds() {
@@ -244,29 +171,11 @@ function createSurfaceRuntime(options = {}) {
   }
 
   function getSurfaceDefinition(surfaceId) {
-    const normalizedSurfaceId = normalizeSurfaceId(surfaceId);
-    const definition = normalizedSurfaces[normalizedSurfaceId];
-    if (!definition) {
-      return null;
-    }
-
-    return Object.freeze({
-      ...definition
-    });
+    return SURFACE_REGISTRY[normalizeSurfaceId(surfaceId)] || null;
   }
 
   function listSurfaceDefinitions({ enabledOnly = false } = {}) {
-    const ids = enabledOnly ? enabledSurfaceIds : surfaceIds;
-    const definitions = [];
-    for (const surfaceId of ids) {
-      const source = isRecord(normalizedSurfaces[surfaceId]) ? normalizedSurfaces[surfaceId] : {};
-      definitions.push(
-        Object.freeze({
-          ...source
-        })
-      );
-    }
-    return definitions;
+    return enabledOnly ? surfaceDefinitions.filter((definition) => definition.enabled) : [...surfaceDefinitions];
   }
 
   function isSurfaceEnabled(surfaceId) {
@@ -281,8 +190,8 @@ function createSurfaceRuntime(options = {}) {
   return {
     SURFACE_MODE_ALL: allMode,
     SURFACE_IDS: [...surfaceIds],
-    DEFAULT_SURFACE_ID: registry.DEFAULT_SURFACE_ID,
-    DEFAULT_SURFACE: defaultSurfaceDefinition,
+    DEFAULT_SURFACE_ID,
+    DEFAULT_SURFACE: SURFACE_REGISTRY[DEFAULT_SURFACE_ID],
     normalizeSurfaceMode,
     resolveSurfaceFromPathname: pathHelpers.resolveSurfaceFromPathname,
     getSurfaceDefinition,