/src/moddable/xs/sources/xsModule.c

Source
/*
 * Copyright (c) 2016-2025  Moddable Tech, Inc.
 *
 *   This file is part of the Moddable SDK Runtime.
 * 
 *   The Moddable SDK Runtime is free software: you can redistribute it and/or modify
 *   it under the terms of the GNU Lesser General Public License as published by
 *   the Free Software Foundation, either version 3 of the License, or
 *   (at your option) any later version.
 * 
 *   The Moddable SDK Runtime is distributed in the hope that it will be useful,
 *   but WITHOUT ANY WARRANTY; without even the implied warranty of
 *   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *   GNU Lesser General Public License for more details.
 * 
 *   You should have received a copy of the GNU Lesser General Public License
 *   along with the Moddable SDK Runtime.  If not, see <http://www.gnu.org/licenses/>.
 *
 * This file incorporates work covered by the following copyright and  
 * permission notice:  
 *
 *       Copyright (C) 2010-2016 Marvell International Ltd.
 *       Copyright (C) 2002-2010 Kinoma, Inc.
 *
 *       Licensed under the Apache License, Version 2.0 (the "License");
 *       you may not use this file except in compliance with the License.
 *       You may obtain a copy of the License at
 *
 *        http://www.apache.org/licenses/LICENSE-2.0
 *
 *       Unless required by applicable law or agreed to in writing, software
 *       distributed under the License is distributed on an "AS IS" BASIS,
 *       WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 *       See the License for the specific language governing permissions and
 *       limitations under the License.
 */

#include "xsAll.h"

#ifndef mxReport
#define mxReport 0
#endif

static void fxCheckModuleFlag(txMachine* the, txID moduleID, txFlag moduleFlag, txFlag requestFlag);
static txFlag fxCheckModuleOptions(txMachine* the, txSlot* options);
static void fxPushModuleOptions(txMachine* the, txFlag moduleFlag);
static void fxCompleteModule(txMachine* the, txSlot* module, txSlot* exception);
static void fxDuplicateModuleTransfers(txMachine* the, txSlot* srcModule, txSlot* dstModule);

static void fxExecuteModules(txMachine* the, txSlot* queue);
static txID fxExecuteModulesFrom(txMachine* the, txSlot* queue, txSlot* module, txSlot** exception);

static txSlot* fxGetModule(txMachine* the, txSlot* realm, txID moduleID, txFlag moduleFlag);

static void fxLinkCircularities(txMachine* the, txSlot* module, txSlot* circularities, txSlot* exports);
static void fxLinkExports(txMachine* the, txSlot* module);
static void fxLinkLocals(txMachine* the, txSlot* module);
static void fxLinkModules(txMachine* the, txSlot* queue);
static void fxLinkNamespace(txMachine* the, txSlot* module, txSlot* transfer);
static void fxLinkTransfer(txMachine* the, txSlot* module, txID importID, txSlot* transfer);

static void fxLoadModules(txMachine* the, txSlot* queue);
static void fxLoadModulesFrom(txMachine* the, txSlot* queue, txSlot* module, txBoolean now);

static txBoolean fxMapModule(txMachine* the, txSlot* realm, txID moduleID, txSlot* module, txSlot* queue, txSlot* result);
static void fxMapModuleDescriptor(txMachine* the, txSlot* realm, txID moduleID, txSlot* module, txSlot* queue, txSlot* result, txSlot* descriptor);
static void fxNewModule(txMachine* the, txSlot* realm, txID moduleID, txFlag moduleFlag, txSlot* module);
static void fxOrderModule(txMachine* the, txSlot* queue, txSlot* order, txSlot* module);
static void fxOverrideModule(txMachine* the, txSlot* queue, txSlot* list, txSlot* result, txSlot* module, txSlot* record);
static txBoolean fxQueueModule(txMachine* the, txSlot* queue, txSlot* module);

static txID fxResolveSpecifier(txMachine* the, txSlot* realm, txID moduleID, txSlot* name);

static txSlot* fxRunImportAux(txMachine* the, txSlot* realm, txSlot* referrer, txSlot* specifier, txSlot* options, txBoolean now);
static void fxRunImportFulfilled(txMachine* the, txSlot* module, txSlot* with);
static void fxRunImportRejected(txMachine* the, txSlot* module, txSlot* with);

static void fxRunImportNow(txMachine* the, txSlot* realm, txSlot* referrer);

static txBoolean fxModuleDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask);
static txBoolean fxModuleDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
static txSlot* fxModuleFindProperty(txMachine* the, txSlot* instance, txID id, txIndex index);
static txBoolean fxModuleGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot);
static txSlot* fxModuleGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);
static txBoolean fxModuleGetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* receiver, txSlot* value);
static txBoolean fxModuleGetPrototype(txMachine* the, txSlot* instance, txSlot* result);
static txBoolean fxModuleHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index); 
static txBoolean fxModuleIsExtensible(txMachine* the, txSlot* instance);
static void fxModuleOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys);
static int fxModuleOwnKeysCompare(const void* p, const void* q);
static txBoolean fxModulePreventExtensions(txMachine* the, txSlot* instance);
static txSlot* fxModuleSetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag);
static txBoolean fxModuleSetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* value, txSlot* receiver);
static txBoolean fxModuleSetPrototype(txMachine* the, txSlot* instance, txSlot* prototype);

static txSlot* fxCheckCompartmentInstance(txMachine* the, txSlot* slot);
static void fxPrepareCompartmentFunction(txMachine* the, txSlot* program, txSlot* instance);

static txSlot* fxCheckModuleSourceInstance(txMachine* the, txSlot* slot);
static txSlot* fxNewModuleSourceInstance(txMachine* the);

#if mxModuleStuff
static txSlot* fxCheckModuleStuffInstance(txMachine* the, txSlot* slot);
static txSlot* fxImportModuleStuff(txMachine* the, txSlot* realm, txSlot* queue, txSlot* reference, txSlot* name, txBoolean now);
static txBoolean fxLoadModuleStuffFrom(txMachine* the, txSlot* queue, txSlot* module, txBoolean now);
static void fxLoadModuleStuff(txMachine* the, txSlot* queue, txSlot* module, txSlot* stuff);
static void fxLoadModuleStuffFulfilled(txMachine* the);
static void fxLoadModuleStuffRejected(txMachine* the);
#endif

const txBehavior ICACHE_FLASH_ATTR gxModuleBehavior = {
  fxModuleGetProperty,
  fxModuleSetProperty,
  fxOrdinaryCall,
  fxOrdinaryConstruct,
  fxModuleDefineOwnProperty,
  fxModuleDeleteProperty,
  fxModuleGetOwnProperty,
  fxModuleGetPropertyValue,
  fxModuleGetPrototype,
  fxModuleHasProperty,
  fxModuleIsExtensible,
  fxModuleOwnKeys,
  fxModulePreventExtensions,
  fxModuleSetPropertyValue,
  fxModuleSetPrototype,
};

enum {
  XS_MODULE_STATUS_NEW = 0,
  XS_MODULE_STATUS_LOADING,
  XS_MODULE_STATUS_LOADED,
  XS_MODULE_STATUS_LINKING,
  XS_MODULE_STATUS_LINKED,
  XS_MODULE_STATUS_EXECUTING,
  XS_MODULE_STATUS_EXECUTED,
  XS_MODULE_STATUS_ERROR,
};


#define mxIsModule(THE_SLOT) \
  (((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_MODULE_KIND))
#define mxIsModuleSource(THE_SLOT) \
  (((THE_SLOT)->next) && ((THE_SLOT)->next->flag & XS_INTERNAL_FLAG) && ((THE_SLOT)->next->kind == XS_MODULE_SOURCE_KIND))

#define mxModuleInstanceStatus(MODULE)    ((MODULE)->next->next->ID)
#define mxModuleStatus(MODULE)        mxModuleInstanceStatus((MODULE)->value.reference)

#if mxReport
#define mxModuleName(ID) c_strrchr(fxGetKeyName(the, (ID)), '/')
#define mxReportModuleQueue(LABEL) fxReportModuleQueue(the, queue, LABEL)
static void fxReportModuleQueue(txMachine* the, txSlot* queue, txString label)
{
  static txString STATUS[8] = {
  "NEW",
  "LOADING",
  "LOADED",
  "LINKING",
  "LINKED",
  "EXECUTING",
  "EXECUTED",
  "ERROR",
  };
  txSlot* module = queue->next;
  fprintf(stderr, "%s %p\n", label, queue);
  while (module) {
    txString name = (module->ID != XS_NO_ID) ? fxGetKeyName(the, module->ID) : "?";
    fprintf(stderr, "\t'%s' %p %s\n", name, module->value.reference, STATUS[mxModuleStatus(module)]);
    module = module->next;
  }
}
#else
#define mxReportModuleQueue(LABEL)
#endif  

void fxBuildModule(txMachine* the)
{
  txSlot* slot;
  
  fxNewHostFunction(the, mxCallback(fxModuleGetter), 0, XS_NO_ID, XS_NO_ID);
  mxPushUndefined();
  the->stack->flag = XS_DONT_DELETE_FLAG;
  the->stack->kind = XS_ACCESSOR_KIND;
  the->stack->value.accessor.getter = (the->stack + 1)->value.reference;
  the->stack->value.accessor.setter = C_NULL;
  mxPull(mxModuleAccessor);
  the->stack += 1;
  
  mxPush(mxObjectPrototype);
  slot = fxLastProperty(the, fxNewObjectInstance(the));
  slot = fxNextStringXProperty(the, slot, "Module", mxID(_Symbol_toStringTag), XS_GET_ONLY);
  mxModulePrototype = *the->stack;
  mxPop();
  
  mxPush(mxObjectPrototype);
  fxNewObjectInstance(the);
  mxTransferPrototype = *the->stack;
  mxPop();

  mxPush(mxObjectPrototype);
  slot = fxLastProperty(the, fxNewObjectInstance(the));
  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_Compartment_prototype_get_globalThis), C_NULL, mxID(_globalThis), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Compartment_prototype_evaluate), 1, mxID(_evaluate), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Compartment_prototype_import), 1, mxID(_import), XS_DONT_ENUM_FLAG);
  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Compartment_prototype_importNow), 1, mxID(_importNow), XS_DONT_ENUM_FLAG);
//  slot = fxNextHostFunctionProperty(the, slot, mxCallback(fx_Compartment_prototype_module), 1, mxID(_module), XS_DONT_ENUM_FLAG);
  slot = fxNextStringXProperty(the, slot, "Compartment", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
  mxCompartmentPrototype = *the->stack;
  slot = fxBuildHostConstructor(the, mxCallback(fx_Compartment), 1, mxID(_Compartment));
  mxCompartmentConstructor = *the->stack;
  mxPop();
  
  mxPush(mxObjectPrototype);
  slot = fxLastProperty(the, fxNewObjectInstance(the));
  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_ModuleSource_prototype_get_bindings), C_NULL, mxID(_bindings), XS_DONT_ENUM_FLAG);
  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_ModuleSource_prototype_get_needsImport), C_NULL, mxID(_needsImport), XS_DONT_ENUM_FLAG);
  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_ModuleSource_prototype_get_needsImportMeta), C_NULL, mxID(_needsImportMeta), XS_DONT_ENUM_FLAG);
#if mxECMAScript2025  
  slot = fxNextHostAccessorProperty(the, slot, mxCallback(fx_ModuleSource_prototype_get_options), C_NULL, mxID(_options), XS_DONT_ENUM_FLAG);
#endif
  slot = fxNextStringXProperty(the, slot, "ModuleSource", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
  mxModuleSourcePrototype = *the->stack;
  slot = fxBuildHostConstructor(the, mxCallback(fx_ModuleSource), 1, mxID(_ModuleSource));
  mxModuleSourceConstructor = *the->stack;
  mxPop();
  
#if mxModuleStuff 
  mxPush(mxObjectPrototype);
  slot = fxLastProperty(the, fxNewObjectInstance(the));
  slot = fxNextStringXProperty(the, slot, "ModuleStuff", mxID(_Symbol_toStringTag), XS_DONT_ENUM_FLAG | XS_DONT_SET_FLAG);
  mxModuleStuffPrototype = *the->stack;
  slot = fxBuildHostConstructor(the, mxCallback(fx_ModuleStuff), 1, mxID(_ModuleStuff));
  mxModuleStuffConstructor = *the->stack;
  mxPop();
#endif
}

void fxCheckModuleFlag(txMachine* the, txID moduleID, txFlag moduleFlag, txFlag requestFlag)
{
#ifndef mxLink
  if (moduleFlag & XS_JSON_MODULE_FLAG) {
    if (!(requestFlag & XS_JSON_MODULE_FLAG)) {
      fxIDToString(the, moduleID, the->nameBuffer, sizeof(the->nameBuffer));
      fxThrowMessage(the, C_NULL, 0, XS_TYPE_ERROR, "%s: JSON module", the->nameBuffer);
    }
  }
  else {
    if (requestFlag & XS_JSON_MODULE_FLAG) {
      fxIDToString(the, moduleID, the->nameBuffer, sizeof(the->nameBuffer));
      fxThrowMessage(the, C_NULL, 0, XS_TYPE_ERROR, "%s: not a JSON module", the->nameBuffer);
    }
  }
#endif
}

void fxPushModuleOptions(txMachine* the, txFlag moduleFlag)
{
#if mxECMAScript2025  
  if (moduleFlag & XS_JSON_MODULE_FLAG) {
    txSlot* optionsInstance = fxNewObject(the);
    txSlot* withInstance = fxNewObject(the);
    fxNextSlotProperty(the, optionsInstance, the->stack, mxID(_with), XS_NO_FLAG);
    mxPop();
    fxNextStringProperty(the, withInstance, "json", mxID(_type), XS_NO_FLAG);
  }
  else
#endif
    mxPushUndefined();
}

txFlag fxCheckModuleOptions(txMachine* the, txSlot* options)
{
  txFlag moduleFlag = XS_NO_FLAG;
#if mxECMAScript2025  
  if (!mxIsUndefined(options)) {
    txSlot* with;
    if (!mxIsReference(options))
      mxTypeError("options: not an object");
    mxPushSlot(options);
    mxGetID(mxID(_with));
    with = the->stack;
    if (!mxIsUndefined(with)) {
      txSlot* key;
      txSlot* property;
      txSlot* value;
      txInteger count = 0;
      if (!mxIsReference(with))
        mxTypeError("options.with: not an object");
      key = fxNewInstance(the);
      mxBehaviorOwnKeys(the, with->value.reference, XS_EACH_NAME_FLAG, key);
      mxTemporary(property);
      while ((key = key->next)) {
        if (mxBehaviorGetOwnProperty(the, with->value.reference, key->value.at.id, key->value.at.index, property) && !(property->flag & XS_DONT_ENUM_FLAG)) {
          mxPushSlot(with);
          mxGetAll(key->value.at.id, key->value.at.index);
          value = the->stack;
          count++;
          if ((value->kind != XS_STRING_KIND) && (value->kind != XS_STRING_X_KIND)) {
            mxPop();
            break;
          }
          if ((key->value.at.id == mxID(_type)) && (!c_strcmp(value->value.string, "json"))) {
            count--;
            moduleFlag |= XS_JSON_MODULE_FLAG;
          }
          mxPop();
        }
      }
      mxPop();
      mxPop();
      if (count > 0)
        mxTypeError("options.with: invalid attributes");
    }
    mxPop();
  }
#endif
  return moduleFlag;
}

void fxCompleteModule(txMachine* the, txSlot* module, txSlot* exception)
{
  if (exception) {
    txSlot* exports = mxModuleInstanceExports(module);
    txSlot* meta = mxModuleInstanceMeta(module);
    if (exports->kind == XS_REFERENCE_KIND) {
      exports->value.reference->next = C_NULL;
    }
    else {
      fxNewInstance(the);
      mxPullSlot(exports);
    }
    meta->value = exception->value;
    meta->kind = exception->kind;
    mxModuleInstanceStatus(module) = XS_MODULE_STATUS_ERROR;
  }
  else {
    mxModuleInstanceStatus(module) = XS_MODULE_STATUS_EXECUTED;
  }
}

