@granite-js/micro-frontend 2.0.2 → 2.1.0

package/src/runtime/containerModuleExposure.ts

@@ -0,0 +1,92 @@
+import { getLegacyContainerPair } from './containerPairing';
+import { ExposedModuleAlreadyRegisteredError } from './errors';
+import { getMicroFrontendGlobalContext, MicroFrontendGlobalContextCompatibilityError } from './globalContext';
+import type { AppContainer } from './registry';
+
+export function exposeContainerModule(container: AppContainer, exposedModule: string, module: unknown): void {
+  const normalizedModule = normalizeExposedModule(exposedModule);
+  const legacyModule = normalizeLegacyModule(exposedModule);
+  const legacyContainer = getLegacyContainerPair(container);
+  if (
+    Reflect.has(container.exposedModules, normalizedModule) ||
+    (legacyContainer != null && Reflect.has(legacyContainer.exposeMap, legacyModule))
+  ) {
+    throw new ExposedModuleAlreadyRegisteredError(container.appName, normalizedModule);
+  }
+
+  const ownsModernContainer = Object.is(
+    Reflect.get(getMicroFrontendGlobalContext().__CONTAINERS__, container.appName),
+    container
+  );
+  const legacyModuleValue = legacyContainer == null ? module : toLegacyEsm(module);
+  try {
+    if (ownsModernContainer && !Reflect.set(container.exposedModules, normalizedModule, module)) {
+      throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+    }
+    if (
+      legacyContainer != null &&
+      !Reflect.defineProperty(legacyContainer.exposeMap, legacyModule, {
+        configurable: true,
+        enumerable: true,
+        get: () => legacyModuleValue,
+      })
+    ) {
+      throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+    }
+  } catch (error) {
+    if (ownsModernContainer) {
+      Reflect.deleteProperty(container.exposedModules, normalizedModule);
+    }
+    if (legacyContainer != null) {
+      Reflect.deleteProperty(legacyContainer.exposeMap, legacyModule);
+    }
+    throw error;
+  }
+}
+
+function toLegacyEsm(module: unknown): unknown {
+  if ((typeof module !== 'object' || module == null) && typeof module !== 'function') {
+    return module;
+  }
+  if (Reflect.get(module, '__esModule') === true) {
+    return module;
+  }
+  const legacyModule =
+    typeof module === 'function'
+      ? function (this: unknown, ...args: unknown[]): unknown {
+          return Reflect.apply(module, this, args);
+        }
+      : {};
+  for (const exportName of Reflect.ownKeys(module)) {
+    if (exportName === '__esModule' || exportName === 'default') {
+      continue;
+    }
+    const sourceDescriptor = Reflect.getOwnPropertyDescriptor(module, exportName);
+    const facadeDescriptor = Reflect.getOwnPropertyDescriptor(legacyModule, exportName);
+    if (sourceDescriptor == null || facadeDescriptor?.configurable === false) {
+      // Callable facades keep intrinsic non-configurable slots such as prototype.
+      continue;
+    }
+    Reflect.defineProperty(legacyModule, exportName, {
+      enumerable: sourceDescriptor.enumerable,
+      get: () => Reflect.get(module, exportName),
+    });
+  }
+  const hasDefaultExport = Reflect.getOwnPropertyDescriptor(module, 'default') != null;
+  Object.defineProperties(legacyModule, {
+    __esModule: { value: true },
+    default: {
+      enumerable: true,
+      get: hasDefaultExport ? () => Reflect.get(module, 'default') : () => module,
+    },
+  });
+  return legacyModule;
+}
+
+function normalizeExposedModule(exposedModule: string): string {
+  return exposedModule.startsWith('./') ? exposedModule : `./${exposedModule}`;
+}
+
+function normalizeLegacyModule(exposedModule: string): string {
+  return exposedModule.startsWith('./') ? exposedModule.slice(2) : exposedModule;
+}

package/src/runtime/containerPairing.ts

