import {
  Value, JSStringValue, ObjectValue, UndefinedValue, BooleanValue,
  NullValue,
} from './value.mts';
import { surroundingAgent, type GCMarker } from './host-defined/engine.mts';
import { ExecutionContext } from './execution-context/ExecutionContext.mts';
import {
  VarScopedDeclarations,
  LexicallyScopedDeclarations,
  BoundNames,
  IsConstantDeclaration,
  type ImportEntry,
  type ExportEntry,
} from './static-semantics/all.mts';
import { InstantiateFunctionObject } from './runtime-semantics/all.mts';
import {
  Completion,
  NormalCompletion,
  AbruptCompletion,
  EnsureCompletion,
  Q, X, ThrowCompletion,
  IfAbruptRejectPromise,
} from './completion.mts';
import { OutOfRange, type Mutable } from './utils/language.mts';
import { JSStringSet } from './utils/container.mts';
import {
  Evaluate, type Evaluator, type PlainEvaluator, type ValueEvaluator,
} from './evaluator.mts';
import type { ParseNode } from './parser/ParseNode.mts';
import {
  Assert,
  Call,
  NewPromiseCapability,
  GetImportedModule,
  GetModuleNamespace,
  InnerModuleEvaluation,
  InnerModuleLinking,
  InnerModuleLoading,
  MergeImportedNames,
  ModuleRequestsKeyEqual,
  SafePerformPromiseAll,
  SameValue,
  AsyncBlockStart,
  PromiseCapabilityRecord,
  GraphLoadingState,
  Realm,
  Throw,
  isEvaluator,
} from '#self';
import {
  type ImportAttributeRecord,
  type ImportedNamesValue,
  type ModuleRequestRecord,
  type PlainCompletion, type PromiseObject, ModuleEnvironmentRecord,
} from '#self';

// https://tc39.es/ecma262/#loadedmodulerequest-record
export interface LoadedModuleRequestRecord {
  readonly Specifier: string;
  readonly Attributes: readonly ImportAttributeRecord[];
  readonly Module: AbstractModuleRecord
}

// #resolvedbinding-record
export class ResolvedBindingRecord {
  readonly Module: AbstractModuleRecord;

  readonly BindingName: 'namespace' | 'deferred-namespace' | 'source' | JSStringValue;

  constructor({ Module, BindingName }: Pick<ResolvedBindingRecord, 'BindingName' | 'Module'>) {
    Assert(Module instanceof AbstractModuleRecord);
    Assert(BindingName === 'namespace' || BindingName === 'deferred-namespace' || BindingName === 'source' || BindingName instanceof JSStringValue);
    this.Module = Module;
    this.BindingName = BindingName;
  }

  mark(m: GCMarker) {
    m(this.Module);
  }
}

export type ModuleRecordHostDefinedPublic = unknown;
export type ModuleRecordHostDefined = {
  public?: ModuleRecordHostDefinedPublic;
  specifier?: string | undefined;
  readonly SourceTextModuleRecord?: typeof SourceTextModuleRecord;
  scriptId?: string;
  readonly doNotTrackScriptId?: boolean;
};
export interface AbstractModuleInit {
  readonly Realm: AbstractModuleRecord['Realm'];
  readonly Environment: AbstractModuleRecord['Environment'];
  readonly HostDefined: AbstractModuleRecord['HostDefined'];
  // change to non optional after proposal merged
  readonly ModuleSource?: AbstractModuleRecord['ModuleSource'];
  readonly Namespace: AbstractModuleRecord['Namespace'];
}

interface ResolveSetItem {
  readonly Module: AbstractModuleRecord;
  readonly ExportName: JSStringValue;
}

/** https://tc39.es/ecma262/#sec-abstract-module-records */
export abstract class AbstractModuleRecord {
  abstract LoadRequestedModules(hostDefined?: ModuleRecordHostDefined, importedNames?: ImportedNamesValue): PromiseObject;

  abstract GetExportedNames(exportStarSet?: AbstractModuleRecord[]): readonly JSStringValue[];

  abstract ResolveExport(exportName: JSStringValue, resolveSet?: ResolveSetItem[]): 'ambiguous' | ResolvedBindingRecord | null;

  abstract Link(importedNames?: ImportedNamesValue): PlainCompletion<void>;

  abstract Evaluate(importedNames?: ImportedNamesValue): Evaluator<PromiseObject>;

  /** https://tc39.es/proposal-deferred-reexports/#abstract-getoptionalindirectexportsmodulerequests */
  GetOptionalIndirectExportsModuleRequests(_importedNames: ImportedNamesValue): readonly ModuleRequestRecord[] {
    // 1. Return a new empty List.
    return [];
  }

  // https://github.com/tc39/ecma262/pull/3492/#abstract-get-module-source-kind
  GetModuleSourceKind(): string {
    // For Module Records that do not have a source representation (currently all ECMA-262-defined Module Records), GetModuleSourceKind() is never called.
    throw new Error('GetModuleSourceKind must be implemented by module records that have a ModuleSource');
  }

  readonly Realm: Realm;

  readonly Environment: ModuleEnvironmentRecord | undefined;

  readonly Namespace: ObjectValue | undefined = undefined;

  readonly DeferredNamespace: ObjectValue | undefined = undefined;

  readonly ModuleSource: ObjectValue | undefined = undefined;

  readonly HostDefined: ModuleRecordHostDefined | undefined;

  constructor(init: AbstractModuleInit) {
    this.Realm = init.Realm;
    this.Environment = init.Environment;
    this.ModuleSource = init.ModuleSource;
    this.HostDefined = init.HostDefined;
  }

  mark(m: GCMarker) {
    m(this.Realm);
    m(this.Environment);
    m(this.Namespace);
    m(this.DeferredNamespace);
    m(this.ModuleSource);
  }
}

export { AbstractModuleRecord as ModuleRecord };