void fxDuplicateModuleTransfers(txMachine* the, txSlot* srcModule, txSlot* dstModule)
{
  txSlot* srcSlot;
  txSlot* dstSlot;
  txSlot* transfer;
  txSlot* aliases;
  txSlot* function;
  srcSlot = mxModuleInternal(srcModule);
  dstSlot = mxModuleInternal(dstModule);
  dstSlot->flag |= (srcSlot->flag & (XS_IMPORT_FLAG | XS_IMPORT_META_FLAG));
  srcSlot = mxModuleTransfers(srcModule);
  dstSlot = mxModuleTransfers(dstModule);
  fxDuplicateInstance(the, srcSlot->value.reference);
  mxPullSlot(dstSlot);
  transfer = dstSlot->value.reference->next;
  while (transfer) {
    fxDuplicateInstance(the, transfer->value.reference);
    mxPullSlot(transfer);
    aliases = mxTransferAliases(transfer);
    if (aliases->kind == XS_REFERENCE_KIND) {
      fxDuplicateInstance(the, aliases->value.reference);
      mxPullSlot(aliases);
    }    
    transfer = transfer->next;
  }
  srcSlot = mxModuleInitialize(srcModule);
  dstSlot = mxModuleInitialize(dstModule);
  if (srcSlot->kind == XS_REFERENCE_KIND) {
    function = fxDuplicateInstance(the, srcSlot->value.reference);
    mxPullSlot(dstSlot);
    mxFunctionInstanceHome(function)->value.home.module =   dstModule->value.reference;
  }
  else {
    dstSlot->kind = srcSlot->kind;
    dstSlot->value = srcSlot->value;
  }
  srcSlot = mxModuleExecute(srcModule);
  dstSlot = mxModuleExecute(dstModule);
  function = fxDuplicateInstance(the, srcSlot->value.reference);
  mxPullSlot(dstSlot);
  mxFunctionInstanceHome(function)->value.home.module =   dstModule->value.reference;
}

void fxExecuteModules(txMachine* the, txSlot* queue)
{
  txBoolean done = 1;
  txSlot* module = queue->next;
  mxReportModuleQueue("INIT");
  while (module) {
    txID status = mxModuleStatus(module);
    if (status == XS_MODULE_STATUS_LINKED) {
      txSlot* exception;
      txID fromStatus = fxExecuteModulesFrom(the, queue, module, &exception);
      if (fromStatus == XS_MODULE_STATUS_ERROR) {
        fxCompleteModule(the, module->value.reference, exception);
        fxRunImportRejected(the, module->value.reference, module->value.reference);
      }
      else if (fromStatus == XS_MODULE_STATUS_LINKED) {
        mxModuleStatus(module) = XS_MODULE_STATUS_EXECUTING;
        mxPushSlot(mxModuleHosts(module));
        mxPull(mxHosts);
        {
          mxTry(the) {
            txSlot* result;
            mxPushUndefined();
            mxPushSlot(mxModuleExecute(module));
            mxCall();
            mxRunCount(0);
            result = the->stack;
            if (mxIsReference(result) && mxIsPromise(result->value.reference)) {
              txSlot* function;
              txSlot* home;
              txSlot* resolveExecuteFunction;
              txSlot* rejectExecuteFunction;
              
              function = fxNewHostFunction(the, fxExecuteModulesFulfilled, 1, XS_NO_ID, mxExecuteModulesFulfilledProfileID);
              home = mxFunctionInstanceHome(function);
              home->value.home.object = queue;
              home->value.home.module = module->value.reference;
              resolveExecuteFunction = the->stack;
  
              function = fxNewHostFunction(the, fxExecuteModulesRejected, 1, XS_NO_ID, mxExecuteModulesRejectedProfileID);
              home = mxFunctionInstanceHome(function);
              home->value.home.object = queue;
              home->value.home.module = module->value.reference;
              rejectExecuteFunction = the->stack;
        
              fxPromiseThen(the, result->value.reference, resolveExecuteFunction, rejectExecuteFunction, C_NULL, C_NULL);
            
              mxPop();
              mxPop();
              mxPop();
              done = 0;
            }
            else {
              mxPop();
              fxCompleteModule(the, module->value.reference, C_NULL);
              fxRunImportFulfilled(the, module->value.reference, module->value.reference);
            }
          }
          mxCatch(the) {
            mxPush(mxException);
            mxException = mxUndefined;
            fxCompleteModule(the, module->value.reference, the->stack);
            fxRunImportRejected(the, module->value.reference, module->value.reference);
            mxPop();
          }
        }
        mxPushUndefined();
        mxPull(mxHosts);
      }
      else
        done = 0;
    }
    else if (status < XS_MODULE_STATUS_EXECUTED)
      done = 0;
    module = module->next;
  }
  if (done) {
    queue->next = C_NULL;
    mxReportModuleQueue("DONE");
  }
}

txID fxExecuteModulesFrom(txMachine* the, txSlot* queue, txSlot* module, txSlot** exception)
{
  txSlot* fromModules = mxModuleTransfers(module)->value.reference;
  txSlot* fromModule;
  if (mxModuleTransfers(module)->kind == XS_NULL_KIND)
    return XS_MODULE_STATUS_LINKED;
  fromModule = fromModules->next;
  while (fromModule) {
    if (mxModuleStatus(fromModule) == XS_MODULE_STATUS_ERROR) {
      *exception = mxModuleMeta(fromModule);
      return XS_MODULE_STATUS_ERROR;
    }
    fromModule = fromModule->next;
  }
  fromModule = fromModules->next;
  while (fromModule) {
    if (mxModuleStatus(fromModule) == XS_MODULE_STATUS_EXECUTING) {
      return XS_MODULE_STATUS_EXECUTING;
    }
    fromModule = fromModule->next;
  }
  fromModule = fromModules->next;
  while (fromModule) {
    if (mxModuleStatus(fromModule) == XS_MODULE_STATUS_LINKED) {
      txSlot* waitingModule = queue->next;
      while (waitingModule) {
        if (module->value.reference == waitingModule->value.reference)
          break;
        if (fromModule->value.reference == waitingModule->value.reference)
          return XS_MODULE_STATUS_EXECUTING;
        waitingModule = waitingModule->next;
      }
    }
    fromModule = fromModule->next;
  }
  return XS_MODULE_STATUS_LINKED;
}

void fxExecuteModulesFulfilled(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  fxCompleteModule(the, module, C_NULL);
  fxRunImportFulfilled(the, module, module);
  fxExecuteModules(the, queue);
}

void fxExecuteModulesRejected(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  fxCompleteModule(the, module,  mxArgv(0));
  fxRunImportRejected(the, module, module);
  fxExecuteModules(the, queue);
}

void fxExecuteVirtualModuleSource(txMachine* the)
{
  txSlot* instance = mxFunction->value.reference;
  txSlot* function = fxLastProperty(the, instance);
  txSlot* home = mxFunctionInstanceHome(instance);
  txSlot* module = home->value.home.module;
  txSlot* internal = mxModuleInstanceInternal(module);
  txSlot* meta = mxModuleInstanceMeta(module);
  txSlot* closures = mxFunctionInstanceCode(instance)->value.callback.closures;
  txSlot* property;
  if (mxIsUndefined(function))
    return;
  closures->flag |= XS_DONT_PATCH_FLAG;
  closures->value.instance.prototype = C_NULL;
  property = closures->next->next;
  while (property) {
    property->flag |= XS_DONT_DELETE_FLAG;
    property = property->next;
  }
  /* THIS */
  mxPushReference(home->value.home.object);
  /* FUNCTION */
  mxPushSlot(function);
  mxCall();
  /* ARGUMENTS */
  mxPushReference(closures);
  if (internal->flag & XS_IMPORT_FLAG) {
    function = fxNewHostFunction(the, fxExecuteVirtualModuleSourceImport, 1, XS_NO_ID, mxExecuteVirtualModuleSourceImportProfileID);
    mxFunctionInstanceHome(function)->value.home.module = module;
  }
  else
    mxPushUndefined();
  if (internal->flag & XS_IMPORT_META_FLAG)
    mxPushSlot(meta);
  else
    mxPushUndefined();
  mxRunCount(3);
  mxPullSlot(mxResult);
}

txSlot* fxGetModule(txMachine* the, txSlot* realm, txID moduleID, txFlag moduleFlag)
{
  txSlot* result = mxBehaviorGetProperty(the, mxOwnModules(realm)->value.reference, moduleID, 0, XS_ANY);
  if (result)
    fxCheckModuleFlag(the, moduleID, mxModuleInternal(result)->flag, moduleFlag);
  return result;
}

void fxLinkCircularities(txMachine* the, txSlot* module, txSlot* circularities, txSlot* exports)
{
  txSlot* circularitiesInstance;
  txSlot* circularity;
  txSlot* transfers;
  txSlot* exportsInstance;
  txSlot* export;
  txSlot* transfer;
  txSlot* aliases;
  txSlot* alias;
  txSlot* circularitiesCopy;
  txSlot* circularityCopy;
  txSlot* from;
  txSlot* stars;
  txSlot* star;
  circularitiesInstance = circularities->value.reference;
  circularity = circularitiesInstance->next;
  while (circularity) {
    if (circularity->value.reference == module->value.reference)
      return;
    circularity = circularity->next;
  }
  circularity = fxDuplicateSlot(the, module);
  circularity->next = circularitiesInstance->next;
  circularitiesInstance->next = circularity;
  exportsInstance = exports->value.reference;
  export = exportsInstance;
  transfers = mxModuleExports(module);
  if (transfers->kind == XS_REFERENCE_KIND) {
    transfer = transfers->value.reference->next;
    while (transfer) {
      export = export->next = fxNewSlot(the);
      export->ID = transfer->ID;
      export->kind = transfer->kind;
      export->value = transfer->value;
      transfer = transfer->next;
    }
    return;
  }
  transfers = mxModuleTransfers(module);
  if (transfers->kind == XS_REFERENCE_KIND) {
    txBoolean starFlag = 0;
    transfer = transfers->value.reference->next;
    while (transfer) {
      aliases = mxTransferAliases(transfer);
      if (aliases->kind == XS_REFERENCE_KIND) {
        alias = aliases->value.reference->next;
        if (alias) {
          while (alias) {
            export = export->next = fxNewSlot(the);
            export->ID = alias->value.symbol;
            export->kind = transfer->kind;
            export->value = transfer->value;
            alias = alias->next;
          }
        }
        else {
          mxCheck(the, mxTransferLocal(transfer)->kind == XS_NULL_KIND);
          starFlag = 1;
        }
      }
      transfer = transfer->next;
    }
    if (starFlag) {
      txSlot* reexportsInstance;
      txSlot* reexport;
      fxNewInstance(the);
      reexportsInstance = the->stack->value.reference;
      reexport = reexportsInstance;
      transfer = transfers->value.reference->next;
      while (transfer) {
        aliases = mxTransferAliases(transfer);
        if ((aliases->kind == XS_REFERENCE_KIND) && (aliases->value.reference->next == C_NULL)) {
          from = mxTransferFrom(transfer);
          fxNewInstance(the);
          circularitiesCopy = the->stack;
          circularity = circularitiesInstance->next;
          circularityCopy = circularitiesCopy->value.reference;
          while (circularity) {
            circularityCopy = circularityCopy->next = fxDuplicateSlot(the, circularity);
            circularity = circularity->next;
          }
          fxNewInstance(the);
          stars = the->stack;
          fxLinkCircularities(the, from, circularitiesCopy, stars);
          star = stars->value.reference->next;
          while (star) {
            if (star->ID != mxID(_default)) {
              txSlot* ambiguous = mxBehaviorGetProperty(the, exportsInstance, star->ID, 0, XS_OWN);
              if (!ambiguous) {
                ambiguous = mxBehaviorGetProperty(the, reexportsInstance, star->ID, 0, XS_OWN);
                if (ambiguous) {
                  txSlot* ambiguousModule;
                  txSlot* starModule;
                  if (ambiguous->kind == XS_EXPORT_KIND)
                    ambiguousModule = ambiguous->value.export.module;
                  else {
                    txSlot* ambiguousClosure = mxTransferClosure(ambiguous);
                    if (ambiguousClosure->kind == XS_EXPORT_KIND)
                      ambiguousModule = ambiguousClosure->value.export.module;
                    else {
                      txSlot* ambiguousFrom = mxTransferFrom(ambiguous);
                      if (ambiguousFrom->kind == XS_REFERENCE_KIND)
                        ambiguousModule = ambiguousFrom->value.reference;
                      else
                        ambiguousModule = C_NULL;
                    }
                  }
                  if (star->kind == XS_EXPORT_KIND)
                    starModule = star->value.export.module;
                  else {
                    txSlot* starClosure = mxTransferClosure(star);
                    if (starClosure->kind == XS_EXPORT_KIND)
                      starModule = starClosure->value.export.module;
                    else {
                      txSlot* starFrom = mxTransferFrom(star);
                      if (starFrom->kind == XS_REFERENCE_KIND)
                        starModule = starFrom->value.reference;
                      else
                        starModule = C_NULL;
                    }
                  }
                  if (ambiguousModule != starModule) {
                    ambiguous->kind = XS_EXPORT_KIND;
                    ambiguous->value.export.closure = C_NULL;
                    ambiguous->value.export.module = C_NULL;
                  }
                }
                else {
                  reexport = reexport->next = fxNewSlot(the);
                  reexport->ID = star->ID;
                  reexport->kind = star->kind;
                  reexport->value = star->value;
                }
              }
            }
            star = star->next;
          }
          mxPop();
          mxPop();
        }
        transfer = transfer->next;
      }
      export->next = reexportsInstance->next;
      reexportsInstance->next = C_NULL;
      mxPop();
    }
  }
}

void fxLinkExports(txMachine* the, txSlot* module)
{
  txSlot* exports;
  txSlot* transfer;
  txSlot* from;
  txSlot* import;
  txSlot* closure;

  exports = mxModuleExports(module)->value.reference;
  exports->flag |= XS_DONT_PATCH_FLAG;
  transfer = exports->next;
  while (transfer) {
    if (transfer->kind != XS_EXPORT_KIND) {
      from = mxTransferFrom(transfer);
      if (from->kind != XS_NULL_KIND) {
        import = mxTransferImport(transfer);
        if (import->kind != XS_NULL_KIND)
          fxLinkTransfer(the, from, import->value.symbol, transfer);
        else
          fxLinkNamespace(the, from, transfer);
      }
      closure = mxTransferClosure(transfer);
      transfer->kind = closure->kind;
      transfer->value = closure->value;
    }
    transfer->flag |= XS_DONT_DELETE_FLAG | XS_DONT_SET_FLAG;
    transfer = transfer->next;
  }
}

void fxLinkLocals(txMachine* the, txSlot* module)
{
  txSlot* transfer;
  txSlot* local;
  txSlot* from;
  txSlot* import;
  txSlot* closure;

  transfer = mxModuleTransfers(module)->value.reference->next;
  while (transfer) {
    local = mxTransferLocal(transfer);
    if (local->kind != XS_NULL_KIND) {
      from = mxTransferFrom(transfer);
      if (from->kind != XS_NULL_KIND) {
        import = mxTransferImport(transfer);
        if (import->kind != XS_NULL_KIND)
          fxLinkTransfer(the, from, import->value.symbol, transfer);
        else
          fxLinkNamespace(the, from, transfer);
        closure = mxTransferClosure(transfer);
        closure->flag |= XS_DONT_SET_FLAG;
      }
    }
    transfer = transfer->next;
  }
}