@@ -0,0 +1,120 @@
+import type { AppContainer } from './registry';
+
+export const CONTAINER_PAIRING_KEY = 'granite.micro-frontend.container-pair' as const;
+
+const containerPairingSymbol = Symbol.for(CONTAINER_PAIRING_KEY);
+const pairedLegacyByModern = new WeakMap<AppContainer, LegacyAppContainer>();
+const pairedModernByLegacy = new WeakMap<LegacyAppContainer, AppContainer>();
+const legacyAdapters = new WeakSet<AppContainer>();
+
+export interface LegacyAppContainer {
+  readonly name: string;
+  readonly config: unknown;
+  readonly exposeMap: Record<string, unknown>;
+}
+
+export function defineContainerPair(first: object, second: object): boolean {
+  try {
+    if (!definePairMarker(first, second) || !definePairMarker(second, first)) {
+      clearContainerPair(first, second);
+      return false;
+    }
+  } catch (error) {
+    clearContainerPair(first, second);
+    throw error;
+  }
+  return true;
+}
+
+export function isContainerPair(first: object, second: object): boolean {
+  return hasPairMarker(first, second) && hasPairMarker(second, first);
+}
+
+export function getContainerPair(container: object): object | null {
+  const descriptor = Reflect.getOwnPropertyDescriptor(container, containerPairingSymbol);
+  if (!isPairDescriptor(descriptor) || !isObject(descriptor.value)) {
+    return null;
+  }
+  return hasPairMarker(descriptor.value, container) ? descriptor.value : null;
+}
+
+export function clearContainerPair(first: object, second: object): void {
+  Reflect.deleteProperty(first, containerPairingSymbol);
+  Reflect.deleteProperty(second, containerPairingSymbol);
+}
+
+export function rememberContainerPair(modern: AppContainer, legacy: LegacyAppContainer): void {
+  pairedLegacyByModern.set(modern, legacy);
+  pairedModernByLegacy.set(legacy, modern);
+}
+
+export function rememberLegacyAdapterPair(modern: AppContainer, legacy: LegacyAppContainer): void {
+  rememberContainerPair(modern, legacy);
+  legacyAdapters.add(modern);
+}
+
+export function getLegacyContainerPair(modern: AppContainer): LegacyAppContainer | undefined {
+  const markedPair = getContainerPair(modern);
+  if (isLegacyAppContainer(markedPair) && markedPair.name === modern.appName) {
+    rememberContainerPair(modern, markedPair);
+    return markedPair;
+  }
+  return legacyAdapters.has(modern) ? pairedLegacyByModern.get(modern) : undefined;
+}
+
+export function getModernContainerPair(legacy: LegacyAppContainer): AppContainer | undefined {
+  return pairedModernByLegacy.get(legacy);
+}
+
+export function forgetContainerPair(modern: AppContainer | null, legacy: LegacyAppContainer | null): void {
+  if (modern != null) {
+    pairedLegacyByModern.delete(modern);
+    legacyAdapters.delete(modern);
+  }
+  if (legacy != null) {
+    pairedModernByLegacy.delete(legacy);
+  }
+}
+
+export function isLegacyAppContainer(value: unknown): value is LegacyAppContainer {
+  return (
+    isObjectRecord(value) &&
+    typeof Reflect.get(value, 'name') === 'string' &&
+    isObjectRecord(Reflect.get(value, 'config')) &&
+    isObjectRecord(Reflect.get(value, 'exposeMap'))
+  );
+}
+
+function definePairMarker(container: object, pair: object): boolean {
+  return Reflect.defineProperty(container, containerPairingSymbol, {
+    configurable: true,
+    enumerable: false,
+    value: pair,
+    writable: false,
+  });
+}
+
+function hasPairMarker(container: object, pair: object): boolean {
+  const descriptor = Reflect.getOwnPropertyDescriptor(container, containerPairingSymbol);
+  return isPairDescriptor(descriptor) && Object.is(descriptor.value, pair);
+}
+
+function isPairDescriptor(descriptor: PropertyDescriptor | undefined): descriptor is PropertyDescriptor & {
+  readonly value: unknown;
+} {
+  return (
+    descriptor != null &&
+    descriptor.configurable === true &&
+    descriptor.enumerable === false &&
+    descriptor.writable === false &&
+    Reflect.has(descriptor, 'value')
+  );
+}
+
+export function isObjectRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value != null && !Array.isArray(value);
+}
+
+function isObject(value: unknown): value is object {
+  return (typeof value === 'object' && value != null) || typeof value === 'function';
+}

package/src/runtime/containerRegistry.ts