export type CyclicModuleRecordInit = AbstractModuleInit & Readonly<Pick<CyclicModuleRecord, 'Status' | 'EvaluationError' | 'DFSAncestorIndex' | 'RequestedModules' | 'LoadedModules' | 'CycleRoot' | 'HasTLA' | 'AsyncEvaluationOrder' | 'TopLevelCapability' | 'AsyncParentModules' | 'PendingAsyncDependencies'>>;
export type CyclicModuleRecordStatus = 'new' | 'unlinked' | 'linking' | 'linked' | 'evaluating' | 'evaluating-async' | 'evaluated';
/** https://tc39.es/ecma262/#sec-cyclic-module-records */
export abstract class CyclicModuleRecord extends AbstractModuleRecord {
  Status: CyclicModuleRecordStatus;

  EvaluationError: ThrowCompletion | undefined;

  DFSAncestorIndex: number | undefined;

  readonly RequestedModules: readonly ModuleRequestRecord[];

  readonly LoadedModules: LoadedModuleRequestRecord[];

  readonly HasTLA: BooleanValue;

  AsyncEvaluationOrder: 'unset' | number | 'done';

  AsyncParentModules: CyclicModuleRecord[];

  CycleRoot: CyclicModuleRecord | undefined;

  TopLevelCapability: PromiseCapabilityRecord | undefined;

  PendingAsyncDependencies: number | undefined;

  constructor(init: CyclicModuleRecordInit) {
    super(init);
    this.Status = init.Status;
    this.EvaluationError = init.EvaluationError;
    this.DFSAncestorIndex = init.DFSAncestorIndex;
    this.RequestedModules = init.RequestedModules;
    this.LoadedModules = init.LoadedModules;
    this.CycleRoot = init.CycleRoot;
    this.HasTLA = init.HasTLA;
    this.AsyncEvaluationOrder = init.AsyncEvaluationOrder;
    this.TopLevelCapability = init.TopLevelCapability;
    this.AsyncParentModules = init.AsyncParentModules;
    this.PendingAsyncDependencies = init.PendingAsyncDependencies;
  }

  abstract ExecuteModule(capability?: PromiseCapabilityRecord): ValueEvaluator;

  /** https://tc39.es/ecma262/#sec-LoadRequestedModules */
  LoadRequestedModules(hostDefined?: ModuleRecordHostDefined, importedNames: ImportedNamesValue = 'all') {
    const module = this;
    // 1. If importedNames is not present, set importedNames to ~all~.
    // 2. If hostDefined is not present, set hostDefined to empty.
    // 3. Let pc be ! NewPromiseCapability(%Promise%).
    const pc = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
    // 4. Let state be the GraphLoadingState Record { [[IsLoading]]: true, [[PendingModulesCount]]: 1, [[Visited]]: « », [[PromiseCapability]]: pc, [[HostDefined]]: hostDefined }.
    const state = new GraphLoadingState({
      PromiseCapability: pc,
      HostDefined: hostDefined,
    });
    // 5. Perform InnerModuleLoading(state, module, importedNames).
    InnerModuleLoading(state, module, importedNames, 'recursive-load');
    // 6. Return pc.[[Promise]].
    return pc.Promise;
  }

  /** https://tc39.es/ecma262/#sec-moduledeclarationlinking */
  Link(importedNames: ImportedNamesValue = 'all'): PlainCompletion<void> {
    const module = this;
    // 1. Assert: module.[[Status]] is one of unlinked, linked, evaluating-async, or evaluated.
    Assert(module.Status === 'unlinked' || module.Status === 'linked' || module.Status === 'evaluating-async' || module.Status === 'evaluated');
    // 2. If importedNames is not present, set importedNames to ~all~.
    //    (handled via the default parameter above)
    // 3. Let stack be a new empty List.
    const stack: CyclicModuleRecord[] = [];
    // 4. Let result be Completion(InnerModuleLinking(module, stack, 0)).
    const result = InnerModuleLinking(module, stack, 0);
    // 5. If result is an abrupt completion, then
    if (result instanceof AbruptCompletion) {
      // a. For each Cyclic Module Record m of stack, do
      for (const m of stack) {
        // i. Assert: m.[[Status]] is linking.
        Assert(m.Status === 'linking');
        // ii. Set m.[[Status]] to unlinked.
        m.Status = 'unlinked';
      }
      // b. Assert: module.[[Status]] is unlinked.
      Assert(module.Status === 'unlinked');
      // c. Return ? result.
      return Q(result);
    }
    // 6. Assert: module.[[Status]] is one of linked, evaluating-async, or evaluated.
    Assert(module.Status === 'linked' || module.Status === 'evaluating-async' || module.Status === 'evaluated');
    // 7. Assert: stack is empty.
    Assert(stack.length === 0);
    // 8. Let optionalIndirectRequests be module.GetOptionalIndirectExportsModuleRequests(importedNames).
    const optionalIndirectRequests = module.GetOptionalIndirectExportsModuleRequests(importedNames);
    // 9. For each ModuleRequest Record request of optionalIndirectRequests, do
    for (const request of optionalIndirectRequests) {
      // a. Let requiredModule be GetImportedModule(module, request).
      const requiredModule = GetImportedModule(module, request);
      // b. Assert: requiredModule.[[Status]] is one of unlinked, linked, evaluating-async, or evaluated.
      Assert(
        !(requiredModule instanceof CyclicModuleRecord)
        || requiredModule.Status === 'unlinked' || requiredModule.Status === 'linked'
        || requiredModule.Status === 'evaluating-async' || requiredModule.Status === 'evaluated',
      );
      // c. If requiredModule.[[Status]] is unlinked, perform ? requiredModule.Link(request.[[ImportedNames]]).
      if (requiredModule instanceof CyclicModuleRecord && requiredModule.Status === 'unlinked') {
        Q(requiredModule.Link(request.ImportedNames));
      }
    }
    // 10. Return unused.
    return NormalCompletion(undefined);
  }