void fxLinkModules(txMachine* the, txSlot* queue)
{
  txSlot* module;
  txSlot* order;
  txSlot* transfer;
  txSlot* local;
  txSlot* from;
  txSlot* import;
  txSlot* aliases;
  txSlot* closure;
  txSlot* property;
  txSlot* circularities;
  txSlot* exports;
  txSlot* realm;
  txSlot* closures;
  txSlot* export;
  
  order = fxNewInstance(the);
  while ((module = queue->next))
    fxOrderModule(the, queue, order, module);
  queue->next = order->next;
  order->next = C_NULL;
  mxPop();

  mxReportModuleQueue("LINK");
  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
      transfer = mxModuleTransfers(module)->value.reference->next;
      while (transfer) {
        local = mxTransferLocal(transfer);
        from = mxTransferFrom(transfer);
        import = mxTransferImport(transfer);
        aliases = mxTransferAliases(transfer);
        if (local->kind != XS_NULL_KIND) {
          if ((from->kind == XS_NULL_KIND) || (import->kind == XS_NULL_KIND)) {
            closure = mxTransferClosure(transfer);
            closure->value.export.closure = fxNewSlot(the);
            closure->value.export.closure->kind = XS_UNINITIALIZED_KIND;
            closure->value.export.module = module->value.reference;
            closure->kind = XS_EXPORT_KIND;
          }
        }
        else {
          if ((from->kind != XS_NULL_KIND) && (import->kind == XS_NULL_KIND) && (aliases->kind != XS_NULL_KIND)) {
            closure = mxTransferClosure(transfer);
            closure->value.export.closure = fxNewSlot(the);
            closure->value.export.closure->kind = XS_UNINITIALIZED_KIND;
            closure->value.export.module = module->value.reference;
            closure->kind = XS_EXPORT_KIND;
          }
        }
        transfer = transfer->next;
      }
    }
    module = module->next;
  }

  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
      fxNewInstance(the);
      circularities = the->stack;
      fxNewInstance(the);
      exports = the->stack;
      fxLinkCircularities(the, module, circularities, exports);
      mxModuleExports(module)->kind = XS_REFERENCE_KIND;
      mxModuleExports(module)->value.reference = exports->value.reference;
      mxPop();
      mxPop();
    }
    module = module->next;
  }

  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING)
      fxLinkExports(the, module);
    module = module->next;
  }
  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING)
      fxLinkLocals(the, module);
    module = module->next;
  }

  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
      txInteger count = 0;
      mxPushUndefined();
      realm = mxModuleInternal(module)->value.module.realm;
      closures = fxNewEnvironmentInstance(the, mxRealmClosures(realm));
      closure = closures->next;
      transfer = mxModuleTransfers(module)->value.reference->next;
      while (transfer) {
        local = mxTransferLocal(transfer);
        if (local->kind != XS_NULL_KIND) {
          export = mxTransferClosure(transfer);
          mxCheck(the, export->kind == XS_EXPORT_KIND);
          closure = closure->next = fxNewSlot(the);
          closure->ID = local->value.symbol;
          closure->flag = export->flag;
          closure->kind = XS_CLOSURE_KIND;
          closure->value.closure = export->value.export.closure;
        }
        from = mxTransferFrom(transfer);
        if (from->kind != XS_NULL_KIND)
          count++;
        transfer = transfer->next;
      }
      property = mxModuleInitialize(module);
      if (property->kind == XS_REFERENCE_KIND) {
        property = property->value.reference->next;
        if ((property->kind == XS_CODE_KIND) || (property->kind == XS_CODE_X_KIND))
          property->value.code.closures = closures;
        else if (property->kind == XS_CALLBACK_KIND)
          property->value.callback.closures = closures;
      }
      property = mxModuleExecute(module);
      if (property->kind == XS_REFERENCE_KIND) {
        property = property->value.reference->next;
        if ((property->kind == XS_CODE_KIND) || (property->kind == XS_CODE_X_KIND))
          property->value.code.closures = closures;
        else if (property->kind == XS_CALLBACK_KIND)
          property->value.callback.closures = closures;
      }
      mxPop();
      if (count > 0) {
        txSlot* instance = fxNewInstance(the);
        transfer = mxModuleTransfers(module)->value.reference->next;
        while (transfer) {
          from = mxTransferFrom(transfer);
          if (from->kind != XS_NULL_KIND) {
            txSlot** address = &(instance->next);
            txSlot* slot;
            while ((slot = *address)) {
              if (slot->value.reference == from->value.reference)
                break;
              address = &slot->next;
            }
            if (!slot)
              slot = *address = fxDuplicateSlot(the, from);
          }
          transfer = transfer->next;
        }
        mxModuleTransfers(module)->value.reference = instance;
        mxPop();
      }
      else
        mxModuleTransfers(module)->kind = XS_NULL_KIND;
    }
    module = module->next;
  }

  module = queue->next;
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
      mxModuleStatus(module) = XS_MODULE_STATUS_LINKED;
      property = mxModuleInitialize(module);
      if (property->kind == XS_REFERENCE_KIND) {
        mxPushSlot(mxModuleHosts(module));
        mxPull(mxHosts);
        mxPushUndefined();
        mxPushSlot(property);
        mxCall();
        mxRunCount(0);
        mxPop();
        mxPushUndefined();
        mxPull(mxHosts);
      }
    }
    module = module->next;
  }
}

void fxLinkNamespace(txMachine* the, txSlot* module, txSlot* transfer)
{
  txSlot* export = mxTransferClosure(transfer);
  mxCheck(the, export->kind == XS_EXPORT_KIND);
  export->value.export.closure = fxDuplicateSlot(the, module);
  export->value.export.closure->ID = XS_NO_ID;
}

void fxLinkTransfer(txMachine* the, txSlot* module, txID importID, txSlot* transfer)
{
  txSlot* export;
  txSlot* exportClosure;
  txSlot* transferClosure;
  txSlot* from;
  txSlot* import;
  
  export = mxBehaviorGetProperty(the, mxModuleExports(module)->value.reference, importID, 0, XS_OWN);
  if (export) {
    if (export->kind == XS_EXPORT_KIND) {
      if (export->value.export.closure == C_NULL) {
        txString path = C_NULL;
        txInteger line = 0;
      #ifdef mxDebug
        txSlot* slot = mxTransferClosure(transfer)->next;
        if (slot) {
          path = slot->value.string;
          line = slot->next->value.integer;
        }
      #endif  
        fxIDToString(the, importID, the->nameBuffer, sizeof(the->nameBuffer));
        fxThrowMessage(the, path, line, XS_SYNTAX_ERROR, "import %s ambiguous", the->nameBuffer);
      }
      transferClosure = mxTransferClosure(transfer);
      transferClosure->value = export->value;
      transferClosure->kind = export->kind;
    }
    else {
      exportClosure = mxTransferClosure(export);
      if (exportClosure->kind != XS_NULL_KIND) {
        transferClosure = mxTransferClosure(transfer);
        transferClosure->value = exportClosure->value;
        transferClosure->kind = exportClosure->kind;
      }
      else {
        from = mxTransferFrom(export);
        import = mxTransferImport(export);
        if (((from->value.reference == module->value.reference) && (import->value.symbol == importID))
          || ((from->value.reference == mxTransferFrom(transfer)->value.reference) && (import->value.symbol == mxTransferImport(transfer)->value.symbol))) {
          txString path = C_NULL;
          txInteger line = 0;
        #ifdef mxDebug
          txSlot* slot = mxTransferClosure(transfer)->next;
          if (slot) {
            path = slot->value.string;
            line = slot->next->value.integer;
          }
        #endif  
          fxIDToString(the, importID, the->nameBuffer, sizeof(the->nameBuffer));
          fxThrowMessage(the, path, line, XS_SYNTAX_ERROR, "import %s circular", the->nameBuffer);
        }
        fxCheckCStack(the);
        fxLinkTransfer(the, from, import->value.symbol, transfer);
      }
    }
  }
  else {
    txString path = C_NULL;
    txInteger line = 0;
  #ifdef mxDebug
    txSlot* slot = mxTransferClosure(transfer)->next;
    if (slot) {
      path = slot->value.string;
      line = slot->next->value.integer;
    }
  #endif  
    fxIDToString(the, importID, the->nameBuffer, sizeof(the->nameBuffer));
    fxThrowMessage(the, path, line, XS_SYNTAX_ERROR, "import %s not found", the->nameBuffer);
  }
}

void fxLoadModulesPromise(txMachine* the, txSlot* queue, txSlot* module, txSlot* promise, txCallback fulfilled, txCallback rejected)
{
  txSlot* function;
  txSlot* home;
  txSlot* resolveLoadFunction;
  txSlot* rejectLoadFunction;

  mxPushUndefined();
  mxPush(mxPromiseConstructor);
  mxPushSlot(promise);
  fx_Promise_resolveAux(the);
  mxPop();
  mxPop();
  promise = the->stack;

  function = fxNewHostFunction(the, fulfilled, 1, XS_NO_ID, mxLoadModulesFulfilledProfileID);
  home = mxFunctionInstanceHome(function);
  home->value.home.object = queue;
  home->value.home.module = module->value.reference;
  resolveLoadFunction = the->stack;

  function = fxNewHostFunction(the, rejected, 1, XS_NO_ID, mxLoadModulesRejectedProfileID);
  home = mxFunctionInstanceHome(function);
  home->value.home.object = queue;
  home->value.home.module = module->value.reference;
  rejectLoadFunction = the->stack;

  fxPromiseThen(the, promise->value.reference, resolveLoadFunction, rejectLoadFunction, C_NULL, C_NULL);
  
  mxPop();
  mxPop();
}

void fxLoadModules(txMachine* the, txSlot* queue)
{
  txSlot* module = queue->next;
  txBoolean done = 1;
  if (queue->flag & XS_LEVEL_FLAG)
    return;
  queue->flag |= XS_LEVEL_FLAG;
  mxReportModuleQueue("LOAD");
  while (module) {
    if (mxModuleStatus(module) == XS_MODULE_STATUS_NEW) {
      txSlot* loader = mxModuleLoader(module);
      txID moduleID = loader->value.module.id;
      txSlot* realm = loader->value.module.realm;
      mxTry(the) {
        if (fxMapModule(the, realm, moduleID, module, queue, C_NULL)) {
          module = queue;
          done = 0;
        }
        else {
          txSlot* loadHook = mxLoadHook(realm);
          mxModuleStatus(module) = XS_MODULE_STATUS_LOADING;
          if (mxIsUndefined(loadHook)) {
            if (realm != mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm)
              mxTypeError("no loadHook");
            fxLoadModule(the, module, moduleID);
            if (mxModuleExecute(module)->kind == XS_NULL_KIND)
              mxTypeError("no module");
            mxModuleStatus(module) = XS_MODULE_STATUS_LOADED;
            module = queue;
            done = 1;
            mxReportModuleQueue("LOAD");
          }
          else {
            done = 0;
            mxModuleStatus(module) = XS_MODULE_STATUS_LOADING;
            
            mxPushUndefined();
            mxPushSlot(loadHook);
            mxCall();
            fxPushKeyString(the, moduleID, C_NULL);
            fxPushModuleOptions(the, loader->flag);
            mxRunCount(2);
            
            fxLoadModulesPromise(the, queue, module, the->stack, fxLoadModulesFulfilled, fxLoadModulesRejected);

            mxPop();
          }
        }
      }
      mxCatch(the) {
        mxPush(mxException);
        mxException = mxUndefined;
        fxCompleteModule(the, module->value.reference, the->stack);
        fxRunImportRejected(the, module->value.reference, module->value.reference);
      }
    }
    else if (mxModuleStatus(module) == XS_MODULE_STATUS_LOADING) {
      done = 0;
    }
    else if (mxModuleStatus(module) == XS_MODULE_STATUS_LOADED) {
      mxTry(the) {
      #if mxModuleStuff
        if (!fxLoadModuleStuffFrom(the, queue, module->value.reference, 0))
      #endif
          fxLoadModulesFrom(the, queue, module->value.reference, 0);
        mxModuleStatus(module) = XS_MODULE_STATUS_LINKING;
        module = queue;
        done = 1;
      }
      mxCatch(the) {
        mxPush(mxException);
        mxException = mxUndefined;
        fxCompleteModule(the, module->value.reference, the->stack);
        fxRunImportRejected(the, module->value.reference, module->value.reference);
      }
    }
    module = module->next;
  }
  queue->flag &= ~XS_LEVEL_FLAG;
  if (done) {
    mxTry(the) {
      fxLinkModules(the, queue);
    }
    mxCatch(the) {
      mxPush(mxException);
      mxException = mxUndefined;
      module = queue->next;
      while (module) {
        if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
          fxCompleteModule(the, module->value.reference, the->stack);
          fxRunImportRejected(the, module->value.reference, module->value.reference);
        }
        module = module->next;
      }
      mxPop();
    }
    fxExecuteModules(the, queue);
  }
}

void fxLoadModulesFrom(txMachine* the, txSlot* queue, txSlot* module, txBoolean now)
{
  txSlot* internal = mxModuleInstanceInternal(module);
  txID moduleID = internal->value.module.id;
  txSlot* realm = internal->value.module.realm;
  txSlot* transfer = mxModuleInstanceTransfers(module)->value.reference->next;
  txSlot* already = the->stack;
  while (transfer) {
    txSlot* from = mxTransferFrom(transfer);
    if (from->kind != XS_NULL_KIND) {
      txID importModuleID = XS_NO_ID;
      txSlot* importModule;
      txID status;
      txSlot* former = the->stack;
      while (former < already) {
        if (!c_strcmp(former->value.string, from->value.string)) {
          importModuleID = former->ID;
          break;
        }
        former++;
      }
      if (importModuleID == XS_NO_ID) {
        mxPushSlot(from);
        importModuleID = fxResolveSpecifier(the, realm, moduleID, from);
        the->stack->ID = importModuleID;
      }
      importModule = fxGetModule(the, realm, importModuleID, from->flag & XS_JSON_MODULE_FLAG);
      if (!importModule) {
        importModule = mxBehaviorSetProperty(the, mxOwnModules(realm)->value.reference, importModuleID, 0, XS_OWN);
        fxNewModule(the, realm, importModuleID, from->flag & XS_JSON_MODULE_FLAG, importModule);
      }
      from->kind = XS_REFERENCE_KIND;
      from->value.reference = importModule->value.reference;
      status = mxModuleStatus(importModule);
      if ((status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADED)) {
        fxQueueModule(the, queue, importModule);
      }
      else if (now) {
        if (status == XS_MODULE_STATUS_LINKING) {
          txSlot* slot = queue->next;
          while (slot) {
            if (slot->value.reference == importModule->value.reference)
              break;
            slot= slot->next;
          }
          if (!slot)
            mxTypeError("async module");
        }
        else if (status == XS_MODULE_STATUS_ERROR) {
          mxPushSlot(mxModuleInstanceMeta(module));
          mxPull(mxException);
          fxJump(the);
        }
        else if (status != XS_MODULE_STATUS_EXECUTED) {
          mxTypeError("async module");
        }
      }
    }
    transfer = transfer->next;
  }
  the->stack = already;
}

void fxLoadModulesFulfilled(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  txSlot* internal = mxModuleInstanceInternal(module);
  txSlot* realm = internal->value.module.realm;
  txID moduleID = internal->value.module.id;
  mxTry(the) {
    mxPushReference(module);
    fxMapModuleDescriptor(the, realm, moduleID, the->stack, queue, C_NULL, mxArgv(0));
    mxPop(); // module
  }
  mxCatch(the) {
    mxPush(mxException);
    mxException = mxUndefined;
    fxCompleteModule(the, module, the->stack);
    fxRunImportRejected(the, module, module);
    mxPop();
  }
  fxLoadModules(the, queue);
}

void fxLoadModulesRejected(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  fxCompleteModule(the, module, mxArgv(0));
  fxRunImportRejected(the, module, module);
  fxLoadModules(the, queue);
}

void fxLoadVirtualModuleNamespace(txMachine* the, txSlot* object, txSlot* module)
{
  txSlot* exports = fxNewInstance(the);
  txSlot* export = exports;
  txSlot* at;
  txSlot* property;
  at = fxNewInstance(the);
  mxBehaviorOwnKeys(the, object, XS_EACH_NAME_FLAG, at);
  mxTemporary(property);
  while ((at = at->next)) {
    if (at->value.at.id != XS_NO_ID) {
      if (mxBehaviorGetOwnProperty(the, object, at->value.at.id, at->value.at.index, property) && !(property->flag & XS_DONT_ENUM_FLAG)) {
        mxPushReference(object);
        mxGetAll(at->value.at.id, at->value.at.index);
        export = export->next = fxNewSlot(the);
        export->ID = at->value.at.id;
        export->value.export.closure = fxNewSlot(the);
        export->value.export.closure->kind = the->stack->kind;
        export->value.export.closure->value = the->stack->value;
        export->value.export.module = module;
        export->kind = XS_EXPORT_KIND;
        mxPop();
      }
    }
  }
  mxPop();
  mxPop();
  mxPullSlot(mxModuleInstanceExports(module));
}