@@ -0,0 +1,239 @@
+import {
+  clearContainerPair,
+  defineContainerPair,
+  forgetContainerPair,
+  getLegacyContainerPair,
+  getModernContainerPair,
+  isLegacyAppContainer,
+  isContainerPair,
+  isObjectRecord,
+  rememberContainerPair,
+  rememberLegacyAdapterPair,
+  type LegacyAppContainer,
+} from './containerPairing';
+import { AppContainerAlreadyRegisteredError } from './errors';
+import { getMicroFrontendGlobalContext, MicroFrontendGlobalContextCompatibilityError } from './globalContext';
+import type { AppContainer, AppContainerConfig } from './registry';
+
+export { exposeContainerModule as exposeModule } from './containerModuleExposure';
+
+export function createContainer(appName: string, config: AppContainerConfig = {}): AppContainer {
+  const context = getMicroFrontendGlobalContext();
+  const canonicalValue: unknown = Reflect.get(context.__CONTAINERS__, appName);
+  const legacyIndex: unknown = Reflect.get(context.__INSTANCES__, appName);
+  if (canonicalValue != null || typeof legacyIndex === 'number') {
+    throw new AppContainerAlreadyRegisteredError(appName);
+  }
+  if (!Reflect.isExtensible(context.__CONTAINERS__) || !Reflect.isExtensible(context.__INSTANCES__)) {
+    throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+  }
+
+  const modernContainer: AppContainer = { appName, config, exposedModules: {} };
+  const legacyContainer: LegacyAppContainer = { name: appName, config, exposeMap: {} };
+  const containerIndex = context.__INSTANCES__.length;
+
+  try {
+    if (
+      !Reflect.defineProperty(context.__INSTANCES__, appName, {
+        configurable: true,
+        enumerable: false,
+        value: containerIndex,
+        writable: false,
+      })
+    ) {
+      throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+    }
+    context.__INSTANCES__.push(legacyContainer);
+    if (
+      !Reflect.set(context.__CONTAINERS__, appName, modernContainer) ||
+      !defineContainerPair(modernContainer, legacyContainer)
+    ) {
+      throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+    }
+  } catch (error) {
+    if (Object.is(context.__INSTANCES__[context.__INSTANCES__.length - 1], legacyContainer)) {
+      context.__INSTANCES__.pop();
+    }
+    Reflect.deleteProperty(context.__INSTANCES__, appName);
+    Reflect.deleteProperty(context.__CONTAINERS__, appName);
+    clearContainerPair(modernContainer, legacyContainer);
+    throw error;
+  }
+
+  rememberContainerPair(modernContainer, legacyContainer);
+  return modernContainer;
+}
+
+export function getContainer(appName: string): AppContainer | null {
+  const context = getMicroFrontendGlobalContext();
+  const canonicalValue: unknown = Reflect.get(context.__CONTAINERS__, appName);
+  const modernContainer = isAppContainer(canonicalValue) ? canonicalValue : null;
+  const legacyContainer = getLegacyContainer(context.__INSTANCES__, appName);
+
+  if (modernContainer != null && legacyContainer != null) {
+    if (!isContainerPair(modernContainer, legacyContainer)) {
+      throw new AppContainerAlreadyRegisteredError(appName);
+    }
+    return modernContainer;
+  }
+  if (modernContainer != null) {
+    return modernContainer;
+  }
+  if (legacyContainer != null) {
+    return getLegacyAdapter(legacyContainer);
+  }
+  return null;
+}
+
+export function getExposedModule(container: AppContainer, exposedModule: string): unknown {
+  const module: unknown = Reflect.get(container.exposedModules, normalizeExposedModule(exposedModule));
+  const legacyContainer = getLegacyContainerPair(container);
+  return (
+    module ??
+    (legacyContainer == null ? undefined : Reflect.get(legacyContainer.exposeMap, normalizeLegacyModule(exposedModule)))
+  );
+}
+
+export function removeContainer(appName: string): void {
+  const context = getMicroFrontendGlobalContext();
+  const canonicalValue: unknown = Reflect.get(context.__CONTAINERS__, appName);
+  const modernContainer = isAppContainer(canonicalValue) ? canonicalValue : null;
+  const legacyContainer = getLegacyContainer(context.__INSTANCES__, appName);
+
+  if (modernContainer != null && legacyContainer != null && !isContainerPair(modernContainer, legacyContainer)) {
+    throw new AppContainerAlreadyRegisteredError(appName);
+  }
+  if (modernContainer == null && legacyContainer == null) {
+    return;
+  }
+
+  const nextInstances = createLegacyInstancesWithout(context.__INSTANCES__, legacyContainer);
+  if (legacyContainer != null && !Reflect.set(context, '__INSTANCES__', nextInstances)) {
+    throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+  }
+
+  if (modernContainer != null) {
+    clearRegistry(modernContainer.exposedModules);
+    Reflect.deleteProperty(context.__CONTAINERS__, appName);
+  }
+  if (legacyContainer != null) {
+    clearLegacyModules(legacyContainer);
+  }
+  if (modernContainer != null) {
+    if (legacyContainer != null) {
+      clearContainerPair(modernContainer, legacyContainer);
+    }
+  }
+  forgetContainerPair(modernContainer, legacyContainer);
+}
+
+function getLegacyAdapter(legacyContainer: LegacyAppContainer): AppContainer {
+  const existingAdapter = getModernContainerPair(legacyContainer);
+  if (existingAdapter != null) {
+    return existingAdapter;
+  }
+  const adapter: AppContainer = {
+    appName: legacyContainer.name,
+    config: isAppContainerConfig(legacyContainer.config) ? legacyContainer.config : {},
+    exposedModules: createNormalizedExposedModules(legacyContainer),
+  };
+  rememberLegacyAdapterPair(adapter, legacyContainer);
+  return adapter;
+}
+
+function createNormalizedExposedModules(container: LegacyAppContainer): Record<string, unknown> {
+  return new Proxy(
+    {},
+    {
+      get: (_target, property, receiver) =>
+        Reflect.get(
+          container.exposeMap,
+          typeof property === 'string' ? normalizeLegacyModule(property) : property,
+          receiver
+        ),
+      ownKeys: () =>
+        Reflect.ownKeys(container.exposeMap).map((key) =>
+          typeof key === 'string' ? normalizeExposedModule(key) : key
+        ),
+      getOwnPropertyDescriptor: (_target, property) => {
+        const moduleName = typeof property === 'string' ? normalizeLegacyModule(property) : property;
+        return Reflect.has(container.exposeMap, moduleName)
+          ? { configurable: true, enumerable: true, value: Reflect.get(container.exposeMap, moduleName) }
+          : undefined;
+      },
+    }
+  );
+}
+
+function getLegacyContainer(instances: unknown[], appName: string): LegacyAppContainer | null {
+  const index: unknown = Reflect.get(instances, appName);
+  if (typeof index !== 'number' || !Number.isInteger(index) || index < 0) {
+    return null;
+  }
+  const value: unknown = instances[index];
+  return isLegacyAppContainer(value) && value.name === appName ? value : null;
+}
+
+function createLegacyInstancesWithout(instances: unknown[], removed: LegacyAppContainer | null): unknown[] {
+  const nextInstances =
+    removed == null ? Array.from(instances) : instances.filter((entry) => !Object.is(entry, removed));
+  const registeredNames = new Set<string>();
+  for (const [index, entry] of nextInstances.entries()) {
+    if (!isLegacyAppContainer(entry)) {
+      continue;
+    }
+    if (registeredNames.has(entry.name) || typeof Reflect.get(nextInstances, entry.name) === 'number') {
+      throw new AppContainerAlreadyRegisteredError(entry.name);
+    }
+    registeredNames.add(entry.name);
+    if (
+      !Reflect.defineProperty(nextInstances, entry.name, {
+        configurable: true,
+        enumerable: false,
+        value: index,
+        writable: false,
+      })
+    ) {
+      throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+    }
+  }
+  return nextInstances;
+}
+
+function clearRegistry(registry: Record<string, unknown>): void {
+  for (const key of Object.keys(registry)) {
+    Reflect.deleteProperty(registry, key);
+  }
+}
+
+function clearLegacyModules(container: LegacyAppContainer): void {
+  clearRegistry(container.exposeMap);
+  if (Object.keys(container.exposeMap).length > 0 && !Reflect.set(container, 'exposeMap', {})) {
+    throw new MicroFrontendGlobalContextCompatibilityError('registry-is-not-extensible');
+  }
+}
+
+function normalizeExposedModule(exposedModule: string): string {
+  return exposedModule.startsWith('./') ? exposedModule : `./${exposedModule}`;
+}
+
+function normalizeLegacyModule(exposedModule: string): string {
+  return exposedModule.startsWith('./') ? exposedModule.slice(2) : exposedModule;
+}
+
+function isAppContainer(value: unknown): value is AppContainer {
+  return (
+    isObjectRecord(value) &&
+    typeof Reflect.get(value, 'appName') === 'string' &&
+    isAppContainerConfig(Reflect.get(value, 'config')) &&
+    isObjectRecord(Reflect.get(value, 'exposedModules'))
+  );
+}
+
+function isAppContainerConfig(value: unknown): value is AppContainerConfig {
+  if (!isObjectRecord(value)) {
+    return false;
+  }
+  const shared: unknown = Reflect.get(value, 'shared');
+  return shared == null || isObjectRecord(shared);
+}