  /** https://tc39.es/ecma262/#sec-moduleevaluation */
  * Evaluate(importedNames: ImportedNamesValue = []): Evaluator<PromiseObject> {
    const module: CyclicModuleRecord = this;

    // 1. Assert: None of module or any of its recursive dependencies have [[Status]] set to evaluating, linking, unlinked, or new.
    Assert((function getModules(module: AbstractModuleRecord, list: CyclicModuleRecord[]) {
      if (!(module instanceof CyclicModuleRecord) || list.includes(module)) {
        return list;
      }
      list.push(module);
      for (const r of module.RequestedModules) {
        getModules(GetImportedModule(module, r), list);
      }
      return list;
    }(this, [])).every((m) => m.Status !== 'evaluating' && m.Status !== 'linking' && m.Status !== 'unlinked' && m.Status !== 'new'));
    // 2. Assert: module.[[Status]] is one of linked, evaluating-async, or evaluated.
    Assert(module.Status === 'linked' || module.Status === 'evaluating-async' || module.Status === 'evaluated');
    // 3. If importedNames is not present, set importedNames to « ».
    let topLevelPromise: PromiseObject;
    // 4. If module.[[Status]] is either evaluating-async or evaluated, then
    if ((module.Status === 'evaluating-async' || module.Status === 'evaluated')
        && module.CycleRoot !== undefined && module.CycleRoot.TopLevelCapability !== undefined) {
      // a. Assert: module.[[CycleRoot]].[[TopLevelCapability]] is not empty.
      // b. Let topLevelPromise be module.[[CycleRoot]].[[TopLevelCapability]].[[Promise]].
      topLevelPromise = module.CycleRoot.TopLevelCapability.Promise;
    } else { // 5. Else,
      // a. Assert: module.[[CycleRoot]] and module.[[TopLevelCapability]] are empty.
      // b. Let stack be a new empty List.
      const stack: CyclicModuleRecord[] = [];
      // c. Let capability be ! NewPromiseCapability(%Promise%).
      const capability = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
      // d. Set module.[[TopLevelCapability]] to capability.
      module.TopLevelCapability = capability;
      // e. Let result be Completion(InnerModuleEvaluation(module, stack, 0)).
      const result = yield* InnerModuleEvaluation(module, stack, 0);
      // f. If result is an abrupt completion, then
      if (result instanceof AbruptCompletion) {
        // i. For each Cyclic Module Record m of stack, do
        for (const m of stack) {
          // 1. Assert: m.[[Status]] is evaluating.
          Assert(m.Status === 'evaluating');
          // 2. Set m.[[Status]] to evaluated.
          m.Status = 'evaluated';
          // 3. Set m.[[EvaluationError]] to result.
          m.EvaluationError = result;
          m.CycleRoot = m;
        }
        // ii. Assert: module.[[Status]] is evaluated.
        // iii. Assert: module.[[EvaluationError]] is result.
        Assert((module.Status as CyclicModuleRecordStatus) === 'evaluated' && module.EvaluationError === result);
        // iv. Perform ! Call(capability.[[Reject]], undefined, « result.[[Value]] »).
        X(Call(capability.Reject, Value.undefined, [result.Value]));
      } else { // g. Else,
        const postStatus = module.Status as CyclicModuleRecordStatus;
        // i. Assert: module.[[Status]] is either evaluating-async or evaluated.
        Assert(postStatus === 'evaluating-async' || postStatus === 'evaluated');
        // ii. Assert: module.[[EvaluationError]] is empty.
        Assert(module.EvaluationError === undefined);
        // iii. If module.[[Status]] is evaluated, then
        if (postStatus === 'evaluated') {
          //    1. NOTE: This implies that evaluation of module completed synchronously.
          //    2. Assert: module.[[AsyncEvaluationOrder]] is unset.
          Assert(typeof module.AsyncEvaluationOrder !== 'number');
          //    3. Perform ! Call(capability.[[Resolve]], undefined, « undefined »).
          X(Call(capability.Resolve, Value.undefined, [Value.undefined]));
        }
        // iv. Assert: stack is empty.
        Assert(stack.length === 0);
      }
      // h. Let topLevelPromise be capability.[[Promise]].
      topLevelPromise = capability.Promise;
    }

    // 6. If topLevelPromise.[[PromiseState]] is rejected, return topLevelPromise.
    if (topLevelPromise.PromiseState === 'rejected') {
      return topLevelPromise;
    }

    // 7. Let optionalIndirectRequests be module.GetOptionalIndirectExportsModuleRequests(importedNames).
    const optionalIndirectRequests = module.GetOptionalIndirectExportsModuleRequests(importedNames);
    // 8. Let promises be « topLevelPromise ».
    const promises: PromiseObject[] = [topLevelPromise];
    // 9. For each ModuleRequest Record request of optionalIndirectRequests, do
    for (const request of optionalIndirectRequests) {
      // a. Let requiredModule be GetImportedModule(module, request).
      const requiredModule = GetImportedModule(module, request);
      // b. Assert: requiredModule.[[Status]] is one of linked, evaluating-async, or evaluated.
      Assert(
        !(requiredModule instanceof CyclicModuleRecord)
        || requiredModule.Status === 'linked'
        || requiredModule.Status === 'evaluating-async'
        || requiredModule.Status === 'evaluated',
      );
      // c. Let innerPromise be requiredModule.Evaluate(request.[[ImportedNames]]).
      const innerPromise = yield* requiredModule.Evaluate(request.ImportedNames);
      // d. If innerPromise.[[PromiseState]] is rejected, return innerPromise.
      if (innerPromise.PromiseState === 'rejected') {
        return innerPromise;
      }
      // e. Append innerPromise to promises.
      promises.push(innerPromise);
    }

    // 10. If promises contains a Promise P such that P.[[PromiseState]] is pending, then
    if (promises.some((p) => p.PromiseState === 'pending')) {
      // a. NOTE: If all modules in the graph are synchronous, the usage of promises is an internal specification detail.
      //    In that case, we do not use SafePerformPromiseAll to keep returning an already settled promise.
      // b. Return SafePerformPromiseAll(CreateListIteratorRecord(promises)).
      return SafePerformPromiseAll(promises);
    }
    // 11. Return topLevelPromise.
    return topLevelPromise;
  }