void fxLoadVirtualModuleSource(txMachine* the, txSlot* record, txSlot* instance)
{
  txSlot* slot;
  txSlot* function;
  txSlot* property;
  txSlot* transfers;
  txSlot* transfer;
  
  mxPushSlot(record);
  mxGetID(fxID(the, "execute"));
  slot = the->stack;
  if (!mxIsUndefined(slot)) {
    if (!fxIsCallable(the, slot))
      mxTypeError("execute: not a function");
  }
  function = fxNewHostFunction(the, fxExecuteVirtualModuleSource, 0, XS_NO_ID, mxExecuteVirtualModuleSourceProfileID);
  property = mxFunctionInstanceHome(function);
  property->value.home.object = fxToInstance(the, record);
  property->value.home.module = instance;
  property = fxLastProperty(the, function);
  property = fxNextSlotProperty(the, property, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  mxPullSlot(mxModuleInstanceExecute(instance));
  mxPop(); // initialize
      
  mxPush(mxObjectPrototype);
  transfers = fxNewObjectInstance(the);
  transfer = fxLastProperty(the, transfers);
  
  mxPushSlot(record);
  mxGetID(mxID(_bindings));
  if (!mxIsUndefined(the->stack)) {
    txSlot* array;
    txInteger length, index;
    
    array = the->stack;
    mxPushSlot(array);
    mxGetID(mxID(_length));
    length = fxToInteger(the, the->stack);
    mxPop();
    
    for (index = 0; index < length; index++) {
      txSlot* item;
      txSlot* temporary;
      txInteger from = 0;
      txInteger export = 0;
      txInteger import = 0;
      txID nameID = 0, asID;
      txSlot* specifier = C_NULL;
      txSlot* former;

      mxPushSlot(array);
      mxGetIndex(index);
      item = the->stack;
    
      mxTemporary(temporary);
    
      mxPushSlot(item);
      mxGetID(mxID(_from));
      if (!mxIsUndefined(the->stack)) {
        from++;
        fxToString(the, the->stack);
        mxPullSlot(temporary);
        specifier = temporary;
      }
      else
        mxPop();
        
      mxPushSlot(item);
      mxGetID(fxID(the, "exportAllFrom"));
      if (!mxIsUndefined(the->stack)) {
        from++;
        export++;
        fxToString(the, the->stack);
        mxPullSlot(temporary);
        specifier = temporary;
        nameID = XS_NO_ID;
      }
      else
        mxPop();
    
      mxPushSlot(item);
      mxGetID(fxID(the, "importAllFrom"));
      if (!mxIsUndefined(the->stack)) {
        from++;
        import++;
        fxToString(the, the->stack);
        mxPullSlot(temporary);
        specifier = temporary;
        nameID = XS_NO_ID;
      }
      else
        mxPop();
    
      mxPushSlot(item);
      mxGetID(mxID(_export));
      if (!mxIsUndefined(the->stack)) {
        export++;
        nameID = fxToID(the, the->stack);
      }
      mxPop();
      
      mxPushSlot(item);
      mxGetID(mxID(_import));
      if (!mxIsUndefined(the->stack)) {
        import++;
        nameID = fxToID(the, the->stack);
      }
      mxPop();
    
      mxPushSlot(item);
      mxGetID(mxID(_as));
      if (!mxIsUndefined(the->stack)) {
        asID = fxToID(the, the->stack);
      }
      else
        asID = nameID;
      mxPop();
        
      if (from > 1)
        mxSyntaxError("too many from");
      else if (export > 1)
        mxSyntaxError("too many export");
      else if (import > 1)
        mxSyntaxError("too many import");
      else if (export && import)
        mxSyntaxError("export and import");
      else if (!export && !import)
        mxSyntaxError("neither export nor import");
      
      if (export) {
        if (asID != XS_NO_ID) {
          former = transfers->next;
          while (former) {
            txSlot* aliases = mxTransferAliases(former);
            if (!mxIsNull(aliases)) {
              txSlot* alias = aliases->value.reference->next;
              while (alias) {
                if (alias->value.symbol == asID) {
                  fxIDToString(the, asID, the->nameBuffer, sizeof(the->nameBuffer));
                  mxSyntaxError("duplicate export %s", the->nameBuffer);
                }
                alias = alias->next;
              }
            }
            former = former->next;
          }
          if (specifier) {
            former = transfers->next;
            while (former) {
              txSlot* aliases = mxTransferAliases(former);
              if (!mxIsNull(aliases)) {
                txSlot* local = mxTransferLocal(former);
                if (mxIsNull(local)) {
                  txSlot* from = mxTransferFrom(former);
                  if (!mxIsNull(from) && !c_strcmp(from->value.string, specifier->value.string)) {
                    txSlot* import = mxTransferImport(former);
                    if (mxIsNull(import)) {
                      if (nameID == XS_NO_ID) 
                        break;
                    }
                    else {
                      if (nameID == import->value.symbol)
                        break;
                    }
                  }
                }
              }
              former = former->next;
            }
          }
          else {
            former = transfers->next;
            while (former) {
              txSlot* local = mxTransferLocal(former);
              if ((local->kind == XS_SYMBOL_KIND) && (local->value.symbol == nameID))
                break;
              former = former->next;
            }
          }
          if (former) {
            txSlot* aliases = mxTransferAliases(former);
            txSlot* alias;
            if (mxIsNull(aliases)) {
              mxPush(mxObjectPrototype);
              alias = fxLastProperty(the, fxNewObjectInstance(the));
              mxPullSlot(mxTransferAliases(former));
            }
            else {
              alias = fxLastProperty(the, aliases->value.reference);
            }
            fxNextSymbolProperty(the, alias, asID, XS_NO_ID, XS_DONT_ENUM_FLAG);
          }
          else if (specifier) {
            mxPushNull();
            mxPushSlot(specifier);
            if ((nameID != XS_NO_ID) || (asID != XS_NO_ID)) {
              if (nameID != XS_NO_ID) 
                mxPushSymbol(nameID);
              else
                mxPushNull();
              if (asID != XS_NO_ID) 
                mxPushSymbol(asID);
              else      
                mxPushSymbol(nameID);
              mxPushInteger(4);
            }
            else { 
              mxPushNull();
              mxPushInteger(3);
            }
            fxPrepareTransfer(the, XS_NO_FLAG);
            transfer = fxNextSlotProperty(the, transfer, the->stack, XS_NO_ID, XS_DONT_ENUM_FLAG);
            mxPop(); // transfer
          }
          else {
            mxPushSymbol(nameID);
            mxPushNull();
            mxPushNull();
            mxPushSymbol(asID);
            mxPushInteger(4);
            fxPrepareTransfer(the, XS_NO_FLAG);
            transfer = fxNextSlotProperty(the, transfer, the->stack, XS_NO_ID, XS_DONT_ENUM_FLAG);
            mxPop(); // transfer
          }
        }
        else if (specifier) {
          former = transfers->next;
          while (former) {
            txSlot* from = mxTransferFrom(former);
            if (!mxIsNull(from) && !c_strcmp(from->value.string, specifier->value.string)) {
              txSlot* local = mxTransferLocal(former);
              if (mxIsNull(local)) {
                txSlot* import = mxTransferImport(former);
                if (mxIsNull(import)) {
                  txSlot* aliases = mxTransferAliases(former);
                  if (mxIsNull(aliases)) {
                    mxSyntaxError("duplicate export *");
                  }
                }
              }
            }
            former = former->next;
          }
          mxPushNull();
          mxPushSlot(specifier);
          mxPushNull();
          mxPushInteger(3);
          fxPrepareTransfer(the, XS_NO_FLAG);
          transfer = fxNextSlotProperty(the, transfer, the->stack, XS_NO_ID, XS_DONT_ENUM_FLAG);
          mxPop(); // transfer
        }
        else
          mxSyntaxError("invalid export *");
      }
      else {
        if (!specifier) {
          if (asID == XS_NO_ID)
            mxSyntaxError("invalid import *");
          else {
            fxIDToString(the, asID, the->nameBuffer, sizeof(the->nameBuffer));
            mxSyntaxError("invalid import %s", the->nameBuffer);
          }
        }
        else if (asID == XS_NO_ID)
          mxSyntaxError("invalid import * from %s", specifier->value.string);
      
        former = transfers->next;
        while (former) {
          txSlot* local = mxTransferLocal(former);
          if ((local->kind == XS_SYMBOL_KIND) && (local->value.symbol == asID)) {
            txSlot* from = mxTransferFrom(former);
            if (!mxIsNull(from)) {
              fxIDToString(the, asID, the->nameBuffer, sizeof(the->nameBuffer));
              mxSyntaxError("duplicate import %s", the->nameBuffer);
            }
            break;
          }
          former = former->next;
        }
        if (former) {
          txSlot* from = mxTransferFrom(former);
          mxPushSlot(specifier);
          mxPullSlot(from); 
          if (nameID != XS_NO_ID) {
            txSlot* import = mxTransferImport(former);
            import->kind = XS_SYMBOL_KIND;
            import->value.symbol = nameID;
          }
        }
        else {
          mxPushSymbol(asID);
          mxPushSlot(specifier);
          if (nameID != XS_NO_ID)
            mxPushSymbol(nameID);
          else      
            mxPushNull();
          mxPushInteger(3);
          fxPrepareTransfer(the, XS_NO_FLAG);
          transfer = fxNextSlotProperty(the, transfer, the->stack, XS_NO_ID, XS_DONT_ENUM_FLAG);
          mxPop(); // transfer
        }
      }  

      mxPop(); // temporary
      mxPop(); // item
    }
  }
  mxPop(); // bindings

#if mxReport
  {
    fxIDToString(the, mxModuleInstanceInternal(instance)->value.module.id, the->nameBuffer, sizeof(the->nameBuffer));
    fprintf(stderr, "### %s\n", the->nameBuffer);
    txSlot* transfer = the->stack->value.reference->next;
    while (transfer) {
      txSlot* local = mxTransferLocal(transfer);
      txSlot* from = mxTransferFrom(transfer);
      txSlot* import = mxTransferImport(transfer);
      txSlot* aliases = mxTransferAliases(transfer);
      if (local->kind != XS_NULL_KIND) {
        fxIDToString(the, local->value.symbol, the->nameBuffer, sizeof(the->nameBuffer));
        fprintf(stderr, " local %s", the->nameBuffer);
      }
      if (from->kind != XS_NULL_KIND) {
        fprintf(stderr, " from %s", from->value.string);
      }
      if (import->kind != XS_NULL_KIND) {
        fxIDToString(the, import->value.symbol, the->nameBuffer, sizeof(the->nameBuffer));
        fprintf(stderr, " import %s", the->nameBuffer);
      }
      if (!mxIsNull(aliases)) {
        txSlot* alias = aliases->value.reference->next;
        while (alias) {
          fxIDToString(the, alias->value.symbol, the->nameBuffer, sizeof(the->nameBuffer));
          fprintf(stderr, " alias %s", the->nameBuffer);
          alias = alias->next;
        }
      }
      fprintf(stderr, "\n");
      transfer = transfer->next;
    }
  }
#endif
  
  mxPullSlot(mxModuleInstanceTransfers(instance));

  mxPushSlot(record);
  mxGetID(mxID(_needsImport));
  if (!mxIsUndefined(the->stack)) {
    if (fxToBoolean(the, the->stack)) {
      txSlot* internal = mxModuleInstanceInternal(instance);
      internal->flag |= XS_IMPORT_FLAG;
    }
  }
  mxPop(); // needsImport
  
  mxPushSlot(record);
  mxGetID(mxID(_needsImportMeta));
  if (!mxIsUndefined(the->stack)) {
    if (fxToBoolean(the, the->stack)) {
      txSlot* internal = mxModuleInstanceInternal(instance);
      internal->flag |= XS_IMPORT_META_FLAG;
    }
  }
  mxPop(); // _needsImportMeta
}

txBoolean fxMapModule(txMachine* the, txSlot* realm, txID moduleID, txSlot* module, txSlot* queue, txSlot* result)
{
  txSlot* moduleMap = mxModuleMap(realm);
  txSlot* descriptor = moduleMap->value.reference->next;
  while (descriptor) {
    if (descriptor->ID == moduleID) {
      fxMapModuleDescriptor(the, realm, moduleID, module, queue, result,descriptor);
      return 1;
    }
    descriptor = descriptor->next;
  }
  return 0;
}

void fxMapModuleDescriptor(txMachine* the, txSlot* realm, txID moduleID, txSlot* module, txSlot* queue, txSlot* result, txSlot* descriptor)
{
  txSlot* property;
  if (!mxIsReference(descriptor))
    mxTypeError("descriptor: not an object");

  mxPushSlot(descriptor);
  mxGetID(fxID(the, "namespace"));
  property = the->stack;
  if (!mxIsUndefined(property)) {
    if ((property->kind == XS_STRING_KIND) || (property->kind == XS_STRING_X_KIND)) {
      txSlot* aliasRealm;
      txSlot* aliasOwn;
      txID aliasModuleID;
      txSlot* aliasModule;
      mxPushSlot(descriptor);
      mxGetID(fxID(the, "compartment"));
      if (!mxIsUndefined(the->stack)) {
        txSlot* program = fxCheckCompartmentInstance(the, the->stack);
        aliasRealm = mxModuleInstanceInternal(program)->value.module.realm;
      }
      else {
        aliasRealm = mxRealmParent(realm)->value.reference;
      }
      aliasOwn = mxOwnModules(aliasRealm)->value.reference;
      mxPop();
      aliasModuleID = fxResolveSpecifier(the, aliasRealm, XS_NO_ID, property);
  //       if ((aliasRealm == realm) && (aliasModuleID == moduleID))
  //         mxTypeError("descriptor.specifier is circular");
      
      aliasModule = mxBehaviorGetProperty(the, aliasOwn, aliasModuleID, 0, XS_ANY);
      if (aliasModule) {
        property = aliasModule;
      }
      else {
        property = mxBehaviorSetProperty(the, aliasOwn, aliasModuleID, 0, XS_OWN);
        fxNewModule(the, aliasRealm, aliasModuleID, XS_NO_FLAG, property);
      }
      goto namespace;
    }
    else {
      txSlot* instance = module->value.reference;
      if (!mxIsReference(property))
        mxTypeError("descriptor.namespace: not an object");
      if (mxIsModule(property->value.reference))
        goto namespace;
      fxLoadVirtualModuleNamespace(the, property->value.reference, instance);
      txID status = mxModuleInstanceStatus(instance);
      if ((status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADING)) {
        mxModuleInstanceStatus(instance) = XS_MODULE_STATUS_EXECUTED;
        if (result) {
      
        }
        else {
          fxCompleteModule(the, instance, C_NULL);
          fxRunImportFulfilled(the, instance, instance);
        }
      }
      goto done;
    }
    
namespace:
    if (module->kind == XS_UNDEFINED_KIND) {
      module->kind = property->kind;
      module->value = property->value;
    }
    else {
      txID status = mxModuleStatus(module);
      mxCheck(the, (status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADING));
      mxPushSlot(module);
      realm = mxModuleInternal(module)->value.module.realm;
      fxOverrideModule(the, queue, mxOwnModules(realm), result, module->value.reference, property->value.reference);
      status = mxModuleStatus(property);
      if (result) {
        if (status == XS_MODULE_STATUS_ERROR) {
          mxPushSlot(mxModuleMeta(property));
          mxPull(mxException);
          fxJump(the);
        }
        else if (status == XS_MODULE_STATUS_EXECUTED) {
        }
        else {
          fxQueueModule(the, queue, property);
        }
      }
      else {
        if (status == XS_MODULE_STATUS_ERROR) {
          fxCompleteModule(the, module->value.reference, C_NULL);
          fxRunImportRejected(the, module->value.reference, property->value.reference);
        }
        else if (status == XS_MODULE_STATUS_EXECUTED) {
          fxCompleteModule(the, module->value.reference, C_NULL);
          fxRunImportFulfilled(the, module->value.reference, property->value.reference);
        }
        else {
          txSlot* srcSlot = mxModuleFulfill(module);
          txSlot* dstSlot = fxLastProperty(the, property->value.reference);
          while (srcSlot) {
            dstSlot = fxNextSlotProperty(the, dstSlot, srcSlot, XS_NO_ID, XS_NO_FLAG);
            srcSlot = srcSlot->next;
          }
          fxQueueModule(the, queue, property);
        }
      }
      mxPop();
    }
    goto done;
  }
  mxPop(); // property;

  if (module->kind == XS_UNDEFINED_KIND)
    fxNewModule(the, realm, moduleID, XS_NO_FLAG, module);
  else {
    txID status = mxModuleStatus(module);
    mxCheck(the, (status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADING));
  }
  
  mxPushSlot(descriptor);
  mxGetID(fxID(the, "archive"));
  property = the->stack;
  if (!mxIsUndefined(property)) {
    void* archive = fxGetHostData(the, property);
    txString path;
    void* code;
    size_t size;
    txScript script;
    mxPushSlot(descriptor);
    mxGetID(fxID(the, "path"));
    property = the->stack;
    path = fxToString(the, property);
    code = fxGetArchiveCode(the, archive, path, &size);
    if (code == C_NULL)
      mxURIError("module not found: %s", path);
    mxPop();
    script.callback = NULL;
    script.symbolsBuffer = NULL;
    script.symbolsSize = 0;
    script.codeBuffer = code;
    script.codeSize = (txSize)size;
    script.hostsBuffer = NULL;
    script.hostsSize = 0;
    script.path = path;
    script.version[0] = XS_MAJOR_VERSION;
    script.version[1] = XS_MINOR_VERSION;
    script.version[2] = XS_PATCH_VERSION;
    script.version[3] = 0;
    fxRunScript(the, &script, module, C_NULL, C_NULL, C_NULL, module->value.reference);

//    mxPushClosure(module);
    mxPop();
//    mxPop(); // path
    if (mxModuleExecute(module)->kind == XS_NULL_KIND)
      mxTypeError("no module");
    goto importMeta;
  }
  mxPop(); // property;
  
  mxPushSlot(descriptor);
  mxGetID(fxID(the, "source"));
  property = the->stack;
  if (!mxIsUndefined(property)) {
    if ((property->kind == XS_STRING_KIND) || (property->kind == XS_STRING_X_KIND)) {
      txSlot* loader = mxModuleLoader(module);
      loader->value.module.realm = mxRealmParent(realm)->value.reference;
      if (property->kind == XS_STRING_X_KIND)
        loader->value.module.id = fxNewNameX(the, property->value.string);
      else
        loader->value.module.id = fxNewName(the, property);
      mxModuleStatus(module) = XS_MODULE_STATUS_NEW;
      goto done;
    }
    if (!mxIsReference(property))
      mxTypeError("descriptor.source: not an object");
    if (mxIsModuleSource(property->value.reference))
      fxDuplicateModuleTransfers(the, property, module);
    else
//      mxTypeError("descriptor.source is object");
      fxLoadVirtualModuleSource(the, property, module->value.reference);
    goto importMeta;
  }
  mxPop(); // property
  
  mxTypeError("invalid descriptor");
  
importMeta:
  mxPop(); // property
  mxModuleStatus(module) = XS_MODULE_STATUS_LOADED;
  
  mxPushSlot(descriptor);
  mxGetID(fxID(the, "importMeta"));
  property = the->stack;
  if (!mxIsUndefined(property)) {
    if (!mxIsReference(property))
      mxTypeError("descriptor.importMeta: not an object");
    txSlot* meta = mxModuleMeta(module);
    if (mxIsNull(meta)) {
      txSlot* instance = fxNewInstance(the);
      meta->value.reference = instance;
      meta->kind = XS_REFERENCE_KIND;
    }
    meta->value.reference->flag &= ~XS_DONT_PATCH_FLAG;
    mxPushUndefined();
    mxPush(mxAssignObjectFunction);
    mxCall();
    mxPushSlot(meta);
    mxPushSlot(property);
    mxRunCount(2);
    mxPop();
    meta->value.reference->flag |= XS_DONT_PATCH_FLAG;
  }
  mxPop(); // property
  
  mxPushSlot(descriptor);
  mxGetID(fxID(the, "specifier"));
  property = the->stack;
  if (!mxIsUndefined(property)) {
    txSlot* internal = mxModuleInternal(module);
    fxToString(the, property);
    if (property->kind == XS_STRING_X_KIND)
      internal->value.module.id = fxNewNameX(the, property->value.string);
    else
      internal->value.module.id = fxNewName(the, property);
  }
  
  goto done;
  
done:
  mxPop(); // property
}


void fxNewModule(txMachine* the, txSlot* realm, txID moduleID, txFlag moduleFlag, txSlot* module)
{
  txSlot* slot;
  
  mxPush(mxModulePrototype);
  slot = fxNewObjectInstance(the);
  slot->flag |= XS_EXOTIC_FLAG | XS_DONT_PATCH_FLAG;
  /* HOST */
  slot = slot->next = fxNewSlot(the);
  slot->ID = XS_MODULE_BEHAVIOR;
  slot->flag = XS_INTERNAL_FLAG | moduleFlag;
  slot->kind = XS_MODULE_KIND;
  slot->value.module.realm = realm;
  slot->value.module.id = moduleID;
  /* EXPORTS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* STUFF */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* META */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* TRANSFERS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* INITIALIZE */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* FUNCTION */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* HOSTS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* LOADER */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  slot->flag = XS_INTERNAL_FLAG | moduleFlag;
  slot->kind = XS_MODULE_KIND;
  slot->value.module.realm = realm;
  slot->value.module.id = moduleID; 
  module->kind = the->stack->kind;
  module->value = the->stack->value;
  mxPop();
#if mxInstrument
  the->loadedModulesCount++;
#endif
}

void fxOrderModule(txMachine* the, txSlot* queue, txSlot* order, txSlot* module)
{
  txSlot** fromAddress = &(queue->next);
  txSlot** toAddress = &(order->next);
  txSlot* from;
  txSlot* to;
  while ((from = *fromAddress)) {
    if (from == module) {
      *fromAddress = module->next;
      module->next = C_NULL;
      break;
    }
    fromAddress = &(from->next);
  }
  if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKING) {
    txSlot* transfer = mxModuleTransfers(module)->value.reference->next;
    while (transfer) {
      from = mxTransferFrom(transfer);
      if (from->kind != XS_NULL_KIND) {
        to = queue->next;
        while (to) {
          if (to->value.reference == from->value.reference)
            break;
          to = to->next;
        }
        if (to)
          fxOrderModule(the, queue, order, to);
      }
      transfer = transfer->next;
    }
  }
  while ((to = *toAddress)) {
    if (to->value.reference == module->value.reference)
      return;
    toAddress = &(to->next);
  }
  *toAddress = module;
}

