@jskit-ai/kernel 0.1.147 → 0.1.149

package/internal/node/installedPackages.js

@@ -0,0 +1,283 @@
+import { readFile, realpath } from "node:fs/promises";
+import path from "node:path";
+import { normalizeObject } from "../../shared/support/normalize.js";
+import { sortStrings } from "../../shared/support/sorting.js";
+import { fileExists } from "./fileSystem.js";
+
+const ROOT_DEPENDENCY_SECTIONS = Object.freeze([
+  "dependencies",
+  "optionalDependencies",
+  "peerDependencies",
+  "devDependencies"
+]);
+
+async function readJsonFile(filePath, fallback = {}) {
+  try {
+    return JSON.parse(await readFile(filePath, "utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+function collectRootDependencySpecifiers(packageJson = {}) {
+  const specifiers = new Map();
+  for (const sectionName of ROOT_DEPENDENCY_SECTIONS) {
+    for (const [packageId, specifier] of Object.entries(normalizeObject(packageJson?.[sectionName]))) {
+      const normalizedPackageId = String(packageId || "").trim();
+      if (!normalizedPackageId || specifiers.has(normalizedPackageId)) {
+        continue;
+      }
+      specifiers.set(normalizedPackageId, String(specifier || "").trim());
+    }
+  }
+  return specifiers;
+}
+
+function collectPackageDependencyIds(packageJson = {}) {
+  const dependencyIds = new Set();
+  for (const sectionName of ["dependencies", "optionalDependencies", "peerDependencies"]) {
+    for (const packageId of Object.keys(normalizeObject(packageJson?.[sectionName]))) {
+      const normalizedPackageId = String(packageId || "").trim();
+      if (normalizedPackageId) {
+        dependencyIds.add(normalizedPackageId);
+      }
+    }
+  }
+  return sortStrings([...dependencyIds]);
+}
+
+function createPackageMetadata(packageJson = {}) {
+  const jskit = normalizeObject(packageJson.jskit);
+  if (Object.keys(jskit).length === 0) {
+    return null;
+  }
+
+  const packageId = String(packageJson.name || "").trim();
+  const version = String(packageJson.version || "").trim();
+  if (!packageId || !version) {
+    return null;
+  }
+
+  return Object.freeze({
+    ...jskit,
+    packageId,
+    version,
+    ...(String(packageJson.description || "").trim()
+      ? { description: String(packageJson.description).trim() }
+      : {})
+  });
+}
+
+function resolveFileDependencyRoot(appRoot, specifier = "") {
+  const normalizedSpecifier = String(specifier || "").trim();
+  if (!normalizedSpecifier.startsWith("file:")) {
+    return "";
+  }
+  const relativePath = normalizedSpecifier.slice("file:".length).trim();
+  return relativePath ? path.resolve(appRoot, relativePath) : "";
+}
+
+async function resolveInstalledPackageRoot({ appRoot, packageId, parentPackageRoot = "" }) {
+  const candidates = [];
+  const seen = new Set();
+  const appendCandidate = (candidateRoot) => {
+    const normalized = path.resolve(candidateRoot);
+    if (!seen.has(normalized)) {
+      seen.add(normalized);
+      candidates.push(normalized);
+    }
+  };
+
+  if (parentPackageRoot) {
+    let currentRoot = path.resolve(parentPackageRoot);
+    while (true) {
+      appendCandidate(path.join(currentRoot, "node_modules", ...packageId.split("/")));
+      const parentRoot = path.dirname(currentRoot);
+      if (parentRoot === currentRoot) {
+        break;
+      }
+      currentRoot = parentRoot;
+    }
+  }
+  appendCandidate(path.resolve(appRoot, "node_modules", ...packageId.split("/")));
+
+  for (const candidateRoot of candidates) {
+    if (await fileExists(path.join(candidateRoot, "package.json"))) {
+      return candidateRoot;
+    }
+  }
+  return path.resolve(appRoot, "node_modules", ...packageId.split("/"));
+}
+
+async function resolvePackageRoots({
+  appRoot,
+  packageId,
+  directSpecifier = "",
+  parentPackageRoot = ""
+}) {
+  const installedPackageRoot = await resolveInstalledPackageRoot({
+    appRoot,
+    packageId,
+    parentPackageRoot
+  });
+  const fileDependencyRoot = resolveFileDependencyRoot(appRoot, directSpecifier);
+  let sourcePackageRoot = fileDependencyRoot && (await fileExists(fileDependencyRoot))
+    ? fileDependencyRoot
+    : "";
+
+  if (!sourcePackageRoot && (await fileExists(installedPackageRoot))) {
+    try {
+      const resolvedRoot = await realpath(installedPackageRoot);
+      const relativeToNodeModules = path.relative(path.resolve(appRoot, "node_modules"), resolvedRoot);
+      if (
+        relativeToNodeModules === ".." ||
+        relativeToNodeModules.startsWith(`..${path.sep}`) ||
+        path.isAbsolute(relativeToNodeModules)
+      ) {
+        sourcePackageRoot = resolvedRoot;
+      }
+    } catch {
+      sourcePackageRoot = "";
+    }
+  }
+
+  return {
+    installedPackageRoot,
+    sourcePackageRoot,
+    packageRoot: sourcePackageRoot || installedPackageRoot,
+    sourceType: sourcePackageRoot ? "local-package" : "npm-package"
+  };
+}
+
+async function discoverInstalledPackages({ appRoot } = {}) {
+  const normalizedAppRoot = String(appRoot || "").trim();
+  if (!normalizedAppRoot) {
+    throw new TypeError("discoverInstalledPackages requires appRoot.");
+  }
+
+  const rootPackageJson = await readJsonFile(path.resolve(normalizedAppRoot, "package.json"), {});
+  const directSpecifiers = collectRootDependencySpecifiers(rootPackageJson);
+  const directPackageIds = new Set(directSpecifiers.keys());
+  const runtimeRootPackageIds = new Set(
+    ["dependencies", "optionalDependencies", "peerDependencies"]
+      .flatMap((sectionName) => Object.keys(normalizeObject(rootPackageJson?.[sectionName])))
+  );
+  const visited = new Set();
+  const queue = [];
+  const queued = new Map();
+  const packages = [];
+
+  const sortQueue = () => {
+    queue.sort((left, right) => {
+      if (left.traverseDependencies !== right.traverseDependencies) {
+        return left.traverseDependencies ? -1 : 1;
+      }
+      return left.packageId.localeCompare(right.packageId);
+    });
+  };
+  const enqueue = ({ packageId, parentPackageRoot = "", traverseDependencies = false }) => {
+    const normalizedPackageId = String(packageId || "").trim();
+    if (!normalizedPackageId || visited.has(normalizedPackageId)) {
+      return;
+    }
+    const existing = queued.get(normalizedPackageId);
+    if (existing) {
+      if (traverseDependencies && !existing.traverseDependencies) {
+        existing.traverseDependencies = true;
+        existing.parentPackageRoot = parentPackageRoot || existing.parentPackageRoot;
+        sortQueue();
+      }
+      return;
+    }
+    const entry = {
+      packageId: normalizedPackageId,
+      parentPackageRoot,
+      traverseDependencies: Boolean(traverseDependencies)
+    };
+    queue.push(entry);
+    queued.set(normalizedPackageId, entry);
+    sortQueue();
+  };
+
+  for (const packageId of sortStrings([...directPackageIds])) {
+    enqueue({
+      packageId,
+      traverseDependencies: runtimeRootPackageIds.has(packageId)
+    });
+  }
+
+  while (queue.length > 0) {
+    const { packageId, parentPackageRoot, traverseDependencies } = queue.shift();
+    queued.delete(packageId);
+    if (!packageId || visited.has(packageId)) {
+      continue;
+    }
+    visited.add(packageId);
+
+    const directSpecifier = directSpecifiers.get(packageId) || "";
+    const roots = await resolvePackageRoots({
+      appRoot: normalizedAppRoot,
+      packageId,
+      directSpecifier,
+      parentPackageRoot
+    });
+    const packageJsonPath = path.join(roots.packageRoot, "package.json");
+    if (!(await fileExists(packageJsonPath))) {
+      continue;
+    }
+
+    const packageJson = await readJsonFile(packageJsonPath, {});
+    const manifestPackageId = String(packageJson.name || "").trim();
+    if (manifestPackageId && manifestPackageId !== packageId) {
+      throw new Error(
+        `Installed package manifest mismatch: expected ${packageId}, received ${manifestPackageId}.`
+      );
+    }
+
+    const dependencyIds = collectPackageDependencyIds(packageJson);
+    if (traverseDependencies) {
+      for (const dependencyId of dependencyIds) {
+        const normalizedDependencyId = String(dependencyId || "").trim();
+        enqueue({
+          packageId: normalizedDependencyId,
+          parentPackageRoot: roots.packageRoot,
+          traverseDependencies: true
+        });
+      }
+    }
+
+    const packageMetadata = createPackageMetadata(packageJson);
+    if (!packageMetadata) {
+      continue;
+    }
+
+    packages.push(
+      Object.freeze({
+        packageId,
+        version: String(packageJson.version || "").trim(),
+        packageMetadata,
+        manifestPath: packageJsonPath,
+        packageJson: Object.freeze({ ...normalizeObject(packageJson) }),
+        packageRoot: roots.packageRoot,
+        installedPackageRoot: roots.installedPackageRoot,
+        sourcePackageRoot: roots.sourcePackageRoot || roots.packageRoot,
+        sourceType: roots.sourceType,
+        direct: directPackageIds.has(packageId),
+        directSpecifier,
+        dependencyIds: Object.freeze(dependencyIds)
+      })
+    );
+  }
+
+  return Object.freeze(
+    packages.sort((left, right) => left.packageId.localeCompare(right.packageId))
+  );
+}
+
+export {
+  ROOT_DEPENDENCY_SECTIONS,
+  collectPackageDependencyIds,
+  collectRootDependencySpecifiers,
+  createPackageMetadata,
+  discoverInstalledPackages
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jskit-ai/kernel",
-  "version": "0.1.147",
+  "version": "0.1.149",
   "type": "module",
   "dependencies": {
     "json-rest-schema": "^1.0.17"

package/server/platform/providerRuntime/{descriptorCatalog.js → packageCatalog.js}

@@ -1,6 +1,5 @@
-import path from "node:path";
 import { sortStrings } from "../../../shared/support/sorting.js";
-import { loadInstalledPackageDescriptor } from "../../../internal/node/installedPackageDescriptor.js";
+import { discoverInstalledPackages } from "../../../internal/node/installedPackages.js";
 
 const EXCLUSIVE_CAPABILITIES = Object.freeze(["auth.provider"]);
 
@@ -18,13 +17,13 @@ function normalizeUiRoutePath(pathValue) {
   return normalizedPath.replace(/\/+$/, "") || "/";
 }
 
-function collectGlobalUiPaths(descriptorEntries) {
+function collectGlobalUiPaths(packageEntries) {
   const globalUiPaths = [];
-  const entries = Array.isArray(descriptorEntries) ? descriptorEntries : [];
+  const entries = Array.isArray(packageEntries) ? packageEntries : [];
 
-  for (const descriptorEntry of entries) {
-    const uiRoutes = Array.isArray(descriptorEntry?.descriptor?.metadata?.ui?.routes)
-      ? descriptorEntry.descriptor.metadata.ui.routes
+  for (const packageEntry of entries) {
+    const uiRoutes = Array.isArray(packageEntry?.packageMetadata?.metadata?.ui?.routes)
+      ? packageEntry.packageMetadata.metadata.ui.routes
       : [];
 
     for (const routeEntry of uiRoutes) {
@@ -51,34 +50,21 @@ function collectGlobalUiPaths(descriptorEntries) {
   return Object.freeze(sortStrings(globalUiPaths));
 }
 
-async function resolveInstalledPackageDescriptors({ appRoot, lock }) {
-  const installedPackages =
-    lock && typeof lock === "object" && lock.installedPackages && typeof lock.installedPackages === "object"
-      ? lock.installedPackages
-      : {};
-
-  const descriptorEntries = [];
-  for (const packageId of sortStrings(Object.keys(installedPackages))) {
-    const installedPackageState = installedPackages[packageId] || {};
-    const descriptorRecord = await loadInstalledPackageDescriptor({
-      appRoot,
-      installedPackageState,
-      packageId,
-      required: true
-    });
-    descriptorEntries.push({
-      packageId,
-      descriptor: descriptorRecord.descriptor,
-      descriptorPath: descriptorRecord.descriptorPath,
-      packageRoot: path.dirname(descriptorRecord.descriptorPath)
-    });
-  }
-
-  return descriptorEntries;
+async function resolveInstalledJskitPackages({ appRoot }) {
+  return (await discoverInstalledPackages({ appRoot })).map((entry) => ({
+    packageId: entry.packageId,
+    packageMetadata: entry.packageMetadata,
+    manifestPath: entry.manifestPath,
+    packageRoot: entry.packageRoot,
+    dependencyIds: entry.dependencyIds,
+    sourceType: entry.sourceType,
+    direct: entry.direct,
+    version: entry.version
+  }));
 }
 
-function resolveDescriptorLoadOrder(descriptorEntries) {
-  const byPackageId = new Map(descriptorEntries.map((entry) => [entry.packageId, entry]));
+function resolvePackageLoadOrder(packageEntries) {
+  const byPackageId = new Map(packageEntries.map((entry) => [entry.packageId, entry]));
   const visiting = new Set();
   const visited = new Set();
   const ordered = [];
@@ -97,8 +83,7 @@ function resolveDescriptorLoadOrder(descriptorEntries) {
     }
 
     visiting.add(packageId);
-    const dependsOn = Array.isArray(entry.descriptor?.dependsOn) ? entry.descriptor.dependsOn : [];
-    for (const dependencyPackageId of dependsOn) {
+    for (const dependencyPackageId of Array.isArray(entry.dependencyIds) ? entry.dependencyIds : []) {
       if (byPackageId.has(dependencyPackageId)) {
         visit(dependencyPackageId, [...lineage, packageId]);
       }
@@ -128,13 +113,13 @@ function registerCapabilityProvider(providersByCapability, capabilityId, provide
   providersByCapability.get(normalizedCapabilityId).add(normalizedProviderPackageId);
 }
 
-function validateDescriptorCapabilities(descriptorEntries, { builtinProvidersByCapability = {} } = {}) {
+function validatePackageCapabilities(packageEntries, { builtinProvidersByCapability = {} } = {}) {
   const providersByCapability = new Map();
-  for (const descriptorEntry of descriptorEntries) {
-    for (const capabilityId of Array.isArray(descriptorEntry.descriptor?.capabilities?.provides)
-      ? descriptorEntry.descriptor.capabilities.provides
+  for (const packageEntry of packageEntries) {
+    for (const capabilityId of Array.isArray(packageEntry.packageMetadata?.capabilities?.provides)
+      ? packageEntry.packageMetadata.capabilities.provides
       : []) {
-      registerCapabilityProvider(providersByCapability, capabilityId, descriptorEntry.packageId);
+      registerCapabilityProvider(providersByCapability, capabilityId, packageEntry.packageId);
     }
   }
 
@@ -146,9 +131,9 @@ function validateDescriptorCapabilities(descriptorEntries, { builtinProvidersByC
     }
   }
 
-  for (const descriptorEntry of descriptorEntries) {
-    for (const capabilityId of Array.isArray(descriptorEntry.descriptor?.capabilities?.requires)
-      ? descriptorEntry.descriptor.capabilities.requires
+  for (const packageEntry of packageEntries) {
+    for (const capabilityId of Array.isArray(packageEntry.packageMetadata?.capabilities?.requires)
+      ? packageEntry.packageMetadata.capabilities.requires
       : []) {
       const normalizedCapabilityId = String(capabilityId || "").trim();
       if (!normalizedCapabilityId) {
@@ -157,7 +142,7 @@ function validateDescriptorCapabilities(descriptorEntries, { builtinProvidersByC
       const providers = providersByCapability.get(normalizedCapabilityId);
       if (!providers || providers.size < 1) {
         throw new Error(
-          `Package ${descriptorEntry.packageId} requires capability ${normalizedCapabilityId}, but no installed package provides it.`
+          `Package ${packageEntry.packageId} requires capability ${normalizedCapabilityId}, but no installed package provides it.`
         );
       }
     }
@@ -175,7 +160,7 @@ function validateDescriptorCapabilities(descriptorEntries, { builtinProvidersByC
 
 export {
   collectGlobalUiPaths,
-  resolveInstalledPackageDescriptors,
-  resolveDescriptorLoadOrder,
-  validateDescriptorCapabilities
+  resolveInstalledJskitPackages,
+  resolvePackageLoadOrder,
+  validatePackageCapabilities
 };

package/server/platform/providerRuntime/providerLoader.js

@@ -10,10 +10,10 @@ import {
   toAbsoluteSortedUniquePaths
 } from "./helpers.js";
 
-function normalizeServerProviderDefinitions(descriptor, packageId) {
+function normalizeServerProviderDefinitions(packageMetadata, packageId) {
   const runtime =
-    descriptor && typeof descriptor.runtime === "object" && descriptor.runtime && !Array.isArray(descriptor.runtime)
-      ? descriptor.runtime
+    packageMetadata && typeof packageMetadata.runtime === "object" && packageMetadata.runtime && !Array.isArray(packageMetadata.runtime)
+      ? packageMetadata.runtime
       : {};
   const server =
     runtime && typeof runtime.server === "object" && runtime.server && !Array.isArray(runtime.server)
@@ -162,11 +162,11 @@ function resolveProviderClassesFromModule(moduleNamespace, { packageId, provider
   return discovered;
 }
 
-async function collectDiscoveredProviderModulePaths({ descriptorEntry, providerDefinition }) {
-  const discoverRoot = path.resolve(descriptorEntry.packageRoot, providerDefinition.discoverDir);
-  if (!isInsidePackageRoot(descriptorEntry.packageRoot, discoverRoot)) {
+async function collectDiscoveredProviderModulePaths({ packageEntry, providerDefinition }) {
+  const discoverRoot = path.resolve(packageEntry.packageRoot, providerDefinition.discoverDir);
+  if (!isInsidePackageRoot(packageEntry.packageRoot, discoverRoot)) {
     throw new Error(
-      `Package ${descriptorEntry.packageId} runtime.server.providers[] discover.dir escapes package root: ${providerDefinition.discoverDir}`
+      `Package ${packageEntry.packageId} runtime.server.providers[] discover.dir escapes package root: ${providerDefinition.discoverDir}`
     );
   }
   if (!(await fileExists(discoverRoot))) {
@@ -176,7 +176,7 @@ async function collectDiscoveredProviderModulePaths({ descriptorEntry, providerD
   const patternMatcher = createWildcardMatcher(providerDefinition.discoverPattern);
   if (!(patternMatcher instanceof RegExp)) {
     throw new Error(
-      `Package ${descriptorEntry.packageId} runtime.server.providers[] discover.pattern is invalid: ${providerDefinition.discoverPattern}`
+      `Package ${packageEntry.packageId} runtime.server.providers[] discover.pattern is invalid: ${providerDefinition.discoverPattern}`
     );
   }
   const collectedPaths = [];
@@ -227,8 +227,8 @@ function registerProviderClass({ providerClass, sourceId, seenProviderIds, order
   orderedProviderClasses.push(providerClass);
 }
 
-async function loadPackageProviders({ descriptorEntry }) {
-  const providerDefinitions = normalizeServerProviderDefinitions(descriptorEntry.descriptor, descriptorEntry.packageId);
+async function loadPackageProviders({ packageEntry }) {
+  const providerDefinitions = normalizeServerProviderDefinitions(packageEntry.packageMetadata, packageEntry.packageId);
   if (providerDefinitions.length < 1) {
     return Object.freeze([]);
   }
@@ -237,7 +237,7 @@ async function loadPackageProviders({ descriptorEntry }) {
   for (const providerDefinition of providerDefinitions) {
     if (providerDefinition.type === "discover") {
       const discoveredProviderPaths = await collectDiscoveredProviderModulePaths({
-        descriptorEntry,
+        packageEntry,
         providerDefinition
       });
 
@@ -245,8 +245,8 @@ async function loadPackageProviders({ descriptorEntry }) {
         const providerModule = await import(pathToFileURL(discoveredProviderPath).href);
         providerClasses.push(
           ...resolveProviderClassesFromModule(providerModule, {
-            packageId: `${descriptorEntry.packageId} (${normalizeRelativePath(
-              descriptorEntry.packageRoot,
+            packageId: `${packageEntry.packageId} (${normalizeRelativePath(
+              packageEntry.packageRoot,
               discoveredProviderPath
             )})`,
             providerExport: ""
@@ -256,22 +256,22 @@ async function loadPackageProviders({ descriptorEntry }) {
       continue;
     }
 
-    const providerModulePath = path.resolve(descriptorEntry.packageRoot, providerDefinition.providerEntrypoint);
-    if (!isInsidePackageRoot(descriptorEntry.packageRoot, providerModulePath)) {
+    const providerModulePath = path.resolve(packageEntry.packageRoot, providerDefinition.providerEntrypoint);
+    if (!isInsidePackageRoot(packageEntry.packageRoot, providerModulePath)) {
       throw new Error(
-        `Package ${descriptorEntry.packageId} runtime.server.providers[] entrypoint escapes package root: ${providerDefinition.providerEntrypoint}`
+        `Package ${packageEntry.packageId} runtime.server.providers[] entrypoint escapes package root: ${providerDefinition.providerEntrypoint}`
       );
     }
     if (!(await fileExists(providerModulePath))) {
       throw new Error(
-        `Package ${descriptorEntry.packageId} runtime.server.providers[] entrypoint not found: ${providerDefinition.providerEntrypoint}`
+        `Package ${packageEntry.packageId} runtime.server.providers[] entrypoint not found: ${providerDefinition.providerEntrypoint}`
       );
     }
 
     const providerModule = await import(pathToFileURL(providerModulePath).href);
     providerClasses.push(
       ...resolveProviderClassesFromModule(providerModule, {
-        packageId: descriptorEntry.packageId,
+        packageId: packageEntry.packageId,
         providerExport: providerDefinition.providerExport
       })
     );

package/server/platform/providerRuntime.js

@@ -2,13 +2,12 @@ import { ActionRuntimeServiceProvider } from "../actions/ActionRuntimeServicePro
 import { ServerRuntimeCoreServiceProvider } from "../runtime/ServerRuntimeCoreServiceProvider.js";
 import { createApplication } from "../kernel/index.js";
 import { createHttpRuntime } from "../http/lib/kernel.js";
-import { readLockFromApp } from "./providerRuntime/lockfile.js";
 import {
   collectGlobalUiPaths,
-  resolveInstalledPackageDescriptors,
-  resolveDescriptorLoadOrder,
-  validateDescriptorCapabilities
-} from "./providerRuntime/descriptorCatalog.js";
+  resolveInstalledJskitPackages,
+  resolvePackageLoadOrder,
+  validatePackageCapabilities
+} from "./providerRuntime/packageCatalog.js";
 import { loadPackageProviders, registerProviderClass } from "./providerRuntime/providerLoader.js";
 
 const KERNEL_BUILTIN_CAPABILITY_PROVIDERS = Object.freeze({
@@ -62,7 +61,6 @@ async function createProviderRuntimeApp({
 
 async function createProviderRuntimeFromApp({
   appRoot,
-  lockPath = ".jskit/lock.json",
   profile = "",
   env = {},
   logger = console,
@@ -72,39 +70,34 @@ async function createProviderRuntimeFromApp({
     throw new TypeError("createProviderRuntimeFromApp requires appRoot.");
   }
 
-  const { lock } = await readLockFromApp({
-    appRoot,
-    lockPath
+  const installedPackages = await resolveInstalledJskitPackages({
+    appRoot
   });
-  const descriptors = await resolveInstalledPackageDescriptors({
-    appRoot,
-    lock
-  });
-  validateDescriptorCapabilities(descriptors, {
+  validatePackageCapabilities(installedPackages, {
     builtinProvidersByCapability: KERNEL_BUILTIN_CAPABILITY_PROVIDERS
   });
-  const orderedDescriptors = resolveDescriptorLoadOrder(descriptors);
+  const orderedPackages = resolvePackageLoadOrder(installedPackages);
   const catalog = Object.freeze({
-    packageOrder: Object.freeze(orderedDescriptors.map((entry) => entry.packageId)),
-    globalUiPaths: collectGlobalUiPaths(orderedDescriptors),
-    descriptors: Object.freeze(orderedDescriptors)
+    packageOrder: Object.freeze(orderedPackages.map((entry) => entry.packageId)),
+    globalUiPaths: collectGlobalUiPaths(orderedPackages),
+    packages: Object.freeze(orderedPackages)
   });
 
   const orderedProviderClasses = [];
   const providerPackageIds = [];
   const seenProviderIds = new Map();
 
-  for (const descriptorEntry of catalog.descriptors) {
-    const packageProviders = await loadPackageProviders({ descriptorEntry });
+  for (const packageEntry of catalog.packages) {
+    const packageProviders = await loadPackageProviders({ packageEntry });
     if (packageProviders.length < 1) {
       continue;
     }
-    providerPackageIds.push(descriptorEntry.packageId);
+    providerPackageIds.push(packageEntry.packageId);
 
     for (const providerClass of packageProviders) {
       registerProviderClass({
         providerClass,
-        sourceId: descriptorEntry.packageId,
+        sourceId: packageEntry.packageId,
         seenProviderIds,
         orderedProviderClasses
       });