  override mark(m: GCMarker) {
    super.mark(m);
    m(this.EvaluationError);
    for (const v of this.LoadedModules) {
      m(v.Module);
    }
  }
}

export type SourceTextModuleRecordInit = CyclicModuleRecordInit & Pick<SourceTextModuleRecord, 'ImportMeta' | 'ECMAScriptCode' | 'Context' | 'ImportEntries' | 'LocalExportEntries' | 'IndirectExportEntries' | 'StarExportEntries'> & Partial<Pick<SourceTextModuleRecord, 'OptionalIndirectExportEntries'>>;
/** https://tc39.es/ecma262/#sec-source-text-module-records */
export class SourceTextModuleRecord extends CyclicModuleRecord {
  ImportMeta: ObjectValue | undefined;

  readonly ECMAScriptCode: ParseNode.Module;

  readonly Context: ExecutionContext | undefined;

  readonly ImportEntries: readonly ImportEntry[];

  readonly LocalExportEntries: readonly ExportEntry[];

  readonly IndirectExportEntries: readonly ExportEntry[];

  readonly StarExportEntries: readonly ExportEntry[];

  /** https://tc39.es/proposal-deferred-reexports/ — deferred re-export entries (`export defer ... from`). */
  readonly OptionalIndirectExportEntries: readonly ExportEntry[];

  constructor(init: SourceTextModuleRecordInit) {
    super(init);

    this.ImportMeta = init.ImportMeta;
    this.ECMAScriptCode = init.ECMAScriptCode;
    this.Context = init.Context;
    this.ImportEntries = init.ImportEntries;
    this.LocalExportEntries = init.LocalExportEntries;
    this.IndirectExportEntries = init.IndirectExportEntries;
    this.StarExportEntries = init.StarExportEntries;
    this.OptionalIndirectExportEntries = init.OptionalIndirectExportEntries ?? [];
  }

  /** https://tc39.es/ecma262/#sec-getexportednames */
  GetExportedNames(exportStarSet: AbstractModuleRecord[]) {
    const module = this;
    // 1. Assert: module.[[Status]] is not new.
    Assert(module.Status !== 'new');
    // 2. If exportStarSet is not present, set exportStarSet to a new empty List.
    if (!exportStarSet) {
      exportStarSet = [];
    }
    // 3. If exportStarSet contains module, then
    if (exportStarSet.includes(module)) {
      // a. Assert: We've reached the starting point of an import * circularity.
      // b. Return a new empty List.
      return [];
    }
    // 4. Append module to exportStarSet.
    exportStarSet.push(module);
    // 5. Let exportedNames be a new empty List.
    const exportedNames: JSStringValue[] = [];
    // 6. For each ExportEntry Record e in module.[[LocalExportEntries]], do
    for (const e of module.LocalExportEntries) {
      // a. Assert: module provides the direct binding for this export.
      // b. Assert: e.[[ExportName]] is not null.
      Assert(!(e.ExportName instanceof NullValue));
      // c. Append e.[[ExportName]] to exportedNames.
      exportedNames.push(e.ExportName);
    }
    // 6. Let allNamedExportEntries be the list-concatenation of module.[[LocalExportEntries]], module.[[IndirectExportEntries]], and module.[[OptionalIndirectExportEntries]].
    const allNamedExportEntries = [...module.IndirectExportEntries, ...module.OptionalIndirectExportEntries];
    // 7. For each ExportEntry Record e of allNamedExportEntries, do
    //    https://tc39.es/proposal-deferred-reexports/#sec-getexportednames
    for (const e of allNamedExportEntries) {
      // a. Assert: module imports a specific binding for this export.
      // b. Assert: e.[[ExportName]] is not null.
      Assert(!(e.ExportName instanceof NullValue));
      // c. Append e.[[ExportName]] to exportedNames.
      exportedNames.push(e.ExportName);
    }
    // 8. For each ExportEntry Record e in module.[[StarExportEntries]], do
    for (const e of module.StarExportEntries) {
      // a. Let requestedModule be GetImportedModule(module, e.[[ModuleRequest]]).
      const requestedModule = GetImportedModule(module, e.ModuleRequest as ModuleRequestRecord);
      // b. Let starNames be requestedModule.GetExportedNames(exportStarSet).
      const starNames = requestedModule.GetExportedNames(exportStarSet);
      // c. For each element n of starNames, do
      for (const n of starNames) {
        // i. If SameValue(n, "default") is false, then
        if (!SameValue(n, Value('default'))) {
          // 1. If n is not an element of exportedNames, then
          if (!exportedNames.includes(n)) {
            // a. Append n to exportedNames.
            exportedNames.push(n);
          }
        }
      }
    }
    // 9. Return exportedNames.
    return exportedNames;
  }