void fxOverrideModule(txMachine* the, txSlot* queue, txSlot* list, txSlot* result, txSlot* module, txSlot* record)
{
  txSlot** address = &(queue->next);
  txSlot* slot;
  while ((slot = *address)) {
    if (slot->value.reference == module) {
//       slot->value.reference = record;
      *address = slot->next;
    }
    else {
      if (mxModuleStatus(slot) == XS_MODULE_STATUS_LINKING) {
        txSlot* transfer = mxModuleTransfers(slot)->value.reference->next;
        while (transfer) {
          txSlot* from = mxTransferFrom(transfer);
          if ((from->kind == XS_REFERENCE_KIND) && (from->value.reference == module))
            from->value.reference = record;
          transfer = transfer->next;
        }
      }
    }
    address = &(slot->next);
  }
  slot = list->value.reference->next;
  while (slot) {
    if (slot->value.reference == module) {
      slot->value.reference = record;
    }
    slot = slot->next;
  }
  if (result) {
    if (result->value.reference == module) {
      result->value.reference = record;
    }
  }
}

void fxPrepareModule(txMachine* the, txFlag flag)
{
  txSlot* module = mxFunctionInstanceHome(mxFunction->value.reference)->value.home.module;
  txInteger c = the->stack->value.integer, i;
  txSlot* argument = the->stack + c;
  txSlot* result = the->stack + c;
  txSlot* slot;
  txSlot* property;
  property = mxModuleInstanceInternal(module); 
  fxCheckModuleFlag(the, property->value.module.id, flag, property->flag);
  property->flag |= flag;
  slot = argument--;
  property = mxModuleInstanceInitialize(module); 
  property->kind = slot->kind;
  property->value = slot->value;
  slot = argument--;
  property = mxModuleInstanceExecute(module); 
  property->kind = slot->kind;
  property->value = slot->value;
  mxFunctionInstanceCode(slot->value.reference)->ID = mxModuleInstanceInternal(module)->value.module.id;
  slot = &mxHosts; 
  property = mxModuleInstanceHosts(module); 
  property->kind = slot->kind;
  property->value = slot->value;
  mxPush(mxObjectPrototype);
  slot = fxLastProperty(the, fxNewObjectInstance(the));
  for (i = 2; i < c; i++)
    slot = fxNextSlotProperty(the, slot, argument--, XS_NO_ID, XS_DONT_ENUM_FLAG);
  property = mxModuleInstanceTransfers(module); 
  mxPullSlot(property);
  result->kind = XS_REFERENCE_KIND;
  result->value.reference = module;
  the->stack = result;
}

void fxPrepareTransfer(txMachine* the, txFlag flag)
{
  txInteger c = the->stack->value.integer, i;
  txSlot* argument = the->stack + c;
  txSlot* result = the->stack + c;
  txSlot* property;
  txSlot* slot;
  mxPush(mxTransferPrototype);
  property = fxNewObjectInstance(the);
  property = fxNextSlotProperty(the, property, argument--, mxID(_local), XS_DONT_ENUM_FLAG);
  property = fxNextSlotProperty(the, property, argument--, mxID(_from), XS_DONT_ENUM_FLAG | flag);
  property = fxNextSlotProperty(the, property, argument--, mxID(_import), XS_DONT_ENUM_FLAG);
  if (c > 3) {
    mxPush(mxObjectPrototype);
    slot = fxLastProperty(the, fxNewObjectInstance(the));
    if (argument->kind != XS_NULL_KIND) {
      for (i = 3; i < c; i++)
        slot = fxNextSlotProperty(the, slot, argument--, XS_NO_ID, XS_DONT_ENUM_FLAG);
    }
    property = fxNextSlotProperty(the, property, the->stack, mxID(_aliases), XS_DONT_ENUM_FLAG);
    mxPop();
  }
  else {
    property = fxNextNullProperty(the, property, mxID(_aliases), XS_DONT_ENUM_FLAG);
  }
  property = fxNextNullProperty(the, property, mxID(_closure), XS_DONT_ENUM_FLAG);
  result->kind = the->stack->kind;
  result->value = the->stack->value;
  the->stack = result;
  
// #ifdef mxDebug
//  slot = the->frame->next;
//  if (slot) {
//    slot = slot - 1;
//    if (slot->next) {
//      property = fxNextSlotProperty(the, property, slot->next, XS_NO_ID, XS_DONT_ENUM_FLAG);
//      property = fxNextIntegerProperty(the, property, slot->ID, XS_NO_ID, XS_DONT_ENUM_FLAG);
//    }
//  }
// #endif
}

txBoolean fxQueueModule(txMachine* the, txSlot* queue, txSlot* module)
{
  txSlot** address = &(queue->next);
  txSlot* slot;
  while ((slot = *address)) {
    if (slot->value.reference == module->value.reference)
      return 0;
    address = &(slot->next);
  }
  slot = *address = fxNewSlot(the);
  slot->ID = mxModuleInternal(module)->value.module.id; //??
  slot->kind = XS_REFERENCE_KIND;
  slot->value.reference = module->value.reference;
  return 1;
}

void fxResolveModule(txMachine* the, txSlot* module, txID moduleID, txScript* script, void* data, txDestructor destructor)
{
  if (script->codeBuffer) {
    if (moduleID != XS_NO_ID) {
      txSlot* key = fxGetKey(the, moduleID);
      txSlot* meta = mxModuleMeta(module);
      txSlot* slot;
      if (mxIsNull(meta)) {
        txSlot* instance = fxNewInstance(the);
        meta->value.reference = instance;
        meta->kind = XS_REFERENCE_KIND;
      }
      slot = fxLastProperty(the, meta->value.reference);
      slot = slot->next = fxNewSlot(the);
      slot->value.string = key->value.key.string;
      if (key->kind == XS_KEY_KIND)
        slot->kind = XS_STRING_KIND;
      else
        slot->kind = XS_STRING_X_KIND;
      slot->ID = mxID(_uri);
      slot->flag |= XS_DONT_DELETE_FLAG | XS_DONT_SET_FLAG;
    }
//    mxPushClosure(module);
    fxRunScript(the, script, module, C_NULL, C_NULL, C_NULL, module->value.reference);
    mxPop();
  }
}

txID fxResolveSpecifier(txMachine* the, txSlot* realm, txID moduleID, txSlot* name)
{
  if (moduleID == XS_NO_ID) {
    if (realm == mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm) {
      moduleID = fxFindModule(the, realm, XS_NO_ID, name);
      if (moduleID == XS_NO_ID) {
        fxToStringBuffer(the, name, the->nameBuffer, sizeof(the->nameBuffer));
        mxReferenceError("module \"%s\" not found", the->nameBuffer);
      }
    }
    else {
      if (name->kind == XS_STRING_X_KIND)
        moduleID = fxNewNameX(the, name->value.string);
      else
        moduleID = fxNewName(the, name);
    }
  }
  else {
    txSlot* resolveHook = mxResolveHook(realm);
    while (mxIsUndefined(resolveHook)) {
      txSlot* parent = mxRealmParent(realm);
      if (mxIsReference(parent)) {
        realm = parent->value.reference;
        resolveHook = mxResolveHook(realm);
      }
      else
        break;
    }
    if (mxIsUndefined(resolveHook)) {
      mxCheck(the, realm == mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm);
      moduleID = fxFindModule(the, realm, moduleID, name);
      if (moduleID == XS_NO_ID) {
        fxToStringBuffer(the, name, the->nameBuffer, sizeof(the->nameBuffer));
        mxReferenceError("module \"%s\" not found", the->nameBuffer);
      }
    }
    else {
      mxPushUndefined();
      mxPushSlot(resolveHook);
      mxCall();
      mxPushSlot(name);
      fxPushKeyString(the, moduleID, C_NULL);
      mxRunCount(2);
      moduleID = fxToID(the, the->stack);
      mxPop();
    }
  }
  name->kind = XS_SYMBOL_KIND;
  name->value.symbol = moduleID;
  return moduleID;
}

void fxImport(txMachine* the)
{
  txSlot* realm = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
  fxToString(the, the->stack);
  mxPushUndefined();
  fxRunImport(the, realm, C_NULL);
}


void fxRunImport(txMachine* the, txSlot* realm, txSlot* referrer)
{
  txSlot* stack = the->stack + 1;
  txSlot* promise;
  txSlot* fulfillFunction;
  txSlot* rejectFunction;
  txSlot* module;
  txID status;
  txSlot* slot;
  
  fxBeginHost(the);
  mxPush(mxPromisePrototype);
  promise = fxNewPromiseInstance(the);
  mxPromiseStatus(promise)->value.integer = mxPendingStatus;
  fxPushPromiseFunctions(the, promise);
  fulfillFunction = the->stack + 1;
  rejectFunction = the->stack;
  {
    mxTry(the) {
      module = fxRunImportAux(the, realm, referrer, stack, stack - 1, 0);
      status = mxModuleStatus(module);
      if (status == XS_MODULE_STATUS_ERROR) {
        /* THIS */
        mxPushUndefined();
        /* FUNCTION */
        mxPushSlot(rejectFunction);
        mxCall();
        /* ARGUMENTS */
        mxPushSlot(mxModuleMeta(module));
        mxRunCount(1);
      }
      else if (status == XS_MODULE_STATUS_EXECUTED) {
        /* THIS */
        mxPushUndefined();
        /* FUNCTION */
        mxPushSlot(fulfillFunction);
        mxCall();
        /* ARGUMENTS */
        mxPushSlot(module);
        mxRunCount(1);
      }
      else {
        txSlot* queue = mxModuleQueue.value.reference;
        slot = fxLastProperty(the, module->value.reference);
        slot = fxNextSlotProperty(the, slot, fulfillFunction, XS_NO_ID, XS_NO_FLAG);
        slot = fxNextSlotProperty(the, slot, rejectFunction, XS_NO_ID, XS_NO_FLAG);
//        if ((status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADED)) {
//          txSlot* queue = fxNewInstance(the);
          if (fxQueueModule(the, queue, module))
            fxLoadModules(the, queue);
//        }
      }
    }
    mxCatch(the) {
      fxRejectException(the, rejectFunction);
    }
  }
  fxEndHost(the);
  stack->value.reference = promise;
  stack->kind = XS_REFERENCE_KIND;
  the->stack = stack;
}

