bazis 0.96.1

package/core/di/module/createContainer.ts

@@ -0,0 +1,261 @@
+import { DiContainer } from "../container";
+import { ServiceCollection } from "../ServiceCollection";
+import { HOSTED_SERVICE, type HostedService } from "../extensions/hosted-service";
+import { SERVICE_PROVIDER, SERVICE_PROVIDER_BY_TYPE } from "../extensions/service-provider-token";
+import { isClassProvider, ProviderDefinition, type Provider } from "../provider";
+import { getClassDeps } from "../internal/classDeps";
+import { ModuleEncapsulationError } from "../errors";
+import { OpenGenericRegistration } from "../internal/OpenGenericRegistration";
+import type { Class } from "../token";
+import type { BuildServiceProviderOptions } from "../types";
+import { DI } from "./DI";
+import { Global } from "./Global";
+import { Module } from "./Module";
+import { validateModuleEncapsulation, type ModuleGraphRecord } from "./encapsulation";
+import { expandModuleMetadata } from "./moduleExtensions";
+import {
+  applyModuleOwnedProviderContributors,
+  ModuleOwnedContributionStore,
+  validateModuleOwnedContributions,
+} from "./moduleOwnedProviderContributors";
+import { createModuleScopedNameBinder } from "./moduleNameBinding";
+import { createProviderSelectionValidator } from "./providerSelection";
+import { ModuleRegistrar } from "./ModuleRegistrar";
+import { scoped, singleton } from "./shortcuts";
+import { getGeneratedClassDeps } from "./autoDeps";
+import { applyClassProviderHooksToDefinition, collectClassProviderHooks } from "./classProviderHooks";
+import type { BazisModuleRef } from "./types";
+
+function moduleDiagnosticName(moduleRef: BazisModuleRef, fallbackIndex: number): string {
+  if (typeof moduleRef === "function") {
+    const name = moduleRef.name.trim();
+    if (name.length > 0) {
+      return name;
+    }
+  }
+  return `module#${fallbackIndex}`;
+}
+
+export function createContainer(rootModule: BazisModuleRef, options?: BuildServiceProviderOptions): DiContainer {
+  // The container itself is injectable (SERVICE_PROVIDER, .NET-style). The
+  // instance does not exist until the end of this function, so the factory
+  // closes over a ref that is assigned right after construction.
+  let built: DiContainer | undefined;
+  @Global()
+  @Module({
+    providers: [
+      DI.singleton(
+        DI.factoryProvider(SERVICE_PROVIDER, [], () => {
+          if (!built) {
+            throw new Error("SERVICE_PROVIDER resolved before the container finished building.");
+          }
+          return built;
+        }),
+      ),
+      // Canonical class token for generated identity and name-based deps.
+      DI.singleton(
+        DI.factoryProvider(SERVICE_PROVIDER_BY_TYPE, [], () => {
+          if (!built) {
+            throw new Error("SERVICE_PROVIDER resolved before the container finished building.");
+          }
+          return built;
+        }),
+      ),
+    ],
+  })
+  class BazisDiInfraModule {}
+
+  const diInfraModule = BazisDiInfraModule;
+
+  const collection = new ServiceCollection();
+  const registrar = new ModuleRegistrar(collection);
+  const records = new Map<BazisModuleRef, ModuleGraphRecord>();
+  const moduleOwnedContributions = new ModuleOwnedContributionStore();
+  // Which module declared each definition — used for module-scoped name binding.
+  const recordOf = new Map<ProviderDefinition, ModuleGraphRecord>();
+  const openGenericRecordOf = new Map<OpenGenericRegistration, ModuleGraphRecord>();
+  const loading: BazisModuleRef[] = [];
+  const activeModules = new Set<BazisModuleRef>();
+
+  const loadModule = (moduleRef: BazisModuleRef): void => {
+    if (activeModules.has(moduleRef)) {
+      const cycle = [...loading.slice(loading.indexOf(moduleRef)), moduleRef]
+        .map((ref) => records.get(ref)!.name).join(" -> ");
+      throw new ModuleEncapsulationError([`Module imports cycle: ${cycle}`]);
+    }
+    if (records.has(moduleRef)) {
+      return;
+    }
+    const record: ModuleGraphRecord = {
+      name: moduleDiagnosticName(moduleRef, records.size),
+      imports: [],
+      exports: moduleRef.exports,
+      global: moduleRef.global === true,
+      providedTokens: new Set(),
+      providedFamilies: new Set(),
+      definitions: [],
+    };
+    records.set(moduleRef, record);
+    activeModules.add(moduleRef);
+    loading.push(moduleRef);
+
+    const imports = moduleRef.imports;
+    if (imports) {
+      for (let index = 0; index < imports.length; index += 1) {
+        const importedModule = imports[index] as BazisModuleRef;
+        loadModule(importedModule);
+        record.imports.push(records.get(importedModule) as ModuleGraphRecord);
+      }
+    }
+
+    // Extra declarative keys (e.g. `ormBazis`) contributed by higher layers via
+    // registered expanders — loaded exactly like `imports`.
+    const expanded = expandModuleMetadata(moduleRef);
+    for (let index = 0; index < expanded.length; index += 1) {
+      const expandedModule = expanded[index] as BazisModuleRef;
+      loadModule(expandedModule);
+      record.imports.push(records.get(expandedModule) as ModuleGraphRecord);
+    }
+
+    const definitionsStart = collection.size;
+    const openGenericsStart = collection.openGenericSize;
+
+    const providers = moduleRef.providers;
+    if (providers) {
+      for (let index = 0; index < providers.length; index += 1) {
+        collection.add(providers[index] as ProviderDefinition);
+      }
+    }
+
+    const controllers = moduleRef.controllers;
+    if (controllers) {
+      for (let index = 0; index < controllers.length; index += 1) {
+        collection.add(scoped(controllers[index] as Class<object>));
+      }
+    }
+
+    const background = moduleRef.background;
+    if (background) {
+      for (let index = 0; index < background.length; index += 1) {
+        const ServiceClass = background[index] as Class<HostedService>;
+        // Singleton instance + a HOSTED_SERVICE entry resolving to it, so the
+        // kernel starts/stops it with the rest of the app.
+        collection.add(singleton(ServiceClass));
+        collection.add(
+          DI.singleton(DI.factoryProviderWithResolver(HOSTED_SERVICE, [], (resolver) => resolver.resolve(ServiceClass))),
+        );
+      }
+    }
+
+    moduleRef.configure?.(registrar);
+
+    // Higher-layer declarative capabilities are registered while their owner
+    // record is still open. This preserves access to private feature deps
+    // without turning a contribution into a synthetic imported module.
+    applyModuleOwnedProviderContributors(
+      moduleRef,
+      record.name,
+      collection,
+      moduleOwnedContributions,
+      definitionsStart,
+    );
+
+    // Attribute everything registered by this module (providers + configure)
+    // to its graph record for build-time encapsulation validation.
+    // configure() may remove/replace earlier entries, moving array offsets.
+    // New definitions still belong to this module even after such a mutation.
+    const ownDefinitions = moduleRef.configure
+      ? collection.toArray().filter((definition) => !recordOf.has(definition))
+      : collection.definitionsFrom(definitionsStart);
+    for (let index = 0; index < ownDefinitions.length; index += 1) {
+      const definition = ownDefinitions[index] as ProviderDefinition;
+      record.definitions.push(definition);
+      record.providedTokens.add(definition.provider.provide);
+      const providedToken = definition.provider.provide;
+      if (typeof providedToken !== "function" && providedToken.genericFamilyId) {
+        record.providedFamilies.add(providedToken.genericFamilyId);
+      }
+      recordOf.set(definition, record);
+    }
+    for (const registration of collection.openGenericsFrom(openGenericsStart)) {
+      record.providedFamilies.add(registration.family.id);
+      openGenericRecordOf.set(registration, record);
+    }
+    loading.pop();
+    activeModules.delete(moduleRef);
+  };
+
+  loadModule(diInfraModule);
+  loadModule(rootModule);
+  const recordList = Array.from(records.values());
+  const collectedDefinitions = collection.toArray();
+  const classProviderHooks = collectClassProviderHooks(collectedDefinitions);
+  const normalizeDefinition = (definition: ProviderDefinition): ProviderDefinition =>
+    normalizeLateGeneratedClassDeps(applyClassProviderHooksToDefinition(definition, classProviderHooks));
+  const activeDefinitions = new Set(collectedDefinitions);
+  for (const record of recordList) {
+    // Removed providers must not continue to contribute dependency checks.
+    const active = record.definitions.filter((definition) => activeDefinitions.has(definition));
+    record.definitions.splice(0, record.definitions.length, ...active);
+  }
+  const definitions = collectedDefinitions.map(normalizeDefinition);
+  const normalizedRecordOf = new Map<ProviderDefinition, ModuleGraphRecord>();
+  for (let index = 0; index < collectedDefinitions.length; index += 1) {
+    const original = collectedDefinitions[index] as ProviderDefinition;
+    const normalized = definitions[index] as ProviderDefinition;
+    const record = recordOf.get(original);
+    if (record) {
+      normalizedRecordOf.set(normalized, record);
+      const definitionIndex = record.definitions.indexOf(original);
+      if (definitionIndex >= 0) {
+        record.definitions[definitionIndex] = normalized;
+      }
+    }
+  }
+  moduleOwnedContributions.validateProviderExclusivity(collection.toArray());
+  validateModuleOwnedContributions(moduleOwnedContributions, definitions);
+  const validateDefinition = validateModuleEncapsulation(recordList);
+  const bindDefinition = createModuleScopedNameBinder(recordList);
+  const validateSelection = createProviderSelectionValidator(
+    recordList, definitions, normalizedRecordOf, collection.openGenericToArray(), openGenericRecordOf,
+  );
+  const boundDefinitions = definitions.map((definition) => {
+    const record = normalizedRecordOf.get(definition);
+    if (!record) return definition;
+    const bound = bindDefinition(definition, record);
+    validateSelection(bound, record);
+    return bound;
+  });
+  const openGenerics = collection.openGenericToArray().map((registration) => {
+    const record = openGenericRecordOf.get(registration);
+    if (!record) {
+      return registration;
+    }
+    return new OpenGenericRegistration(registration.family, (argument) => {
+      const definition = normalizeDefinition(new ProviderDefinition(
+        registration.providerFactory(argument), registration.lifetime, registration.key,
+      ));
+      // Validate and bind before the container publishes the closed batch.
+      // Root resolution still uses the generic declaration's module visibility.
+      validateDefinition(definition, record);
+      const bound = bindDefinition(definition, record);
+      validateSelection(bound, record);
+      return bound.provider;
+    }, registration.lifetime, registration.key);
+  });
+  built = new DiContainer(boundDefinitions, openGenerics, options, moduleOwnedContributions);
+  return built;
+}
+
+function normalizeLateGeneratedClassDeps(definition: ProviderDefinition): ProviderDefinition {
+  const provider = definition.provider;
+  if (!isClassProvider(provider) || provider.deps !== undefined || getClassDeps(provider.useClass) !== undefined) {
+    return definition;
+  }
+  const generatedDeps = getGeneratedClassDeps(provider.useClass);
+  if (generatedDeps === undefined) {
+    return definition;
+  }
+  const normalizedProvider = { ...provider, deps: generatedDeps } as Provider<unknown>;
+  return new ProviderDefinition(normalizedProvider, definition.lifetime, definition.key);
+}