  /** https://tc39.es/ecma262/#sec-resolveexport */
  ResolveExport(exportName: JSStringValue, resolveSet?: ResolveSetItem[]) {
    const module = this;
    // 1. Assert: module.[[Status]] is not new.
    Assert(module.Status !== 'new');
    // 2. If resolveSet is not present, set resolveSet to a new empty List.
    if (!resolveSet) {
      resolveSet = [];
    }
    // 3. For each Record { [[Module]], [[ExportName]] } r in resolveSet, do
    for (const r of resolveSet) {
      // a. If module and r.[[Module]] are the same Module Record and SameValue(exportName, r.[[ExportName]]) is true, then
      if (module === r.Module && SameValue(exportName, r.ExportName)) {
        // i. Assert: This is a circular import request.
        // ii. Return null.
        return null;
      }
    }
    // 4. Append the Record { [[Module]]: module, [[ExportName]]: exportName } to resolveSet.
    resolveSet.push({ Module: module, ExportName: exportName });
    // 5. For each ExportEntry Record e in module.[[LocalExportEntries]], do
    for (const e of module.LocalExportEntries) {
      // a. If SameValue(exportName, e.[[ExportName]]) is true, then
      if (SameValue(exportName, e.ExportName)) {
        // i. Assert: module provides the direct binding for this export.
        // ii. Return ResolvedBinding Record { [[Module]]: module, [[BindingName]]: e.[[LocalName]] }.
        return new ResolvedBindingRecord({
          Module: module,
          BindingName: e.LocalName as JSStringValue,
        });
      }
    }
    // 6. Let allIndirectEntries be the list-concatenation of module.[[IndirectExportEntries]] and module.[[OptionalIndirectExportEntries]].
    const allIndirectEntries = [...module.IndirectExportEntries, ...module.OptionalIndirectExportEntries];
    // 7. For each ExportEntry Record e in allIndirectEntries, do
    //    https://tc39.es/proposal-deferred-reexports/#sec-resolveexport
    for (const e of allIndirectEntries) {
      // a. If SameValue(exportName, e.[[ExportName]]) is true, then
      if (SameValue(exportName, e.ExportName)) {
        // i. Let importedModule be GetImportedModule(module, e.[[ModuleRequest]]).
        const importedModule = GetImportedModule(module, e.ModuleRequest as ModuleRequestRecord);
        // ii. If e.[[ImportName]] is ~namespace~, then
        if (e.ImportName === 'namespace') {
          // 1. Assert: module does not provide the direct binding for this export
          if ((e.ModuleRequest as ModuleRequestRecord).Phase === 'defer') {
            // https://tc39.es/proposal-defer-import-eval/#sec-resolveexport
            return new ResolvedBindingRecord({
              Module: importedModule,
              BindingName: 'deferred-namespace',
            });
          } else {
            Assert((e.ModuleRequest as ModuleRequestRecord).Phase === 'evaluation');
            // 2. Return ResolvedBinding Record { [[Module]]: importedModule, [[BindingName]]: ~namespace~ }.
            return new ResolvedBindingRecord({
              Module: importedModule,
              BindingName: 'namespace',
            });
          }
        } else if (e.ImportName === 'source') {
          // Assert: _module_ does not provide the direct binding for this export.
          return new ResolvedBindingRecord({
            Module: importedModule,
            BindingName: 'source',
          });
        } else { // iv. Else,
          // 1. Assert: module imports a specific binding for this export.
          Assert(e.ImportName instanceof JSStringValue);
          // 2. Return importedModule.ResolveExport(e.[[ImportName]], resolveSet).
          return importedModule.ResolveExport(e.ImportName, resolveSet);
        }
      }
    }
    // 7. If SameValue(exportName, "default") is true, then
    if (SameValue(exportName, Value('default'))) {
      // a. Assert: A default export was not explicitly defined by this module.
      // b. Return null.
      return null;
      // c. NOTE: A default export cannot be provided by an export * or export * from "mod" declaration.
    }
    // 8. Let starResolution be null.
    let starResolution = null;
    // 9. For each ExportEntry Record e in module.[[StarExportEntries]], do
    for (const e of module.StarExportEntries) {
      // a. Let importedModule be GetImportedModule(module, e.[[ModuleRequest]]).
      const importedModule = GetImportedModule(module, e.ModuleRequest as ModuleRequestRecord);
      // b. Let resolution be importedModule.ResolveExport(exportName, resolveSet).
      const resolution = importedModule.ResolveExport(exportName, resolveSet);
      // c. If resolution is "ambiguous", return "ambiguous".
      if (resolution === 'ambiguous') {
        return 'ambiguous';
      }
      // d. If resolution is not null, then
      if (resolution !== null) {
        // a. Assert: resolution is a ResolvedBinding Record.
        Assert(resolution instanceof ResolvedBindingRecord);
        // b. If starResolution is null, set starResolution to resolution.
        if (starResolution === null) {
          starResolution = resolution;
        } else { // c. Else,
          // 1. Assert: There is more than one * export that includes the requested name.
          // 2. If _resolution_.[[Module]] and _starResolution_.[[Module]] are not the same Module Record, return ~ambiguous~.
          if (resolution.Module !== starResolution.Module) {
            return 'ambiguous';
          }
          // 3. If _resolution_.[[BindingName]] is not _starResolution_.[[BindingName]], return ~ambiguous~.
          const l = resolution.BindingName;
          const r = starResolution.BindingName;
          if (l === r) {
            // pass
          } else if (l instanceof JSStringValue && !(r instanceof JSStringValue)) {
            return 'ambiguous';
          } else if (!(l instanceof JSStringValue) && r instanceof JSStringValue) {
            return 'ambiguous';
          } else if (l instanceof JSStringValue && r instanceof JSStringValue) {
            if (l.value !== r.value) return 'ambiguous';
          } else if (l !== r) {
            return 'ambiguous';
          } else throw OutOfRange.nonExhaustive(l);
        }
      }
    }
    // 11. Return starResolution.
    return starResolution;
  }