txSlot* fxRunImportAux(txMachine* the, txSlot* realm, txSlot* referrer, txSlot* specifier, txSlot* options, txBoolean now)
{
  txSlot* module;
  txID moduleID;
  txFlag moduleFlag = fxCheckModuleOptions(the, options);
#if mxModuleStuff
  if (mxIsReference(specifier)) {
    txSlot* internal = specifier->value.reference->next;
    if (internal && (internal->kind == XS_MODULE_STUFF_KIND)) {
      module = mxModuleStuffModule(specifier);
      if (mxIsNull(module)) {
        txSlot* source = mxModuleStuffSource(specifier);
        fxNewModule(the, realm, XS_NO_ID, XS_NO_FLAG, module);
        if (mxIsModuleSource(source->value.reference))
          fxDuplicateModuleTransfers(the, source, module);
        else
          fxLoadVirtualModuleSource(the, source, module->value.reference);
        internal = mxModuleHook(module);
        internal->kind = specifier->kind;
        internal->value = specifier->value;
        mxModuleStatus(module) = XS_MODULE_STATUS_LOADED;
      }
      return module;
    }
  }
#endif
  fxToString(the, specifier);
  if (referrer) {
#if mxModuleStuff
    if (referrer->next->kind == XS_MODULE_KIND) {
      txSlot* reference = mxModuleInstanceHook(referrer);
      if (mxIsReference(reference)) {
        txSlot* handler = mxModuleStuffHandler(reference);
        txSlot* importHook = (now) ? mxModuleStuffImportNowHook(reference) : mxModuleStuffImportHook(reference);
        if (mxIsReference(handler) && mxIsReference(importHook)) {
          module = fxImportModuleStuff(the, realm, mxModuleQueue.value.reference, reference, specifier, now);
          return module;
        }
      }
    }
#endif
    moduleID = fxResolveSpecifier(the, realm, mxModuleInstanceInternal(referrer)->value.module.id, specifier);
  }
  else
    moduleID = fxResolveSpecifier(the, realm, XS_NO_ID, specifier);
  module = fxGetModule(the, realm, moduleID, moduleFlag);
  if (!module) {
    module = mxBehaviorSetProperty(the, mxOwnModules(realm)->value.reference, moduleID, 0, XS_OWN);
    fxNewModule(the, realm, moduleID, moduleFlag, module);
  }
  return module;
}

void fxRunImportFulfilled(txMachine* the, txSlot* module, txSlot* with)
{
  if (mxModuleInstanceMeta(module)->next) {
    txSlot* stack = the->stack;
    txSlot* slot = mxModuleInstanceFulfill(module);
    while (slot) {
      mxPushSlot(slot);
      slot = slot->next;
      slot = slot->next;
    }
    mxModuleInstanceMeta(module)->next = C_NULL;
    slot = stack;
    while (slot > the->stack) {
      slot--;
      /* THIS */
      mxPushUndefined();
      /* FUNCTION */
      mxPushSlot(slot);
      mxCall();
      /* ARGUMENTS */
      mxPushReference(with);
      mxRunCount(1);
      mxPop();
    }
    the->stack = stack;
  }
}

void fxRunImportRejected(txMachine* the, txSlot* module, txSlot* with)
{
  if (mxModuleInstanceMeta(module)->next) {
    txSlot* stack = the->stack;
    txSlot* slot = mxModuleInstanceFulfill(module);
    txSlot* exception;
    while (slot) {
      slot = slot->next;
      mxPushSlot(slot);
      slot = slot->next;
    }
    mxModuleInstanceMeta(module)->next = C_NULL;
    exception = mxModuleInstanceMeta(with);
    slot = stack;
    while (slot > the->stack) {
      slot--;
      /* THIS */
      mxPushUndefined();
      /* FUNCTION */
      mxPushSlot(slot);
      mxCall();
      /* ARGUMENTS */
      mxPushSlot(exception);
      mxRunCount(1);
      mxPop();
    }
    the->stack = stack;
  }
}

/* META */

void fxRunImportMeta(txMachine* the, txSlot* module)
{
  txSlot* meta = mxModuleInstanceMeta(module);
  if (mxIsNull(meta)) {
    fxNewInstance(the);
    mxPullSlot(meta);
#if mxModuleStuff
    {
      txSlot* reference = mxModuleInstanceHook(module);
      if (mxIsReference(reference)) {
        txSlot* handler = mxModuleStuffHandler(reference);
        txSlot* importMetaHook = mxModuleStuffImportMetaHook(reference);
        if (mxIsReference(handler) && mxIsReference(importMetaHook)) {
          fxBeginHost(the);
          mxPushSlot(handler);
          mxPushSlot(importMetaHook);
          mxCall();
          mxPushSlot(meta);
          mxRunCount(1);
          mxPop();
          fxEndHost(the);
        }
      }
    }
#endif
    meta->value.reference->flag |= XS_DONT_PATCH_FLAG;
  }
  mxPushSlot(meta);
}

/* NOW */

void fxAwaitImport(txMachine* the, txBoolean defaultFlag)
{
  txSlot* stack = the->stack;
  txSlot* realm = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
  txID defaultID;
  txSlot* export;
  mxTry(the) {
    fxToString(the, stack);
    if (defaultFlag & XS_IMPORT_PREFLIGHT) {
      txID moduleID = fxFindModule(the, realm, XS_NO_ID, stack);
      stack->kind = XS_BOOLEAN_KIND;
      stack->value.boolean = moduleID != XS_NO_ID;
    }
    else {
      mxPushUndefined();
      if (defaultFlag & XS_IMPORT_ASYNC) {
        gxDefaults.runImport(the, realm, C_NULL);
      }
      else {
        fxRunImportNow(the, realm, C_NULL);
        if (defaultFlag & XS_IMPORT_DEFAULT) {
          defaultID = mxID(_default);
          export = mxModuleExports(stack)->value.reference->next;
          while (export) {
            mxCheck(the, export->kind == XS_EXPORT_KIND);
            if (export->ID == defaultID) {
              stack->kind = export->value.export.closure->kind;
              stack->value = export->value.export.closure->value;
              break;
            }
            export = export->next;
          }
        }
      }
    }
  }
  mxCatch(the) {
    fxJump(the);
  }
  the->stack = stack;
}

void fxImportNow(txMachine* the)
{
  txSlot* realm = mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm;
  fxToString(the, the->stack);
  mxPushUndefined();
  fxRunImportNow(the, realm, C_NULL);
}

void fxRunImportNow(txMachine* the, txSlot* realm, txSlot* referrer)
{
  txSlot* stack = the->stack + 1;
  txSlot* module = fxRunImportAux(the, realm, referrer, stack, stack - 1, 1);
  txID status = mxModuleStatus(module);
  if ((status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADED)) {
    txSlot* result = stack;
    txSlot* queue = fxNewInstance(the);
    mxTry(the) {
      txBoolean done = 1;
      result->kind = module->kind;
      result->value = module->value;

      fxQueueModule(the, queue, module);
//      slot = mxBehaviorSetProperty(the, queue, moduleID, 0, XS_OWN);;
//      slot->flag |= XS_BASE_FLAG;
//      slot->kind = XS_REFERENCE_KIND;
//      slot->value.reference = module->value.reference;
    
      mxReportModuleQueue("LOAD");
      module = queue->next;
      while (module) {
        if (mxModuleStatus(module) == XS_MODULE_STATUS_NEW) {
          txSlot* loader = mxModuleLoader(module);
          txID moduleID = loader->value.module.id;
          txSlot* realm = loader->value.module.realm;
          if (!fxMapModule(the, realm, moduleID, module, queue, result)) {
            txSlot* loadNowHook = mxLoadNowHook(realm);
            if (mxIsUndefined(loadNowHook)) {
              if (realm != mxModuleInstanceInternal(mxProgram.value.reference)->value.module.realm)
                mxTypeError("no loadNowHook");
              fxLoadModule(the, module, moduleID);
              if (mxModuleExecute(module)->kind == XS_NULL_KIND)
                mxTypeError("no module");
              mxModuleStatus(module) = XS_MODULE_STATUS_LOADED;
            }
            else {
              txSlot* descriptor;
              done = 0;
              mxModuleStatus(module) = XS_MODULE_STATUS_LOADING;
              mxPushUndefined();
              mxPushSlot(loadNowHook);
              mxCall();
              fxPushKeyString(the, moduleID, C_NULL);
              fxPushModuleOptions(the, loader->flag);
              mxRunCount(2);
              descriptor = the->stack;
              fxMapModuleDescriptor(the, realm, moduleID, module, queue, result, descriptor);
              mxPop(); // descriptor
            }
          }
          module = queue;
          done = 1;
          mxReportModuleQueue("LOAD");
        }
        else if (mxModuleStatus(module) == XS_MODULE_STATUS_LOADING) {
          done = 0;
        }
        else if (mxModuleStatus(module) == XS_MODULE_STATUS_LOADED) {
        #if mxModuleStuff
          if (!fxLoadModuleStuffFrom(the, queue, module->value.reference, 1))
        #endif
            fxLoadModulesFrom(the, queue, module->value.reference, 1);
          mxModuleStatus(module) = XS_MODULE_STATUS_LINKING;
          module = queue;
          done = 1;
        }
        module = module->next;
      }
      if (!done)
        mxTypeError("async queue");
      fxLinkModules(the, queue);
      mxReportModuleQueue("INIT");
      module = queue->next;
      while (module) {
        if (mxModuleStatus(module) == XS_MODULE_STATUS_LINKED) {
          mxModuleStatus(module) = XS_MODULE_STATUS_EXECUTING;
          if (mxModuleExecute(module)->value.reference->value.instance.prototype == mxAsyncFunctionPrototype.value.reference)
            mxTypeError("async module");
          mxPushSlot(mxModuleHosts(module));
          mxPull(mxHosts);
          mxPushUndefined();
          mxPushSlot(mxModuleExecute(module));
          mxCall();
          mxRunCount(0);
          mxPop();
          fxCompleteModule(the, module->value.reference, C_NULL);
          mxModuleMeta(module)->next = C_NULL;
          mxPushUndefined();
          mxPull(mxHosts);
          mxReportModuleQueue("INIT");
        }
        module = module->next;
      }
      mxPop();
    }
    mxCatch(the) {
      module = queue->next;
      while (module) {
        if (mxModuleStatus(module) < XS_MODULE_STATUS_EXECUTED) {
          fxCompleteModule(the, module->value.reference, &mxException);
          mxModuleMeta(module)->next = C_NULL;
        }
        module = module->next;
      }
      mxPushUndefined();
      mxPull(mxHosts);
      fxJump(the);
    }
  }
  else if (status == XS_MODULE_STATUS_EXECUTED) {
    stack->kind = module->kind;
    stack->value = module->value;
  }
  else if (status == XS_MODULE_STATUS_ERROR) {
    mxPushSlot(mxModuleMeta(module));
    mxPull(mxException);
    fxJump(the);
  }
  else {
    mxTypeError("async module");
  }
  the->stack = stack;
}

/* BEHAVIOR */

void fxModuleGetter(txMachine* the) {
  mxReferenceError("not initialized yet");
}

txBoolean fxModuleDefineOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot, txFlag mask)
{
  txSlot* property = fxModuleFindProperty(the, instance, id, index);
  if (property) {
    if ((mask & XS_DONT_DELETE_FLAG) && !(slot->flag & XS_DONT_DELETE_FLAG))
      return 0;
    if ((mask & XS_DONT_ENUM_FLAG) && ((property->flag & XS_DONT_ENUM_FLAG) != (slot->flag & XS_DONT_ENUM_FLAG)))
      return 0;
    if (mask & XS_ACCESSOR_FLAG) {
      if (property->kind != XS_ACCESSOR_KIND)
        return 0;
      if (mask & XS_GETTER_FLAG) {
        if (property->value.accessor.getter != slot->value.accessor.getter)
          return 0;
      }
      if (mask & XS_SETTER_FLAG) {
        if (property->value.accessor.setter != slot->value.accessor.setter)
          return 0;
      }
      return 1;
    }
    if ((mask & XS_DONT_SET_FLAG) && ((property->flag & XS_DONT_SET_FLAG) != (slot->flag & XS_DONT_SET_FLAG)))
      return 0;
    if (property->kind == XS_ACCESSOR_KIND)
      return 0;
    if ((slot->kind != XS_UNINITIALIZED_KIND) && !fxIsSameValue(the, property, slot, 0))
      return 0;
    return 1;
  }
  return 0;
}

txBoolean fxModuleDeleteProperty(txMachine* the, txSlot* instance, txID id, txIndex index)
{
  if (id == XS_NO_ID)
    return 1;
  if (fxIsKeySymbol(the, id)) {
    return (id == mxID(_Symbol_toStringTag)) ? 0 : 1;
  }
//  if (mxModuleInstanceStatus(instance) < XS_MODULE_STATUS_LINKED) {
//    mxReferenceError("module not initialized yet");
//  }
//  else
  {
    txSlot* exports = mxModuleInstanceExports(instance);
    if (mxIsReference(exports)) {
      txSlot* property = exports->value.reference->next;
      while (property) {
        if (property->ID == id)
          return 0;
        property = property->next;
      }
    }
  }
  return 1;
}

txSlot* fxModuleFindProperty(txMachine* the, txSlot* instance, txID id, txIndex index)
{
  if (id == XS_NO_ID)
    return C_NULL;
  if (fxIsKeySymbol(the, id)) {
    if (id == mxID(_Symbol_toStringTag))
      return mxModulePrototype.value.reference->next;
  }
//  if (mxModuleInstanceStatus(instance) < XS_MODULE_STATUS_LINKED) {
//    mxReferenceError("module not initialized yet");
//  }
//  else
  {
    txSlot* exports = mxModuleInstanceExports(instance);
    if (mxIsReference(exports)) {
      txSlot* property = exports->value.reference->next;
      while (property) {
        if (property->ID == id) {
          property = property->value.export.closure;
          if (property && (property->kind == XS_UNINITIALIZED_KIND)) {
            fxIDToString(the, id, the->nameBuffer, sizeof(the->nameBuffer));
            mxReferenceError("get %s: not initialized yet", the->nameBuffer);
          }
          return property;
        }
        property = property->next;
      }
    }
  }
  return C_NULL;
}

txBoolean fxModuleGetOwnProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* slot)
{
  txSlot* property = fxModuleFindProperty(the, instance, id, index);
  if (property) {
    slot->flag = (id == mxID(_Symbol_toStringTag)) ? property->flag : XS_DONT_DELETE_FLAG;
    slot->kind = property->kind;
    slot->value = property->value;
    return 1;
  }
  slot->flag = XS_NO_FLAG;
  slot->kind = XS_UNDEFINED_KIND;
  return 0;
}

txSlot* fxModuleGetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
{
  if (id == XS_NO_ID)
    return C_NULL;
  if (fxIsKeySymbol(the, id)) {
    if (id == mxID(_Symbol_toStringTag))
      return mxModulePrototype.value.reference->next;
  }
//  if (mxModuleInstanceStatus(instance) < XS_MODULE_STATUS_LINKED) {
//    return &mxModuleAccessor;
//  }
//  else
  {
    txSlot* exports = mxModuleInstanceExports(instance);
    if (mxIsReference(exports)) {
      txSlot* property = exports->value.reference->next;
      while (property) {
        if (property->ID == id) {
          property = property->value.export.closure;
          if (property && (property->kind == XS_UNINITIALIZED_KIND)) {
            return &mxModuleAccessor;
          }
          return property;
        }
        property = property->next;
      }
    }
  }
  return C_NULL;
}

txBoolean fxModuleGetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* receiver, txSlot* value)
{
  txSlot* property = fxModuleFindProperty(the, instance, id, index);
  if (property) {
    value->kind = property->kind;
    value->value = property->value;
    return 1;
  }
  value->kind = XS_UNDEFINED_KIND;
  return 0;
}

txBoolean fxModuleGetPrototype(txMachine* the, txSlot* instance, txSlot* result)
{
  result->kind = XS_NULL_KIND;
  return 0;
}

txBoolean fxModuleHasProperty(txMachine* the, txSlot* instance, txID id, txIndex index) 
{
  if (id == XS_NO_ID)
    return 0;
  if (fxIsKeySymbol(the, id)) {
    return (id == mxID(_Symbol_toStringTag)) ? 1 : 0;
  }
//  if (mxModuleInstanceStatus(instance) < XS_MODULE_STATUS_LINKED) {
//    mxReferenceError("module not initialized yet");
//  }
//  else
  {
    txSlot* exports = mxModuleInstanceExports(instance);
    if (mxIsReference(exports)) {
      txSlot* property = exports->value.reference->next;
      while (property) {
        if (property->ID == id) {
          property = property->value.export.closure;
          return property ? 1 : 0;
        }
        property = property->next;
      }
    }
  }
  return 0;
}

txBoolean fxModuleIsExtensible(txMachine* the, txSlot* instance)
{
  return 0;
}

void fxModuleOwnKeys(txMachine* the, txSlot* instance, txFlag flag, txSlot* keys)
{
  if (flag & XS_EACH_NAME_FLAG) {
//    if (mxModuleInstanceStatus(instance) < XS_MODULE_STATUS_LINKED) {
//      mxReferenceError("module not initialized yet");
//    }
//    else
    {
      txSlot* exports = mxModuleInstanceExports(instance);
      if (mxIsReference(exports)) {
        txSlot* property = exports->value.reference->next;
        txSlot* stack = the->stack;
        while (property) {
          if (property->value.export.closure) {
            txSlot* key = fxGetKey(the, property->ID);
            mxPushSlot(key);
            the->stack->ID = key->ID;
          }
          property = property->next;
        }
        c_qsort(the->stack, stack - the->stack, sizeof(txSlot), fxModuleOwnKeysCompare);
        while (the->stack < stack) {
          keys = fxQueueKey(the, the->stack->ID, 0, keys);
          mxPop();
        } 
      }
    }
  }
  if (flag & XS_EACH_SYMBOL_FLAG) {
    txSlot* property = mxModulePrototype.value.reference->next;
    keys = fxQueueKey(the, property->ID, 0, keys);
  }
}