package/core/di/module/encapsulation.ts

@@ -0,0 +1,416 @@
+import { ModuleEncapsulationError } from "../errors";
+import { getProviderDeps } from "../internal/providerDeps";
+import type { ProviderDefinition, ProviderDependencyList } from "../provider";
+import { isKeyedDependency, isLazyDependency, isNamedDependency } from "../provider";
+import type { OpenGenericTokenFamily, Token } from "../token";
+import { tokenToDebugName } from "../token";
+import { applyNamedDependencyEncapsulationHooks } from "./encapsulationHooks";
+import type { ModuleExport } from "./types";
+
+/**
+ * Build-time module graph record. Collected by `createContainer` while
+ * loading modules; consumed by `validateModuleEncapsulation`.
+ */
+export interface ModuleGraphRecord {
+  readonly name: string;
+  readonly imports: ModuleGraphRecord[];
+  /** undefined — the module is fully open; otherwise the explicit export list. */
+  readonly exports: readonly ModuleExport[] | undefined;
+  /** Global module: exported tokens are visible everywhere without imports. */
+  readonly global: boolean;
+  readonly providedTokens: Set<Token<unknown>>;
+  readonly providedFamilies: Set<symbol>;
+  readonly definitions: ProviderDefinition[];
+}
+
+/**
+ * Validates that every provider's dependencies are visible to its module:
+ * a module sees its own providers plus whatever its direct imports export.
+ * Open modules (no `exports` field) transitively expose everything they see,
+ * which keeps pre-encapsulation code working unchanged.
+ *
+ * Runs once at container build time and returns a checker for providers
+ * materialized later by an open generic factory. Visibility is computed once;
+ * cached service resolution does not repeat validation.
+ */
+export function validateModuleEncapsulation(
+  records: readonly ModuleGraphRecord[],
+): (definition: ProviderDefinition, record: ModuleGraphRecord) => void {
+  if (!hasClosedModules(records)) {
+    return () => {};
+  }
+
+  const issues: string[] = [];
+  const tokensByName = collectTokensByName(records);
+  const allProvidedTokens = new Set<Token<unknown>>();
+  const allProvidedFamilies = new Set<symbol>();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index] as ModuleGraphRecord;
+    for (const token of record.providedTokens) {
+      allProvidedTokens.add(token);
+    }
+    for (const familyId of record.providedFamilies) {
+      allProvidedFamilies.add(familyId);
+    }
+  }
+  const exportedTokensMemo = new Map<ModuleGraphRecord, Set<Token<unknown>>>();
+  const exportedFamiliesMemo = new Map<ModuleGraphRecord, Set<symbol>>();
+  const visiting = new Set<ModuleGraphRecord>();
+
+  const exportedTokens = (record: ModuleGraphRecord): Set<Token<unknown>> => {
+    const memoized = exportedTokensMemo.get(record);
+    if (memoized) {
+      return memoized;
+    }
+    if (visiting.has(record)) {
+      return new Set();
+    }
+    visiting.add(record);
+
+    const result = new Set<Token<unknown>>();
+    if (record.exports === undefined) {
+      for (const token of record.providedTokens) {
+        result.add(token);
+      }
+      for (let index = 0; index < record.imports.length; index += 1) {
+        for (const token of exportedTokens(record.imports[index] as ModuleGraphRecord)) {
+          result.add(token);
+        }
+      }
+    } else {
+      const visible = visibleTokens(record);
+      for (let index = 0; index < record.exports.length; index += 1) {
+        const ref = record.exports[index] as ModuleExport;
+        if (isFamilyExport(ref)) {
+          continue;
+        }
+        if (record.providedTokens.has(ref) || visible.has(ref)) {
+          result.add(ref);
+        } else {
+          issues.push(
+            `Module "${record.name}" exports "${tokenToDebugName(ref)}" which it neither provides nor imports.`,
+          );
+        }
+      }
+    }
+
+    visiting.delete(record);
+    exportedTokensMemo.set(record, result);
+    return result;
+  };
+
+  const visibleTokens = (record: ModuleGraphRecord): Set<Token<unknown>> => {
+    const result = new Set<Token<unknown>>(record.providedTokens);
+    for (let index = 0; index < record.imports.length; index += 1) {
+      for (const token of exportedTokens(record.imports[index] as ModuleGraphRecord)) {
+        result.add(token);
+      }
+    }
+    return result;
+  };
+
+  const exportedFamilies = (record: ModuleGraphRecord): Set<symbol> => {
+    const memoized = exportedFamiliesMemo.get(record);
+    if (memoized) {
+      return memoized;
+    }
+    if (visiting.has(record)) {
+      return new Set();
+    }
+    visiting.add(record);
+
+    const result = new Set<symbol>();
+    if (record.exports === undefined) {
+      for (const familyId of record.providedFamilies) {
+        result.add(familyId);
+      }
+      for (let index = 0; index < record.imports.length; index += 1) {
+        for (const familyId of exportedFamilies(record.imports[index] as ModuleGraphRecord)) {
+          result.add(familyId);
+        }
+      }
+    } else {
+      for (let index = 0; index < record.exports.length; index += 1) {
+        const ref = record.exports[index] as ModuleExport;
+        if (isFamilyExport(ref)) {
+          result.add(ref.id);
+        }
+      }
+    }
+
+    visiting.delete(record);
+    exportedFamiliesMemo.set(record, result);
+    return result;
+  };
+
+  const visibleFamilies = (record: ModuleGraphRecord): Set<symbol> => {
+    const result = new Set<symbol>(record.providedFamilies);
+    for (let index = 0; index < record.imports.length; index += 1) {
+      for (const familyId of exportedFamilies(record.imports[index] as ModuleGraphRecord)) {
+        result.add(familyId);
+      }
+    }
+    return result;
+  };
+
+  // Global modules (kernel infrastructure) are visible to everyone without an
+  // explicit import, mirroring NestJS @Global().
+  const globalTokens = new Set<Token<unknown>>();
+  const globalFamilies = new Set<symbol>();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index] as ModuleGraphRecord;
+    if (!record.global) {
+      continue;
+    }
+    for (const token of exportedTokens(record)) {
+      globalTokens.add(token);
+    }
+    for (const familyId of exportedFamilies(record)) {
+      globalFamilies.add(familyId);
+    }
+  }
+
+  const contexts = new Map<ModuleGraphRecord, DependencyCheckContext>();
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+    const record = records[recordIndex] as ModuleGraphRecord;
+    const visible = visibleTokens(record);
+    const familiesVisible = visibleFamilies(record);
+    for (const token of globalTokens) {
+      visible.add(token);
+    }
+    for (const familyId of globalFamilies) {
+      familiesVisible.add(familyId);
+    }
+
+    const context: DependencyCheckContext = {
+      visible, familiesVisible, tokensByName, allProvidedTokens, allProvidedFamilies, issues,
+    };
+    contexts.set(record, context);
+    for (const definition of record.definitions) {
+      checkDefinition(record, definition, context);
+    }
+  }
+
+  if (issues.length > 0) {
+    throw new ModuleEncapsulationError(issues);
+  }
+  return (definition, record) => {
+    const context = contexts.get(record);
+    if (!context) {
+      return;
+    }
+    const materializedIssues: string[] = [];
+    checkDefinition(record, definition, { ...context, issues: materializedIssues });
+    if (materializedIssues.length > 0) {
+      throw new ModuleEncapsulationError(materializedIssues);
+    }
+  };
+}
+
+interface DependencyCheckContext {
+  readonly visible: ReadonlySet<Token<unknown>>;
+  readonly familiesVisible: ReadonlySet<symbol>;
+  readonly tokensByName: ReadonlyMap<string, Token<unknown>[]>;
+  readonly allProvidedTokens: ReadonlySet<Token<unknown>>;
+  readonly allProvidedFamilies: ReadonlySet<symbol>;
+  readonly issues: string[];
+}
+
+function checkDefinition(
+  record: ModuleGraphRecord,
+  definition: ProviderDefinition,
+  context: DependencyCheckContext,
+): void {
+  for (const dependency of getProviderDeps(definition.provider)) {
+    if (dependency !== undefined) {
+      checkDependency(record, definition, dependency, context);
+    }
+  }
+}
+
+function checkDependency(
+  record: ModuleGraphRecord,
+  definition: ProviderDefinition,
+  dep: NonNullable<ProviderDependencyList[number]>,
+  context: DependencyCheckContext,
+): void {
+  const consumer = tokenToDebugName(definition.provider.provide);
+
+  // Laziness changes "when" a dependency is created, not "whether" the module
+  // may see it — validate the inner descriptor with the same rules.
+  if (isLazyDependency(dep)) {
+    checkDependency(record, definition, dep.inner, context);
+    return;
+  }
+
+  if (isNamedDependency(dep)) {
+    if (
+      applyNamedDependencyEncapsulationHooks({
+        depName: dep.name,
+        consumer,
+        moduleName: record.name,
+        visible: context.visible,
+        familiesVisible: context.familiesVisible,
+      })
+    ) {
+      return;
+    }
+    const candidates = context.tokensByName.get(dep.name);
+    // No candidates at all is a missing-dependency problem, not encapsulation.
+    if (!candidates || candidates.length === 0) {
+      return;
+    }
+    for (let index = 0; index < candidates.length; index += 1) {
+      if (context.visible.has(candidates[index] as Token<unknown>)) {
+        return;
+      }
+    }
+    context.issues.push(
+      `Module "${record.name}": "${consumer}" depends on "${dep.name}", which is provided by another module but not exported.`,
+    );
+    return;
+  }
+
+  const token = isKeyedDependency(dep) ? dep.token : dep;
+  if (typeof token !== "function" && token.genericFamilyId) {
+    if (context.visible.has(token)) {
+      return;
+    }
+    // Unknown family is a missing-registration problem, not encapsulation.
+    if (
+      context.allProvidedFamilies.has(token.genericFamilyId) &&
+      !context.familiesVisible.has(token.genericFamilyId)
+    ) {
+      context.issues.push(
+        `Module "${record.name}": "${consumer}" depends on open generic "${tokenToDebugName(token)}", whose family is not exported by any imported module.`,
+      );
+    }
+    return;
+  }
+
+  // Missing tokens are reported by validateOnBuild / resolve, not here.
+  if (!context.allProvidedTokens.has(token) || context.visible.has(token)) {
+    return;
+  }
+  context.issues.push(
+    `Module "${record.name}": "${consumer}" depends on "${tokenToDebugName(token)}", which is provided by another module but not exported.`,
+  );
+}
+
+function collectTokensByName(records: readonly ModuleGraphRecord[]): Map<string, Token<unknown>[]> {
+  const result = new Map<string, Token<unknown>[]>();
+  for (let recordIndex = 0; recordIndex < records.length; recordIndex += 1) {
+    const record = records[recordIndex] as ModuleGraphRecord;
+    for (const token of record.providedTokens) {
+      const name = tokenToDebugName(token);
+      const existing = result.get(name);
+      if (existing) {
+        if (!existing.includes(token)) {
+          existing.push(token);
+        }
+      } else {
+        result.set(name, [token]);
+      }
+    }
+  }
+  return result;
+}
+
+function hasClosedModules(records: readonly ModuleGraphRecord[]): boolean {
+  for (let index = 0; index < records.length; index += 1) {
+    if ((records[index] as ModuleGraphRecord).exports !== undefined) {
+      return true;
+    }
+  }
+  return false;
+}
+
+export function isFamilyExport(ref: ModuleExport): ref is OpenGenericTokenFamily<unknown, unknown> {
+  return typeof ref === "object" && ref !== null && "of" in ref && typeof (ref as { of: unknown }).of === "function";
+}
+
+/**
+ * Effective set of tokens visible to each module: its own providers, the tokens
+ * exported (transitively, with re-export) by its direct imports, plus everything
+ * exported by global modules. Same visibility semantics as
+ * {@link validateModuleEncapsulation}, but computed for *every* graph (including
+ * the fully-open default) and without issue reporting — validation has already
+ * run by the time this is consumed. Powers module-scoped named-dependency
+ * resolution (see `bindModuleScopedNames`).
+ */
+export function computeModuleVisibleTokens(
+  records: readonly ModuleGraphRecord[],
+): Map<ModuleGraphRecord, Set<Token<unknown>>> {
+  const exportedMemo = new Map<ModuleGraphRecord, Set<Token<unknown>>>();
+  const visiting = new Set<ModuleGraphRecord>();
+
+  const visibleOf = (record: ModuleGraphRecord): Set<Token<unknown>> => {
+    const result = new Set<Token<unknown>>(record.providedTokens);
+    for (let index = 0; index < record.imports.length; index += 1) {
+      for (const token of exported(record.imports[index] as ModuleGraphRecord)) {
+        result.add(token);
+      }
+    }
+    return result;
+  };
+
+  const exported = (record: ModuleGraphRecord): Set<Token<unknown>> => {
+    const memoized = exportedMemo.get(record);
+    if (memoized) {
+      return memoized;
+    }
+    if (visiting.has(record)) {
+      return new Set();
+    }
+    visiting.add(record);
+
+    const result = new Set<Token<unknown>>();
+    if (record.exports === undefined) {
+      for (const token of record.providedTokens) {
+        result.add(token);
+      }
+      for (let index = 0; index < record.imports.length; index += 1) {
+        for (const token of exported(record.imports[index] as ModuleGraphRecord)) {
+          result.add(token);
+        }
+      }
+    } else {
+      const visible = visibleOf(record);
+      for (let index = 0; index < record.exports.length; index += 1) {
+        const ref = record.exports[index] as ModuleExport;
+        if (isFamilyExport(ref)) {
+          continue;
+        }
+        if (record.providedTokens.has(ref) || visible.has(ref)) {
+          result.add(ref);
+        }
+      }
+    }
+
+    visiting.delete(record);
+    exportedMemo.set(record, result);
+    return result;
+  };
+
+  const globalTokens = new Set<Token<unknown>>();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index] as ModuleGraphRecord;
+    if (!record.global) {
+      continue;
+    }
+    for (const token of exported(record)) {
+      globalTokens.add(token);
+    }
+  }
+
+  const result = new Map<ModuleGraphRecord, Set<Token<unknown>>>();
+  for (let index = 0; index < records.length; index += 1) {
+    const record = records[index] as ModuleGraphRecord;
+    const visible = visibleOf(record);
+    for (const token of globalTokens) {
+      visible.add(token);
+    }
+    result.set(record, visible);
+  }
+  return result;
+}