  /** https://tc39.es/proposal-deferred-reexports/#sec-GetOptionalIndirectExportsModuleRequests */
  override GetOptionalIndirectExportsModuleRequests(importedNames: ImportedNamesValue): readonly ModuleRequestRecord[] {
    // 1. Let requests be a new empty List.
    const requests: ModuleRequestRecord[] = [];
    // 2. For each ExportEntry Record oie of module.[[OptionalIndirectExportEntries]], do
    for (const oie of this.OptionalIndirectExportEntries) {
      const exportName = oie.ExportName;
      // a. If importedNames is all or importedNames contains oie.[[ExportName]], then
      let included: boolean;
      if (importedNames === 'all') {
        included = true;
      } else if (importedNames === 'all-but-default') {
        included = exportName instanceof JSStringValue && exportName.stringValue() !== 'default';
      } else if (exportName instanceof JSStringValue) {
        included = (importedNames as readonly JSStringValue[]).some((n) => n.stringValue() === exportName.stringValue());
      } else {
        included = false;
      }
      if (!included) {
        continue;
      }
      // i. Let nextRequest be oie.[[ModuleRequest]].
      const nextRequest = oie.ModuleRequest as ModuleRequestRecord;
      // ii. Let existingRequest be empty.
      let existingRequest: ModuleRequestRecord | undefined;
      // iii. For each ModuleRequest Record r in requests, do
      for (const r of requests) {
        // 1. If existingRequest is empty and ModuleRequestsKeyEqual(r, nextRequest) is true and r.[[Phase]] is nextRequest.[[Phase]], then
        if (existingRequest === undefined && ModuleRequestsKeyEqual(r, nextRequest) && r.Phase === nextRequest.Phase) {
          // a. Set existingRequest to r.
          existingRequest = r;
        }
      }
      // iv. Let newImportedNames be all.
      let newImportedNames: ImportedNamesValue = 'all';
      // v. Assert: oie.[[ImportName]] is a String or namespace.
      // (this is deviating from spec because spec looks wrong)
      Assert(oie.ImportName instanceof JSStringValue || oie.ImportName === 'namespace');
      // vi. If oie.[[ImportName]] is a String, set newImportedNames to « oie.[[ImportName]] ».
      if (oie.ImportName instanceof JSStringValue) {
        newImportedNames = [oie.ImportName];
      }
      // vii. If existingRequest is empty, then
      if (existingRequest === undefined) {
        // 1. Let request be the ModuleRequest Record { [[Specifier]]: nextRequest.[[Specifier]], [[Attributes]]: nextRequest.[[Attributes]], [[Phase]]: nextRequest.[[Phase]], [[ImportedNames]]: newImportedNames }.
        const request: ModuleRequestRecord = {
          Specifier: nextRequest.Specifier,
          Attributes: nextRequest.Attributes,
          Phase: nextRequest.Phase,
          ImportedNames: newImportedNames,
        };
        // 2. Append request to requests.
        requests.push(request);
      } else { // viii. Else,
        // 1. Set existingRequest.[[ImportedNames]] to MergeImportedNames(existingRequest.[[ImportedNames]], newImportedNames).
        (existingRequest as Mutable<ModuleRequestRecord>).ImportedNames = MergeImportedNames(existingRequest.ImportedNames, newImportedNames);
      }
    }
    // 3. Return requests.
    return requests;
  }