int fxModuleOwnKeysCompare(const void* p, const void* q)
{
  return c_strcmp(((txSlot*)p)->value.key.string, ((txSlot*)q)->value.key.string);
}

txBoolean fxModulePreventExtensions(txMachine* the, txSlot* instance)
{
  return 1;
}

txSlot* fxModuleSetProperty(txMachine* the, txSlot* instance, txID id, txIndex index, txFlag flag)
{
  return C_NULL;
}

txBoolean fxModuleSetPropertyValue(txMachine* the, txSlot* instance, txID id, txIndex index, txSlot* value, txSlot* receiver)
{
  return 0;
}

txBoolean fxModuleSetPrototype(txMachine* the, txSlot* instance, txSlot* prototype)
{
  return (prototype->kind == XS_NULL_KIND) ? 1 : 0;
}

/* COMPARTMENT */

txSlot* fxCheckCompartmentInstance(txMachine* the, txSlot* slot)
{
  if (slot->kind == XS_REFERENCE_KIND) {
    txSlot* instance = slot->value.reference;
    if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_PROGRAM_KIND)) {
      return instance;
    }
  }
  mxTypeError("this: not a Compartment instance");
  return C_NULL;
}

void fxPrepareCompartmentFunction(txMachine* the, txSlot* program, txSlot* instance)
{
  txSlot* property = mxFunctionInstanceHome(instance);
  property->value.home.module = program;
  if (mxCompartmentGlobal.kind != XS_UNDEFINED_KIND) {
    instance->flag |= XS_DONT_PATCH_FLAG;
    property = property->next;
    while (property) {
      if (!(property->flag & XS_INTERNAL_FLAG))
        property->flag |= XS_DONT_DELETE_FLAG | XS_DONT_SET_FLAG;
      property = property->next;
    }
  }
}

void fx_Compartment(txMachine* the)
{
  txSlot* module = mxFunctionInstanceHome(mxFunction->value.reference)->value.home.module;
  txSlot* program = C_NULL;
  txSlot* parent;
  txSlot* realm;
  txSlot* global = C_NULL;
  txSlot* closures = C_NULL;
  txSlot* slot;
  txSlot* target;
  txSlot* own;
  txInteger id;
  
  if (!module) module = mxProgram.value.reference;
  mxTry(the) {
    if (!mxHasTarget)
      mxTypeError("call: Compartment");
      
    mxPushSlot(mxTarget);
    fxGetPrototypeFromConstructor(the, &mxCompartmentPrototype);
    program = fxNewProgramInstance(the);
    mxPullSlot(mxResult);
    
    // PARENT
    parent = mxModuleInstanceInternal(module)->value.module.realm;
    mxPushReference(parent);
    
    // GLOBALS
    if (the->sharedMachine == C_NULL) {
      txSlot* instance;
      txSlot* property;
      txSlot* callback;
      mxPush(mxObjectPrototype);
  #ifdef mxLink
      global = fxNewObjectInstance(the);
  #else
      global = fxNewGlobalInstance(the);
  #endif
      slot = fxLastProperty(the, global);
      if (mxCompartmentGlobal.kind == XS_UNDEFINED_KIND) {
        for (id = XS_SYMBOL_ID_COUNT; id < _Infinity; id++)
          slot = fxNextSlotProperty(the, slot, &the->stackIntrinsics[-1 - id], mxID(id), XS_DONT_ENUM_FLAG);
        for (; id < _Compartment; id++)
          slot = fxNextSlotProperty(the, slot, &the->stackIntrinsics[-1 - id], mxID(id), XS_GET_ONLY);
      }
      else {
        txSlot* item = mxCompartmentGlobal.value.reference->next;
        for (id = XS_SYMBOL_ID_COUNT; id < _Infinity; id++) {
          mxPushSlot(item->value.array.address + id);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(id), XS_DONT_ENUM_FLAG);
          mxPop();
        }
        for (; id < _Compartment; id++) {
          mxPushSlot(item->value.array.address + id);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(id), XS_GET_ONLY);
          mxPop();
        }
      }
      
      callback = mxFunctionInstanceCode(mxCompartmentConstructor.value.reference);
      instance = fxBuildHostFunction(the, callback->value.callback.address, 1, mxID(_Compartment));
      instance->flag |= XS_CAN_CONSTRUCT_FLAG;
      property = fxLastProperty(the, instance);
      fxNextSlotProperty(the, property, &mxCompartmentPrototype, mxID(_prototype), XS_GET_ONLY);
      fxPrepareCompartmentFunction(the, program, instance);
      slot = fxNextSlotProperty(the, slot, the->stack, mxID(_Compartment), XS_DONT_ENUM_FLAG);
      mxPop();
      
      callback = mxFunctionInstanceCode(mxFunctionConstructor.value.reference);
      instance = fxBuildHostFunction(the, callback->value.callback.address, 1, mxID(_Function));
      instance->flag |= XS_CAN_CONSTRUCT_FLAG;
      property = fxLastProperty(the, instance);
      fxNextSlotProperty(the, property, &mxFunctionPrototype, mxID(_prototype), XS_GET_ONLY);
      fxPrepareCompartmentFunction(the, program, instance);
      slot = fxNextSlotProperty(the, slot, the->stack, mxID(_Function), XS_DONT_ENUM_FLAG);
      mxPop();
      
    #if mxModuleStuff   
      callback = mxFunctionInstanceCode(mxModuleStuffConstructor.value.reference);
      instance = fxBuildHostFunction(the, callback->value.callback.address, 1, mxID(_ModuleStuff));
      instance->flag |= XS_CAN_CONSTRUCT_FLAG;
      property = fxLastProperty(the, instance);
      fxNextSlotProperty(the, property, &mxModuleStuffPrototype, mxID(_prototype), XS_GET_ONLY);
      fxPrepareCompartmentFunction(the, program, instance);
      slot = fxNextSlotProperty(the, slot, the->stack, mxID(_ModuleStuff), XS_DONT_ENUM_FLAG);
      mxPop();
    #endif
      
      callback = mxFunctionInstanceCode(mxEvalFunction.value.reference);
      instance = fxBuildHostFunction(the, callback->value.callback.address, 1, mxID(_eval));
      fxPrepareCompartmentFunction(the, program, instance);
      slot = fxNextSlotProperty(the, slot, the->stack, mxID(_eval), XS_DONT_ENUM_FLAG);
      mxPop();
    }
    else {
      mxPush(mxCompartmentGlobal);
      global = fxNewObjectInstance(the);
      slot = fxLastProperty(the, global);
      id = _Compartment;
      for (; id < XS_INTRINSICS_COUNT; id++) {
        txSlot* instance = fxDuplicateInstance(the, the->stackIntrinsics[-1 - id].value.reference);
        mxFunctionInstanceHome(instance)->value.home.module = program;
        slot = fxNextSlotProperty(the, slot, the->stack, mxID(id), XS_DONT_ENUM_FLAG);
        mxPop();
      }
    }
    slot = fxNextSlotProperty(the, slot, the->stack, mxID(_global), XS_DONT_ENUM_FLAG);
    slot = fxNextSlotProperty(the, slot, the->stack, mxID(_globalThis), XS_DONT_ENUM_FLAG);
    
    if (mxArgc > 0) {
      if (!mxIsReference(mxArgv(0)))
        mxTypeError("options: not an object");
    
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "globals"))) {
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "globals"));
        slot = the->stack;
        if (!mxIsReference(slot))
          mxTypeError("options.globals: not an object");
        mxPushUndefined();
        mxPush(mxAssignObjectFunction);
        mxCall();
        mxPushReference(global);
        mxPushSlot(slot);
        mxRunCount(2);
        mxPop();
        mxPop(); // globals
      }
      
      target = fxNewInstance(the);
      own = fxNewInstance(the);
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "modules"))) {
        txSlot* source;
        txSlot* at;
        txSlot* temporary;
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "modules"));
        if (!mxIsReference(the->stack))
          mxTypeError("options.modules: not an object");
        source = the->stack->value.reference;
        at = fxNewInstance(the);
        mxBehaviorOwnKeys(the, source, XS_EACH_NAME_FLAG, at);
        mxTemporary(temporary);
        while ((at = at->next)) {
          if (mxBehaviorGetOwnProperty(the, source, at->value.at.id, at->value.at.index, temporary) && !(temporary->flag & XS_DONT_ENUM_FLAG)) {
            txSlot* descriptor;
            txSlot* property;
            mxPushReference(source);
            mxGetAll(at->value.at.id, at->value.at.index);
            descriptor = the->stack;
            property = mxBehaviorSetProperty(the, target, at->value.at.id, at->value.at.index, XS_OWN);
            property->kind = descriptor->kind;
            property->value = descriptor->value;
            mxPop(); // descriptor
          }
        }
        mxPop(); // temporary
        mxPop(); // at
        mxPop(); // modules
      }
      
      mxPushUndefined();
      closures = fxNewEnvironmentInstance(the, C_NULL);
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "globalLexicals"))) {
        txSlot* target = fxLastProperty(the, closures);
        txSlot* source;
        txSlot* at;
        txSlot* property;
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "globalLexicals"));
        if (!mxIsReference(the->stack))
          mxTypeError("options.globalLexicals: not an object");
        source = the->stack->value.reference;
        at = fxNewInstance(the);
        mxBehaviorOwnKeys(the, source, XS_EACH_NAME_FLAG, at);
        mxTemporary(property);
        while ((at = at->next)) {
          if ((at->value.at.id != XS_NO_ID) && mxBehaviorGetOwnProperty(the, source, at->value.at.id, at->value.at.index, property) && !(property->flag & XS_DONT_ENUM_FLAG)) {
            mxPushReference(source);
            mxGetAll(at->value.at.id, at->value.at.index);
            target = target->next = fxNewSlot(the);
            target->value.closure = fxNewSlot(the);;
            target->kind = XS_CLOSURE_KIND;
            target->ID = at->value.at.id;
            if (property->kind == XS_ACCESSOR_KIND)
              target->value.closure->flag = property->value.accessor.setter ? XS_NO_FLAG : XS_DONT_SET_FLAG;
            else
              target->value.closure->flag = property->flag & XS_DONT_SET_FLAG;
            target->value.closure->kind = the->stack->kind;
            target->value.closure->value = the->stack->value;
            mxPop();
          }
        }
        mxPop(); // property
        mxPop(); // at
        mxPop(); // globalLexicals
      }
  
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "resolveHook"))) {
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "resolveHook"));
        if (!fxIsCallable(the, the->stack))
          mxTypeError("options.resolveHook: not a function");
      }
      else
        mxPushUndefined();
      
      mxPushUndefined(); // moduleMapHook;
      
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "importHook"))) {
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "importHook"));
        if (!fxIsCallable(the, the->stack))
          mxTypeError("options.importHook: not a function");
      }
      else {
        mxPushSlot(mxArgv(0));
        if (mxHasID(fxID(the, "loadHook"))) {
          mxPushSlot(mxArgv(0));
          mxGetID(fxID(the, "loadHook"));
          if (!fxIsCallable(the, the->stack))
            mxTypeError("options.loadHook: not a function");
        }
        else
          mxPushUndefined();
      }
        
      mxPushSlot(mxArgv(0));
      if (mxHasID(fxID(the, "importNowHook"))) {
        mxPushSlot(mxArgv(0));
        mxGetID(fxID(the, "importNowHook"));
        if (!fxIsCallable(the, the->stack))
          mxTypeError("options.importNowHook: not a function");
      }
      else {
        mxPushSlot(mxArgv(0));
        if (mxHasID(fxID(the, "loadNowHook"))) {
          mxPushSlot(mxArgv(0));
          mxGetID(fxID(the, "loadNowHook"));
          if (!fxIsCallable(the, the->stack))
            mxTypeError("options.loadNowHook: not a function");
        }
        else
          mxPushUndefined();
      }
      
      mxPushUndefined(); // importMetaHook;
    }
    else {
      target = fxNewInstance(the);
      own = fxNewInstance(the);
  
      mxPushUndefined();
      closures = fxNewEnvironmentInstance(the, C_NULL);

      mxPushUndefined();
      mxPushUndefined();
      mxPushUndefined();
      mxPushUndefined();
      mxPushUndefined();
    }
    
    realm = fxNewRealmInstance(the);
    mxModuleInstanceInternal(program)->value.module.realm = realm;
    
    slot = own->next;
    while (slot) {
      txSlot* internal = mxModuleInternal(slot);
      if (internal->value.module.realm == C_NULL) {
        if (!(internal->flag & XS_MARK_FLAG))
          internal->value.module.realm = realm;
      }
      slot = slot->next;
    }
    
    
    mxPop();
  }
  mxCatch(the) {
    fxJump(the);
  }
}

void fx_Compartment_prototype_get_globalThis(txMachine* the)
{
  txSlot* program = fxCheckCompartmentInstance(the, mxThis);
  txSlot* realm = mxModuleInstanceInternal(program)->value.module.realm;
  txSlot* global = mxRealmGlobal(realm);
  mxResult->kind = global->kind;
  mxResult->value = global->value;
}

void fx_Compartment_prototype_evaluate(txMachine* the)
{
  txSlot* program = fxCheckCompartmentInstance(the, mxThis);
  txSlot* realm = mxModuleInstanceInternal(program)->value.module.realm;
  if (mxArgc > 0) {
    txStringStream stream;
    stream.slot = mxArgv(0);
    stream.offset = 0;
    stream.size = mxStringLength(fxToString(the, mxArgv(0)));
    fxRunScript(the, fxParseScript(the, &stream, fxStringGetter, mxStrictFlag | mxProgramFlag | mxDebugFlag), mxRealmGlobal(realm), C_NULL, mxRealmClosures(realm)->value.reference, C_NULL, program);
    mxPullSlot(mxResult);
  }
}

void fx_Compartment_prototype_import(txMachine* the)
{
  txSlot* program = fxCheckCompartmentInstance(the, mxThis);
  txSlot* realm = mxModuleInstanceInternal(program)->value.module.realm;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  if (mxArgc > 1)
    mxPushSlot(mxArgv(1));
  else
    mxPushUndefined();
  gxDefaults.runImport(the, realm, C_NULL);
  mxPullSlot(mxResult);
}

void fx_Compartment_prototype_importNow(txMachine* the)
{
  txSlot* program = fxCheckCompartmentInstance(the, mxThis);
  txSlot* realm = mxModuleInstanceInternal(program)->value.module.realm;
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else
    mxPushUndefined();
  if (mxArgc > 1)
    mxPushSlot(mxArgv(1));
  else
    mxPushUndefined();
  fxRunImportNow(the, realm, C_NULL);
  mxPullSlot(mxResult);
}

txSlot* fxCheckModuleSourceInstance(txMachine* the, txSlot* slot)
{
  if (slot->kind == XS_REFERENCE_KIND) {
    txSlot* instance = slot->value.reference;
    if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_MODULE_SOURCE_KIND)) {
      return instance;
    }
  }
  mxTypeError("this: not a ModuleSource instance");
  return C_NULL;
}

txSlot* fxNewModuleSourceInstance(txMachine* the)
{
  txSlot* instance;
  txSlot* slot;
  instance = fxNewSlot(the);
  instance->kind = XS_INSTANCE_KIND;
  instance->value.instance.garbage = C_NULL;
  instance->value.instance.prototype = the->stack->value.reference;
  the->stack->kind = XS_REFERENCE_KIND;
  the->stack->value.reference = instance;
  /* HOST */
  slot = instance->next = fxNewSlot(the);
  slot->flag = XS_INTERNAL_FLAG;
  slot->kind = XS_MODULE_SOURCE_KIND;
  slot->value.module.realm = C_NULL;
  slot->value.module.id = XS_NO_ID;
  /* EXPORTS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* STUFF */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* META */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* TRANSFERS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* INITIALIZE */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* FUNCTION */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* HOSTS */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* LOADER */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  return instance;
}

void fxExecuteVirtualModuleSourceImport(txMachine* the)
{
  txSlot* instance = mxFunction->value.reference;
  txSlot* home = mxFunctionInstanceHome(instance);
  txSlot* module = home->value.home.module;
  txSlot* internal = mxModuleInstanceInternal(module);
  mxPushSlot(mxArgv(0));
  gxDefaults.runImport(the, internal->value.module.realm, module);
  mxPullSlot(mxResult);
}