package/src/runtime/createMicroFrontendRuntime.ts

@@ -6,6 +6,7 @@ import type {
   MicroFrontendRuntimeEventSubscription,
 } from '../types';
 import { AppContainerNotFoundError, InvalidAppNameError } from './errors';
+import { getMicroFrontendGlobalContext } from './globalContext';
 import { parseAppRequest } from './parseAppRequest';
 
 export interface NativeMicroFrontendRuntimeEvent {
@@ -68,10 +69,15 @@ export function createMicroFrontendRuntimeWithDependencies(
     return evaluation;
   }
 
+  function evaluateScript(filePath: string): Promise<void> {
+    getMicroFrontendGlobalContext();
+    return dependencies.nativeRuntime.evaluateScript({ filePath });
+  }
+
   async function evaluateApp(appName: string): Promise<void> {
     try {
       const { filePath } = await dependencies.adapter.loadBundle({ appName });
-      await dependencies.nativeRuntime.evaluateScript({ filePath });
+      await evaluateScript(filePath);
 
       if (!dependencies.registry.hasContainer(appName)) {
         throw new AppContainerNotFoundError(appName);
@@ -83,7 +89,7 @@ export function createMicroFrontendRuntimeWithDependencies(
   }
 
   return {
-    evaluateScript: (filePath) => dependencies.nativeRuntime.evaluateScript({ filePath }),
+    evaluateScript,
     preloadApp,
     async importApp<TModule>(request: AppRequest): Promise<TModule> {
       const { appName } = parseAppRequest(request);

package/src/runtime/globalContext.ts

@@ -0,0 +1,164 @@
+import type { AppContainer } from './registry';
+
+const CANONICAL_GLOBAL_KEY = '__MICRO_FRONTEND__';
+type ObjectRecord = Record<string, unknown>;
+type SharedModule = {
+  readonly get: () => unknown;
+  readonly loaded: boolean;
+};
+
+export type MicroFrontendGlobalContext = {
+  readonly __INSTANCES__: unknown[];
+  readonly __SHARED__: Record<string, SharedModule>;
+  readonly __CONTAINERS__: Record<string, AppContainer>;
+};
+
+type LegacyGlobalContext = {
+  readonly __INSTANCES__: unknown[];
+  readonly __SHARED__: Record<string, SharedModule>;
+};
+
+type CompatibilityFailureReason =
+  | 'canonical-global-is-not-adoptable'
+  | 'canonical-global-is-locked'
+  | 'global-object-is-not-extensible'
+  | 'registry-is-not-extensible';
+
+export class MicroFrontendGlobalContextCompatibilityError extends Error {
+  public readonly reason: CompatibilityFailureReason;
+
+  public constructor(reason: CompatibilityFailureReason) {
+    super(`Cannot establish the micro-frontend global context: ${reason}`);
+    this.name = 'MicroFrontendGlobalContextCompatibilityError';
+    this.reason = reason;
+  }
+}
+
+function assertCompatible(condition: boolean, reason: CompatibilityFailureReason): asserts condition {
+  if (!condition) {
+    throw new MicroFrontendGlobalContextCompatibilityError(reason);
+  }
+}
+
+export function getMicroFrontendGlobalContext(globalObject: object = globalThis): MicroFrontendGlobalContext {
+  const canonicalValue: unknown = Reflect.get(globalObject, CANONICAL_GLOBAL_KEY);
+  assertCompatible(
+    canonicalValue == null || isMicroFrontendGlobalContext(canonicalValue) || isLegacyGlobalContext(canonicalValue),
+    'canonical-global-is-not-adoptable'
+  );
+
+  if (isMicroFrontendGlobalContext(canonicalValue)) {
+    return canonicalValue;
+  }
+
+  const canonicalDescriptor = Object.getOwnPropertyDescriptor(globalObject, CANONICAL_GLOBAL_KEY);
+  const legacyHasCanonicalOrder =
+    isLegacyGlobalContext(canonicalValue) && hasKeysInOrder(canonicalValue, ['__INSTANCES__', '__SHARED__']);
+
+  assertCompatible(
+    canonicalDescriptor != null || Reflect.isExtensible(globalObject),
+    'global-object-is-not-extensible'
+  );
+  assertCompatible(
+    canonicalDescriptor == null || legacyHasCanonicalOrder || canonicalDescriptor.configurable === true,
+    'canonical-global-is-locked'
+  );
+
+  if (legacyHasCanonicalOrder) {
+    return addContainersRegistry(canonicalValue);
+  }
+
+  const context: MicroFrontendGlobalContext = {
+    __INSTANCES__: canonicalValue?.__INSTANCES__ ?? [],
+    __SHARED__: canonicalValue?.__SHARED__ ?? {},
+    __CONTAINERS__: {},
+  };
+
+  try {
+    assertCompatible(
+      Reflect.defineProperty(globalObject, CANONICAL_GLOBAL_KEY, {
+        configurable: true,
+        enumerable: true,
+        value: context,
+        writable: true,
+      }),
+      'canonical-global-is-not-adoptable'
+    );
+    return context;
+  } catch (error) {
+    restoreProperty(globalObject, CANONICAL_GLOBAL_KEY, canonicalDescriptor);
+    throw error;
+  }
+}
+
+function addContainersRegistry(context: LegacyGlobalContext): MicroFrontendGlobalContext {
+  const containersDescriptor = Object.getOwnPropertyDescriptor(context, '__CONTAINERS__');
+  assertCompatible(Reflect.isExtensible(context), 'canonical-global-is-not-adoptable');
+
+  try {
+    assertCompatible(
+      Reflect.defineProperty(context, '__CONTAINERS__', {
+        configurable: true,
+        enumerable: true,
+        value: {},
+        writable: true,
+      }),
+      'canonical-global-is-not-adoptable'
+    );
+    assertCompatible(isMicroFrontendGlobalContext(context), 'canonical-global-is-not-adoptable');
+    return context;
+  } catch (error) {
+    restoreProperty(context, '__CONTAINERS__', containersDescriptor);
+    throw error;
+  }
+}
+
+function restoreProperty(target: object, key: PropertyKey, descriptor: PropertyDescriptor | undefined): void {
+  const current = Object.getOwnPropertyDescriptor(target, key) ?? {};
+  const previous = descriptor ?? {};
+  const currentKeys = Object.keys(current);
+  const descriptorsMatch =
+    currentKeys.length === Object.keys(previous).length &&
+    currentKeys.every((property) => Object.is(Reflect.get(current, property), Reflect.get(previous, property)));
+
+  if (descriptorsMatch) {
+    return;
+  }
+
+  assertCompatible(
+    descriptor == null ? Reflect.deleteProperty(target, key) : Reflect.defineProperty(target, key, descriptor),
+    'canonical-global-is-not-adoptable'
+  );
+}
+
+function isMicroFrontendGlobalContext(value: unknown): value is MicroFrontendGlobalContext {
+  return (
+    isObjectRecord(value) &&
+    hasKeysInOrder(value, ['__INSTANCES__', '__SHARED__', '__CONTAINERS__']) &&
+    Array.isArray(Reflect.get(value, '__INSTANCES__')) &&
+    isObjectRecord(Reflect.get(value, '__SHARED__')) &&
+    isObjectRecord(Reflect.get(value, '__CONTAINERS__'))
+  );
+}
+
+function isLegacyGlobalContext(value: unknown): value is LegacyGlobalContext {
+  return (
+    isObjectRecord(value) &&
+    hasExactKeySet(value, ['__INSTANCES__', '__SHARED__']) &&
+    Array.isArray(Reflect.get(value, '__INSTANCES__')) &&
+    isObjectRecord(Reflect.get(value, '__SHARED__'))
+  );
+}
+
+const isObjectRecord = (value: unknown): value is ObjectRecord =>
+  typeof value === 'object' && value != null && !Array.isArray(value);
+
+function hasExactKeySet(value: object, expectedKeys: readonly string[]): boolean {
+  const actualKeys = Object.keys(value);
+  return actualKeys.length === expectedKeys.length && expectedKeys.every((key) => actualKeys.includes(key));
+}
+
+function hasKeysInOrder(value: object, expectedKeys: readonly string[]): boolean {
+  const actualKeys = Object.keys(value);
+  return actualKeys.length === expectedKeys.length && actualKeys.every((key, index) => key === expectedKeys[index]);
+}