  /** https://tc39.es/ecma262/#sec-source-text-module-record-initialize-environment */
  InitializeEnvironment() {
    const module = this as Mutable<SourceTextModuleRecord>;
    // 1. For each ExportEntry Record e in module.[[IndirectExportEntries]], do
    for (const e of module.IndirectExportEntries) {
      // a. Let resolution be module.ResolveExport(e.[[ExportName]]).
      const resolution = module.ResolveExport(e.ExportName as JSStringValue);
      // b. If resolution is null or "ambiguous", throw a SyntaxError exception.
      if (resolution === null || resolution === 'ambiguous') {
        const moduleName = module.HostDefined?.specifier || '<anonymous module>';
        if (resolution === null) {
          return Throw.SyntaxError('Module "$1" does not have an export named $2', moduleName, e.ExportName);
        }
        return Throw.SyntaxError('Export $1 from module "$2" is ambiguous', e.ExportName, moduleName);
      }
      // c. Assert: resolution is a ResolvedBinding Record.
      Assert(resolution instanceof ResolvedBindingRecord);
    }
    // 2. Assert: All named exports from module are resolvable.
    // 3. Let realm be module.[[Realm]].
    const realm = module.Realm;
    // 4. Assert: realm is not undefined.
    Assert(!(realm instanceof UndefinedValue));
    // 5. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
    const env = new ModuleEnvironmentRecord(realm.GlobalEnv);
    // 6. Set module.[[Environment]] to env.
    module.Environment = env;
    // 7. For each ImportEntry Record in in module.[[ImportEntries]], do
    for (const ie of module.ImportEntries) {
      // a. Let importedModule be GetImportedModule(module, in.[[ModuleRequest]]).
      const importedModule = GetImportedModule(module, ie.ModuleRequest);
      if (ie.ImportName === 'namespace') {
        // i. Let namespace be GetModuleNamespace(importedModule).
        Assert(ie.ModuleRequest.Phase !== 'source');
        const namespacePhase = ie.ModuleRequest.Phase === 'defer' ? 'defer' : 'evaluation';
        const namespace = GetModuleNamespace(importedModule, namespacePhase);
        // ii. Perform ! env.CreateImmutableBinding(in.[[LocalName]], true).
        X(env.CreateImmutableBinding(ie.LocalName, Value.true));
        // iii. Call env.InitializeBinding(in.[[LocalName]], namespace).
        X(env.InitializeBinding(ie.LocalName, namespace));
      } else if (ie.ImportName === 'source') {
        const moduleSourceObject = importedModule.ModuleSource;
        if (moduleSourceObject === undefined) {
          return Throw.SyntaxError('Module source is not available');
        }
        X(env.CreateImmutableBinding(ie.LocalName, Value.true));
        X(env.InitializeBinding(ie.LocalName, moduleSourceObject));
      } else { // c. Else,
        // i. Let resolution be importedModule.ResolveExport(in.[[ImportName]]).
        const resolution = importedModule.ResolveExport(ie.ImportName);
        // ii. If resolution is null or "ambiguous", throw a SyntaxError exception.
        if (resolution === null || resolution === 'ambiguous') {
          const moduleName = importedModule.HostDefined?.specifier || '<anonymous module>';
          if (resolution === null) {
            return Throw.SyntaxError('Module "$1" does not have an export named $2', moduleName, ie.ImportName);
          }
          return Throw.SyntaxError('Export $1 from module "$2" is ambiguous', ie.ImportName, moduleName);
        }
        // iii. If resolution.[[BindingName]] is ~namespace~, then
        if (resolution.BindingName === 'namespace' || resolution.BindingName === 'deferred-namespace') {
          // https://tc39.es/proposal-defer-import-eval/#sec-source-text-module-record-initialize-environment
          const phase = resolution.BindingName === 'namespace' ? 'evaluation' : 'defer';
          // 1. Let namespace be GetModuleNamespace(resolution.[[Module]]).
          const namespace = GetModuleNamespace(resolution.Module, phase);
          // 2. Perform ! env.CreateImmutableBinding(in.[[LocalName]], true).
          X(env.CreateImmutableBinding(ie.LocalName, Value.true));
          // 3. Call env.InitializeBinding(in.[[LocalName]], namespace).
          X(env.InitializeBinding(ie.LocalName, namespace));
        } else if (resolution.BindingName === 'source') {
          const moduleSourceObject = resolution.Module.ModuleSource;
          if (moduleSourceObject === undefined) {
            return Throw.SyntaxError('Module source is not available');
          }
          X(env.CreateImmutableBinding(ie.LocalName, Value.true));
          X(env.InitializeBinding(ie.LocalName, moduleSourceObject));
        } else { // iv. Else,
          // 1. Call env.CreateImportBinding(in.[[LocalName]], resolution.[[Module]], resolution.[[BindingName]]).
          X(env.CreateImportBinding(ie.LocalName, resolution.Module, resolution.BindingName));
        }
      }
    }
    // 8. Let moduleContext be a new ECMAScript code execution context.
    const moduleContext = new ExecutionContext();
    // 9. Set the Function of moduleContext to null.
    moduleContext.Function = Value.null;
    // 10. Assert: module.[[Realm]] is not undefined.
    Assert(!(module.Realm instanceof UndefinedValue));
    // 11. Set the Realm of moduleContext to module.[[Realm]].
    moduleContext.Realm = module.Realm;
    // 12. Set the ScriptOrModule of moduleContext to module.
    moduleContext.ScriptOrModule = module;
    // 13. Set the VariableEnvironment of moduleContext to module.[[Environment]].
    moduleContext.VariableEnvironment = module.Environment!;
    // 14. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
    moduleContext.LexicalEnvironment = module.Environment!;
    // 15. Set the PrivateEnvironment of moduleContext to null.
    moduleContext.PrivateEnvironment = Value.null;
    // 16. Set module.[[Context]] to moduleContext.
    module.Context = moduleContext;
    // 17. Push moduleContext onto the execution context stack; moduleContext is now the running execution context.
    surroundingAgent.executionContextStack.push(moduleContext);
    // 18. Let code be module.[[ECMAScriptCode]].
    const code = module.ECMAScriptCode;
    // 19. Let varDeclarations be the VarScopedDeclarations of code.
    const varDeclarations = VarScopedDeclarations(code);
    // 20. Let declaredVarNames be a new empty List.
    const declaredVarNames = new JSStringSet();
    // 21. For each element d in varDeclarations, do
    for (const d of varDeclarations) {
      // a. For each element dn of the BoundNames of d, do
      for (const dn of BoundNames(d)) {
        // i. If dn is not an element of declaredVarNames, then
        if (!declaredVarNames.has(dn)) {
          // 1. Perform ! env.CreateMutableBinding(dn, false).
          X(env.CreateMutableBinding(dn, Value.false));
          // 2. Call env.InitializeBinding(dn, undefined).
          X(env.InitializeBinding(dn, Value.undefined));
          // 3. Append dn to declaredVarNames.
          declaredVarNames.add(dn);
        }
      }
    }
    // 22. Let lexDeclarations be the LexicallyScopedDeclarations of code.
    const lexDeclarations = LexicallyScopedDeclarations(code);
    // 24. For each element d in lexDeclarations, do
    for (const d of lexDeclarations) {
      // a. For each element dn of the BoundNames of d, do
      for (const dn of BoundNames(d)) {
        // i. If IsConstantDeclaration of d is true, then
        if (IsConstantDeclaration(d)) {
          // 1. Perform ! env.CreateImmutableBinding(dn, true).
          X(env.CreateImmutableBinding(dn, Value.true));
        } else { // ii. Else,
          // 1. Perform ! env.CreateMutableBinding(dn, false).
          X(env.CreateMutableBinding(dn, Value.false));
        }
        // iii. If d is a FunctionDeclaration, a GeneratorDeclaration, an AsyncFunctionDeclaration, or an AsyncGeneratorDeclaration, then
        if (d.type === 'FunctionDeclaration'
          || d.type === 'GeneratorDeclaration'
          || d.type === 'AsyncFunctionDeclaration'
          || d.type === 'AsyncGeneratorDeclaration') {
          // 1. Let fo be InstantiateFunctionObject of d with argument env.
          const fo = InstantiateFunctionObject(d, env, Value.null);
          // 2. Call env.InitializeBinding(dn, fo).
          X(env.InitializeBinding(dn, fo));
        }
      }
    }
    // 25. Remove moduleContext from the execution context stack.
    surroundingAgent.executionContextStack.pop(moduleContext);
    // 26. Return unused.
    return NormalCompletion(undefined);
  }