void fx_ModuleSource(txMachine* the)
{
  txSlot* instance;
  txUnsigned flags = mxDebugFlag;
  txSlot* slot;
  txStringStream stream;
  txScript* script;
  if (!mxHasTarget)
    mxTypeError("call: ModuleSource");
  mxPushSlot(mxTarget);
  fxGetPrototypeFromConstructor(the, &mxModuleSourcePrototype);
  instance = fxNewModuleSourceInstance(the);
  mxPullSlot(mxResult);
  if (mxArgc > 0)
    mxPushSlot(mxArgv(0));
  else    
    mxPushUndefined();
  if (mxArgc > 1) {
    if (fxCheckModuleOptions(the, mxArgv(1))) {
      instance->next->flag |= XS_JSON_MODULE_FLAG;
      flags |= mxJSONModuleFlag;
    }
  }
  slot = the->stack;
  stream.slot = slot;
  stream.offset = 0;
  stream.size = mxStringLength(fxToString(the, slot));
  script = fxParseScript(the, &stream, fxStringGetter, flags);
//    mxPushClosure(mxResult);
  fxRunScript(the, script, mxResult, C_NULL, C_NULL, C_NULL, instance);
  mxPop();
  if (mxModuleInstanceExecute(instance)->kind == XS_NULL_KIND)
    mxTypeError("no module");
  mxPop();
  mxPop();
}

void fx_ModuleSource_prototype_get_bindings(txMachine* the)
{
  txSlot* record = fxCheckModuleSourceInstance(the, mxThis);
  txSlot* resultInstance;
  txSlot* resultArray;
  txSlot* resultItem;
  txSlot* transfer;

  mxPush(mxArrayPrototype);
  resultInstance = fxNewArrayInstance(the);
  mxPullSlot(mxResult);
  resultArray = resultInstance->next;
  resultItem = resultArray;
  
  transfer = mxModuleInstanceTransfers(record)->value.reference->next;
  while (transfer) {
    txSlot* local = mxTransferLocal(transfer);
    txSlot* from = mxTransferFrom(transfer);
    txSlot* import = mxTransferImport(transfer);
    txSlot* aliases = mxTransferAliases(transfer);
    
    if (local->kind != XS_NULL_KIND) {
      if (from->kind != XS_NULL_KIND) {
        txSlot* slot = fxNewObject(the);
        if (import->kind == XS_NULL_KIND) {
          mxPushString(from->value.string);
          slot = fxNextSlotProperty(the, slot, the->stack, fxID(the, "importAllFrom"), XS_NO_FLAG);
          mxPop();
          fxPushKeyString(the, local->value.symbol, C_NULL);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(_as), XS_NO_FLAG);
          mxPop();
        }
        else {
          fxPushKeyString(the, import->value.symbol, C_NULL);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(_import), XS_NO_FLAG);
          mxPop();
          if (local->value.symbol != import->value.symbol) {
            fxPushKeyString(the, local->value.symbol, C_NULL);
            slot = fxNextSlotProperty(the, slot, the->stack, mxID(_as), XS_NO_FLAG);
            mxPop();
          }
          mxPushString(from->value.string);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(_from), XS_NO_FLAG);
          mxPop();
        }
        resultItem = resultItem->next = fxNewSlot(the);
        mxPullSlot(resultItem);
        resultArray->value.array.length++;
      }
      if (aliases->kind == XS_REFERENCE_KIND) {
        txSlot* alias = aliases->value.reference->next;
        while (alias) {
          txSlot* slot = fxNewObject(the);
          fxPushKeyString(the, local->value.symbol, C_NULL);
          slot = fxNextSlotProperty(the, slot, the->stack, mxID(_export), XS_NO_FLAG);
          mxPop();
          if (local->value.symbol != alias->value.symbol) {
            fxPushKeyString(the, alias->value.symbol, C_NULL);
            slot = fxNextSlotProperty(the, slot, the->stack, mxID(_as), XS_NO_FLAG);
            mxPop();
          }
          resultItem = resultItem->next = fxNewSlot(the);
          mxPullSlot(resultItem);
          resultArray->value.array.length++;
          alias = alias->next;
        }
      }
    }
    else if (aliases->kind == XS_REFERENCE_KIND) {
      txSlot* alias = aliases->value.reference->next;
      if (alias) {
        while (alias) {
          txSlot* slot = fxNewObject(the);
          if (from->kind != XS_NULL_KIND) {
            if (import->kind == XS_NULL_KIND) {
              mxPushString(from->value.string);
              slot = fxNextSlotProperty(the, slot, the->stack, fxID(the, "exportAllFrom"), XS_NO_FLAG);
              mxPop();
              fxPushKeyString(the, alias->value.symbol, C_NULL);
              slot = fxNextSlotProperty(the, slot, the->stack, mxID(_as), XS_NO_FLAG);
              mxPop();
            }
            else {
              fxPushKeyString(the, import->value.symbol, C_NULL);
              slot = fxNextSlotProperty(the, slot, the->stack, mxID(_export), XS_NO_FLAG);
              mxPop();
              if (alias->value.symbol != import->value.symbol) {
                fxPushKeyString(the, alias->value.symbol, C_NULL);
                slot = fxNextSlotProperty(the, slot, the->stack, mxID(_as), XS_NO_FLAG);
                mxPop();
              }
              mxPushString(from->value.string);
              slot = fxNextSlotProperty(the, slot, the->stack, mxID(_from), XS_NO_FLAG);
              mxPop();
            }
            resultItem = resultItem->next = fxNewSlot(the);
            mxPullSlot(resultItem);
            resultArray->value.array.length++;
          }
          alias = alias->next;
        }
      }
      else {
        txSlot* slot = fxNewObject(the);
        mxPushString(from->value.string);
        slot = fxNextSlotProperty(the, slot, the->stack, fxID(the, "exportAllFrom"), XS_NO_FLAG);
        mxPop();
        resultItem = resultItem->next = fxNewSlot(the);
        mxPullSlot(resultItem);
        resultArray->value.array.length++;
      }
    }
    else if ((from->kind != XS_NULL_KIND) && (import->kind == XS_NULL_KIND)) {
      txSlot* slot = fxNewObject(the);
      mxPushString(from->value.string);
      slot = fxNextSlotProperty(the, slot, the->stack, fxID(the, "importFrom"), XS_NO_FLAG);
      mxPop();
      resultItem = resultItem->next = fxNewSlot(the);
      mxPullSlot(resultItem);
      resultArray->value.array.length++;
    }
    transfer = transfer->next;
  }
  
  fxCacheArray(the, resultInstance);
}

void fx_ModuleSource_prototype_get_needsImport(txMachine* the)
{
  txSlot* record = fxCheckModuleSourceInstance(the, mxThis);
  txFlag flag = mxModuleInstanceInternal(record)->flag;
  mxResult->value.boolean = (flag & XS_IMPORT_FLAG) ? 1 : 0;
  mxResult->kind = XS_BOOLEAN_KIND;
}

void fx_ModuleSource_prototype_get_needsImportMeta(txMachine* the)
{
  txSlot* record = fxCheckModuleSourceInstance(the, mxThis);
  txFlag flag = mxModuleInstanceInternal(record)->flag;
  mxResult->value.boolean = (flag & XS_IMPORT_META_FLAG) ? 1 : 0;
  mxResult->kind = XS_BOOLEAN_KIND;
}

void fx_ModuleSource_prototype_get_options(txMachine* the)
{
  txSlot* record = fxCheckModuleSourceInstance(the, mxThis);
  txFlag flag = mxModuleInstanceInternal(record)->flag;
  fxPushModuleOptions(the, flag);
  mxPullSlot(mxResult);
}

#if mxModuleStuff

txSlot* fxCheckModuleStuffInstance(txMachine* the, txSlot* slot)
{
  if (slot->kind == XS_REFERENCE_KIND) {
    txSlot* instance = slot->value.reference;
    if (((slot = instance->next)) && (slot->flag & XS_INTERNAL_FLAG) && (slot->kind == XS_MODULE_STUFF_KIND)) {
      return instance;
    }
  }
  mxTypeError("this: not a ModuleStuff instance");
  return C_NULL;
}

txSlot* fxImportModuleStuff(txMachine* the, txSlot* realm, txSlot* queue, txSlot* reference, txSlot* name, txBoolean now)
{
  txID moduleID = (name->kind == XS_STRING_X_KIND) ? fxNewNameX(the, name->value.string) : fxNewName(the, name);
  txSlot* list = mxModuleStuffModules(reference)->value.reference;
  txSlot* module = mxBehaviorGetProperty(the, list, moduleID, 0, XS_ANY);
  if (!module) {
    txSlot* handler = mxModuleStuffHandler(reference);
    txSlot* importHook = (now) ? mxModuleStuffImportNowHook(reference) : mxModuleStuffImportHook(reference);
    txSlot* loader;
    
    module = mxBehaviorSetProperty(the, list, moduleID, 0, XS_OWN);
    fxNewModule(the, realm, XS_NO_ID, XS_NO_FLAG, module);
    mxModuleStatus(module) = XS_MODULE_STATUS_LOADING;
    fxQueueModule(the, queue, module);
    
    loader = mxModuleLoader(module);
    loader->kind = reference->kind;
    loader->value = reference->value;
  
    mxPushSlot(handler);
    mxPushSlot(importHook);
    mxCall();
    mxPushSlot(name);
    fxPushModuleOptions(the, name->flag);
    mxRunCount(2);
    
    if (now) {
      fxLoadModuleStuff(the, queue, module, the->stack);
    }
    else {
      fxLoadModulesPromise(the, queue, module, the->stack, fxLoadModuleStuffFulfilled, fxLoadModuleStuffRejected);
    }
    mxPop();
  }
  return module;
}

void fxLoadModuleStuff(txMachine* the, txSlot* queue, txSlot* module, txSlot* stuff)
{
  txSlot* instance = fxCheckModuleStuffInstance(the, stuff);
  txSlot* internal = mxModuleStuffInstanceModule(instance);
  if (mxIsReference(internal)) {
    txSlot* loader = mxModuleLoader(module);
    fxOverrideModule(the, queue, mxModuleStuffModules(loader), C_NULL, module->value.reference, internal->value.reference);
    loader->kind = XS_UNDEFINED_KIND;
  }
  else {
    txSlot* source = mxModuleStuffInstanceSource(instance);
    if (mxIsModuleSource(source->value.reference))
      fxDuplicateModuleTransfers(the, source, module);
    else
      fxLoadVirtualModuleSource(the, source, module->value.reference);
    internal->value.reference = module->value.reference;
    internal->kind = XS_REFERENCE_KIND;
    internal = mxModuleHook(module);
    internal->value.reference = instance;
    internal->kind = XS_REFERENCE_KIND;
    mxModuleStatus(module) = XS_MODULE_STATUS_LOADED;
  }
}

txBoolean fxLoadModuleStuffFrom(txMachine* the, txSlot* queue, txSlot* module, txBoolean now)
{
  txSlot* realm = mxModuleInstanceInternal(module)->value.module.realm;
  txSlot* reference = mxModuleInstanceHook(module);
  if (mxIsReference(reference)) {
    txSlot* handler = mxModuleStuffHandler(reference);
    txSlot* importHook = (now) ? mxModuleStuffImportNowHook(reference) : mxModuleStuffImportHook(reference);
    if (mxIsReference(handler) && mxIsReference(importHook)) {
      txSlot* transfer = mxModuleInstanceTransfers(module)->value.reference->next;
      while (transfer) {
        txSlot* from = mxTransferFrom(transfer);
        if (from->kind != XS_NULL_KIND) {
          txSlot* importModule = fxImportModuleStuff(the, realm, queue, reference, from, now);
          txID status = mxModuleStatus(importModule);
          from->value.reference = importModule->value.reference;
          from->kind = XS_REFERENCE_KIND;
          if ((status == XS_MODULE_STATUS_NEW) || (status == XS_MODULE_STATUS_LOADED)) {
            fxQueueModule(the, queue, importModule);
          }
        }
        transfer = transfer->next;
      }
      return 1;
    }
  }
  return 0;
}

void fxLoadModuleStuffFulfilled(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  mxTry(the) {
    mxPushReference(module);
    fxLoadModuleStuff(the, queue, the->stack, mxArgv(0));
    mxPop();
  }
  mxCatch(the) {
    mxPush(mxException);
    mxException = mxUndefined;
    fxCompleteModule(the, module, the->stack);
    fxRunImportRejected(the, module, module);
    mxPop();
  }
  fxLoadModules(the, queue);
}

void fxLoadModuleStuffRejected(txMachine* the)
{
  txSlot* home = mxFunctionInstanceHome(mxFunction->value.reference);
  txSlot* queue = home->value.home.object;
  txSlot* module = home->value.home.module;
  fxCompleteModule(the, module, mxArgv(0));
  fxRunImportRejected(the, module, module);
  fxLoadModules(the, queue);
}

txSlot* fxNewModuleStuffInstance(txMachine* the)
{
  txSlot* instance;
  txSlot* slot;
  txSlot* modules;
  instance = fxNewSlot(the);
  instance->kind = XS_INSTANCE_KIND;
  instance->value.instance.garbage = C_NULL;
  instance->value.instance.prototype = the->stack->value.reference;
  the->stack->kind = XS_REFERENCE_KIND;
  the->stack->value.reference = instance;
  /* HOST */
  slot = instance->next = fxNewSlot(the);
  slot->flag = XS_INTERNAL_FLAG;
  slot->kind = XS_MODULE_STUFF_KIND;
  /* MODULE */
  slot = fxNextNullProperty(the, slot, XS_NO_ID, XS_INTERNAL_FLAG);
  /* MODULES */
  modules = fxNewInstance(the);
  slot = fxNextReferenceProperty(the, slot, modules, XS_NO_ID, XS_INTERNAL_FLAG);
  mxPop();
  return instance;
}

void fx_ModuleStuff(txMachine* the)
{
  txSlot* instance;
  txSlot* handler;
  txSlot* importHook;
  txSlot* importMetaHook;
  txSlot* importNowHook;
  txSlot* slot;
  if (!mxHasTarget)
    mxTypeError("call: ModuleStuff");
  if ((mxArgc < 1) || (!mxIsReference(mxArgv(0))))
    mxTypeError("source: not an object");
  if ((mxArgc < 2) || mxIsUndefined(mxArgv(1))) {
    mxPushUndefined();
    mxPushUndefined();
    mxPushUndefined();
    mxPushUndefined();
  }
  else if (mxIsReference(mxArgv(1))) {
    mxPushSlot(mxArgv(1));
    mxPushSlot(mxArgv(1));
    mxGetID(fxID(the, "importHook"));
    if (!mxIsUndefined(the->stack) && !fxIsCallable(the, the->stack))
      mxTypeError("handler.importHook: not a function");
    mxPushSlot(mxArgv(1));
    mxGetID(fxID(the, "importMetaHook"));
    if (!mxIsUndefined(the->stack) && !fxIsCallable(the, the->stack))
      mxTypeError("handler.importMetaHook: not a function");
    mxPushSlot(mxArgv(1));
    mxGetID(fxID(the, "importNowHook"));
    if (!mxIsUndefined(the->stack) && !fxIsCallable(the, the->stack))
      mxTypeError("handler.importNowHook: not a function");
  }
  else {
    mxTypeError("handler: not an object");
  }
  handler = the->stack + 3;
  importHook = the->stack + 2;
  importMetaHook = the->stack + 1;
  importNowHook = the->stack;
  
  mxPushSlot(mxTarget);
  fxGetPrototypeFromConstructor(the, &mxModuleStuffPrototype);
  instance = fxNewModuleStuffInstance(the);
  mxPullSlot(mxResult);
  
  slot = fxLastProperty(the, instance);
  slot = fxNextSlotProperty(the, slot, mxArgv(0), XS_NO_ID, XS_INTERNAL_FLAG);
  slot = fxNextSlotProperty(the, slot, handler, XS_NO_ID, XS_INTERNAL_FLAG);
  slot = fxNextSlotProperty(the, slot, importHook, XS_NO_ID, XS_INTERNAL_FLAG);
  slot = fxNextSlotProperty(the, slot, importMetaHook, XS_NO_ID, XS_INTERNAL_FLAG);
  slot = fxNextSlotProperty(the, slot, importNowHook, XS_NO_ID, XS_INTERNAL_FLAG);
  
  mxPop();
  mxPop();
  mxPop();
  mxPop();
}

#endif

Coverage Report

Created: 2026-06-10 07:01