@agoric/xsnap 0.14.3-u14.0 → 0.14.3-u16.0

package/moddable/xs/sources/xsSnapshot.c

@@ -0,0 +1,2161 @@
+/*
+ * Copyright (c) 2016-2018  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/>.
+ *
+ */
+
+#define _GNU_SOURCE
+#include "xsSnapshot.h"
+#if mxMacOSX || mxLinux
+#include <dlfcn.h>
+#endif
+
+static void fxIndexInstance(txMachine* the, txSnapshot* snapshot, txSlot* theCurrent);
+static void fxIndexReference(txMachine* the, txSnapshot* snapshot, txSlot* theSlot);
+static void fxIndexSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot);
+static void fxIndexSlots(txMachine* the, txSnapshot* snapshot);
+
+static void fxLinkChunks(txMachine* the);
+
+static void fxMeasureSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txSize* chunkSize);
+static void fxMeasureChunk(txMachine* the, txSnapshot* snapshot, void* address, txSize* chunkSize);
+static void fxMeasureChunkArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize* chunkSize);
+
+static txCallback fxProjectCallback(txMachine* the, txSnapshot* snapshot, txCallback callback);
+static void* fxProjectChunk(txMachine* the, void* address);
+static txSlot* fxProjectSlot(txMachine* the, txProjection* firstProjection, txSlot* slot);
+static txTypeAtomics* fxProjectTypeAtomics(txMachine* the, txTypeAtomics* atomics);
+static txTypeDispatch* fxProjectTypeDispatch(txMachine* the, txTypeDispatch* dispatch);
+
+static void fxReadAtom(txMachine* the, txSnapshot* snapshot, Atom* atom, txString type);
+static void fxReadMapSet(txMachine* the, txSlot* table, txBoolean paired);
+static void fxReadSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txFlag flag);
+static void fxReadSlotArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize length);
+static void fxReadSlotTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length);
+
+static void fxUnlinkChunks(txMachine* the);
+
+#define mxUnprojectChunk(ADDRESS) (snapshot->firstChunk + ((size_t)ADDRESS));
+static txCallback fxUnprojectCallback(txMachine* the, txSnapshot* snapshot, txCallback callback);
+static txSlot* fxUnprojectSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot);
+
+static void fxWriteChunk(txMachine* the, txSnapshot* snapshot, txSlot* slot);
+static void fxWriteChunkArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize length, txFlag flag);
+static void fxWriteChunkBigInt(txMachine* the, txSnapshot* snapshot, void* address, txSize size);
+static void fxWriteChunkData(txMachine* the, txSnapshot* snapshot, void* address);
+static void fxWriteChunkTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length);
+static void fxWriteChunkZero(txMachine* the, txSnapshot* snapshot, txSize size);
+static void fxWriteChunks(txMachine* the, txSnapshot* snapshot);
+static void fxWriteSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txFlag flag);
+static void fxWriteSlotTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length);
+static void fxWriteSlots(txMachine* the, txSnapshot* snapshot);
+static void fxWriteStack(txMachine* the, txSnapshot* snapshot);
+
+#define mxAssert(_ASSERTION,...) { if (!(_ASSERTION)) { fxReport(the, __VA_ARGS__); snapshot->error = C_EINVAL; fxJump(the); } }
+#define mxThrowIf(_ERROR) { if (_ERROR) { snapshot->error = _ERROR; fxJump(the); } }
+#define mxChunkFlag 0x80000000
+
+#define mxCallbacksLength 496
+static txCallback gxCallbacks[mxCallbacksLength] = {
+	fx_AggregateError,
+	fx_Array_from,
+	fx_Array_isArray,
+	fx_Array_of,
+	fx_Array_prototype_at,
+	fx_Array_prototype_concat,
+	fx_Array_prototype_copyWithin,
+	fx_Array_prototype_entries,
+	fx_Array_prototype_every,
+	fx_Array_prototype_fill,
+	fx_Array_prototype_filter,
+	fx_Array_prototype_find,
+	fx_Array_prototype_findIndex,
+	fx_Array_prototype_findLast,
+	fx_Array_prototype_findLastIndex,
+	fx_Array_prototype_flat,
+	fx_Array_prototype_flatMap,
+	fx_Array_prototype_forEach,
+	fx_Array_prototype_includes,
+	fx_Array_prototype_indexOf,
+	fx_Array_prototype_join,
+	fx_Array_prototype_keys,
+	fx_Array_prototype_lastIndexOf,
+	fx_Array_prototype_map,
+	fx_Array_prototype_pop,
+	fx_Array_prototype_push,
+	fx_Array_prototype_reduce,
+	fx_Array_prototype_reduceRight,
+	fx_Array_prototype_reverse,
+	fx_Array_prototype_shift,
+	fx_Array_prototype_slice,
+	fx_Array_prototype_some,
+	fx_Array_prototype_sort,
+	fx_Array_prototype_splice,
+	fx_Array_prototype_toLocaleString,
+	fx_Array_prototype_toString,
+	fx_Array_prototype_unshift,
+	fx_Array_prototype_values,
+	fx_Array,
+	fx_ArrayBuffer_fromBigInt,
+	fx_ArrayBuffer_isView,
+	fx_ArrayBuffer_prototype_concat,
+	fx_ArrayBuffer_prototype_get_byteLength,
+	fx_ArrayBuffer_prototype_get_maxByteLength,
+	fx_ArrayBuffer_prototype_get_resizable,
+	fx_ArrayBuffer_prototype_resize,
+	fx_ArrayBuffer_prototype_slice,
+	fx_ArrayBuffer_prototype_transfer,
+	fx_ArrayBuffer,
+	fx_ArrayIterator_prototype_next,
+	fx_AsyncFromSyncIterator_prototype_next,
+	fx_AsyncFromSyncIterator_prototype_return,
+	fx_AsyncFromSyncIterator_prototype_throw,
+	fx_AsyncFunction,
+	fx_AsyncGenerator_prototype_next,
+	fx_AsyncGenerator_prototype_return,
+	fx_AsyncGenerator_prototype_throw,
+	fx_AsyncGenerator,
+	fx_AsyncGeneratorFunction,
+	fx_AsyncIterator_asyncIterator,
+	fx_Atomics_add,
+	fx_Atomics_and,
+	fx_Atomics_compareExchange,
+	fx_Atomics_exchange,
+	fx_Atomics_isLockFree,
+	fx_Atomics_load,
+	fx_Atomics_notify,
+	fx_Atomics_or,
+	fx_Atomics_store,
+	fx_Atomics_sub,
+	fx_Atomics_wait,
+	fx_Atomics_xor,
+	fx_BigInt_asIntN,
+	fx_BigInt_asUintN,
+	fx_BigInt_bitLength,
+	fx_BigInt_fromArrayBuffer,
+	fx_BigInt_prototype_toString,
+	fx_BigInt_prototype_valueOf,
+	fx_BigInt,
+	fx_Boolean_prototype_toString,
+	fx_Boolean_prototype_valueOf,
+	fx_Boolean,
+	fx_Compartment_prototype_evaluate,
+	fx_Compartment_prototype_get_globalThis,
+	fx_Compartment_prototype_import,
+	fx_Compartment_prototype_importNow,
+	fx_Compartment,
+	fx_DataView_prototype_buffer_get,
+	fx_DataView_prototype_byteLength_get,
+	fx_DataView_prototype_byteOffset_get,
+	fx_DataView_prototype_getBigInt64,
+	fx_DataView_prototype_getBigUint64,
+	fx_DataView_prototype_getFloat32,
+	fx_DataView_prototype_getFloat64,
+	fx_DataView_prototype_getInt8,
+	fx_DataView_prototype_getInt16,
+	fx_DataView_prototype_getInt32,
+	fx_DataView_prototype_getUint8,
+	fx_DataView_prototype_getUint16,
+	fx_DataView_prototype_getUint32,
+	fx_DataView_prototype_setBigInt64,
+	fx_DataView_prototype_setBigUint64,
+	fx_DataView_prototype_setFloat32,
+	fx_DataView_prototype_setFloat64,
+	fx_DataView_prototype_setInt8,
+	fx_DataView_prototype_setInt16,
+	fx_DataView_prototype_setInt32,
+	fx_DataView_prototype_setUint8,
+	fx_DataView_prototype_setUint16,
+	fx_DataView_prototype_setUint32,
+	fx_DataView,
+	fx_Date_now,
+	fx_Date_now_secure,
+	fx_Date_parse,
+	fx_Date_prototype_getDate,
+	fx_Date_prototype_getDay,
+	fx_Date_prototype_getFullYear,
+	fx_Date_prototype_getHours,
+	fx_Date_prototype_getMilliseconds,
+	fx_Date_prototype_getMinutes,
+	fx_Date_prototype_getMonth,
+	fx_Date_prototype_getSeconds,
+	fx_Date_prototype_getTimezoneOffset,
+	fx_Date_prototype_getUTCDate,
+	fx_Date_prototype_getUTCDay,
+	fx_Date_prototype_getUTCFullYear,
+	fx_Date_prototype_getUTCHours,
+	fx_Date_prototype_getUTCMilliseconds,
+	fx_Date_prototype_getUTCMinutes,
+	fx_Date_prototype_getUTCMonth,
+	fx_Date_prototype_getUTCSeconds,
+	fx_Date_prototype_getYear,
+	fx_Date_prototype_setDate,
+	fx_Date_prototype_setFullYear,
+	fx_Date_prototype_setHours,
+	fx_Date_prototype_setMilliseconds,
+	fx_Date_prototype_setMinutes,
+	fx_Date_prototype_setMonth,
+	fx_Date_prototype_setSeconds,
+	fx_Date_prototype_setTime,
+	fx_Date_prototype_setUTCDate,
+	fx_Date_prototype_setUTCFullYear,
+	fx_Date_prototype_setUTCHours,
+	fx_Date_prototype_setUTCMilliseconds,
+	fx_Date_prototype_setUTCMinutes,
+	fx_Date_prototype_setUTCMonth,
+	fx_Date_prototype_setUTCSeconds,
+	fx_Date_prototype_setYear,
+	fx_Date_prototype_toDateString,
+	fx_Date_prototype_toISOString,
+	fx_Date_prototype_toJSON,
+	fx_Date_prototype_toPrimitive,
+	fx_Date_prototype_toString,
+	fx_Date_prototype_toTimeString,
+	fx_Date_prototype_toUTCString,
+	fx_Date_prototype_valueOf,
+	fx_Date_UTC,
+	fx_Date,
+	fx_Date_secure,
+	fx_decodeURI,
+	fx_decodeURIComponent,
+	fx_encodeURI,
+	fx_encodeURIComponent,
+	fx_Enumerator_next,
+	fx_Enumerator,
+	fx_Error_prototype_get_stack,
+	fx_Error_toString,
+	fx_Error,
+	fx_escape,
+	fx_eval,
+	fx_EvalError,
+	// fx_FinalizationRegistry_prototype_cleanupSome,
+	fx_FinalizationRegistry_prototype_register,
+	fx_FinalizationRegistry_prototype_unregister,
+	fx_FinalizationRegistry,
+	fx_Function_prototype_apply,
+	fx_Function_prototype_bind,
+	fx_Function_prototype_bound,
+	fx_Function_prototype_call,
+	fx_Function_prototype_hasInstance,
+	fx_Function_prototype_toString,
+	fx_Function,
+	fx_Generator_prototype_next,
+	fx_Generator_prototype_return,
+	fx_Generator_prototype_throw,
+	fx_Generator,
+	fx_GeneratorFunction,
+	fx_isFinite,
+	fx_isNaN,
+	fx_Iterator_iterator,
+	fx_JSON_parse,
+	fx_JSON_stringify,
+	fx_Map_prototype_clear,
+	fx_Map_prototype_delete,
+	fx_Map_prototype_entries,
+	fx_Map_prototype_forEach,
+	fx_Map_prototype_get,
+	fx_Map_prototype_has,
+	fx_Map_prototype_keys,
+	fx_Map_prototype_set,
+	fx_Map_prototype_size,
+	fx_Map_prototype_values,
+	fx_Map,
+	fx_MapIterator_prototype_next,
+	fx_Math_abs,
+	fx_Math_acos,
+	fx_Math_acosh,
+	fx_Math_asin,
+	fx_Math_asinh,
+	fx_Math_atan,
+	fx_Math_atan2,
+	fx_Math_atanh,
+	fx_Math_cbrt,
+	fx_Math_ceil,
+	fx_Math_clz32,
+	fx_Math_cos,
+	fx_Math_cosh,
+	fx_Math_exp,
+	fx_Math_expm1,
+	fx_Math_floor,
+	fx_Math_fround,
+	fx_Math_hypot,
+	fx_Math_idiv,
+	fx_Math_idivmod,
+	fx_Math_imod,
+	fx_Math_imul,
+	fx_Math_imuldiv,
+	fx_Math_irem,
+	fx_Math_log,
+	fx_Math_log1p,
+	fx_Math_log2,
+	fx_Math_log10,
+	fx_Math_max,
+	fx_Math_min,
+	fx_Math_mod,
+	fx_Math_pow,
+	fx_Math_random,
+	fx_Math_random_secure,
+	fx_Math_round,
+	fx_Math_sign,
+	fx_Math_sin,
+	fx_Math_sinh,
+	fx_Math_sqrt,
+	fx_Math_tan,
+	fx_Math_tanh,
+	fx_Math_trunc,
+	fx_ModuleSource,
+	fx_ModuleSource_prototype_get_bindings,
+	fx_ModuleSource_prototype_get_needsImport,
+	fx_ModuleSource_prototype_get_needsImportMeta,
+	fx_Number_isFinite,
+	fx_Number_isInteger,
+	fx_Number_isNaN,
+	fx_Number_isSafeInteger,
+	fx_Number_prototype_toExponential,
+	fx_Number_prototype_toFixed,
+	fx_Number_prototype_toLocaleString,
+	fx_Number_prototype_toPrecision,
+	fx_Number_prototype_toString,
+	fx_Number_prototype_valueOf,
+	fx_Number,
+	fx_Object_assign,
+	fx_Object_copy,
+	fx_Object_create,
+	fx_Object_defineProperties,
+	fx_Object_defineProperty,
+	fx_Object_entries,
+	fx_Object_freeze,
+	fx_Object_fromEntries,
+	fx_Object_getOwnPropertyDescriptor,
+	fx_Object_getOwnPropertyDescriptors,
+	fx_Object_getOwnPropertyNames,
+	fx_Object_getOwnPropertySymbols,
+	fx_Object_getPrototypeOf,
+	fx_Object_hasOwn,
+	fx_Object_is,
+	fx_Object_isExtensible,
+	fx_Object_isFrozen,
+	fx_Object_isSealed,
+	fx_Object_keys,
+	fx_Object_preventExtensions,
+	fx_Object_prototype___defineGetter__,
+	fx_Object_prototype___defineSetter__,
+	fx_Object_prototype___lookupGetter__,
+	fx_Object_prototype___lookupSetter__,
+	fx_Object_prototype___proto__get,
+	fx_Object_prototype___proto__set,
+	fx_Object_prototype_hasOwnProperty,
+	fx_Object_prototype_isPrototypeOf,
+	fx_Object_prototype_propertyIsEnumerable,
+	fx_Object_prototype_toLocaleString,
+	fx_Object_prototype_toString,
+	fx_Object_prototype_valueOf,
+	fx_Object_seal,
+	fx_Object_setPrototypeOf,
+	fx_Object_values,
+	fx_Object,
+	fx_parseFloat,
+	fx_parseInt,
+	fx_Promise_all,
+	fx_Promise_allSettled,
+	fx_Promise_any,
+	fx_Promise_prototype_catch,
+	fx_Promise_prototype_finally,
+	fx_Promise_prototype_then,
+	fx_Promise_race,
+	fx_Promise_reject,
+	fx_Promise_resolve,
+	fx_Promise,
+	fx_Proxy_revocable,
+	fx_Proxy_revoke,
+	fx_Proxy,
+	fx_RangeError,
+	fx_ReferenceError,
+	fx_Reflect_apply,
+	fx_Reflect_construct,
+	fx_Reflect_defineProperty,
+	fx_Reflect_deleteProperty,
+	fx_Reflect_get,
+	fx_Reflect_getOwnPropertyDescriptor,
+	fx_Reflect_getPrototypeOf,
+	fx_Reflect_has,
+	fx_Reflect_isExtensible,
+	fx_Reflect_ownKeys,
+	fx_Reflect_preventExtensions,
+	fx_Reflect_set,
+	fx_Reflect_setPrototypeOf,
+	fx_RegExp_prototype_compile,
+	fx_RegExp_prototype_exec,
+	fx_RegExp_prototype_get_dotAll,
+	fx_RegExp_prototype_get_flags,
+	fx_RegExp_prototype_get_global,
+	fx_RegExp_prototype_get_hasIndices,
+	fx_RegExp_prototype_get_ignoreCase,
+	fx_RegExp_prototype_get_multiline,
+	fx_RegExp_prototype_get_source,
+	fx_RegExp_prototype_get_sticky,
+	fx_RegExp_prototype_get_unicode,
+	fx_RegExp_prototype_match,
+	fx_RegExp_prototype_matchAll_next,
+	fx_RegExp_prototype_matchAll,
+	fx_RegExp_prototype_replace,
+	fx_RegExp_prototype_search,
+	fx_RegExp_prototype_split,
+	fx_RegExp_prototype_test,
+	fx_RegExp_prototype_toString,
+	fx_RegExp,
+	fx_Set_prototype_add,
+	fx_Set_prototype_clear,
+	fx_Set_prototype_delete,
+	fx_Set_prototype_entries,
+	fx_Set_prototype_forEach,
+	fx_Set_prototype_has,
+	fx_Set_prototype_size,
+	fx_Set_prototype_values,
+	fx_Set,
+	fx_SetIterator_prototype_next,
+	fx_SharedArrayBuffer_prototype_get_byteLength,
+	fx_SharedArrayBuffer_prototype_get_growable,
+	fx_SharedArrayBuffer_prototype_get_maxByteLength,
+	fx_SharedArrayBuffer_prototype_grow,
+	fx_SharedArrayBuffer_prototype_slice,
+	fx_SharedArrayBuffer,
+	fx_species_get,
+	fx_String_fromCharCode,
+	fx_String_fromCodePoint,
+	fx_String_prototype_at,
+	fx_String_prototype_charAt,
+	fx_String_prototype_charCodeAt,
+	fx_String_prototype_codePointAt,
+	fx_String_prototype_compare,
+	fx_String_prototype_concat,
+	fx_String_prototype_endsWith,
+	fx_String_prototype_includes,
+	fx_String_prototype_indexOf,
+	fx_String_prototype_iterator_next,
+	fx_String_prototype_iterator,
+	fx_String_prototype_lastIndexOf,
+	fx_String_prototype_localeCompare,
+	fx_String_prototype_match,
+	fx_String_prototype_matchAll,
+	fx_String_prototype_normalize,
+	fx_String_prototype_padEnd,
+	fx_String_prototype_padStart,
+	fx_String_prototype_repeat,
+	fx_String_prototype_replace,
+	fx_String_prototype_replaceAll,
+	fx_String_prototype_search,
+	fx_String_prototype_slice,
+	fx_String_prototype_split,
+	fx_String_prototype_startsWith,
+	fx_String_prototype_substr,
+	fx_String_prototype_substring,
+	fx_String_prototype_toLowerCase,
+	fx_String_prototype_toUpperCase,
+	fx_String_prototype_trim,
+	fx_String_prototype_trimEnd,
+	fx_String_prototype_trimStart,
+	fx_String_prototype_valueOf,
+	fx_String_raw,
+	fx_String,
+	fx_Symbol_for,
+	fx_Symbol_keyFor,
+	fx_Symbol_prototype_get_description,
+	fx_Symbol_prototype_toPrimitive,
+	fx_Symbol_prototype_toString,
+	fx_Symbol_prototype_valueOf,
+	fx_Symbol,
+	fx_SyntaxError,
+	fx_trace_center,
+	fx_trace_left,
+	fx_trace_right,
+	fx_trace,
+	fx_TypedArray_from,
+	fx_TypedArray_of,
+	fx_TypedArray_prototype_at,
+	fx_TypedArray_prototype_buffer_get,
+	fx_TypedArray_prototype_byteLength_get,
+	fx_TypedArray_prototype_byteOffset_get,
+	fx_TypedArray_prototype_copyWithin,
+	fx_TypedArray_prototype_entries,
+	fx_TypedArray_prototype_every,
+	fx_TypedArray_prototype_fill,
+	fx_TypedArray_prototype_filter,
+	fx_TypedArray_prototype_find,
+	fx_TypedArray_prototype_findIndex,
+	fx_TypedArray_prototype_findLast,
+	fx_TypedArray_prototype_findLastIndex,
+	fx_TypedArray_prototype_forEach,
+	fx_TypedArray_prototype_includes,
+	fx_TypedArray_prototype_indexOf,
+	fx_TypedArray_prototype_join,
+	fx_TypedArray_prototype_keys,
+	fx_TypedArray_prototype_lastIndexOf,
+	fx_TypedArray_prototype_length_get,
+	fx_TypedArray_prototype_map,
+	fx_TypedArray_prototype_reduce,
+	fx_TypedArray_prototype_reduceRight,
+	fx_TypedArray_prototype_reverse,
+	fx_TypedArray_prototype_set,
+	fx_TypedArray_prototype_slice,
+	fx_TypedArray_prototype_some,
+	fx_TypedArray_prototype_sort,
+	fx_TypedArray_prototype_subarray,
+	fx_TypedArray_prototype_toLocaleString,
+	fx_TypedArray_prototype_toStringTag_get,
+	fx_TypedArray_prototype_values,
+	fx_TypedArray,
+	fx_TypeError,
+	fx_unescape,
+	fx_URIError,
+	fx_WeakMap_prototype_delete,
+	fx_WeakMap_prototype_get,
+	fx_WeakMap_prototype_has,
+	fx_WeakMap_prototype_set,
+	fx_WeakMap,
+	fx_WeakRef_prototype_deref,
+	fx_WeakRef,
+	fx_WeakSet_prototype_add,
+	fx_WeakSet_prototype_delete,
+	fx_WeakSet_prototype_has,
+	fx_WeakSet,
+	fxAsyncGeneratorRejectAwait,
+	fxAsyncGeneratorRejectYield,
+	fxAsyncGeneratorResolveAwait,
+	fxAsyncGeneratorResolveYield,
+	fxAsyncFromSyncIteratorDone,
+	fxArrayLengthGetter,
+	fxArrayLengthSetter,
+	fxExecuteModulesFulfilled,
+	fxExecuteModulesRejected,
+	fxExecuteVirtualModuleSource,
+	fxExecuteVirtualModuleSourceImport,
+	fxInitializeRegExp,
+	fxLoadModulesFulfilled,
+	fxLoadModulesRejected,
+	fxModuleGetter,
+	fxOnRejectedPromise,
+	fxOnResolvedPromise,
+	fxOnThenable,
+	fxOrdinaryToPrimitive,
+	fxProxyGetter,
+	fxProxySetter,
+	fxStringAccessorGetter,
+	fxStringAccessorSetter,
+	fxThrowTypeError,
+	fxTypedArrayGetter,
+	fxTypedArraySetter,
+	fxCombinePromisesCallback,
+	fxNewPromiseCapabilityCallback,
+	fxRejectAwait,
+	fxRejectPromise,
+	fxResolveAwait,
+	fxResolvePromise,
+	fx_Promise_prototype_finallyAux,
+	fx_Promise_prototype_finallyReturn,
+	fx_Promise_prototype_finallyThrow,
+};
+extern const txTypeDispatch gxTypeDispatches[];
+extern const txTypeAtomics gxTypeAtomics[];
+
+void fxIndexInstance(txMachine* the, txSnapshot* snapshot, txSlot* theCurrent)
+{
+	txSlot* aProperty;
+	txSlot* aTemporary;
+
+	mxCheck(the, theCurrent->kind == XS_INSTANCE_KIND);
+	aProperty = theCurrent;
+	theCurrent->value.instance.garbage = C_NULL;
+	for (;;) {
+		if (aProperty) {
+			if (!(aProperty->flag & XS_MARK_FLAG)) {
+				fxIndexSlot(the, snapshot, aProperty);
+				
+				switch (aProperty->kind) {
+				case XS_INSTANCE_KIND:
+					aTemporary = aProperty->value.instance.prototype;
+					if (aTemporary && !(aTemporary->flag & XS_MARK_FLAG)) {
+						aProperty->value.instance.prototype = theCurrent;
+						theCurrent = aTemporary;
+						theCurrent->value.instance.garbage = aProperty;
+						aProperty = theCurrent;
+					}
+					else
+						aProperty = aProperty->next;
+					break;
+				case XS_REFERENCE_KIND:
+					aTemporary = aProperty->value.reference;
+					if (!(aTemporary->flag & XS_MARK_FLAG)) {
+						aProperty->value.reference = theCurrent;
+						theCurrent = aTemporary;
+						theCurrent->value.instance.garbage = aProperty;
+						aProperty = theCurrent;
+					}
+					else
+						aProperty = aProperty->next;
+					break;
+					
+				case XS_PROXY_KIND:
+					aTemporary = aProperty->value.proxy.handler;
+					if (aTemporary && !(aTemporary->flag & XS_MARK_FLAG)) {
+						aProperty->flag |= XS_INSPECTOR_FLAG;
+						aProperty->value.proxy.handler = theCurrent;
+						theCurrent = aTemporary;
+						theCurrent->value.instance.garbage = aProperty;
+						aProperty = theCurrent;
+					}
+					else {
+						aTemporary = aProperty->value.proxy.target;
+						if (aTemporary && !(aTemporary->flag & XS_MARK_FLAG)) {
+							aProperty->value.proxy.target = theCurrent;
+							theCurrent = aTemporary;
+							theCurrent->value.instance.garbage = aProperty;
+							aProperty = theCurrent;
+						}
+						else
+							aProperty = aProperty->next;
+					}
+					break;
+					
+				case XS_CLOSURE_KIND:
+					aTemporary = aProperty->value.closure;
+					if (aTemporary && !(aTemporary->flag & XS_MARK_FLAG)) {
+						fxIndexSlot(the, snapshot, aTemporary); 
+						if (aTemporary->kind == XS_REFERENCE_KIND) {
+							aTemporary = aTemporary->value.reference;
+							if (!(aTemporary->flag & XS_MARK_FLAG)) {
+								aProperty->value.closure->value.reference = theCurrent;
+								theCurrent = aTemporary;
+								theCurrent->value.instance.garbage = aProperty;
+								aProperty = theCurrent;
+						
+							}
+						}
+						else {
+							fxIndexReference(the, snapshot, aTemporary);
+							aProperty = aProperty->next;
+						}
+					}
+					else
+						aProperty = aProperty->next;
+					break;
+					
+				default:
+					fxIndexReference(the, snapshot, aProperty);
+					aProperty = aProperty->next;
+					break;	
+				}
+			}
+			else
+				aProperty = aProperty->next;
+		}
+		else if (theCurrent->value.instance.garbage) {
+			aProperty = theCurrent->value.instance.garbage;
+			theCurrent->value.instance.garbage = C_NULL;
+			switch (aProperty->kind) {
+			case XS_INSTANCE_KIND:
+				aTemporary = aProperty->value.instance.prototype;
+				aProperty->value.instance.prototype = theCurrent;
+				theCurrent = aTemporary;
+				aProperty = aProperty->next;
+				break;
+			case XS_REFERENCE_KIND:
+				aTemporary = aProperty->value.reference;
+				aProperty->value.reference = theCurrent;
+				theCurrent = aTemporary;
+				aProperty = aProperty->next;
+				break;
+			case XS_PROXY_KIND:
+				if (aProperty->flag & XS_INSPECTOR_FLAG) {
+					aProperty->flag &= ~XS_INSPECTOR_FLAG;
+					aTemporary = aProperty->value.proxy.handler;
+					aProperty->value.proxy.handler = theCurrent;
+					theCurrent = aTemporary;
+					
+					aTemporary = aProperty->value.proxy.target;
+					if (aTemporary && !(aTemporary->flag & XS_MARK_FLAG)) {
+						aProperty->value.proxy.target = theCurrent;
+						theCurrent = aTemporary;
+						theCurrent->value.instance.garbage = aProperty;
+						aProperty = theCurrent;
+					}
+					else {
+						aProperty = aProperty->next;
+					}
+				}
+				else {
+					aTemporary = aProperty->value.proxy.target;
+					aProperty->value.proxy.target = theCurrent;
+					theCurrent = aTemporary;
+					aProperty = aProperty->next;
+				}
+				break;
+			case XS_CLOSURE_KIND:
+				aTemporary = aProperty->value.closure->value.reference;
+				aProperty->value.closure->value.reference = theCurrent;
+				theCurrent = aTemporary;
+				aProperty = aProperty->next;
+				break;
+			}
+		}
+		else
+			break;
+	}
+}
+
+void fxIndexReference(txMachine* the, txSnapshot* snapshot, txSlot* theSlot)
+{
+	txSlot* aSlot;
+	switch (theSlot->kind) {
+	case XS_REFERENCE_KIND:
+		aSlot = theSlot->value.reference;
+		if (!(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+	case XS_CLOSURE_KIND:
+		aSlot = theSlot->value.closure;
+		if (aSlot && (!(aSlot->flag & XS_MARK_FLAG))) {
+			fxIndexSlot(the, snapshot, aSlot); 
+			fxIndexReference(the, snapshot, aSlot);
+		}
+		break;
+	case XS_INSTANCE_KIND:
+		if (!(theSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, theSlot);
+		break;
+	case XS_ACCESSOR_KIND:
+		aSlot = theSlot->value.accessor.getter;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		aSlot = theSlot->value.accessor.setter;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_ARRAY_KIND:
+	case XS_STACK_KIND:
+		fxCheckCStack(the);
+		if ((aSlot = theSlot->value.array.address)) {
+			txIndex aLength = (((txChunk*)(((txByte*)aSlot) - sizeof(txChunk)))->size) / sizeof(txSlot);
+			while (aLength) {
+				fxIndexReference(the, snapshot, aSlot);
+				aSlot++;
+				aLength--;
+			}
+		}
+		break;
+	case XS_CODE_KIND:
+	case XS_CODE_X_KIND:
+		aSlot = theSlot->value.code.closures;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG)) {
+			fxCheckCStack(the);
+			fxIndexInstance(the, snapshot, aSlot);
+		}
+		break;
+	case XS_HOME_KIND:
+		aSlot = theSlot->value.home.object;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG)) {
+			fxCheckCStack(the);
+			fxIndexInstance(the, snapshot, aSlot);
+		}
+		aSlot = theSlot->value.home.module;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG)) {
+			fxCheckCStack(the);
+			fxIndexInstance(the, snapshot, aSlot);
+		}
+		break;
+	case XS_MODULE_KIND:
+	case XS_PROGRAM_KIND:
+		fxCheckCStack(the);
+		aSlot = theSlot->value.module.realm;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+	case XS_EXPORT_KIND:
+		aSlot = theSlot->value.export.closure;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG)) {
+			fxIndexSlot(the, snapshot, aSlot); 
+			fxIndexReference(the, snapshot, aSlot);
+		}
+		aSlot = theSlot->value.export.module;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+	case XS_HOST_KIND:
+		// ??
+		break;
+	case XS_PROXY_KIND:
+		aSlot = theSlot->value.proxy.handler;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		aSlot = theSlot->value.proxy.target;
+		if (aSlot && !(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+		
+	case XS_ERROR_KIND:
+		aSlot = theSlot->value.error.info;
+		if (aSlot && (!(aSlot->flag & XS_MARK_FLAG)))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;
+	case XS_LIST_KIND:
+		aSlot = theSlot->value.list.first;
+		while (aSlot) {
+			if (!(aSlot->flag & XS_MARK_FLAG)) {
+				fxIndexSlot(the, snapshot, aSlot);
+				fxIndexReference(the, snapshot, aSlot);
+			}
+			aSlot = aSlot->next;
+		}
+		break;
+		
+	case XS_PRIVATE_KIND:
+		aSlot = theSlot->value.private.check;
+		if (!(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		aSlot = theSlot->value.private.first;
+		while (aSlot) {
+			fxIndexSlot(the, snapshot, aSlot);
+			fxIndexReference(the, snapshot, aSlot);
+			aSlot = aSlot->next;
+		}
+		break;
+
+	case XS_WEAK_MAP_KIND:
+	case XS_WEAK_SET_KIND:
+		aSlot = theSlot->value.weakList.first;
+		while (aSlot) {
+			if (!(aSlot->flag & XS_MARK_FLAG)) {
+				fxIndexSlot(the, snapshot, aSlot);
+				fxIndexReference(the, snapshot, aSlot);
+			}
+			aSlot = aSlot->next;
+		}
+		break;
+	case XS_WEAK_ENTRY_KIND:
+		aSlot = theSlot->value.weakEntry.check;
+		if (aSlot->flag & XS_MARK_FLAG) {
+			aSlot = theSlot->value.weakEntry.value;
+			if (!(aSlot->flag & XS_MARK_FLAG)) {
+				fxIndexSlot(the, snapshot, aSlot); 
+				fxIndexReference(the, snapshot, aSlot);
+			}
+		}
+		break;
+	case XS_FINALIZATION_REGISTRY_KIND:
+		aSlot = theSlot->value.finalizationRegistry.callback;
+		if (aSlot) {
+			fxIndexSlot(the, snapshot, aSlot);
+			fxIndexReference(the, snapshot, aSlot);
+			aSlot = aSlot->next;
+			while (aSlot) {
+				fxIndexSlot(the, snapshot, aSlot);
+				fxIndexReference(the, snapshot, aSlot); // holdings
+				aSlot = aSlot->next;
+				if (aSlot) {
+					fxIndexSlot(the, snapshot, aSlot);
+					// weak target and token
+					aSlot = aSlot->next;
+				}
+			}
+		}
+		break;
+		
+	case XS_HOST_INSPECTOR_KIND:
+		aSlot = theSlot->value.hostInspector.cache;
+		if (!(aSlot->flag & XS_MARK_FLAG))
+			fxIndexInstance(the, snapshot, aSlot);
+		break;	
+	}
+}
+
+void fxIndexSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot)
+{
+	slot->flag |= XS_MARK_FLAG;
+	txProjection* projection = snapshot->firstProjection;
+	while (projection) {
+		txSlot* heap = projection->heap;
+		txSlot* limit = projection->limit;
+		if ((heap < slot) && (slot < limit)) {
+			projection->indexes[slot - heap] = snapshot->slotSize;
+			snapshot->slotSize++;
+			return;
+		}
+		projection = projection->nextProjection;
+	}
+}
+
+void fxIndexSlots(txMachine* the, txSnapshot* snapshot)
+{
+	txSlot* heap;
+	txSlot* limit;
+	txProjection** projectionAddress = &(snapshot->firstProjection);
+	txProjection* projection;
+	txSlot* slot;
+	txSlot** slotAddress;
+	txID id;
+	size_t* indexAddress;
+
+	heap = the->firstHeap;
+	while (heap) {
+		limit = heap->value.reference;
+		projection = c_calloc(sizeof(txProjection) + (limit - heap - 1) * sizeof(size_t), 1);
+		if (!projection) { snapshot->error = C_ENOMEM; fxJump(the); }
+		projection->heap = heap;
+		projection->limit = limit;
+		*projectionAddress = projection;
+		projectionAddress = &projection->nextProjection;
+		heap = heap->next;
+	}
+	
+	snapshot->slotSize = 1;
+	slotAddress = the->keyArray;
+	id = the->keyIndex;
+	while (id) {
+		if ((slot = *slotAddress)) {
+			fxIndexSlot(the, snapshot, slot);
+			fxIndexReference(the, snapshot, slot);
+		}
+		slotAddress++;
+		id--;
+	}	
+	slot = the->stackTop;
+	while (slot > the->stack) {
+        slot--;
+		fxIndexReference(the, snapshot, slot);
+	}
+	
+	snapshot->slots = c_calloc(sizeof(txSlot*) * snapshot->slotSize, 1);
+	if (!snapshot->slots) { snapshot->error = C_ENOMEM; fxJump(the); }
+	projection = snapshot->firstProjection;
+	while (projection) {
+		heap = projection->heap;
+		limit = projection->limit;
+		slot = heap + 1;
+		indexAddress = &projection->indexes[1];
+		while (slot < limit) {
+			if (slot->flag & XS_MARK_FLAG) {
+				slot->flag &= ~XS_MARK_FLAG; 
+				snapshot->slots[*indexAddress] = slot;
+			}
+			slot++;
+			indexAddress++;
+		}
+		projection = projection->nextProjection;
+	}
+	
+	slot = the->stackTop;
+	while (slot > the->stack) {
+        slot--;
+		slot->flag &= ~XS_MARK_FLAG; 
+	}
+}
+
+void fxLinkChunks(txMachine* the)
+{
+	txBlock* block = the->firstBlock;
+	while (block) {
+		txByte* current = ((txByte*)block) + sizeof(txBlock);
+		txByte* limit = block->current;
+		while (current < limit) {
+			txSize size = ((txChunk*)current)->size;
+			size &= ~mxChunkFlag;
+			((txChunk*)current)->size = size;
+			txByte* next = current + size;
+			((txChunk*)current)->temporary = next;
+			current = next;
+		}	
+		block = block->nextBlock;
+	}
+}
+
+void fxMeasureSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txSize* chunkSize)
+{
+	switch (slot->kind) {
+	case XS_STRING_KIND:
+		fxMeasureChunk(the, snapshot, slot->value.string, chunkSize);
+		break;
+	case XS_BIGINT_KIND:
+		fxMeasureChunk(the, snapshot, slot->value.bigint.data, chunkSize);
+		break;
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_ARRAY_KIND:
+	case XS_STACK_KIND:
+		if (slot->value.array.address)
+			fxMeasureChunkArray(the, snapshot, slot->value.array.address, chunkSize);
+		break;
+	case XS_ARRAY_BUFFER_KIND:
+		if (slot->value.arrayBuffer.address)
+			fxMeasureChunk(the, snapshot, slot->value.arrayBuffer.address, chunkSize);
+		break;
+	
+	case XS_CODE_KIND:
+		fxMeasureChunk(the, snapshot, slot->value.code.address, chunkSize);
+		break;
+	
+	case XS_REGEXP_KIND:
+		if (slot->value.regexp.code)
+			fxMeasureChunk(the, snapshot, slot->value.regexp.code, chunkSize);
+		if (slot->value.regexp.data)
+			fxMeasureChunk(the, snapshot, slot->value.regexp.data, chunkSize);
+		break;
+	case XS_KEY_KIND:
+		if (slot->value.key.string)
+			fxMeasureChunk(the, snapshot, slot->value.key.string, chunkSize);
+		break;
+	case XS_GLOBAL_KIND:
+	case XS_MAP_KIND:
+	case XS_SET_KIND:
+		fxMeasureChunk(the, snapshot, slot->value.table.address, chunkSize);
+		break;
+		
+	case XS_HOST_KIND:
+#if mxMacOSX || mxLinux
+		if (slot->value.host.variant.destructor) {
+			txDestructor destructor;
+			Dl_info info;
+			if (slot->flag & XS_HOST_HOOKS_FLAG)
+				destructor = slot->value.host.variant.hooks->destructor;
+			else
+				destructor = slot->value.host.variant.destructor;
+		    if (dladdr(destructor, &info)) {
+				mxAssert(0, "# snapshot: no host destructor: %s!\n", info.dli_sname);
+			}
+			else {
+				mxAssert(0, "# snapshot: no host destructor!\n");
+			}
+		}
+#else
+		mxAssert(slot->value.host.variant.destructor == C_NULL, "# snapshot: no host destructor!\n");
+#endif
+		if (slot->value.host.data) {
+			mxAssert(slot->flag & XS_HOST_CHUNK_FLAG, "# snapshot: no host data!\n");
+			fxMeasureChunk(the, snapshot, slot->value.host.data, chunkSize);
+		}
+		break;
+// 	case XS_PROMISE_KIND:
+// 		mxAssert(slot->value.integer != mxPendingStatus, "# snapshot: no pending promise instances!\n");
+// 		break;
+	case XS_STRING_X_KIND:
+		mxAssert(0, "# snapshot: external string %s!\n", slot->value.string);
+		break;
+	}
+}
+
+void fxMeasureChunk(txMachine* the, txSnapshot* snapshot, void* address, txSize* chunkSize)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (!(chunk->size & mxChunkFlag)) {
+		chunk->temporary = (txByte*)(*chunkSize + sizeof(txChunk));
+		*chunkSize += chunk->size;
+		chunk->size |= mxChunkFlag;
+	}
+}
+
+void fxMeasureChunkArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize* chunkSize)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (!(chunk->size & mxChunkFlag)) {
+		txSize size = chunk->size - sizeof(txChunk);
+		chunk->temporary = (txByte*)(*chunkSize + sizeof(txChunk));
+		*chunkSize += chunk->size;
+		chunk->size |= mxChunkFlag;
+		while (size > 0) {
+			fxMeasureSlot(the, snapshot, address, chunkSize);
+			address++;
+			size -= sizeof(txSlot);
+		}
+	}
+}
+
+txCallback fxProjectCallback(txMachine* the, txSnapshot* snapshot, txCallback callback) 
+{
+	if (callback) {
+		size_t callbackIndex = 0;
+		txCallback* callbackItem = (txCallback*)(gxCallbacks);
+		while (callbackIndex < mxCallbacksLength) {
+			if (*callbackItem == callback)
+				return (txCallback)callbackIndex;
+			callbackIndex++;
+			callbackItem++;
+		}
+		callbackIndex = 0;
+		callbackItem = snapshot->callbacks;
+		while (callbackIndex < (size_t)snapshot->callbacksLength) {
+			if (*callbackItem == callback)
+				return (txCallback)(mxCallbacksLength + callbackIndex);
+			callbackIndex++;
+			callbackItem++;
+		}
+		{
+#if mxMacOSX || mxLinux
+			Dl_info info;
+		    if (dladdr(callback, &info)) {
+				mxAssert(0, "# snapshot: unknown callback: %s!\n", info.dli_sname);
+			}
+		    else
+#endif
+				mxAssert(0, "# snapshot: unknown callback!\n");
+		}
+	}
+	return C_NULL;
+}
+
+void* fxProjectChunk(txMachine* the, void* address) 
+{
+    if (address) {
+        txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+        return chunk->temporary;
+    }
+    return C_NULL;
+}
+
+txSlot* fxProjectSlot(txMachine* the, txProjection* firstProjection, txSlot* slot) 
+{
+	txSlot* address = NULL;
+	if (slot) {
+		txProjection* projection = firstProjection;
+		while (projection) {
+			if ((projection->heap < slot) && (slot < projection->limit)) {
+				address = (txSlot*)(projection->indexes[slot - projection->heap]);
+				break;
+			}
+			projection = projection->nextProjection;
+		}
+	}
+	return address;
+}
+
+txTypeDispatch* fxProjectTypeDispatch(txMachine* the, txTypeDispatch* dispatch) 
+{
+	size_t i = 0;
+	while (i < mxTypeArrayCount) {
+		if (dispatch == &gxTypeDispatches[i])
+			return (txTypeDispatch*)i;
+		i++;
+	}
+	fprintf(stderr, "dispatch %p %p\n", dispatch, &gxTypeDispatches[0]);
+	return C_NULL;
+}
+
+txTypeAtomics* fxProjectTypeAtomics(txMachine* the, txTypeAtomics* atomics) 
+{
+	size_t i = 0;
+	while (i < mxTypeArrayCount) {
+		if (atomics == &gxTypeAtomics[i])
+			return (txTypeAtomics*)i;
+		i++;
+	}
+	fprintf(stderr, "atomics %p %p\n", atomics, &gxTypeAtomics[0]);
+	return C_NULL;
+}
+
+void fxReadAtom(txMachine* the, txSnapshot* snapshot, Atom* atom, txString type)
+{
+	txString check = (txString)&(atom->atomType);
+	mxThrowIf((*snapshot->read)(snapshot->stream, atom, sizeof(Atom)));
+	atom->atomSize = ntohl(atom->atomSize) - 8;
+	mxAssert((check[0] == type[0]) && (check[1] == type[1]) && (check[2] == type[2]) && (check[3] == type[3]), "snapshot: invalid atom %s\n", type);
+}
+
+void fxReadMapSet(txMachine* the, txSlot* table, txBoolean paired)
+{
+	txSlot* list = table->next;
+	txSlot* key = list->value.list.first;
+	while (key) {
+		txU4 sum = fxSumEntry(the, key);
+		txU4 index = sum & (table->value.table.length - 1);
+		txSlot*  entry = fxNewSlot(the);
+		txSlot** address = &(table->value.table.address[index]);
+		entry->next = *address;
+		entry->kind = XS_ENTRY_KIND;
+		entry->value.entry.slot = key;
+		entry->value.entry.sum = sum;
+		*address = entry;
+		key = key->next;
+		if (paired)
+			key = key->next;
+	}
+}
+
+txMachine* fxReadSnapshot(txSnapshot* snapshot, txString theName, void* theContext)
+{
+	Atom atom;
+	txByte byte;
+	txString signature;
+	txCreation creation;
+	txSlot* slot;
+	
+	txMachine* the = (txMachine* )c_calloc(sizeof(txMachine), 1);
+	if (the) {
+		txJump aJump;
+		snapshot->error = 0;
+		aJump.nextJump = C_NULL;
+		aJump.stack = C_NULL;
+		aJump.scope = C_NULL;
+		aJump.frame = C_NULL;
+		aJump.code = C_NULL;
+		aJump.flag = 0;
+		the->firstJump = &aJump;
+		if (c_setjmp(aJump.buffer) == 0) {
+			if (gxDefaults.initializeSharedCluster)
+				gxDefaults.initializeSharedCluster();
+				
+			the->dtoa = fxNew_dtoa(the);
+			the->context = theContext;
+			fxCreateMachinePlatform(the);
+
+		#ifdef mxDebug
+			the->name = theName;
+		#endif
+
+			fxReadAtom(the, snapshot, &atom, "XS_M");
+			fxReadAtom(the, snapshot, &atom, "VERS");
+			mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+			mxAssert(byte == XS_MAJOR_VERSION, "snapshot: invalid major version %d\n", byte);
+			mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+			mxAssert(byte == XS_MINOR_VERSION, "snapshot: invalid minor version %d\n", byte);
+			mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+// 			mxAssert(byte == XS_PATCH_VERSION, "snapshot: invalid patch version %d\n", byte);
+			mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		#if mxBigEndian
+			mxAssert(byte == -((txByte)sizeof(txSlot)), "snapshot: invalid architecture %d\n", byte);
+		#else
+			mxAssert(byte == (txByte)sizeof(txSlot), "snapshot: invalid architecture %d\n", byte);
+		#endif
+	
+			fxReadAtom(the, snapshot, &atom, "SIGN");
+			mxAssert(atom.atomSize == snapshot->signatureLength, "snapshot: invalid signature length %d\n", atom.atomSize);
+			signature = snapshot->signature;
+			while (atom.atomSize) {
+				mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+				mxAssert(byte == *signature, "snapshot: invalid signature byte %d\n", byte);
+				atom.atomSize--;
+				signature++;
+			}
+			
+			fxReadAtom(the, snapshot, &atom, "CREA");
+			mxThrowIf((*snapshot->read)(snapshot->stream, &creation, sizeof(txCreation)));
+			fxAllocate(the, &creation);
+			mxThrowIf((*snapshot->read)(snapshot->stream, &(the->profileID), sizeof(txID)));
+			mxThrowIf((*snapshot->read)(snapshot->stream, &(the->tag), sizeof(txInteger)));
+	
+			snapshot->firstChunk = the->firstBlock->current;
+			snapshot->firstSlot = the->firstHeap;
+	
+			fxReadAtom(the, snapshot, &atom, "BLOC");
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->firstBlock->current, atom.atomSize));
+			the->currentChunksSize = atom.atomSize;
+			the->firstBlock->current += atom.atomSize;
+	
+			fxReadAtom(the, snapshot, &atom, "HEAP");
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->freeHeap, atom.atomSize));
+			the->currentHeapCount = (atom.atomSize / sizeof(txSlot));
+			the->freeHeap = the->freeHeap + the->currentHeapCount;
+	
+            slot = the->firstHeap + 1;
+			while (slot < the->freeHeap) {
+				fxReadSlot(the, snapshot, slot, 1);
+				slot++;
+			}
+				
+			slot = the->firstHeap + 1;
+			while (slot < the->freeHeap) {
+				switch (slot->kind) {
+				case XS_MAP_KIND:
+					fxReadMapSet(the, slot, 1);
+					break;
+				case XS_SET_KIND:
+					fxReadMapSet(the, slot, 0);
+					break;
+				}
+				slot++;
+			}
+
+			fxReadAtom(the, snapshot, &atom, "STAC");
+			the->stack = the->stackTop - (atom.atomSize / sizeof(txSlot));
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->stack, atom.atomSize));
+	
+			slot = the->stack;
+			while (slot < the->stackTop) {
+				fxReadSlot(the, snapshot, slot, 0);
+				slot++;
+			}
+
+			fxReadAtom(the, snapshot, &atom, "KEYS");
+			the->keyIndex = atom.atomSize / sizeof(txSlot*);
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->keyArray, atom.atomSize));
+			fxReadSlotTable(the, snapshot, the->keyArray, the->keyIndex);
+	
+			fxReadAtom(the, snapshot, &atom, "NAME");
+			the->nameModulo = atom.atomSize / sizeof(txSlot*);
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->nameTable, atom.atomSize));
+			fxReadSlotTable(the, snapshot, the->nameTable, the->nameModulo);
+	
+			fxReadAtom(the, snapshot, &atom, "SYMB");
+			the->symbolModulo = atom.atomSize / sizeof(txSlot*);
+			mxThrowIf((*snapshot->read)(snapshot->stream, the->symbolTable, atom.atomSize));
+			fxReadSlotTable(the, snapshot, the->symbolTable, the->symbolModulo);
+			
+			slot = &mxDuringJobs;
+            the->collectFlag = XS_COLLECTING_FLAG;
+
+			fxLinkChunks(the);
+
+		#ifdef mxDebug
+			fxLogin(the);
+		#endif
+
+			the->firstJump = C_NULL;
+		}
+		else {
+			fxFree(the);
+			c_free(the);
+			the = NULL;
+			
+			if (gxDefaults.terminateSharedCluster)
+				gxDefaults.terminateSharedCluster();
+		}
+	}
+	else {
+		snapshot->error = C_ENOMEM;
+	}
+	return the;
+}
+
+
+void fxReadSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txFlag flag)
+{
+	if (flag)
+		slot->next = fxUnprojectSlot(the, snapshot, slot->next);
+	switch (slot->kind) {
+	case XS_STRING_KIND:
+		slot->value.string = (txString)mxUnprojectChunk(slot->value.string);
+		break;
+	case XS_BIGINT_KIND:
+		slot->value.bigint.data = (txU4*)mxUnprojectChunk(slot->value.bigint.data);
+		break;
+	case XS_REFERENCE_KIND:
+		slot->value.reference = fxUnprojectSlot(the, snapshot, slot->value.reference);
+		break;
+	case XS_CLOSURE_KIND:
+		slot->value.closure = fxUnprojectSlot(the, snapshot, slot->value.closure);
+		break;
+	case XS_INSTANCE_KIND:
+		slot->value.instance.prototype = fxUnprojectSlot(the, snapshot, slot->value.instance.prototype);
+		break;
+		
+	case XS_ARRAY_KIND:
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_STACK_KIND:
+		if (slot->value.array.address) {
+			slot->value.array.address = (txSlot*)mxUnprojectChunk(slot->value.array.address);
+			fxReadSlotArray(the, snapshot, slot->value.array.address, slot->value.array.length);
+		}
+		break;
+	case XS_ARRAY_BUFFER_KIND:
+		if (slot->value.array.address)
+			slot->value.arrayBuffer.address = (txByte*)mxUnprojectChunk(slot->value.arrayBuffer.address);
+		break;
+	case XS_CALLBACK_KIND:
+		slot->value.callback.address = fxUnprojectCallback(the, snapshot, slot->value.callback.address);
+		break;
+	case XS_CODE_KIND:
+		slot->value.code.address = (txByte*)mxUnprojectChunk(slot->value.code.address);
+		slot->value.code.closures = fxUnprojectSlot(the, snapshot, slot->value.code.closures);
+		break;
+	case XS_CODE_X_KIND:
+		slot->value.code.address = (txByte*)gxNoCode;
+		break;
+	case XS_FINALIZATION_CELL_KIND:
+		slot->value.finalizationCell.target = fxUnprojectSlot(the, snapshot, slot->value.finalizationCell.target);
+		slot->value.finalizationCell.token = fxUnprojectSlot(the, snapshot, slot->value.finalizationCell.token);
+		break;
+	case XS_FINALIZATION_REGISTRY_KIND:
+		slot->value.finalizationRegistry.callback = fxUnprojectSlot(the, snapshot, slot->value.finalizationRegistry.callback);
+		break;
+	case XS_TYPED_ARRAY_KIND:
+		slot->value.typedArray.dispatch = (txTypeDispatch*)&gxTypeDispatches[(size_t)slot->value.typedArray.dispatch];
+		slot->value.typedArray.atomics = (txTypeAtomics*)&gxTypeAtomics[(size_t)slot->value.typedArray.atomics];
+		break;
+	case XS_GLOBAL_KIND:
+	case XS_MAP_KIND:
+	case XS_SET_KIND:
+		slot->value.table.address = (txSlot**)mxUnprojectChunk(slot->value.table.address);
+		fxReadSlotTable(the, snapshot, slot->value.table.address, slot->value.table.length);
+		break;
+		
+	case XS_WEAK_MAP_KIND:
+	case XS_WEAK_SET_KIND:
+		slot->value.weakList.first = fxUnprojectSlot(the, snapshot, slot->value.weakList.first);
+		slot->value.weakList.link = the->firstWeakListLink;
+		the->firstWeakListLink = slot;
+		break;
+	case XS_WEAK_ENTRY_KIND:
+		slot->value.weakEntry.check = fxUnprojectSlot(the, snapshot, slot->value.weakEntry.check);
+		slot->value.weakEntry.value = fxUnprojectSlot(the, snapshot, slot->value.weakEntry.value);
+		break;
+	case XS_WEAK_REF_KIND:
+		slot->value.weakRef.target = fxUnprojectSlot(the, snapshot, slot->value.weakRef.target);
+		slot->value.weakRef.link = fxUnprojectSlot(the, snapshot, slot->value.weakRef.link);
+		break;
+
+	case XS_MODULE_KIND:
+	case XS_PROGRAM_KIND:
+	case XS_MODULE_SOURCE_KIND:
+		slot->value.module.realm = fxUnprojectSlot(the, snapshot, slot->value.module.realm);
+		break;
+		
+	case XS_PROXY_KIND:
+		slot->value.proxy.handler = fxUnprojectSlot(the, snapshot, slot->value.proxy.handler);
+		slot->value.proxy.target = fxUnprojectSlot(the, snapshot, slot->value.proxy.target);
+		break;
+	case XS_REGEXP_KIND:
+		if (slot->value.regexp.code)
+			slot->value.regexp.code = (void*)mxUnprojectChunk(slot->value.regexp.code);
+		if (slot->value.regexp.data)
+			slot->value.regexp.data = (void*)mxUnprojectChunk(slot->value.regexp.data);
+		break;
+		
+	case XS_ACCESSOR_KIND:
+		slot->value.accessor.getter = fxUnprojectSlot(the, snapshot, slot->value.accessor.getter);
+		slot->value.accessor.setter = fxUnprojectSlot(the, snapshot, slot->value.accessor.setter);
+		break;
+	case XS_ENTRY_KIND:
+		slot->value.entry.slot = fxUnprojectSlot(the, snapshot, slot->value.entry.slot);
+		break;
+	case XS_ERROR_KIND:
+		slot->value.error.info = fxUnprojectSlot(the, snapshot, slot->value.error.info);
+		break;
+	case XS_HOME_KIND:
+		slot->value.home.object = fxUnprojectSlot(the, snapshot, slot->value.home.object);
+		slot->value.home.module = fxUnprojectSlot(the, snapshot, slot->value.home.module);
+		break;
+	case XS_KEY_KIND:
+		if (slot->value.key.string)
+			slot->value.key.string = (txString)mxUnprojectChunk(slot->value.key.string);
+		break;
+	case XS_LIST_KIND:
+		slot->value.list.first = fxUnprojectSlot(the, snapshot, slot->value.list.first);
+		slot->value.list.last = fxUnprojectSlot(the, snapshot, slot->value.list.last);
+		break;
+	case XS_PRIVATE_KIND:
+		slot->value.private.check = fxUnprojectSlot(the, snapshot, slot->value.private.check);
+		slot->value.private.first = fxUnprojectSlot(the, snapshot, slot->value.private.first);
+		break;
+	case XS_EXPORT_KIND:
+		slot->value.export.closure = fxUnprojectSlot(the, snapshot, slot->value.export.closure);
+		slot->value.export.module = fxUnprojectSlot(the, snapshot, slot->value.export.module);
+		break;
+		
+	case XS_HOST_KIND:
+		if (slot->value.host.data)
+			slot->value.host.data = (txByte*)mxUnprojectChunk(slot->value.host.data);
+		break;
+	}
+}
+
+void fxReadSlotArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize length)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	txSize size = chunk->size - sizeof(txChunk);
+	while (size > 0) {
+		fxReadSlot(the, snapshot, address, 0);
+		address++;
+		size -= sizeof(txSlot);
+	}
+}
+
+void fxReadSlotTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length)
+{
+	while (length > 0) {
+		*address = fxUnprojectSlot(the, snapshot, *address);
+		address++;
+		length--;
+	}
+}
+
+void fxUnlinkChunks(txMachine* the)
+{
+	txBlock* block = the->firstBlock;
+	while (block) {
+		txByte* current = ((txByte*)block) + sizeof(txBlock);
+		txByte* limit = block->current;
+		while (current < limit) {
+			txSize size = ((txChunk*)current)->size;
+			txByte* next = current + size;
+			((txChunk*)current)->temporary = C_NULL;
+			current = next;
+		}	
+		block = block->nextBlock;
+	}
+}
+
+txCallback fxUnprojectCallback(txMachine* the, txSnapshot* snapshot, txCallback callback) 
+{
+	size_t callbackIndex = (size_t)callback;
+	if (callbackIndex < mxCallbacksLength)
+		return gxCallbacks[callbackIndex];
+	callbackIndex -= mxCallbacksLength;
+	if (callbackIndex < (size_t)snapshot->callbacksLength)
+		return snapshot->callbacks[callbackIndex];
+	mxAssert(0, "# snapshot: unknown callback!\n");
+	return C_NULL;
+}
+
+txSlot* fxUnprojectSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot)
+{
+	if (slot)
+		slot = snapshot->firstSlot + ((size_t)slot);
+	return slot;
+}
+
+int fxUseSnapshot(txMachine* the, txSnapshot* snapshot)
+{
+	Atom atom;
+	txByte byte;
+	txCreation creation;
+	txID profileID;
+	txInteger tag;
+	txByte* buffer;
+	txSize size;
+	txSlot* slot;
+	mxTry(the) {
+		snapshot->error = 0;
+		
+		fxReadAtom(the, snapshot, &atom, "XS_M");
+		fxReadAtom(the, snapshot, &atom, "VERS");
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+		fxReadAtom(the, snapshot, &atom, "SIGN");
+		while (atom.atomSize) {
+			mxThrowIf((*snapshot->read)(snapshot->stream, &byte, 1));
+			atom.atomSize--;
+		}
+		fxReadAtom(the, snapshot, &atom, "CREA");
+		mxThrowIf((*snapshot->read)(snapshot->stream, &creation, sizeof(txCreation)));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &profileID, sizeof(txID)));
+		mxThrowIf((*snapshot->read)(snapshot->stream, &tag, sizeof(txInteger)));
+		
+		buffer = (txByte*)the->firstBlock;
+		size = the->firstBlock->limit - buffer;
+		c_memset(buffer, 0, size);
+		the->firstBlock->current = buffer + sizeof(txBlock);
+		the->firstBlock->limit = buffer + size;
+
+		the->freeHeap = slot = the->firstHeap + 1;
+		size = the->maximumHeapCount - 1;
+	    while (size--) {
+			txSlot* next = slot + 1;
+			slot->next = next;
+			slot->flag = XS_NO_FLAG;
+			slot->kind = XS_UNDEFINED_KIND;
+			slot = next;
+		}
+		slot->next = C_NULL;
+		slot->flag = XS_NO_FLAG;
+		slot->kind = XS_UNDEFINED_KIND;
+		the->firstWeakListLink = C_NULL;
+
+		snapshot->firstChunk = the->firstBlock->current;
+		snapshot->firstSlot = the->firstHeap;
+		
+		fxReadAtom(the, snapshot, &atom, "BLOC");
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->firstBlock->current, atom.atomSize));
+		the->currentChunksSize = atom.atomSize;
+		the->firstBlock->current += atom.atomSize;
+
+		fxReadAtom(the, snapshot, &atom, "HEAP");
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->freeHeap, atom.atomSize));
+		the->currentHeapCount = (atom.atomSize / sizeof(txSlot));
+		the->freeHeap = the->freeHeap + the->currentHeapCount;
+
+		slot = the->firstHeap + 1;
+		while (slot < the->freeHeap) {
+			fxReadSlot(the, snapshot, slot, 1);
+			slot++;
+		}
+			
+		slot = the->firstHeap + 1;
+		while (slot < the->freeHeap) {
+			switch (slot->kind) {
+			case XS_MAP_KIND:
+				fxReadMapSet(the, slot, 1);
+				break;
+			case XS_SET_KIND:
+				fxReadMapSet(the, slot, 0);
+				break;
+			}
+			slot++;
+		}
+
+		fxReadAtom(the, snapshot, &atom, "STAC");
+		the->stack = the->stackTop - (atom.atomSize / sizeof(txSlot));
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->stack, atom.atomSize));
+
+		slot = the->stack;
+		while (slot < the->stackTop) {
+			fxReadSlot(the, snapshot, slot, 0);
+			slot++;
+		}
+
+		fxReadAtom(the, snapshot, &atom, "KEYS");
+		the->keyIndex = atom.atomSize / sizeof(txSlot*);
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->keyArray, atom.atomSize));
+		fxReadSlotTable(the, snapshot, the->keyArray, the->keyIndex);
+
+		fxReadAtom(the, snapshot, &atom, "NAME");
+		the->nameModulo = atom.atomSize / sizeof(txSlot*);
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->nameTable, atom.atomSize));
+		fxReadSlotTable(the, snapshot, the->nameTable, the->nameModulo);
+
+		fxReadAtom(the, snapshot, &atom, "SYMB");
+		the->symbolModulo = atom.atomSize / sizeof(txSlot*);
+		mxThrowIf((*snapshot->read)(snapshot->stream, the->symbolTable, atom.atomSize));
+		fxReadSlotTable(the, snapshot, the->symbolTable, the->symbolModulo);
+	
+		fxLinkChunks(the);
+	}
+	mxCatch(the) {
+		
+	}
+	return (snapshot->error) ? 0 : 1;
+}
+
+void fxWriteChunk(txMachine* the, txSnapshot* snapshot, txSlot* slot)
+{
+	switch (slot->kind) {
+	case XS_STRING_KIND:
+		fxWriteChunkData(the, snapshot, slot->value.string);
+		break;
+	case XS_BIGINT_KIND:
+		fxWriteChunkBigInt(the, snapshot, slot->value.bigint.data, slot->value.bigint.size);
+		break;
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_ARRAY_KIND:
+		if (slot->value.array.address)
+			fxWriteChunkArray(the, snapshot, slot->value.array.address, slot->value.array.length, 2);
+		break;
+	case XS_STACK_KIND:
+		if (slot->value.array.address)
+			fxWriteChunkArray(the, snapshot, slot->value.array.address, slot->value.array.length, 0);
+		break;
+	case XS_ARRAY_BUFFER_KIND:
+		if (slot->value.arrayBuffer.address)
+			fxWriteChunkData(the, snapshot, slot->value.arrayBuffer.address);
+		break;
+	
+	case XS_CODE_KIND:
+		fxWriteChunkData(the, snapshot, slot->value.code.address);
+		break;
+	
+	case XS_REGEXP_KIND:
+		if (slot->value.regexp.code)
+			fxWriteChunkData(the, snapshot, slot->value.regexp.code);
+		if (slot->value.regexp.data)
+			fxWriteChunkData(the, snapshot, slot->value.regexp.data);
+		break;
+	case XS_KEY_KIND:
+		if (slot->value.key.string)
+			fxWriteChunkData(the, snapshot, slot->value.key.string);
+		break;
+	case XS_GLOBAL_KIND:
+	case XS_MAP_KIND:
+	case XS_SET_KIND:
+		fxWriteChunkTable(the, snapshot, slot->value.table.address, slot->value.table.length);
+		break;
+		
+	case XS_HOST_KIND:
+		if (slot->value.host.data)
+			fxWriteChunkData(the, snapshot, slot->value.host.data);
+		break;
+	}
+}
+
+void fxWriteChunkArray(txMachine* the, txSnapshot* snapshot, txSlot* address, txSize length, txFlag flag)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (chunk->size & mxChunkFlag) {
+		txByte* temporary = chunk->temporary;
+		chunk->size &= ~mxChunkFlag;
+		chunk->temporary = C_NULL;
+		txSize size;
+		mxThrowIf((*snapshot->write)(snapshot->stream, chunk, sizeof(txChunk)));
+		chunk->temporary = temporary;
+		size = chunk->size - sizeof(txChunk);
+		while (size > 0) {
+			fxWriteSlot(the, snapshot, address, flag);
+			address++;
+			size -= sizeof(txSlot);
+		}
+		address = (txSlot*)(((txByte*)(chunk)) + sizeof(txChunk));
+		size = chunk->size - sizeof(txChunk);
+		while (size > 0) {
+			fxWriteChunk(the, snapshot, address);
+			address++;
+			size -= sizeof(txSlot);
+		}
+	}
+}
+
+void fxWriteChunkBigInt(txMachine* the, txSnapshot* snapshot, void* address, txSize size)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (chunk->size & mxChunkFlag) {
+		txByte* temporary = chunk->temporary;
+		size <<= 2;
+		chunk->size &= ~mxChunkFlag;
+		chunk->temporary = C_NULL;
+		mxThrowIf((*snapshot->write)(snapshot->stream, chunk, sizeof(txChunk) + size));
+		chunk->temporary = temporary;
+		fxWriteChunkZero(the, snapshot, chunk->size - sizeof(txChunk) - size);
+	}
+}
+
+void fxWriteChunkData(txMachine* the, txSnapshot* snapshot, void* address)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (chunk->size & mxChunkFlag) {
+		txByte* temporary = chunk->temporary;
+		chunk->size &= ~mxChunkFlag;
+		chunk->temporary = C_NULL;
+		mxThrowIf((*snapshot->write)(snapshot->stream, chunk, chunk->size));
+		chunk->temporary = temporary;
+	}
+}
+
+void fxWriteChunkTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length)
+{
+	txChunk* chunk = (txChunk*)(((txByte*)(address)) - sizeof(txChunk));
+	if (chunk->size & mxChunkFlag) {
+		txByte* temporary = chunk->temporary;
+		chunk->size &= ~mxChunkFlag;
+		chunk->temporary = C_NULL;
+		mxThrowIf((*snapshot->write)(snapshot->stream, chunk, sizeof(txChunk)));
+		chunk->temporary = temporary;
+		fxWriteSlotTable(the, snapshot, address, length);
+		fxWriteChunkZero(the, snapshot, chunk->size - sizeof(txChunk) - (length * sizeof(txSlot*)));
+	}
+}
+
+void fxWriteChunkZero(txMachine* the, txSnapshot* snapshot, txSize size)
+{
+	txByte zero = 0;
+	while (size > 0) {
+		mxThrowIf((*snapshot->write)(snapshot->stream, &zero, sizeof(txByte)));
+		size--;
+	}
+}
+
+void fxWriteChunks(txMachine* the, txSnapshot* snapshot)
+{
+	size_t slotSize = snapshot->slotSize;
+	txSlot** slots = snapshot->slots;
+	txSlot* stack = the->stackTop - 1;
+	while (stack >= the->stack) {
+		fxWriteChunk(the, snapshot, stack);
+		stack--;
+	}
+	slotSize--;
+	slots++;
+	while (slotSize) {
+		txSlot* slot = *slots;
+		fxWriteChunk(the, snapshot, slot);
+		slotSize--;
+		slots++;
+	}
+}
+
+void fxWriteSlot(txMachine* the, txSnapshot* snapshot, txSlot* slot, txFlag flag)
+{
+	txSlot buffer;
+	c_memset(&buffer, 0, sizeof(buffer));
+	if (flag == 1)
+		buffer.next = fxProjectSlot(the, snapshot->firstProjection, slot->next);
+	else if (flag == 2)
+		*((txIndex*)&buffer) = *((txIndex*)slot);
+	buffer.ID = slot->ID;
+	buffer.flag = slot->flag;
+	buffer.kind = slot->kind;
+	switch (slot->kind) {
+	case XS_UNINITIALIZED_KIND:
+	case XS_UNDEFINED_KIND:
+	case XS_NULL_KIND:
+		break;
+	case XS_BOOLEAN_KIND:
+		buffer.value.boolean = slot->value.boolean;
+		break;
+	case XS_INTEGER_KIND:
+		buffer.value.integer = slot->value.integer;
+		break;
+	case XS_NUMBER_KIND:
+		buffer.value.number = slot->value.number;
+		break;
+	case XS_STRING_KIND:
+		buffer.value.string = (txString)fxProjectChunk(the, slot->value.string);
+		break;
+	case XS_SYMBOL_KIND:
+		buffer.value.symbol = slot->value.symbol;
+		break;
+	case XS_BIGINT_KIND:
+		buffer.value.bigint.data = (txU4*)fxProjectChunk(the, slot->value.bigint.data);
+		buffer.value.bigint.size = slot->value.bigint.size;
+		buffer.value.bigint.sign = slot->value.bigint.sign;
+		break;
+	case XS_REFERENCE_KIND:
+		buffer.value.reference = fxProjectSlot(the, snapshot->firstProjection, slot->value.reference);
+		break;
+	case XS_CLOSURE_KIND:
+		buffer.value.closure = fxProjectSlot(the, snapshot->firstProjection, slot->value.closure);
+		break;
+	case XS_INSTANCE_KIND:
+		buffer.value.instance.prototype = fxProjectSlot(the, snapshot->firstProjection, slot->value.instance.prototype);
+		break;
+		
+	case XS_ARRAY_KIND:
+	case XS_ARGUMENTS_SLOPPY_KIND:
+	case XS_ARGUMENTS_STRICT_KIND:
+	case XS_STACK_KIND:
+		buffer.value.array.address = (txSlot*)fxProjectChunk(the, slot->value.array.address);
+		buffer.value.array.length = slot->value.array.length;
+		break;
+	case XS_ARRAY_BUFFER_KIND:
+		buffer.value.arrayBuffer.address = (txByte*)fxProjectChunk(the, slot->value.arrayBuffer.address);
+		break;
+	case XS_BUFFER_INFO_KIND:
+		buffer.value.bufferInfo.length = slot->value.bufferInfo.length;
+		buffer.value.bufferInfo.maxLength = slot->value.bufferInfo.maxLength;
+		break;
+	case XS_CALLBACK_KIND:
+		buffer.value.callback.address = fxProjectCallback(the, snapshot, slot->value.callback.address);
+		break;
+	case XS_CODE_KIND:
+		buffer.value.code.address = (txByte*)fxProjectChunk(the, slot->value.code.address);
+		buffer.value.code.closures = fxProjectSlot(the, snapshot->firstProjection, slot->value.code.closures);
+		break;
+	case XS_CODE_X_KIND:
+		break;
+	case XS_DATE_KIND:
+		buffer.value.number = slot->value.number;
+		break;
+	case XS_DATA_VIEW_KIND:
+		buffer.value.dataView.offset = slot->value.dataView.offset;
+		buffer.value.dataView.size = slot->value.dataView.size;
+		break;
+	case XS_FINALIZATION_CELL_KIND:
+		buffer.value.finalizationCell.target = fxProjectSlot(the, snapshot->firstProjection, slot->value.finalizationCell.target);
+		buffer.value.finalizationCell.token = fxProjectSlot(the, snapshot->firstProjection, slot->value.finalizationCell.token);
+		break;
+	case XS_FINALIZATION_REGISTRY_KIND:
+		buffer.value.finalizationRegistry.callback = fxProjectSlot(the, snapshot->firstProjection, slot->value.finalizationRegistry.callback);
+		buffer.value.finalizationRegistry.flags = slot->value.finalizationRegistry.flags;
+		break;
+	case XS_TYPED_ARRAY_KIND:
+		buffer.value.typedArray.dispatch = fxProjectTypeDispatch(the, slot->value.typedArray.dispatch);
+		buffer.value.typedArray.atomics = fxProjectTypeAtomics(the, slot->value.typedArray.atomics);
+		break;
+	case XS_GLOBAL_KIND:
+	case XS_MAP_KIND:
+	case XS_SET_KIND:
+		buffer.value.table.address = (txSlot**)fxProjectChunk(the, slot->value.table.address);
+		buffer.value.table.length = slot->value.table.length;
+		break;
+		
+	case XS_WEAK_MAP_KIND:
+	case XS_WEAK_SET_KIND:
+		buffer.value.weakList.first = fxProjectSlot(the, snapshot->firstProjection, slot->value.weakList.first);
+		buffer.value.weakList.link = C_NULL;
+		break;
+	case XS_WEAK_ENTRY_KIND:
+		buffer.value.weakEntry.check = fxProjectSlot(the, snapshot->firstProjection, slot->value.weakEntry.check);
+		buffer.value.weakEntry.value = fxProjectSlot(the, snapshot->firstProjection, slot->value.weakEntry.value);
+		break;
+	case XS_WEAK_REF_KIND:
+		buffer.value.weakRef.target = fxProjectSlot(the, snapshot->firstProjection, slot->value.weakRef.target);
+		buffer.value.weakRef.link = fxProjectSlot(the, snapshot->firstProjection, slot->value.weakRef.link);
+		break;
+
+	case XS_MODULE_KIND:
+	case XS_PROGRAM_KIND:
+	case XS_MODULE_SOURCE_KIND:
+		buffer.value.module.realm = fxProjectSlot(the, snapshot->firstProjection, slot->value.module.realm);
+		buffer.value.module.id = slot->value.module.id;
+		break;
+		
+	case XS_PROMISE_KIND:
+		buffer.value.integer = slot->value.integer;
+		break;
+	case XS_PROXY_KIND:
+		buffer.value.proxy.handler = fxProjectSlot(the, snapshot->firstProjection, slot->value.proxy.handler);
+		buffer.value.proxy.target = fxProjectSlot(the, snapshot->firstProjection, slot->value.proxy.target);
+		break;
+	case XS_REGEXP_KIND:
+		buffer.value.regexp.code = (void*)fxProjectChunk(the, slot->value.regexp.code);
+		buffer.value.regexp.data = (void*)fxProjectChunk(the, slot->value.regexp.data);
+		break;
+		
+	case XS_ACCESSOR_KIND:
+		buffer.value.accessor.getter = fxProjectSlot(the, snapshot->firstProjection, slot->value.accessor.getter);
+		buffer.value.accessor.setter = fxProjectSlot(the, snapshot->firstProjection, slot->value.accessor.setter);
+		break;
+	case XS_AT_KIND:
+		buffer.value.at.index = slot->value.at.index;
+		buffer.value.at.id = slot->value.at.id;
+		break;
+	case XS_ENTRY_KIND:
+		buffer.value.entry.slot = fxProjectSlot(the, snapshot->firstProjection, slot->value.entry.slot);
+		buffer.value.entry.sum = slot->value.entry.sum;
+		break;
+	case XS_ERROR_KIND:
+		buffer.value.error.info = fxProjectSlot(the, snapshot->firstProjection, slot->value.error.info);
+		buffer.value.error.which = slot->value.error.which;
+		break;
+	case XS_HOME_KIND:
+		buffer.value.home.object = fxProjectSlot(the, snapshot->firstProjection, slot->value.home.object);
+		buffer.value.home.module = fxProjectSlot(the, snapshot->firstProjection, slot->value.home.module);
+		break;
+	case XS_KEY_KIND:
+	case XS_KEY_X_KIND:
+		buffer.value.key.string = (txString)fxProjectChunk(the, slot->value.key.string);
+		buffer.value.key.sum = slot->value.key.sum;
+		break;
+	case XS_LIST_KIND:
+		buffer.value.list.first = fxProjectSlot(the, snapshot->firstProjection, slot->value.list.first);
+		buffer.value.list.last = fxProjectSlot(the, snapshot->firstProjection, slot->value.list.last);
+		break;
+	case XS_PRIVATE_KIND:
+		buffer.value.private.check = fxProjectSlot(the, snapshot->firstProjection, slot->value.private.check);
+		buffer.value.private.first = fxProjectSlot(the, snapshot->firstProjection, slot->value.private.first);
+		break;
+	case XS_EXPORT_KIND:
+		buffer.value.export.closure = fxProjectSlot(the, snapshot->firstProjection, slot->value.export.closure);
+		buffer.value.export.module = fxProjectSlot(the, snapshot->firstProjection, slot->value.export.module);
+		break;
+	case XS_FRAME_KIND:
+		buffer.next = C_NULL;
+		break;
+		
+	case XS_HOST_KIND:
+		buffer.value.host.data = fxProjectChunk(the, slot->value.host.data);
+		buffer.value.host.variant.destructor = C_NULL;
+		break;
+	default:
+		fxReport(the, "# snapshot: invalid slot %d!\n", slot->kind);
+		break;
+	}
+	mxThrowIf((*snapshot->write)(snapshot->stream, &buffer, sizeof(buffer)));
+}
+
+void fxWriteSlotTable(txMachine* the, txSnapshot* snapshot, txSlot** address, txSize length)
+{
+	while (length > 0) {
+		txSlot* buffer = fxProjectSlot(the, snapshot->firstProjection, *address);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &buffer, sizeof(txSlot*)));
+		address++;
+		length--;
+	}
+}
+
+void fxWriteSlots(txMachine* the, txSnapshot* snapshot)
+{
+	size_t slotSize = snapshot->slotSize;
+	txSlot** slots = snapshot->slots;
+	slotSize--;
+	slots++;
+	while (slotSize) {
+		txSlot* slot = *slots;
+		fxWriteSlot(the, snapshot, slot, 1);
+		slotSize--;
+		slots++;
+	}
+}
+
+void fxWriteStack(txMachine* the, txSnapshot* snapshot)
+{
+	txSlot* slot = the->stack;
+	while (slot < the->stackTop) {
+		fxWriteSlot(the, snapshot, slot, 0);
+		slot++;
+	}
+}
+
+int fxWriteSnapshot(txMachine* the, txSnapshot* snapshot)
+{
+	txSlot* heap;
+	txSlot* stack;
+	txSlot** slots;
+	txSize size;
+	txByte byte;
+	txProjection** projectionAddress = &(snapshot->firstProjection);
+	txProjection* projection;
+	txSize chunkSize = 0;
+	txSize namesSize = the->nameModulo * sizeof(txSlot*);
+	txSize keysSize = the->keyIndex * sizeof(txSlot*);
+	txSize slotSize = 0;
+	txSize stackSize = (txSize)((the->stackTop - the->stack) * sizeof(txSlot));
+	txSize symbolsSize = the->symbolModulo * sizeof(txSlot*);
+	txCreation creation;
+	
+	mxTry(the) {
+		snapshot->error = 0;
+		fxCollectGarbage(the);
+		fxUnlinkChunks(the);
+		
+		fxIndexSlots(the, snapshot);
+	
+		stack = the->stackTop - 1;
+		while (stack >= the->stack) {
+			fxMeasureSlot(the, snapshot, stack, &chunkSize);
+			stack--;
+		}
+		slotSize = snapshot->slotSize;
+		slots = snapshot->slots;
+		slotSize--;
+		slots++;
+		while (slotSize) {
+			txSlot* slot = *slots;
+			fxMeasureSlot(the, snapshot, slot, &chunkSize);
+			slotSize--;
+			slots++;
+		}
+
+		slotSize = (snapshot->slotSize - 1) * sizeof(txSlot);
+	
+		creation.initialChunkSize = the->maximumChunksSize;
+		creation.incrementalChunkSize = the->minimumChunksSize;
+		creation.initialHeapCount = the->maximumHeapCount + 1;
+		creation.incrementalHeapCount = the->minimumHeapCount;
+		creation.stackCount = (txSize)(the->stackTop - the->stackBottom);
+		creation.initialKeyCount = the->keyCount;
+		creation.incrementalKeyCount = the->keyDelta;
+		creation.nameModulo = the->nameModulo;
+		creation.symbolModulo = the->symbolModulo;
+		creation.parserBufferSize = the->parserBufferSize;
+		creation.parserTableModulo = the->parserTableModulo;
+		creation.staticSize = 0;
+	
+		size = 8 
+			+ 8 + 4 
+			+ 8 + snapshot->signatureLength
+			+ 8 + sizeof(txCreation) 
+			+ 8 + chunkSize
+			+ 8 + slotSize
+			+ 8 + stackSize
+			+ 8 + keysSize
+			+ 8 + namesSize 
+			+ 8 + symbolsSize 
+			;
+
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "XS_M", 4));
+
+		size = 8 + 4;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "VERS", 4));
+		byte = XS_MAJOR_VERSION;
+		mxThrowIf((*snapshot->write)(snapshot->stream, &byte, 1));
+		byte = XS_MINOR_VERSION;
+		mxThrowIf((*snapshot->write)(snapshot->stream, &byte, 1));
+		byte = XS_PATCH_VERSION;
+		mxThrowIf((*snapshot->write)(snapshot->stream, &byte, 1));
+	#if mxBigEndian
+		byte = -((txByte)sizeof(txSlot));
+	#else
+		byte = (txByte)sizeof(txSlot);
+	#endif
+		mxThrowIf((*snapshot->write)(snapshot->stream, &byte, 1));
+
+		size = 8 + snapshot->signatureLength;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "SIGN", 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, snapshot->signature, snapshot->signatureLength));
+
+		size = 8 + sizeof(txCreation) + sizeof(txID) + sizeof(txInteger);
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "CREA", 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, &creation, sizeof(txCreation)));
+		mxThrowIf((*snapshot->write)(snapshot->stream, &(the->profileID), sizeof(txID)));
+		mxThrowIf((*snapshot->write)(snapshot->stream, &(the->tag), sizeof(txInteger)));
+
+		size = 8 + chunkSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "BLOC", 4));
+		fxWriteChunks(the, snapshot);
+	
+		size = 8 + slotSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "HEAP", 4));
+		fxWriteSlots(the, snapshot);
+
+		size = 8 + stackSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "STAC", 4));
+		fxWriteStack(the, snapshot);
+	
+		size = 8 + keysSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "KEYS", 4));
+		fxWriteSlotTable(the, snapshot, the->keyArray, the->keyIndex);
+
+		size = 8 + namesSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "NAME", 4));
+		fxWriteSlotTable(the, snapshot, the->nameTable, the->nameModulo);
+
+		size = 8 + symbolsSize;
+		size = htonl(size);
+		mxThrowIf((*snapshot->write)(snapshot->stream, &size, 4));
+		mxThrowIf((*snapshot->write)(snapshot->stream, "SYMB", 4));
+		fxWriteSlotTable(the, snapshot, the->symbolTable, the->symbolModulo);
+	}
+	mxCatch(the) {
+		
+	}
+	if (snapshot->slots)
+		c_free(snapshot->slots);
+	
+	projectionAddress = &(snapshot->firstProjection);
+	while ((projection = *projectionAddress)) {
+		*projectionAddress = projection->nextProjection;
+		c_free(projection);
+	}
+
+	heap = the->freeHeap;
+	while (heap) {
+		heap->flag &= ~XS_MARK_FLAG;
+		heap = heap->next;
+	}
+	
+	fxLinkChunks(the);
+	
+	return (snapshot->error) ? 0 : 1;
+}