  /** https://tc39.es/ecma262/#sec-source-text-module-record-execute-module */
  * ExecuteModule(capability?: PromiseCapabilityRecord): ValueEvaluator {
    // 1. Let module be this Source Text Module Record.
    const module = this;
    // 2. Assert: module has been linked and declarations in its module environment have been instantiated.
    // 3. Let moduleContext be module.[[Context]].
    const moduleContext = module.Context!;
    if (module.HasTLA === Value.false) {
      Assert(capability === undefined);
      // 4. Push moduleContext onto the execution context stack; moduleContext is now the running execution context.
      surroundingAgent.executionContextStack.push(moduleContext);
      // 5. Let result be the result of evaluating module.[[ECMAScriptCode]].
      const result = EnsureCompletion(yield* (Evaluate(module.ECMAScriptCode)));
      // 6. Suspend moduleContext and remove it from the execution context stack.
      // 7. Resume the context that is now on the top of the execution context stack as the running execution context.
      surroundingAgent.executionContextStack.pop(moduleContext);
      // 8. Return Completion(result).
      return Q(result);
    } else { // (*TopLevelAwait)
      // a. Assert: capability is a PromiseCapability Record.
      Assert(capability instanceof PromiseCapabilityRecord);
      // b. Perform ! AsyncBlockStart(capability, module.[[ECMAScriptCode]], moduleCxt).
      X(yield* AsyncBlockStart(capability, module.ECMAScriptCode, moduleContext));
      // c. Return.
      return Value.undefined;
    }
  }

  override mark(m: GCMarker) {
    super.mark(m);
    m(this.ImportMeta);
    m(this.Context);
  }
}

export type SyntheticModuleRecordInit = AbstractModuleInit & Pick<SyntheticModuleRecord, 'ExportNames' | 'EvaluationSteps'>;
/** https://tc39.es/ecma262/#sec-synthetic-module-records */
export class SyntheticModuleRecord extends AbstractModuleRecord {
  override LoadRequestedModules(): PromiseObject {
    const promise = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
    X(Call(promise.Resolve, Value.undefined, [Value.undefined]));
    return promise.Promise;
  }

  readonly ExportNames: readonly JSStringValue[];

  readonly EvaluationSteps: (module: SyntheticModuleRecord) => PlainEvaluator | Completion<unknown> | void;

  constructor(init: SyntheticModuleRecordInit) {
    super(init);

    this.ExportNames = init.ExportNames;
    this.EvaluationSteps = init.EvaluationSteps;
  }

  /** https://tc39.es/ecma262/#sec-synthetic-module-record-getexportednames */
  GetExportedNames() {
    const module = this;
    // 1. Return module.[[ExportNames]].
    return module.ExportNames;
  }

  /** https://tc39.es/ecma262/#sec-synthetic-module-record-resolveexport */
  ResolveExport(exportName: JSStringValue): ResolvedBindingRecord | null {
    const module = this;
    // 1. If module.[[ExportNames]] does not contain exportName, return null.
    // 2. Return ResolvedBinding Record { [[Module]]: module, [[BindingName]]: exportName }.
    for (const e of module.ExportNames) {
      if (SameValue(e, exportName)) {
        return new ResolvedBindingRecord({ Module: module, BindingName: exportName });
      }
    }
    return null;
  }

  /** https://tc39.es/ecma262/#sec-synthetic-module-record-link */
  Link() {
    const module = this;
    // 1. Let realm be module.[[Realm]].
    const realm = module.Realm;
    // 2. Assert: realm is not undefined.
    Assert(!(realm instanceof UndefinedValue));
    // 3. Let env be NewModuleEnvironment(realm.[[GlobalEnv]]).
    const env = new ModuleEnvironmentRecord(realm.GlobalEnv);
    // 4. Set module.[[Environment]] to env.
    (module as Mutable<AbstractModuleRecord>).Environment = env;
    // 5. For each exportName in module.[[ExportNames]],
    for (const exportName of module.ExportNames) {
      // a. Perform ! env.CreateMutableBinding(exportName, false).
      X(env.CreateMutableBinding(exportName, Value.false));
      // b. Perform ! env.InitializeBinding(exportName, undefined).
      X(env.InitializeBinding(exportName, Value.undefined));
    }
    // 8. Return undefined.
    return undefined;
  }

  /** https://tc39.es/ecma262/#sec-synthetic-module-record-evaluate */
  * Evaluate(): Evaluator<PromiseObject> {
    const module = this;
    // 1. Suspend the currently running execution context.
    // 2. Let moduleContext be a new ECMAScript code execution context.
    const moduleContext = new ExecutionContext();
    // 3. Set the Function of moduleContext to null.
    moduleContext.Function = Value.null;
    // 4. Set the Realm of moduleContext to module.[[Realm]].
    moduleContext.Realm = module.Realm;
    // 5. Set the ScriptOrModule of moduleContext to module.
    moduleContext.ScriptOrModule = module;
    // 6. Set the VariableEnvironment of moduleContext to module.[[Environment]].
    moduleContext.VariableEnvironment = module.Environment!;
    // 7. Set the LexicalEnvironment of moduleContext to module.[[Environment]].
    moduleContext.LexicalEnvironment = module.Environment!;
    moduleContext.PrivateEnvironment = Value.null;
    // 8. Push moduleContext on to the execution context stack; moduleContext is now the running execution context.
    surroundingAgent.executionContextStack.push(moduleContext);
    // 9. Let steps be module.[[EvaluationSteps]].
    const steps = module.EvaluationSteps;
    // 10. Let result be Completion(steps(module)).
    let result = steps(module);
    if (isEvaluator(result)) {
      result = yield* result;
    }
    // 11. Suspend moduleContext and remove it from the execution context stack.
    // 12. Resume the context that is now on the top of the execution context stack as the running execution context.
    surroundingAgent.executionContextStack.pop(moduleContext);
    // 13. Let pc be ! NewPromiseCapability(%Promise%).
    const pc = X(NewPromiseCapability(surroundingAgent.intrinsic('%Promise%')));
    // 14. IfAbruptRejectPromise(result, pc).
    IfAbruptRejectPromise(result, pc);
    // 15. Perform ! Call(pc.[[Resolve]], undefined, « undefined »).
    X(Call(pc.Resolve, Value.undefined, [Value.undefined]));
    // 16. Return pc.[[Promise]].
    return pc.Promise;
  }

  * SetSyntheticExport(name: JSStringValue, value: Value): PlainEvaluator {
    const module = this;
    // 1. Return module.[[Environment]].SetMutableBinding(name, value, true).
    return yield* module.Environment!.SetMutableBinding(name, value, Value.true);
  }
}