webpack 5.110.3 → 5.111.0

package/lib/runtime/OnChunksLoadedRuntimeModule.js

@@ -7,12 +7,31 @@
 const RuntimeGlobals = require("../RuntimeGlobals");
 const RuntimeModule = require("../RuntimeModule");
 const Template = require("../Template");
+const { getOnlyHandlerKey } = require("../util/handlerKeys");
+const { propertyAccess } = require("../util/property");
 
 /** @import Compilation from "../Compilation" */
+/** @import { ReadOnlyRuntimeRequirements } from "../Module" */
 
 class OnChunksLoadedRuntimeModule extends RuntimeModule {
-	constructor() {
+	/**
+	 * @param {ReadOnlyRuntimeRequirements} runtimeRequirements runtime requirements
+	 */
+	constructor(runtimeRequirements) {
 		super("chunk loaded");
+		/** @type {ReadOnlyRuntimeRequirements} */
+		this.runtimeRequirements = runtimeRequirements;
+	}
+
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		// Reads a map rather than installing onto one, so reading its code back would
+		// render it in a cycle.
+		return RuntimeModule.NO_CHUNK_HANDLERS;
 	}
 
 	/**
@@ -22,24 +41,38 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 	generate() {
 		const compilation = /** @type {Compilation} */ (this.compilation);
 		const { runtimeTemplate } = compilation;
+		// Only a prefetch startup callback is queued behind a priority, so without one
+		// the queue keeps insertion order and nothing has to hold the lowest seen.
+		const withPriority = this.runtimeRequirements.has(
+			RuntimeGlobals.hasChunkPriority
+		);
+		const only = getOnlyHandlerKey(this, RuntimeGlobals.onChunksLoaded);
 		return Template.asString([
 			`${runtimeTemplate.renderConst()} deferred = [];`,
 			`${RuntimeGlobals.onChunksLoaded} = ${runtimeTemplate.basicFunction(
-				"result, chunkIds, fn, priority",
+				`result, chunkIds, fn${withPriority ? ", priority" : ""}`,
 				[
 					"if(chunkIds) {",
-					Template.indent([
-						`${runtimeTemplate.assignOr("priority", "0")};`,
-						"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
-						"deferred[i] = [chunkIds, fn, priority];",
-						"return;"
-					]),
+					Template.indent(
+						withPriority
+							? [
+									`${runtimeTemplate.assignOr("priority", "0")};`,
+									"for(var i = deferred.length; i > 0 && deferred[i - 1][2] > priority; i--) deferred[i] = deferred[i - 1];",
+									"deferred[i] = [chunkIds, fn, priority];",
+									"return;"
+								]
+							: ["deferred.push([chunkIds, fn]);", "return;"]
+					),
 					"}",
-					`${runtimeTemplate.renderLet()} notFulfilled = Infinity;`,
+					...(withPriority
+						? [`${runtimeTemplate.renderLet()} notFulfilled = Infinity;`]
+						: []),
 					"for (var i = 0; i < deferred.length; i++) {",
 					Template.indent([
 						runtimeTemplate.destructureArray(
-							["chunkIds", "fn", "priority"],
+							withPriority
+								? ["chunkIds", "fn", "priority"]
+								: ["chunkIds", "fn"],
 							"deferred[i]"
 						),
 						`${runtimeTemplate.renderLet()} fulfilled = true;`,
@@ -47,18 +80,32 @@ class OnChunksLoadedRuntimeModule extends RuntimeModule {
 						Template.indent([
 							// Parenthesized: `&` binds looser than `===`, so `priority & 1 === 0`
 							// is `priority & false` and gates every priority, not just the odd ones.
-							`if (((priority & 1) === 0 || notFulfilled >= priority) && Object.keys(${
-								RuntimeGlobals.onChunksLoaded
-							}).every(${runtimeTemplate.returningFunction(
-								`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
-								"key"
-							)})) {`,
+							`if (${
+								withPriority
+									? "((priority & 1) === 0 || notFulfilled >= priority) && "
+									: ""
+							}${
+								only === null
+									? `Object.keys(${
+											RuntimeGlobals.onChunksLoaded
+										}).every(${runtimeTemplate.returningFunction(
+											`${RuntimeGlobals.onChunksLoaded}[key](chunkIds[j])`,
+											"key"
+										)})`
+									: `${RuntimeGlobals.onChunksLoaded}${propertyAccess([
+											only
+										])}(chunkIds[j])`
+							}) {`,
 							Template.indent(["chunkIds.splice(j--, 1);"]),
 							"} else {",
-							Template.indent([
-								"fulfilled = false;",
-								"if(priority < notFulfilled) notFulfilled = priority;"
-							]),
+							Template.indent(
+								withPriority
+									? [
+											"fulfilled = false;",
+											"if(priority < notFulfilled) notFulfilled = priority;"
+										]
+									: ["fulfilled = false;"]
+							),
 							"}"
 						]),
 						"}",

package/lib/runtime/PublicPathRuntimeModule.js

@@ -30,6 +30,15 @@ class PublicPathRuntimeModule extends RuntimeModule {
 		this.publicPath = publicPath;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/RuntimeIdRuntimeModule.js

@@ -25,6 +25,15 @@ class RuntimeIdRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/SpecNamespaceObjectRuntimeModule.js

@@ -0,0 +1,90 @@
+/*
+	MIT License http://www.opensource.org/licenses/mit-license.php
+	Author Alexander Akait @alexander-akait
+*/
+
+"use strict";
+
+const RuntimeGlobals = require("../RuntimeGlobals");
+const Template = require("../Template");
+const HelperRuntimeModule = require("./HelperRuntimeModule");
+
+/** @import Compilation from "../Compilation" */
+
+class SpecNamespaceObjectRuntimeModule extends HelperRuntimeModule {
+	constructor() {
+		super("spec namespace object");
+	}
+
+	/**
+	 * Generates runtime code for this runtime module.
+	 * @returns {string | null} runtime code
+	 */
+	generate() {
+		const compilation = /** @type {Compilation} */ (this.compilation);
+		const { runtimeTemplate } = compilation;
+		const cst = runtimeTemplate.renderConst();
+		const lt = runtimeTemplate.renderLet();
+		const fn = RuntimeGlobals.specNamespaceObject;
+		return Template.asString([
+			`${fn} = ${runtimeTemplate.basicFunction("exports, record, mode", [
+				// One namespace per module: a module's own exports object identifies it,
+				// while a synthesized one is fresh per site, so its record identifies it.
+				`${cst} owner = record || exports;`,
+				`${lt} slots = ${fn}.c.get(owner);`,
+				`if (!slots) ${fn}.c.set(owner, (slots = { __proto__: null }));`,
+				// A synthesized namespace carries different names per mode, so one
+				// module can owe its importers more than one namespace.
+				`${cst} cached = slots[mode];`,
+				"if (cached) return cached;",
+				// The exports object keeps the live bindings; the sealed target
+				// carries only their names, so the traps stay invariant-safe.
+				`${cst} names = Object.getOwnPropertyNames(exports).filter(${runtimeTemplate.returningFunction(
+					"name !== '__esModule'",
+					"name"
+				)}).sort();`,
+				`${cst} target = { __proto__: null };`,
+				"for (var i = 0; i < names.length; i++) Object.defineProperty(target, names[i], { value: undefined, writable: true, enumerable: true, configurable: false });",
+				"Object.defineProperty(target, Symbol.toStringTag, { value: 'Module' });",
+				"Object.preventExtensions(target);",
+				`${cst} own = ${runtimeTemplate.returningFunction(
+					"typeof name === 'string' && Object.prototype.hasOwnProperty.call(target, name)",
+					"name"
+				)};`,
+				`${cst} ns = new Proxy(target, {`,
+				Template.indent([
+					"__proto__: null,",
+					"getPrototypeOf: function() { return null; },",
+					"setPrototypeOf: function(_, proto) { return proto === null; },",
+					"isExtensible: function() { return false; },",
+					"preventExtensions: function() { return true; },",
+					"get: function(_, name, receiver) { return own(name) ? exports[name] : Reflect.get(target, name, receiver); },",
+					"has: function(_, name) { return own(name) || Reflect.has(target, name); },",
+					"ownKeys: function() { return Reflect.ownKeys(target); },",
+					"getOwnPropertyDescriptor: function(_, name) { return own(name) ? { value: exports[name], writable: true, enumerable: true, configurable: false } : Reflect.getOwnPropertyDescriptor(target, name); },",
+					"set: function() { return false; },",
+					// A namespace may only be redefined to the descriptor it
+					// already reports, so anything else is rejected.
+					"defineProperty: function(_, name, descriptor) {",
+					Template.indent([
+						// Symbol keys are ordinary, so redefining Symbol.toStringTag
+						// to the descriptor it already has must still succeed.
+						"if (typeof name === 'symbol') return Reflect.defineProperty(target, name, descriptor);",
+						"if (!own(name) || 'get' in descriptor || 'set' in descriptor) return false;",
+						"if (descriptor.configurable === true || descriptor.enumerable === false || descriptor.writable === false) return false;",
+						"return !('value' in descriptor) || Object.is(descriptor.value, exports[name]);"
+					]),
+					"},",
+					"deleteProperty: function(_, name) { return !own(name) && !Reflect.has(target, name); }"
+				]),
+				"});",
+				"slots[mode] = ns;",
+				"return ns;"
+			])};`,
+			// The same owner must always yield the same namespace.
+			`${fn}.c = new WeakMap();`
+		]);
+	}
+}
+
+module.exports = SpecNamespaceObjectRuntimeModule;

package/lib/runtime/StartupChunkDependenciesRuntimeModule.js

@@ -23,6 +23,15 @@ class StartupChunkDependenciesRuntimeModule extends RuntimeModule {
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/StartupEntrypointRuntimeModule.js

@@ -31,6 +31,15 @@ class StartupEntrypointRuntimeModule extends RuntimeModule {
 		this.asyncChunkLoading = asyncChunkLoading;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/SystemContextRuntimeModule.js

@@ -22,6 +22,15 @@ class SystemContextRuntimeModule extends RuntimeModule {
 		return false;
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/runtime/ToBinaryRuntimeModule.js

@@ -16,6 +16,15 @@ class ToBinaryRuntimeModule extends RuntimeModule {
 		super("to binary");
 	}
 
+	/**
+	 * The `[handlerMap, key]` pairs this module installs onto a chunk handler map
+	 * such as `__webpack_require__.f`, or `null` where it cannot name them.
+	 * @returns {[string, string][] | null} installed chunk handlers (do not mutate)
+	 */
+	getInstalledChunkHandlers() {
+		return RuntimeModule.NO_CHUNK_HANDLERS;
+	}
+
 	/**
 	 * Generates runtime code for this runtime module.
 	 * @returns {string | null} runtime code

package/lib/serialization/ObjectMiddleware.js

@@ -107,21 +107,6 @@ Technically any value can be used.
  * @property {(context: ObjectDeserializerContext<EXPECTED_ANY>) => EXPECTED_ANY} deserialize
  */
 
-/**
- * Updates set size using the provided set.
- * @template T
- * @param {Set<T>} set set
- * @param {number} size count of items to keep
- */
-const setSetSize = (set, size) => {
-	let i = 0;
-	for (const item of set) {
-		if (i++ >= size) {
-			set.delete(item);
-		}
-	}
-};
-
 /**
  * Updates map size using the provided map.
  * @template K, X
@@ -149,6 +134,9 @@ const toHash = (buffer, hashFunction) => {
 	return hash.digest("latin1");
 };
 
+/** Marks an object whose children are still being written; never a real position. */
+const IN_PROGRESS = -1;
+
 const ESCAPE = null;
 const ESCAPE_ESCAPE_VALUE = null;
 const ESCAPE_END_OBJECT = true;
@@ -463,16 +451,22 @@ class ObjectMiddleware extends SerializerMiddleware {
 		let currentPosTypeLookup = 0;
 		/** @type {Map<SerializerConfigWithSerializer, number>} */
 		let objectTypeLookup = new Map();
-		/** @type {Set<ComplexSerializableType>} */
-		const cycleStack = new Set();
+		/**
+		 * One-entry cache in front of `objectTypeLookup`, since runs of one class are common.
+		 * @type {SerializerConfigWithSerializer | undefined}
+		 */
+		let lastConfig;
+		/** @type {number} */
+		let lastConfigIndex = 0;
+		/** @type {ComplexSerializableType[]} */
+		const cycleStack = [];
 		/**
 		 * Returns stack.
 		 * @param {ComplexSerializableType} item item to stack
 		 * @returns {string} stack
 		 */
 		const stackToString = (item) => {
-			const arr = [...cycleStack];
-			arr.push(item);
+			const arr = [...cycleStack, item];
 			return arr
 				.map((item) => {
 					if (typeof item === "string") {
@@ -528,63 +522,35 @@ class ObjectMiddleware extends SerializerMiddleware {
 		};
 		/** @type {undefined | WeakSet<Error>} */
 		let hasDebugInfoAttached;
-		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
-		let ctx = {
-			write(value) {
-				try {
-					process(/** @type {ComplexSerializableType} */ (value));
-				} catch (err) {
-					if (err !== NOT_SERIALIZABLE) {
-						if (hasDebugInfoAttached === undefined) {
-							hasDebugInfoAttached = new WeakSet();
-						}
-						if (!hasDebugInfoAttached.has(/** @type {Error} */ (err))) {
-							/** @type {Error} */
-							(err).message +=
-								`\nwhile serializing ${stackToString(/** @type {ComplexSerializableType} */ (value))}`;
-							hasDebugInfoAttached.add(/** @type {Error} */ (err));
-						}
-					}
-					throw err;
-				}
-				return ctx;
-			},
-			setCircularReference(ref) {
-				addReferenceable(ref);
-			},
-			snapshot() {
-				return {
-					length: result.length,
-					cycleStackSize: cycleStack.size,
-					referenceableSize: referenceable.size,
-					currentPos,
-					objectTypeLookupSize: objectTypeLookup.size,
-					currentPosTypeLookup
-				};
-			},
-			rollback(snapshot) {
-				result.length = snapshot.length;
-				setSetSize(cycleStack, snapshot.cycleStackSize);
-				setMapSize(referenceable, snapshot.referenceableSize);
-				currentPos = snapshot.currentPos;
-				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
-				currentPosTypeLookup = snapshot.currentPosTypeLookup;
-			},
-			...context
+		/**
+		 * Appends the path from the root to `item`, once per error.
+		 * @param {Error} err error thrown while writing `item`
+		 * @param {ComplexSerializableType} item item being written
+		 * @returns {Error} err
+		 */
+		const attachSerializationPath = (err, item) => {
+			if (hasDebugInfoAttached === undefined) {
+				hasDebugInfoAttached = new WeakSet();
+			}
+			if (!hasDebugInfoAttached.has(err)) {
+				err.message += `\nwhile serializing ${stackToString(item)}`;
+				hasDebugInfoAttached.add(err);
+			}
+			return err;
 		};
-		this.extendContext(ctx);
 		// Dispatched on `typeof` first: two thirds of the items are numbers,
 		// booleans and `undefined`, and only 3% are buffers.
 		/**
-		 * Processes the provided item.
+		 * Writes one item into the output; the context is returned so writes chain.
 		 * @param {ComplexSerializableType} item item to serialize
+		 * @returns {ObjectSerializerContext<EXPECTED_ANY>} context
 		 */
 		const process = (item) => {
 			switch (typeof item) {
 				case "number":
 				case "boolean":
 					result.push(item);
-					return;
+					return ctx;
 				case "string": {
 					if (item.length > 1) {
 						// short strings are shorter when not emitting a reference (this saves 1 byte per empty string)
@@ -602,10 +568,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 							) {
 								// A back-reference is `null` + the offset.
 								result.push(ESCAPE, offset);
-								return;
+								return ctx;
 							}
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 					}
 
 					if (item.length > 102400 && context.logger) {
@@ -617,87 +583,115 @@ class ObjectMiddleware extends SerializerMiddleware {
 					}
 
 					result.push(item);
-					return;
+					return ctx;
 				}
 				case "undefined":
 					result.push(ESCAPE, ESCAPE_UNDEFINED);
-					return;
+					return ctx;
 				case "object": {
 					// ESCAPE is null, so this covers null too
 					if (item === ESCAPE) {
 						result.push(ESCAPE, ESCAPE_ESCAPE_VALUE);
-						return;
+						return ctx;
 					}
 
-					if (Buffer.isBuffer(item)) {
-						// check if we can emit a reference
-						const ref = referenceable.get(item);
-						if (ref !== undefined) {
-							result.push(ESCAPE, ref - currentPos);
-							return;
+					// buffers and objects share one reference table, so a single
+					// lookup answers both before the costlier buffer test
+					const ref = referenceable.get(item);
+					if (ref !== undefined) {
+						if (ref === IN_PROGRESS) {
+							throw attachSerializationPath(
+								new Error(
+									"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
+								),
+								item
+							);
 						}
+						result.push(ESCAPE, ref - currentPos);
+						return ctx;
+					}
+
+					if (Buffer.isBuffer(item)) {
 						const alreadyUsedBuffer = dedupeBuffer(item);
 						if (alreadyUsedBuffer !== item) {
 							const ref = referenceable.get(alreadyUsedBuffer);
 							if (ref !== undefined) {
 								referenceable.set(item, ref);
 								result.push(ESCAPE, ref - currentPos);
-								return;
+								return ctx;
 							}
 							item = alreadyUsedBuffer;
 						}
-						addReferenceable(item);
+						referenceable.set(item, currentPos++);
 
 						result.push(/** @type {Buffer} */ (item));
-						return;
-					}
-
-					// check if we can emit a reference
-					const ref = referenceable.get(item);
-					if (ref !== undefined) {
-						result.push(ESCAPE, ref - currentPos);
-						return;
-					}
-
-					if (cycleStack.has(item)) {
-						throw new Error(
-							"This is a circular references. To serialize circular references use 'setCircularReference' somewhere in the circle during serialize and deserialize."
-						);
+						return ctx;
 					}
 
 					// Keyed by the registration itself: one per class, so it stands in for
 					// `${request}/${name}` without building that string per object.
-					const config = ObjectMiddleware.getSerializerFor(
-						/** @type {Constructor} */
-						(item)
+					const proto = Object.getPrototypeOf(item);
+					const registered = serializers.get(
+						proto === null ? null : proto.constructor
 					);
+					/** @type {SerializerConfigWithSerializer} */
+					let config;
+					if (registered !== undefined && registered.serializer !== undefined) {
+						config = /** @type {SerializerConfigWithSerializer} */ (registered);
+					} else {
+						try {
+							// re-resolved so the miss reports which class is unregistered
+							config = ObjectMiddleware.getSerializerFor(
+								/** @type {Constructor} */
+								(item)
+							);
+						} catch (err) {
+							if (err === NOT_SERIALIZABLE) throw err;
+							throw attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+					}
 					const { request, name, serializer } = config;
-					const lastIndex = objectTypeLookup.get(config);
+					const lastIndex =
+						config === lastConfig
+							? lastConfigIndex
+							: objectTypeLookup.get(config);
 
 					if (lastIndex === undefined) {
-						objectTypeLookup.set(config, currentPosTypeLookup++);
+						lastConfigIndex = currentPosTypeLookup++;
+						objectTypeLookup.set(config, lastConfigIndex);
 
 						result.push(ESCAPE, request, name);
 					} else {
+						lastConfigIndex = lastIndex;
 						result.push(ESCAPE, currentPosTypeLookup - lastIndex);
 					}
+					lastConfig = config;
 
-					cycleStack.add(item);
+					referenceable.set(item, IN_PROGRESS);
+					cycleStack.push(item);
 
 					try {
 						serializer.serialize(item, ctx);
-					} finally {
-						cycleStack.delete(item);
+					} catch (err) {
+						cycleStack.pop();
+						if (err !== NOT_SERIALIZABLE) {
+							attachSerializationPath(/** @type {Error} */ (err), item);
+						}
+						throw err;
 					}
+					cycleStack.pop();
 
 					result.push(ESCAPE, ESCAPE_END_OBJECT);
 
-					addReferenceable(item);
-					return;
+					referenceable.set(item, currentPos++);
+					return ctx;
 				}
 				case "function": {
 					if (!SerializerMiddleware.isLazy(item)) {
-						throw new Error(`Unexpected function ${item}`);
+						throw attachSerializationPath(
+							new Error(`Unexpected function ${item}`),
+							item
+						);
 					}
 
 					/** @type {SerializedType | undefined} */
@@ -708,10 +702,10 @@ class ObjectMiddleware extends SerializerMiddleware {
 						if (typeof serializedData === "function") {
 							result.push(serializedData);
 						} else {
-							throw new Error("Not implemented");
+							throw attachSerializationPath(new Error("Not implemented"), item);
 						}
 					} else if (SerializerMiddleware.isLazy(item, this)) {
-						throw new Error("Not implemented");
+						throw attachSerializationPath(new Error("Not implemented"), item);
 					} else {
 						const data =
 							/** @type {() => PrimitiveSerializableType[] | Promise<PrimitiveSerializableType[]>} */
@@ -723,12 +717,50 @@ class ObjectMiddleware extends SerializerMiddleware {
 						SerializerMiddleware.setLazySerializedValue(item, data);
 						result.push(data);
 					}
-					return;
+					return ctx;
 				}
 				default:
 					result.push(item);
 			}
+			return ctx;
 		};
+		/** @type {ObjectSerializerContext<EXPECTED_ANY>} */
+		let ctx = {
+			write: process,
+			setCircularReference(ref) {
+				addReferenceable(ref);
+			},
+			snapshot() {
+				return {
+					length: result.length,
+					cycleStackSize: cycleStack.length,
+					referenceableSize: referenceable.size,
+					currentPos,
+					objectTypeLookupSize: objectTypeLookup.size,
+					currentPosTypeLookup
+				};
+			},
+			rollback(snapshot) {
+				result.length = snapshot.length;
+				cycleStack.length = snapshot.cycleStackSize;
+				// a `setCircularReference` since the snapshot replaced a marker on an
+				// item already keyed here, which `setMapSize` cannot undo
+				for (let i = 0; i < cycleStack.length; i++) {
+					const item = /** @type {ReferenceableItem} */ (cycleStack[i]);
+					const ref = referenceable.get(item);
+					if (ref !== undefined && ref >= snapshot.currentPos) {
+						referenceable.set(item, IN_PROGRESS);
+					}
+				}
+				setMapSize(referenceable, snapshot.referenceableSize);
+				currentPos = snapshot.currentPos;
+				setMapSize(objectTypeLookup, snapshot.objectTypeLookupSize);
+				lastConfig = undefined;
+				currentPosTypeLookup = snapshot.currentPosTypeLookup;
+			},
+			...context
+		};
+		this.extendContext(ctx);
 
 		try {
 			for (const item of data) {