@xyo-network/xl1-cli 1.21.0 → 1.21.2

package/dist/cli-min.mjs

@@ -53911,7 +53911,7 @@ function getGlobal() {
 }
 const globalObject = getGlobal();
 const nodeBuffer = (_a$4 = globalObject.Buffer) !== null && _a$4 !== void 0 ? _a$4 : null;
-const textEncoder$2 = globalObject.TextEncoder
+const textEncoder$1 = globalObject.TextEncoder
     ? new globalObject.TextEncoder()
     : null;
 function hexCharCodesToInt(a, b) {
@@ -53966,7 +53966,7 @@ const getUInt8Buffer = nodeBuffer !== null
     }
     : (data) => {
         if (typeof data === "string") {
-            return textEncoder$2.encode(data);
+            return textEncoder$1.encode(data);
         }
         if (ArrayBuffer.isView(data)) {
             return new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
@@ -74472,6 +74472,13 @@ var StorageConfigZod = object$4({
     type: "string"
   })
 }).describe("Storage configuration options");
+var DefaultMetricsScrapePorts = {
+  api: 9465,
+  bridge: 9468,
+  mempool: 9466,
+  producer: 9464,
+  rewardRedemptionApi: 9467
+};
 var MetricsScrapeConfigZod = object$4({
   path: string$2().default("/metrics").register(globalRegistry, {
     default: "/metrics",
@@ -186922,20 +186929,7 @@ var NamedLmdbArchivist = class extends LmdbArchivist {
 };
 
 // src/node/manifest/getLocator.ts
-var getLocator$1 = /* @__PURE__ */ __name$8(async ({ logger, config }) => {
-  const { otlpEndpoint } = config.telemetry?.otel ?? {};
-  const { path: endpoint = "/metrics", port = 9465 } = config.telemetry?.metrics?.scrape ?? {};
-  const { traceProvider, meterProvider } = await initTelemetry({
-    attributes: {
-      serviceName: "xl1-api",
-      serviceVersion: "1.0.0"
-    },
-    otlpEndpoint,
-    metricsConfig: {
-      endpoint,
-      port
-    }
-  });
+var getLocator$1 = /* @__PURE__ */ __name$8(async ({ logger, traceProvider, meterProvider, config }) => {
   if (isDefined(logger)) AbstractModule.defaultLogger = logger;
   const statusReporter = logger ? new LoggerModuleStatusReporter(logger) : void 0;
   const locator = new ModuleFactoryLocator();
@@ -187486,9 +187480,9 @@ async function buildStatelessApiLocator(context, needs) {
   return result.locator;
 }
 __name$8(buildStatelessApiLocator, "buildStatelessApiLocator");
-async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
+async function telemetryContextFromConfig(config, serviceName, serviceVersion, defaultScrapePort = 9464) {
   const { otlpEndpoint } = config.telemetry?.otel ?? {};
-  const { path: endpoint = "/metrics", port = 9466 } = config.telemetry?.metrics?.scrape ?? {};
+  const { path: endpoint = "/metrics", port = defaultScrapePort } = config.telemetry?.metrics?.scrape ?? {};
   return await initTelemetry({
     attributes: {
       serviceName,
@@ -187504,10 +187498,10 @@ async function telemetryContextFromConfig(config, serviceName, serviceVersion) {
 __name$8(telemetryContextFromConfig, "telemetryContextFromConfig");
 
 // src/node/config/locators/contextFromConfigWithoutLocator.ts
-async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion) {
+async function contextFromConfigWithoutLocator(config, logger, serviceName, serviceVersion, defaultScrapePort) {
   const singletons = {};
   const caches = {};
-  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion);
+  const telemetryConfig = await telemetryContextFromConfig(config, serviceName, serviceVersion, defaultScrapePort);
   const statusReporter = initStatusReporter({
     logger
   });
@@ -211453,7 +211447,6 @@ const C1 = new C1Type();
 C1.name = 'MessagePack 0xC1';
 var sequentialMode = false;
 var inlineObjectReadThreshold = 2;
-var readStruct$1, onLoadedStructures$1, onSaveState;
 
 class Unpackr {
 	constructor(options) {
@@ -211483,10 +211476,10 @@ class Unpackr {
 	unpack(source, options) {
 		if (src) {
 			// re-entrant execution, save the state and restore it after we do this unpack
-			return saveState$1(() => {
+			return saveState(() => {
 				clearSource();
-				return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options)
-			})
+				return this ? this.unpack(source, options) : Unpackr.prototype.unpack.call(defaultOptions, source, options);
+			});
 		}
 		if (!source.buffer && source.constructor === ArrayBuffer)
 			source = typeof Buffer !== 'undefined' ? Buffer.from(source) : new Uint8Array(source);
@@ -211512,14 +211505,14 @@ class Unpackr {
 			// if it doesn't have a buffer, maybe it is the wrong type of object
 			src = null;
 			if (source instanceof Uint8Array)
-				throw error
-			throw new Error('Source must be a Uint8Array or Buffer but was a ' + ((source && typeof source == 'object') ? source.constructor.name : typeof source))
+				throw error;
+			throw new Error('Source must be a Uint8Array or Buffer but was a ' + ((source && typeof source == 'object') ? source.constructor.name : typeof source));
 		}
 		if (this instanceof Unpackr) {
 			currentUnpackr = this;
 			if (this.structures) {
 				currentStructures = this.structures;
-				return checkedRead(options)
+				return checkedRead(options);
 			} else if (!currentStructures || currentStructures.length > 0) {
 				currentStructures = [];
 			}
@@ -211528,7 +211521,7 @@ class Unpackr {
 			if (!currentStructures || currentStructures.length > 0)
 				currentStructures = [];
 		}
-		return checkedRead(options)
+		return checkedRead(options);
 	}
 	unpackMultiple(source, forEach) {
 		let values, lastPosition = 0;
@@ -211541,7 +211534,7 @@ class Unpackr {
 				while(position$1 < size) {
 					lastPosition = position$1;
 					if (forEach(checkedRead(), lastPosition, position$1) === false) {
-						return
+						return;
 					}
 				}
 			}
@@ -211551,20 +211544,20 @@ class Unpackr {
 					lastPosition = position$1;
 					values.push(checkedRead());
 				}
-				return values
+				return values;
 			}
 		} catch(error) {
 			error.lastPosition = lastPosition;
 			error.values = values;
-			throw error
+			throw error;
 		} finally {
 			sequentialMode = false;
 			clearSource();
 		}
 	}
 	_mergeStructures(loadedStructures, existingStructures) {
-		if (onLoadedStructures$1)
-			loadedStructures = onLoadedStructures$1.call(this, loadedStructures);
+		if (this._onLoadedStructures)
+			loadedStructures = this._onLoadedStructures(loadedStructures);
 		loadedStructures = loadedStructures || [];
 		if (Object.isFrozen(loadedStructures))
 			loadedStructures = loadedStructures.map(structure => structure.slice(0));
@@ -211588,10 +211581,10 @@ class Unpackr {
 				}
 			}
 		}
-		return this.structures = loadedStructures
+		return this.structures = loadedStructures;
 	}
 	decode(source, options) {
-		return this.unpack(source, options)
+		return this.unpack(source, options);
 	}
 }
 function checkedRead(options) {
@@ -211602,8 +211595,8 @@ function checkedRead(options) {
 				currentStructures.length = sharedLength;
 		}
 		let result;
-		if (currentUnpackr.randomAccessStructure && src[position$1] < 0x40 && src[position$1] >= 0x20 && readStruct$1) {
-			result = readStruct$1(src, position$1, srcEnd, currentUnpackr);
+		if (currentUnpackr._readStruct && src[position$1] < 0x40 && src[position$1] >= 0x20) {
+			result = currentUnpackr._readStruct(src, position$1, srcEnd);
 			src = null; // dispose of this so that recursive unpack calls don't save state
 			if (!(options && options.lazy) && result)
 				result = result.toJSON();
@@ -211629,7 +211622,7 @@ function checkedRead(options) {
 				referenceMap = null;
 		} else if (position$1 > srcEnd) {
 			// over read
-			throw new Error('Unexpected end of MessagePack data')
+			throw new Error('Unexpected end of MessagePack data');
 		} else if (!sequentialMode) {
 			let jsonView;
 			try {
@@ -211637,10 +211630,10 @@ function checkedRead(options) {
 			} catch(error) {
 				jsonView = '(JSON view not available ' + error + ')';
 			}
-			throw new Error('Data read, but end of buffer not reached ' + jsonView)
+			throw new Error('Data read, but end of buffer not reached ' + jsonView);
 		}
 		// else more to read, but we are reading sequentially, so don't clear source yet
-		return result
+		return result;
 	} catch(error) {
 		if (currentStructures && currentStructures.restoreStructures)
 			restoreStructures();
@@ -211648,7 +211641,7 @@ function checkedRead(options) {
 		if (error instanceof RangeError || error.message.startsWith('Unexpected end of buffer') || position$1 > srcEnd) {
 			error.incomplete = true;
 		}
-		throw error
+		throw error;
 	}
 }
 
@@ -211664,7 +211657,7 @@ function read() {
 	if (token < 0xa0) {
 		if (token < 0x80) {
 			if (token < 0x40)
-				return token
+				return token;
 			else {
 				let structure = currentStructures[token & 0x3f] ||
 					currentUnpackr.getStructures && loadStructures()[token & 0x3f];
@@ -211672,9 +211665,9 @@ function read() {
 					if (!structure.read) {
 						structure.read = createStructureReader(structure, token & 0x3f);
 					}
-					return structure.read()
+					return structure.read();
 				} else
-					return token
+					return token;
 			}
 		} else if (token < 0x90) {
 			// map
@@ -211687,13 +211680,13 @@ function read() {
 						key = '__proto_';
 					object[key] = read();
 				}
-				return object
+				return object;
 			} else {
 				let map = new Map();
 				for (let i = 0; i < token; i++) {
 					map.set(read(), read());
 				}
-				return map
+				return map;
 			}
 		} else {
 			token -= 0x90;
@@ -211702,91 +211695,91 @@ function read() {
 				array[i] = read();
 			}
 			if (currentUnpackr.freezeData)
-				return Object.freeze(array)
-			return array
+				return Object.freeze(array);
+			return array;
 		}
 	} else if (token < 0xc0) {
 		// fixstr
 		let length = token - 0xa0;
 		if (srcStringEnd >= position$1) {
-			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart)
+			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart);
 		}
 		if (srcStringEnd == 0 && srcEnd < 140) {
 			// for small blocks, avoiding the overhead of the extract call is helpful
 			let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
 			if (string != null)
-				return string
+				return string;
 		}
-		return readFixedString(length)
+		return readFixedString(length);
 	} else {
 		let value;
 		switch (token) {
-			case 0xc0: return null
+			case 0xc0: return null;
 			case 0xc1:
 				if (bundledStrings$1) {
 					value = read(); // followed by the length of the string in characters (not bytes!)
 					if (value > 0)
-						return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value)
+						return bundledStrings$1[1].slice(bundledStrings$1.position1, bundledStrings$1.position1 += value);
 					else
-						return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 -= value)
+						return bundledStrings$1[0].slice(bundledStrings$1.position0, bundledStrings$1.position0 -= value);
 				}
 				return C1; // "never-used", return special object to denote that
-			case 0xc2: return false
-			case 0xc3: return true
+			case 0xc2: return false;
+			case 0xc3: return true;
 			case 0xc4:
 				// bin 8
 				value = src[position$1++];
 				if (value === undefined)
-					throw new Error('Unexpected end of buffer')
-				return readBin(value)
+					throw new Error('Unexpected end of buffer');
+				return readBin(value);
 			case 0xc5:
 				// bin 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readBin(value)
+				return readBin(value);
 			case 0xc6:
 				// bin 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readBin(value)
+				return readBin(value);
 			case 0xc7:
 				// ext 8
-				return readExt(src[position$1++])
+				return readExt(src[position$1++]);
 			case 0xc8:
 				// ext 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readExt(value)
+				return readExt(value);
 			case 0xc9:
 				// ext 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readExt(value)
+				return readExt(value);
 			case 0xca:
 				value = dataView.getFloat32(position$1);
 				if (currentUnpackr.useFloat32 > 2) {
 					// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 					let multiplier = mult10[((src[position$1] & 0x7f) << 1) | (src[position$1 + 1] >> 7)];
 					position$1 += 4;
-					return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier
+					return ((multiplier * value + (value > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
 				}
 				position$1 += 4;
-				return value
+				return value;
 			case 0xcb:
 				value = dataView.getFloat64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 			// uint handlers
 			case 0xcc:
-				return src[position$1++]
+				return src[position$1++];
 			case 0xcd:
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return value
+				return value;
 			case 0xce:
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return value
+				return value;
 			case 0xcf:
 				if (currentUnpackr.int64AsType === 'number') {
 					value = dataView.getUint32(position$1) * 0x100000000;
@@ -211799,19 +211792,19 @@ function read() {
 				} else
 					value = dataView.getBigUint64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 
 			// int handlers
 			case 0xd0:
-				return dataView.getInt8(position$1++)
+				return dataView.getInt8(position$1++);
 			case 0xd1:
 				value = dataView.getInt16(position$1);
 				position$1 += 2;
-				return value
+				return value;
 			case 0xd2:
 				value = dataView.getInt32(position$1);
 				position$1 += 4;
-				return value
+				return value;
 			case 0xd3:
 				if (currentUnpackr.int64AsType === 'number') {
 					value = dataView.getInt32(position$1) * 0x100000000;
@@ -211824,96 +211817,96 @@ function read() {
 				} else
 					value = dataView.getBigInt64(position$1);
 				position$1 += 8;
-				return value
+				return value;
 
 			case 0xd4:
 				// fixext 1
 				value = src[position$1++];
 				if (value == 0x72) {
-					return recordDefinition(src[position$1++] & 0x3f)
+					return recordDefinition(src[position$1++] & 0x3f);
 				} else {
 					let extension = currentExtensions[value];
 					if (extension) {
 						if (extension.read) {
 							position$1++; // skip filler byte
-							return extension.read(read())
+							return extension.read(read());
 						} else if (extension.noBuffer) {
 							position$1++; // skip filler byte
-							return extension()
+							return extension();
 						} else
-							return extension(src.subarray(position$1, ++position$1))
+							return extension(src.subarray(position$1, ++position$1));
 					} else
-						throw new Error('Unknown extension ' + value)
+						throw new Error('Unknown extension ' + value);
 				}
 			case 0xd5:
 				// fixext 2
 				value = src[position$1];
 				if (value == 0x72) {
 					position$1++;
-					return recordDefinition(src[position$1++] & 0x3f, src[position$1++])
+					return recordDefinition(src[position$1++] & 0x3f, src[position$1++]);
 				} else
-					return readExt(2)
+					return readExt(2);
 			case 0xd6:
 				// fixext 4
-				return readExt(4)
+				return readExt(4);
 			case 0xd7:
 				// fixext 8
-				return readExt(8)
+				return readExt(8);
 			case 0xd8:
 				// fixext 16
-				return readExt(16)
+				return readExt(16);
 			case 0xd9:
 			// str 8
 				value = src[position$1++];
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString8(value)
+				return readString8(value);
 			case 0xda:
 			// str 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString16(value)
+				return readString16(value);
 			case 0xdb:
 			// str 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
 				if (srcStringEnd >= position$1) {
-					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart)
+					return srcString.slice(position$1 - srcStringStart, (position$1 += value) - srcStringStart);
 				}
-				return readString32(value)
+				return readString32(value);
 			case 0xdc:
 			// array 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readArray(value)
+				return readArray(value);
 			case 0xdd:
 			// array 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readArray(value)
+				return readArray(value);
 			case 0xde:
 			// map 16
 				value = dataView.getUint16(position$1);
 				position$1 += 2;
-				return readMap(value)
+				return readMap(value);
 			case 0xdf:
 			// map 32
 				value = dataView.getUint32(position$1);
 				position$1 += 4;
-				return readMap(value)
+				return readMap(value);
 			default: // negative int
 				if (token >= 0xe0)
-					return token - 0x100
+					return token - 0x100;
 				if (token === undefined) {
 					let error = new Error('Unexpected end of MessagePack data');
 					error.incomplete = true;
-					throw error
+					throw error;
 				}
-				throw new Error('Unknown MessagePack token ' + token)
+				throw new Error('Unknown MessagePack token ' + token);
 
 		}
 	}
@@ -211934,7 +211927,7 @@ function createStructureReader(structure, firstId) {
 			}
 			if (structure.highByte === 0)
 				structure.read = createSecondByteReader(firstId, structure.read);
-			return optimizedReadObject() // second byte is already read, if there is one so immediately read object
+			return optimizedReadObject(); // second byte is already read, if there is one so immediately read object
 		}
 		let object = {};
 		for (let i = 0, l = structure.length; i < l; i++) {
@@ -211945,38 +211938,38 @@ function createStructureReader(structure, firstId) {
 		}
 		if (currentUnpackr.freezeData)
 			return Object.freeze(object);
-		return object
+		return object;
 	}
 	readObject.count = 0;
 	if (structure.highByte === 0) {
-		return createSecondByteReader(firstId, readObject)
+		return createSecondByteReader(firstId, readObject);
 	}
-	return readObject
+	return readObject;
 }
 
 const createSecondByteReader = (firstId, read0) => {
 	return function() {
 		let highByte = src[position$1++];
 		if (highByte === 0)
-			return read0()
+			return read0();
 		let id = firstId < 32 ? -(firstId + (highByte << 5)) : firstId + (highByte << 5);
 		let structure = currentStructures[id] || loadStructures()[id];
 		if (!structure) {
-			throw new Error('Record id is not defined for ' + id)
+			throw new Error('Record id is not defined for ' + id);
 		}
 		if (!structure.read)
 			structure.read = createStructureReader(structure, firstId);
-		return structure.read()
-	}
+		return structure.read();
+	};
 };
 
 function loadStructures() {
-	let loadedStructures = saveState$1(() => {
+	let loadedStructures = saveState(() => {
 		// save the state in case getStructures modifies our buffer
 		src = null;
-		return currentUnpackr.getStructures()
+		return currentUnpackr.getStructures();
 	});
-	return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures)
+	return currentStructures = currentUnpackr._mergeStructures(loadedStructures, currentStructures);
 }
 
 var readFixedString = readStringJS;
@@ -211994,7 +211987,7 @@ function setExtractor(extractStrings) {
 			let string = strings[stringPosition++];
 			if (string == null) {
 				if (bundledStrings$1)
-					return readStringJS(length)
+					return readStringJS(length);
 				let byteOffset = src.byteOffset;
 				let extraction = extractStrings(position$1 - headerLength + byteOffset, srcEnd + byteOffset, src.buffer);
 				if (typeof extraction == 'string') {
@@ -212006,30 +211999,30 @@ function setExtractor(extractStrings) {
 					srcStringEnd = 1; // even if a utf-8 string was decoded, must indicate we are in the midst of extracted strings and can't skip strings
 					string = strings[0];
 					if (string === undefined)
-						throw new Error('Unexpected end of buffer')
+						throw new Error('Unexpected end of buffer');
 				}
 			}
 			let srcStringLength = string.length;
 			if (srcStringLength <= length) {
 				position$1 += length;
-				return string
+				return string;
 			}
 			srcString = string;
 			srcStringStart = position$1;
 			srcStringEnd = position$1 + srcStringLength;
 			position$1 += length;
-			return string.slice(0, length) // we know we just want the beginning
-		}
+			return string.slice(0, length); // we know we just want the beginning
+		};
 	}
 }
 function readStringJS(length) {
 	let result;
 	if (length < 16) {
 		if (result = shortStringInJS(length))
-			return result
+			return result;
 	}
 	if (length > 64 && decoder)
-		return decoder.decode(src.subarray(position$1, position$1 += length))
+		return decoder.decode(src.subarray(position$1, position$1 += length));
 	const end = position$1 + length;
 	const units = [];
 	result = '';
@@ -212092,17 +212085,7 @@ function readStringJS(length) {
 		result += fromCharCode.apply(String, units);
 	}
 
-	return result
-}
-function readString(source, start, length) {
-	let existingSrc = src;
-	src = source;
-	position$1 = start;
-	try {
-		return readStringJS(length);
-	} finally {
-		src = existingSrc;
-	}
+	return result;
 }
 
 function readArray(length) {
@@ -212111,8 +212094,8 @@ function readArray(length) {
 		array[i] = read();
 	}
 	if (currentUnpackr.freezeData)
-		return Object.freeze(array)
-	return array
+		return Object.freeze(array);
+	return array;
 }
 
 function readMap(length) {
@@ -212124,13 +212107,13 @@ function readMap(length) {
 				key = '__proto_';
 			object[key] = read();
 		}
-		return object
+		return object;
 	} else {
 		let map = new Map();
 		for (let i = 0; i < length; i++) {
 			map.set(read(), read());
 		}
-		return map
+		return map;
 	}
 }
 
@@ -212142,40 +212125,40 @@ function longStringInJS(length) {
 		const byte = src[position$1++];
 		if ((byte & 0x80) > 0) {
 				position$1 = start;
-				return
+				return;
 			}
 			bytes[i] = byte;
 		}
-		return fromCharCode.apply(String, bytes)
+		return fromCharCode.apply(String, bytes);
 }
 function shortStringInJS(length) {
 	if (length < 4) {
 		if (length < 2) {
 			if (length === 0)
-				return ''
+				return '';
 			else {
 				let a = src[position$1++];
 				if ((a & 0x80) > 1) {
 					position$1 -= 1;
-					return
+					return;
 				}
-				return fromCharCode(a)
+				return fromCharCode(a);
 			}
 		} else {
 			let a = src[position$1++];
 			let b = src[position$1++];
 			if ((a & 0x80) > 0 || (b & 0x80) > 0) {
 				position$1 -= 2;
-				return
+				return;
 			}
 			if (length < 3)
-				return fromCharCode(a, b)
+				return fromCharCode(a, b);
 			let c = src[position$1++];
 			if ((c & 0x80) > 0) {
 				position$1 -= 3;
-				return
+				return;
 			}
-			return fromCharCode(a, b, c)
+			return fromCharCode(a, b, c);
 		}
 	} else {
 		let a = src[position$1++];
@@ -212184,34 +212167,34 @@ function shortStringInJS(length) {
 		let d = src[position$1++];
 		if ((a & 0x80) > 0 || (b & 0x80) > 0 || (c & 0x80) > 0 || (d & 0x80) > 0) {
 			position$1 -= 4;
-			return
+			return;
 		}
 		if (length < 6) {
 			if (length === 4)
-				return fromCharCode(a, b, c, d)
+				return fromCharCode(a, b, c, d);
 			else {
 				let e = src[position$1++];
 				if ((e & 0x80) > 0) {
 					position$1 -= 5;
-					return
+					return;
 				}
-				return fromCharCode(a, b, c, d, e)
+				return fromCharCode(a, b, c, d, e);
 			}
 		} else if (length < 8) {
 			let e = src[position$1++];
 			let f = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0) {
 				position$1 -= 6;
-				return
+				return;
 			}
 			if (length < 7)
-				return fromCharCode(a, b, c, d, e, f)
+				return fromCharCode(a, b, c, d, e, f);
 			let g = src[position$1++];
 			if ((g & 0x80) > 0) {
 				position$1 -= 7;
-				return
+				return;
 			}
-			return fromCharCode(a, b, c, d, e, f, g)
+			return fromCharCode(a, b, c, d, e, f, g);
 		} else {
 			let e = src[position$1++];
 			let f = src[position$1++];
@@ -212219,34 +212202,34 @@ function shortStringInJS(length) {
 			let h = src[position$1++];
 			if ((e & 0x80) > 0 || (f & 0x80) > 0 || (g & 0x80) > 0 || (h & 0x80) > 0) {
 				position$1 -= 8;
-				return
+				return;
 			}
 			if (length < 10) {
 				if (length === 8)
-					return fromCharCode(a, b, c, d, e, f, g, h)
+					return fromCharCode(a, b, c, d, e, f, g, h);
 				else {
 					let i = src[position$1++];
 					if ((i & 0x80) > 0) {
 						position$1 -= 9;
-						return
+						return;
 					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i)
+					return fromCharCode(a, b, c, d, e, f, g, h, i);
 				}
 			} else if (length < 12) {
 				let i = src[position$1++];
 				let j = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0) {
 					position$1 -= 10;
-					return
+					return;
 				}
 				if (length < 11)
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j)
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j);
 				let k = src[position$1++];
 				if ((k & 0x80) > 0) {
 					position$1 -= 11;
-					return
+					return;
 				}
-				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k)
+				return fromCharCode(a, b, c, d, e, f, g, h, i, j, k);
 			} else {
 				let i = src[position$1++];
 				let j = src[position$1++];
@@ -212254,34 +212237,34 @@ function shortStringInJS(length) {
 				let l = src[position$1++];
 				if ((i & 0x80) > 0 || (j & 0x80) > 0 || (k & 0x80) > 0 || (l & 0x80) > 0) {
 					position$1 -= 12;
-					return
+					return;
 				}
 				if (length < 14) {
 					if (length === 12)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l);
 					else {
 						let m = src[position$1++];
 						if ((m & 0x80) > 0) {
 							position$1 -= 13;
-							return
+							return;
 						}
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m);
 					}
 				} else {
 					let m = src[position$1++];
 					let n = src[position$1++];
 					if ((m & 0x80) > 0 || (n & 0x80) > 0) {
 						position$1 -= 14;
-						return
+						return;
 					}
 					if (length < 15)
-						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n)
+						return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n);
 					let o = src[position$1++];
 					if ((o & 0x80) > 0) {
 						position$1 -= 15;
-						return
+						return;
 					}
-					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o)
+					return fromCharCode(a, b, c, d, e, f, g, h, i, j, k, l, m, n, o);
 				}
 			}
 		}
@@ -212299,22 +212282,22 @@ function readOnlyJSString() {
 			case 0xd9:
 			// str 8
 				length = src[position$1++];
-				break
+				break;
 			case 0xda:
 			// str 16
 				length = dataView.getUint16(position$1);
 				position$1 += 2;
-				break
+				break;
 			case 0xdb:
 			// str 32
 				length = dataView.getUint32(position$1);
 				position$1 += 4;
-				break
+				break;
 			default:
-				throw new Error('Expected string')
+				throw new Error('Expected string');
 		}
 	}
-	return readStringJS(length)
+	return readStringJS(length);
 }
 
 
@@ -212322,7 +212305,7 @@ function readBin(length) {
 	return currentUnpackr.copyBuffers ?
 		// specifically use the copying slice (not the node one)
 		Uint8Array.prototype.slice.call(src, position$1, position$1 += length) :
-		src.subarray(position$1, position$1 += length)
+		src.subarray(position$1, position$1 += length);
 }
 function readExt(length) {
 	let type = src[position$1++];
@@ -212335,10 +212318,10 @@ function readExt(length) {
 			} finally {
 				position$1 = end;
 			}
-		})
+		});
 	}
 	else
-		throw new Error('Unknown extension type ' + type)
+		throw new Error('Unknown extension type ' + type);
 }
 
 var keyCache = new Array(4096);
@@ -212348,12 +212331,12 @@ function readKey() {
 		// fixstr, potentially use key cache
 		length = length - 0xa0;
 		if (srcStringEnd >= position$1) // if it has been extracted, must use it (and faster anyway)
-			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart)
+			return srcString.slice(position$1 - srcStringStart, (position$1 += length) - srcStringStart);
 		else if (!(srcStringEnd == 0 && srcEnd < 180))
-			return readFixedString(length)
+			return readFixedString(length);
 	} else { // not cacheable, go back and do a standard read
 		position$1--;
-		return asSafeString(read())
+		return asSafeString(read());
 	}
 	let key = ((length << 5) ^ (length > 1 ? dataView.getUint16(position$1) : length > 0 ? src[position$1] : 0)) & 0xfff;
 	let entry = keyCache[key];
@@ -212366,7 +212349,7 @@ function readKey() {
 			chunk = dataView.getUint32(checkPosition);
 			if (chunk != entry[i++]) {
 				checkPosition = 0x70000000;
-				break
+				break;
 			}
 			checkPosition += 4;
 		}
@@ -212375,12 +212358,12 @@ function readKey() {
 			chunk = src[checkPosition++];
 			if (chunk != entry[i++]) {
 				checkPosition = 0x70000000;
-				break
+				break;
 			}
 		}
 		if (checkPosition === end) {
 			position$1 = checkPosition;
-			return entry.string
+			return entry.string;
 		}
 		end -= 3;
 		checkPosition = position$1;
@@ -212401,8 +212384,8 @@ function readKey() {
 	// for small blocks, avoiding the overhead of the extract call is helpful
 	let string = length < 16 ? shortStringInJS(length) : longStringInJS(length);
 	if (string != null)
-		return entry.string = string
-	return entry.string = readFixedString(length)
+		return entry.string = string;
+	return entry.string = readFixedString(length);
 }
 
 function asSafeString(property) {
@@ -212433,7 +212416,7 @@ const recordDefinition = (id, highByte) => {
 	}
 	currentStructures[id] = structure;
 	structure.read = createStructureReader(structure, firstByte);
-	return structure.read()
+	return structure.read();
 };
 currentExtensions[0] = () => {}; // notepack defines extension 0 to mean undefined, so use that as the default here
 currentExtensions[0].noBuffer = true;
@@ -212455,17 +212438,17 @@ currentExtensions[0x42] = data => {
 					out <<= BigInt(64);
 					out |= view.getBigUint64(i);
 				}
-				return out
+				return out;
 			}
 			// if (length === 8) return view.getBigUint64(start)
 			let middle = start + (length >> 4 << 3);
 			let left = decode(start, middle);
 			let right = decode(middle, end);
-			return (left << BigInt((end - middle) * 8)) | right
+			return (left << BigInt((end - middle) * 8)) | right;
 		};
 		head = (head << BigInt((view.byteLength - headLength) * 8)) | decode(headLength, view.byteLength);
 	}
-	return head
+	return head;
 };
 
 let errors = {
@@ -212476,14 +212459,14 @@ currentExtensions[0x65] = () => {
 	if (!errors[data[0]]) {
 		let error = Error(data[1], { cause: data[2] });
 		error.name = data[0];
-		return error
+		return error;
 	}
-	return errors[data[0]](data[1], { cause: data[2] })
+	return errors[data[0]](data[1], { cause: data[2] });
 };
 
 currentExtensions[0x69] = (data) => {
 	// id extension (for structured clones)
-	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
+	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled');
 	let id = dataView.getUint32(position$1 - 4);
 	if (!referenceMap)
 		referenceMap = new Map();
@@ -212504,7 +212487,7 @@ currentExtensions[0x69] = (data) => {
 	let targetProperties = read(); // read the next value as the target object to id
 	if (!refEntry.used) {
 		// no cycle, can just use the returned read object
-		return refEntry.target = targetProperties // replace the placeholder with the real one
+		return refEntry.target = targetProperties; // replace the placeholder with the real one
 	} else {
 		// there is a cycle, so we have to assign properties to original target
 		Object.assign(target, targetProperties);
@@ -212515,16 +212498,16 @@ currentExtensions[0x69] = (data) => {
 		for (let [k, v] of targetProperties.entries()) target.set(k, v);
 	if (target instanceof Set)
 		for (let i of Array.from(targetProperties)) target.add(i);
-	return target
+	return target;
 };
 
 currentExtensions[0x70] = (data) => {
 	// pointer extension (for structured clones)
-	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled')
+	if (currentUnpackr.structuredClone === false) throw new Error('Structured clone extension is disabled');
 	let id = dataView.getUint32(position$1 - 4);
 	let refEntry = referenceMap.get(id);
 	refEntry.used = true;
-	return refEntry.target
+	return refEntry.target;
 };
 
 currentExtensions[0x73] = () => new Set(read());
@@ -212539,15 +212522,15 @@ currentExtensions[0x74] = (data) => {
 
 	let typedArrayName = typedArrays[typeCode];
 	if (!typedArrayName) {
-		if (typeCode === 16) return buffer
-		if (typeCode === 17) return new DataView(buffer)
-		throw new Error('Could not find typed array for code ' + typeCode)
+		if (typeCode === 16) return buffer;
+		if (typeCode === 17) return new DataView(buffer);
+		throw new Error('Could not find typed array for code ' + typeCode);
 	}
-	return new glbl[typedArrayName](buffer)
+	return new glbl[typedArrayName](buffer);
 };
 currentExtensions[0x78] = () => {
 	let data = read();
-	return new RegExp(data[0], data[1])
+	return new RegExp(data[0], data[1]);
 };
 const TEMP_BUNDLE = [];
 currentExtensions[0x62] = (data) => {
@@ -212560,30 +212543,30 @@ currentExtensions[0x62] = (data) => {
 	bundledStrings$1.position1 = 0;
 	bundledStrings$1.postBundlePosition = position$1;
 	position$1 = dataPosition;
-	return read()
+	return read();
 };
 
 currentExtensions[0xff] = (data) => {
 	// 32-bit date extension
 	if (data.length == 4)
-		return new Date((data[0] * 0x1000000 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1000)
+		return new Date((data[0] * 0x1000000 + (data[1] << 16) + (data[2] << 8) + data[3]) * 1000);
 	else if (data.length == 8)
 		return new Date(
 			((data[0] << 22) + (data[1] << 14) + (data[2] << 6) + (data[3] >> 2)) / 1000000 +
-			((data[3] & 0x3) * 0x100000000 + data[4] * 0x1000000 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1000)
+			((data[3] & 0x3) * 0x100000000 + data[4] * 0x1000000 + (data[5] << 16) + (data[6] << 8) + data[7]) * 1000);
 	else if (data.length == 12)
 		return new Date(
 			((data[0] << 24) + (data[1] << 16) + (data[2] << 8) + data[3]) / 1000000 +
-			(((data[4] & 0x80) ? -281474976710656 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000)
+			(((data[4] & 0x80) ? -281474976710656 : 0) + data[6] * 0x10000000000 + data[7] * 0x100000000 + data[8] * 0x1000000 + (data[9] << 16) + (data[10] << 8) + data[11]) * 1000);
 	else
-		return new Date('invalid')
+		return new Date('invalid');
 };
 // registration of bulk record definition?
 // currentExtensions[0x52] = () =>
 
-function saveState$1(callback) {
-	if (onSaveState)
-		onSaveState();
+function saveState(callback) {
+	if (currentUnpackr && currentUnpackr._onSaveState)
+		currentUnpackr._onSaveState();
 	let savedSrcEnd = srcEnd;
 	let savedPosition = position$1;
 	let savedStringPosition = stringPosition;
@@ -212616,7 +212599,7 @@ function saveState$1(callback) {
 	currentStructures.splice(0, currentStructures.length, ...savedStructuresContents);
 	currentUnpackr = savedPackr;
 	dataView = new DataView(src.buffer, src.byteOffset, src.byteLength);
-	return value
+	return value;
 }
 function clearSource() {
 	src = null;
@@ -212634,28 +212617,26 @@ defaultUnpackr.unpackMultiple;
 defaultUnpackr.unpack;
 let f32Array = new Float32Array(1);
 new Uint8Array(f32Array.buffer, 0, 4);
-function setReadStruct(updatedReadStruct, loadedStructs, saveState) {
-	readStruct$1 = updatedReadStruct;
-	onLoadedStructures$1 = loadedStructs;
-	onSaveState = saveState;
-}
+// Marker for downstream libraries (e.g. structon) to detect per-instance
+// struct-decoding hooks (this._readStruct, this._onLoadedStructures,
+// this._onSaveState).  See `checkedRead` for the dispatch.
+Unpackr.SUPPORTS_STRUCT_HOOKS = true;
 
-let textEncoder$1;
+let textEncoder;
 try {
-	textEncoder$1 = new TextEncoder();
+	textEncoder = new TextEncoder();
 } catch (error) {}
 let extensions, extensionClasses;
-const hasNodeBuffer$1 = typeof Buffer !== 'undefined';
-const ByteArrayAllocate = hasNodeBuffer$1 ?
-	function(length) { return Buffer.allocUnsafeSlow(length) } : Uint8Array;
-const ByteArray = hasNodeBuffer$1 ? Buffer : Uint8Array;
-const MAX_BUFFER_SIZE = hasNodeBuffer$1 ? 0x100000000 : 0x7fd00000;
+const hasNodeBuffer = typeof Buffer !== 'undefined';
+const ByteArrayAllocate = hasNodeBuffer ?
+	function(length) { return Buffer.allocUnsafeSlow(length); } : Uint8Array;
+const ByteArray = hasNodeBuffer ? Buffer : Uint8Array;
+const MAX_BUFFER_SIZE = hasNodeBuffer ? 0x100000000 : 0x7fd00000;
 let target, keysTarget;
 let targetView;
 let position = 0;
 let safeEnd;
 let bundledStrings = null;
-let writeStructSlots;
 const MAX_BUNDLE_SIZE = 0x5500; // maximum characters such that the encoded bytes fits in 16 bits.
 const hasNonLatin = /[\u0080-\uFFFF]/;
 const RECORD_SYMBOL = Symbol('record-id');
@@ -212668,10 +212649,10 @@ class Packr extends Unpackr {
 		let structures;
 		let referenceMap;
 		let encodeUtf8 = ByteArray.prototype.utf8Write ? function(string, position) {
-			return target.utf8Write(string, position, target.byteLength - position)
-		} : (textEncoder$1 && textEncoder$1.encodeInto) ?
+			return target.utf8Write(string, position, target.byteLength - position);
+		} : (textEncoder && textEncoder.encodeInto) ?
 			function(string, position) {
-				return textEncoder$1.encodeInto(string, target.subarray(position)).written
+				return textEncoder.encodeInto(string, target.subarray(position)).written;
 			} : false;
 
 		let packr = this;
@@ -212683,7 +212664,7 @@ class Packr extends Unpackr {
 		if (maxSharedStructures == null)
 			maxSharedStructures = hasSharedStructures ? 32 : 0;
 		if (maxSharedStructures > 8160)
-			throw new Error('Maximum maxSharedStructure is 8160')
+			throw new Error('Maximum maxSharedStructure is 8160');
 		if (options.structuredClone && options.moreTypes == undefined) {
 			this.moreTypes = true;
 		}
@@ -212697,7 +212678,7 @@ class Packr extends Unpackr {
 		let sharedLimitId = maxSharedStructures + 0x40;
 		let maxStructureId = maxSharedStructures + maxOwnStructures + 0x40;
 		if (maxStructureId > 8256) {
-			throw new Error('Maximum maxSharedStructure + maxOwnStructure is 8192')
+			throw new Error('Maximum maxSharedStructure + maxOwnStructure is 8192');
 		}
 		let recordIdsToRemove = [];
 		let transitionsCount = 0;
@@ -212733,7 +212714,7 @@ class Packr extends Unpackr {
 				let sharedLength = structures.sharedLength || 0;
 				if (sharedLength > maxSharedStructures) {
 					//if (maxSharedStructures <= 32 && structures.sharedLength > 32) // TODO: could support this, but would need to update the limit ids
-					throw new Error('Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to ' + structures.sharedLength)
+					throw new Error('Shared structures is larger than maximum shared structures, try increasing maxSharedStructures to ' + structures.sharedLength);
 				}
 				if (!structures.transitions) {
 					// rebuild our structure transitions
@@ -212741,7 +212722,7 @@ class Packr extends Unpackr {
 					for (let i = 0; i < sharedLength; i++) {
 						let keys = structures[i];
 						if (!keys)
-							continue
+							continue;
 						let nextTransition, transition = structures.transitions;
 						for (let j = 0, l = keys.length; j < l; j++) {
 							let key = keys[j];
@@ -212763,7 +212744,7 @@ class Packr extends Unpackr {
 				hasSharedUpdate = false;
 			let encodingError;
 			try {
-				if (packr.randomAccessStructure && value && typeof value === 'object') {
+				if (packr._writeStruct && value && typeof value === 'object') {
 					if (value.constructor === Object) writeStruct(value); // simple object
 					else if (value.constructor !== Map && !Array.isArray(value) && !extensionClasses.some(extClass => value instanceof extClass)) {
 						// allow user classes, if they don't need special handling (but do use toJSON if available)
@@ -212807,15 +212788,15 @@ class Packr extends Unpackr {
 					packr.offset = position;
 					let serialized = insertIds(target.subarray(start, position), idsToInsert);
 					referenceMap = null;
-					return serialized
+					return serialized;
 				}
 				packr.offset = position; // update the offset so next serialization doesn't write over our buffer, but can continue writing to same buffer sequentially
 				if (encodeOptions & REUSE_BUFFER_MODE) {
 					target.start = start;
 					target.end = position;
-					return target
+					return target;
 				}
-				return target.subarray(start, position) // position can change if we call pack again in saveStructures, so we get the buffer now
+				return target.subarray(start, position); // position can change if we call pack again in saveStructures, so we get the buffer now
 			} catch(error) {
 				encodingError = error;
 				throw error;
@@ -212826,16 +212807,16 @@ class Packr extends Unpackr {
 						let sharedLength = structures.sharedLength || 0;
 						// we can't rely on start/end with REUSE_BUFFER_MODE since they will (probably) change when we save
 						let returnBuffer = target.subarray(start, position);
-						let newSharedData = prepareStructures$1(structures, packr);
+						let newSharedData = (packr._prepareStructures || prepareStructures)(structures, packr);
 						if (!encodingError) { // TODO: If there is an encoding error, should make the structures as uninitialized so they get rebuilt next time
 							if (packr.saveStructures(newSharedData, newSharedData.isCompatible) === false) {
 								// get updated structures and try again if the update failed
-								return packr.pack(value, encodeOptions)
+								return packr.pack(value, encodeOptions);
 							}
 							packr.lastNamedStructuresLength = sharedLength;
 							// don't keep large buffers around
 							if (target.length > 0x40000000) target = null;
-							return returnBuffer
+							return returnBuffer;
 						}
 					}
 				}
@@ -212921,7 +212902,7 @@ class Packr extends Unpackr {
 					bundledStrings[twoByte ? 0 : 1] += value;
 					target[position++] = 0xc1;
 					pack(twoByte ? -strLength : strLength);
-					return
+					return;
 				}
 				let headerSize;
 				// first we estimate the header size, so we can write to the correct location
@@ -212995,7 +212976,7 @@ class Packr extends Unpackr {
 			} else if (type === 'number') {
 				if (value >>> 0 === value) {// positive integer, 32-bit or less
 					// positive uint
-					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this.randomAccessStructure)) {
+					if (value < 0x20 || (value < 0x80 && this.useRecords === false) || (value < 0x40 && !this._writeStruct)) {
 						target[position++] = value;
 					} else if (value < 0x100) {
 						target[position++] = 0xcc;
@@ -213034,7 +213015,7 @@ class Packr extends Unpackr {
 								// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
 								((xShifted = value * mult10[((target[position] & 0x7f) << 1) | (target[position + 1] >> 7)]) >> 0) === xShifted) {
 							position += 4;
-							return
+							return;
 						} else
 							position--; // move back into position for writing a double
 					}
@@ -213057,7 +213038,7 @@ class Packr extends Unpackr {
 							target[position++] = 0x70; // "p" for pointer
 							targetView.setUint32(position, referee.id);
 							position += 4;
-							return
+							return;
 						} else
 							referenceMap.set(value, { offset: position - start });
 					}
@@ -213107,7 +213088,7 @@ class Packr extends Unpackr {
 									} else {
 										pack(writeResult);
 									}
-									return
+									return;
 								}
 								let currentTarget = target;
 								let currentTargetView = targetView;
@@ -213124,7 +213105,7 @@ class Packr extends Unpackr {
 											makeRoom(position);
 										return {
 											target, targetView, position: position - size
-										}
+										};
 									}, pack);
 								} finally {
 									// restore current target information (unless already restored)
@@ -213140,7 +213121,7 @@ class Packr extends Unpackr {
 										makeRoom(result.length + position);
 									position = writeExtensionData(result, target, position, extension.type);
 								}
-								return
+								return;
 							}
 						}
 						// check isArray after extensions, because extensions can extend Array
@@ -213152,7 +213133,7 @@ class Packr extends Unpackr {
 								const json = value.toJSON();
 								// if for some reason value.toJSON returns itself it'll loop forever
 								if (json !== value)
-									return pack(json)
+									return pack(json);
 							}
 
 							// if there is a writeFunction, use it, otherwise just encode as undefined
@@ -213191,7 +213172,7 @@ class Packr extends Unpackr {
 							let chunks = [];
 							while (true) {
 								chunks.push(value & mask);
-								if ((value >> BigInt(63)) === empty) break
+								if ((value >> BigInt(63)) === empty) break;
 								value >>= BigInt(64);
 							}
 
@@ -213206,7 +213187,7 @@ class Packr extends Unpackr {
 								string = '00' + string;
 							}
 
-							if (hasNodeBuffer$1) {
+							if (hasNodeBuffer) {
 								array = Buffer.from(string, 'hex');
 							} else {
 								array = new Uint8Array(string.length / 2);
@@ -213223,11 +213204,11 @@ class Packr extends Unpackr {
 						if (array.length + position > safeEnd)
 							makeRoom(array.length + position);
 						position = writeExtensionData(array, target, position, 0x42);
-						return
+						return;
 					} else {
 						throw new RangeError(value + ' was too large to fit in MessagePack 64-bit integer format, use' +
 							' useBigIntExtension, or set largeBigIntToFloat to convert to float-64, or set' +
-							' largeBigIntToString to convert to string')
+							' largeBigIntToString to convert to string');
 					}
 				}
 				position += 8;
@@ -213240,7 +213221,7 @@ class Packr extends Unpackr {
 					target[position++] = 0;
 				}
 			} else {
-				throw new Error('Unknown type: ' + type)
+				throw new Error('Unknown type: ' + type);
 			}
 		};
 
@@ -213386,12 +213367,30 @@ class Packr extends Unpackr {
 			checkUseRecords(object) ? writeRecord(object) : writePlainObject(object);
 		} : writeRecord;
 
+		const writeStruct = (object) => {
+			let newPosition = packr._writeStruct(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
+				if (notifySharedUpdate)
+					return hasSharedUpdate = true;
+				position = newPosition;
+				let startTarget = target;
+				pack(value);
+				resetStructures();
+				if (startTarget !== target) {
+					return { position, targetView, target }; // indicate the buffer was re-allocated
+				}
+				return position;
+			});
+			if (newPosition === 0) // bail and go to a msgpack object
+				return writeObject(object);
+			position = newPosition;
+		};
+
 		const makeRoom = (end) => {
 			let newSize;
 			if (end > 0x1000000) {
 				// special handling for really large buffers
 				if ((end - start) > MAX_BUFFER_SIZE)
-					throw new Error('Packed buffer would be larger than maximum buffer size')
+					throw new Error('Packed buffer would be larger than maximum buffer size');
 				newSize = Math.min(MAX_BUFFER_SIZE,
 					Math.round(Math.max((end - start) * (end > 0x4000000 ? 1.25 : 2), 0x400000) / 0x1000) * 0x1000);
 			} else // faster handling for smaller buffers
@@ -213406,7 +213405,7 @@ class Packr extends Unpackr {
 			position -= start;
 			start = 0;
 			safeEnd = newBuffer.length - 10;
-			return target = newBuffer
+			return target = newBuffer;
 		};
 		const newRecord = (transition, keys, newTransitions) => {
 			let recordId = structures.nextId;
@@ -213488,23 +213487,6 @@ class Packr extends Unpackr {
 				target[insertionOffset + start] = keysTarget[0];
 			}
 		};
-		const writeStruct = (object) => {
-			let newPosition = writeStructSlots(object, target, start, position, structures, makeRoom, (value, newPosition, notifySharedUpdate) => {
-				if (notifySharedUpdate)
-					return hasSharedUpdate = true;
-				position = newPosition;
-				let startTarget = target;
-				pack(value);
-				resetStructures();
-				if (startTarget !== target) {
-					return { position, targetView, target }; // indicate the buffer was re-allocated
-				}
-				return position;
-			}, this);
-			if (newPosition === 0) // bail and go to a msgpack object
-				return writeObject(object);
-			position = newPosition;
-		};
 	}
 	useBuffer(buffer) {
 		// this means we are finished using our own buffer and we can write over it safely
@@ -213547,7 +213529,7 @@ extensions = [{
 		} else if (isNaN(seconds)) {
 			if (this.onInvalidDate) {
 				allocateForWrite(0);
-				return pack(this.onInvalidDate())
+				return pack(this.onInvalidDate());
 			}
 			// Intentionally invalid timestamp
 			let { target, targetView, position} = allocateForWrite(3);
@@ -213568,7 +213550,7 @@ extensions = [{
 	pack(set, allocateForWrite, pack) {
 		if (this.setAsEmptyObject) {
 			allocateForWrite(0);
-			return pack({})
+			return pack({});
 		}
 		let array = Array.from(set);
 		let { target, position} = allocateForWrite(this.moreTypes ? 3 : 0);
@@ -213604,7 +213586,7 @@ extensions = [{
 		if (this.moreTypes)
 			writeExtBuffer(arrayBuffer, 0x10, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(typedArray, allocateForWrite) {
@@ -213619,7 +213601,7 @@ extensions = [{
 		if (this.moreTypes)
 			writeExtBuffer(arrayBuffer, 0x11, allocateForWrite);
 		else
-			writeBuffer(hasNodeBuffer$1 ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
+			writeBuffer(hasNodeBuffer ? Buffer.from(arrayBuffer) : new Uint8Array(arrayBuffer), allocateForWrite);
 	}
 }, {
 	pack(c1, allocateForWrite) { // specific 0xC1 object
@@ -213676,19 +213658,19 @@ function writeExtensionData(result, target, position, type) {
 	switch (length) {
 		case 1:
 			target[position++] = 0xd4;
-			break
+			break;
 		case 2:
 			target[position++] = 0xd5;
-			break
+			break;
 		case 4:
 			target[position++] = 0xd6;
-			break
+			break;
 		case 8:
 			target[position++] = 0xd7;
-			break
+			break;
 		case 16:
 			target[position++] = 0xd8;
-			break
+			break;
 		default:
 			if (length < 0x100) {
 				target[position++] = 0xc7;
@@ -213708,7 +213690,7 @@ function writeExtensionData(result, target, position, type) {
 	target[position++] = type;
 	target.set(result, position);
 	position += length;
-	return position
+	return position;
 }
 
 function insertIds(serialized, idsToInsert) {
@@ -213730,7 +213712,7 @@ function insertIds(serialized, idsToInsert) {
 		serialized[position++] = id & 0xff;
 		lastEnd = offset;
 	}
-	return serialized
+	return serialized;
 }
 
 function writeBundles(start, pack, incrementPosition) {
@@ -213743,20 +213725,21 @@ function writeBundles(start, pack, incrementPosition) {
 		pack(writeStrings[1]);
 	}
 }
-function prepareStructures$1(structures, packr) {
+function prepareStructures(structures, packr) {
 	structures.isCompatible = (existingStructures) => {
 		let compatible = !existingStructures || ((packr.lastNamedStructuresLength || 0) === existingStructures.length);
 		if (!compatible) // we want to merge these existing structures immediately since we already have it and we are in the right transaction
 			packr._mergeStructures(existingStructures);
 		return compatible;
 	};
-	return structures
-}
-function setWriteStructSlots(writeSlots, makeStructures) {
-	writeStructSlots = writeSlots;
-	prepareStructures$1 = makeStructures;
+	return structures;
 }
 
+// Marker for downstream libraries (e.g. structon) to detect that this Packr
+// supports per-instance struct-encoding hooks (this._writeStruct,
+// this._prepareStructures).  See `pack` for the dispatch.
+Packr.SUPPORTS_STRUCT_HOOKS = true;
+
 let defaultPackr = new Packr({ useRecords: false });
 defaultPackr.pack;
 defaultPackr.pack;
@@ -213764,779 +213747,6 @@ const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 const RESERVE_START_SPACE = 2048;
 
-const ASCII = 3; // the MIBenum from https://www.iana.org/assignments/character-sets/character-sets.xhtml (and other character encodings could be referenced by MIBenum)
-const NUMBER = 0;
-const UTF8 = 2;
-const OBJECT_DATA = 1;
-const DATE = 16;
-const TYPE_NAMES = ['num', 'object', 'string', 'ascii'];
-TYPE_NAMES[DATE] = 'date';
-const float32Headers = [false, true, true, false, false, true, true, false];
-let evalSupported;
-try {
-	new Function('');
-	evalSupported = true;
-} catch(error) {
-	// if eval variants are not supported, do not create inline object readers ever
-}
-
-let updatedPosition;
-const hasNodeBuffer = typeof Buffer !== 'undefined';
-let textEncoder, currentSource;
-try {
-	textEncoder = new TextEncoder();
-} catch (error) {}
-const encodeUtf8 = hasNodeBuffer ? function(target, string, position) {
-	return target.utf8Write(string, position, target.byteLength - position)
-} : (textEncoder && textEncoder.encodeInto) ?
-	function(target, string, position) {
-		return textEncoder.encodeInto(string, target.subarray(position)).written
-	} : false;
-setWriteStructSlots(writeStruct, prepareStructures);
-function writeStruct(object, target, encodingStart, position, structures, makeRoom, pack, packr) {
-	let typedStructs = packr.typedStructs || (packr.typedStructs = []);
-	// note that we rely on pack.js to load stored structures before we get to this point
-	let targetView = target.dataView;
-	let refsStartPosition = (typedStructs.lastStringStart || 100) + position;
-	let safeEnd = target.length - 10;
-	let start = position;
-	if (position > safeEnd) {
-		target = makeRoom(position);
-		targetView = target.dataView;
-		position -= encodingStart;
-		start -= encodingStart;
-		refsStartPosition -= encodingStart;
-		encodingStart = 0;
-		safeEnd = target.length - 10;
-	}
-
-	let refOffset, refPosition = refsStartPosition;
-
-	let transition = typedStructs.transitions || (typedStructs.transitions = Object.create(null));
-	let nextId = typedStructs.nextId || typedStructs.length;
-	let headerSize =
-		nextId < 0xf ? 1 :
-			nextId < 0xf0 ? 2 :
-				nextId < 0xf000 ? 3 :
-					nextId < 0xf00000 ? 4 : 0;
-	if (headerSize === 0)
-		return 0;
-	position += headerSize;
-	let queuedReferences = [];
-	let usedAscii0;
-	let keyIndex = 0;
-	for (let key in object) {
-		let value = object[key];
-		let nextTransition = transition[key];
-		if (!nextTransition) {
-			transition[key] = nextTransition = {
-				key,
-				parent: transition,
-				enumerationOffset: 0,
-				ascii0: null,
-				ascii8: null,
-				num8: null,
-				string16: null,
-				object16: null,
-				num32: null,
-				float64: null,
-				date64: null
-			};
-		}
-		if (position > safeEnd) {
-			target = makeRoom(position);
-			targetView = target.dataView;
-			position -= encodingStart;
-			start -= encodingStart;
-			refsStartPosition -= encodingStart;
-			refPosition -= encodingStart;
-			encodingStart = 0;
-			safeEnd = target.length - 10;
-		}
-		switch (typeof value) {
-			case 'number':
-				let number = value;
-				// first check to see if we are using a lot of ids and should default to wide/common format
-				if (nextId < 200 || !nextTransition.num64) {
-					if (number >> 0 === number && number < 0x20000000 && number > -520093696) {
-						if (number < 0xf6 && number >= 0 && (nextTransition.num8 && !(nextId > 200 && nextTransition.num32) || number < 0x20 && !nextTransition.num32)) {
-							transition = nextTransition.num8 || createTypeTransition(nextTransition, NUMBER, 1);
-							target[position++] = number;
-						} else {
-							transition = nextTransition.num32 || createTypeTransition(nextTransition, NUMBER, 4);
-							targetView.setUint32(position, number, true);
-							position += 4;
-						}
-						break;
-					} else if (number < 0x100000000 && number >= -2147483648) {
-						targetView.setFloat32(position, number, true);
-						if (float32Headers[target[position + 3] >>> 5]) {
-							let xShifted;
-							// this checks for rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-							if (((xShifted = number * mult10[((target[position + 3] & 0x7f) << 1) | (target[position + 2] >> 7)]) >> 0) === xShifted) {
-								transition = nextTransition.num32 || createTypeTransition(nextTransition, NUMBER, 4);
-								position += 4;
-								break;
-							}
-						}
-					}
-				}
-				transition = nextTransition.num64 || createTypeTransition(nextTransition, NUMBER, 8);
-				targetView.setFloat64(position, number, true);
-				position += 8;
-				break;
-			case 'string':
-				let strLength = value.length;
-				refOffset = refPosition - refsStartPosition;
-				if ((strLength << 2) + refPosition > safeEnd) {
-					target = makeRoom((strLength << 2) + refPosition);
-					targetView = target.dataView;
-					position -= encodingStart;
-					start -= encodingStart;
-					refsStartPosition -= encodingStart;
-					refPosition -= encodingStart;
-					encodingStart = 0;
-					safeEnd = target.length - 10;
-				}
-				if (strLength > ((0xff00 + refOffset) >> 2)) {
-					queuedReferences.push(key, value, position - start);
-					break;
-				}
-				let isNotAscii;
-				let strStart = refPosition;
-				if (strLength < 0x40) {
-					let i, c1, c2;
-					for (i = 0; i < strLength; i++) {
-						c1 = value.charCodeAt(i);
-						if (c1 < 0x80) {
-							target[refPosition++] = c1;
-						} else if (c1 < 0x800) {
-							isNotAscii = true;
-							target[refPosition++] = c1 >> 6 | 0xc0;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						} else if (
-							(c1 & 0xfc00) === 0xd800 &&
-							((c2 = value.charCodeAt(i + 1)) & 0xfc00) === 0xdc00
-						) {
-							isNotAscii = true;
-							c1 = 0x10000 + ((c1 & 0x03ff) << 10) + (c2 & 0x03ff);
-							i++;
-							target[refPosition++] = c1 >> 18 | 0xf0;
-							target[refPosition++] = c1 >> 12 & 0x3f | 0x80;
-							target[refPosition++] = c1 >> 6 & 0x3f | 0x80;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						} else {
-							isNotAscii = true;
-							target[refPosition++] = c1 >> 12 | 0xe0;
-							target[refPosition++] = c1 >> 6 & 0x3f | 0x80;
-							target[refPosition++] = c1 & 0x3f | 0x80;
-						}
-					}
-				} else {
-					refPosition += encodeUtf8(target, value, refPosition);
-					isNotAscii = refPosition - strStart > strLength;
-				}
-				if (refOffset < 0xa0 || (refOffset < 0xf6 && (nextTransition.ascii8 || nextTransition.string8))) {
-					// short strings
-					if (isNotAscii) {
-						if (!(transition = nextTransition.string8)) {
-							if (typedStructs.length > 10 && (transition = nextTransition.ascii8)) {
-								// we can safely change ascii to utf8 in place since they are compatible
-								transition.__type = UTF8;
-								nextTransition.ascii8 = null;
-								nextTransition.string8 = transition;
-								pack(null, 0, true); // special call to notify that structures have been updated
-							} else {
-								transition = createTypeTransition(nextTransition, UTF8, 1);
-							}
-						}
-					} else if (refOffset === 0 && !usedAscii0) {
-						usedAscii0 = true;
-						transition = nextTransition.ascii0 || createTypeTransition(nextTransition, ASCII, 0);
-						break; // don't increment position
-					}// else ascii:
-					else if (!(transition = nextTransition.ascii8) && !(typedStructs.length > 10 && (transition = nextTransition.string8)))
-						transition = createTypeTransition(nextTransition, ASCII, 1);
-					target[position++] = refOffset;
-				} else {
-					// TODO: Enable ascii16 at some point, but get the logic right
-					//if (isNotAscii)
-						transition = nextTransition.string16 || createTypeTransition(nextTransition, UTF8, 2);
-					//else
-						//transition = nextTransition.ascii16 || createTypeTransition(nextTransition, ASCII, 2);
-					targetView.setUint16(position, refOffset, true);
-					position += 2;
-				}
-				break;
-			case 'object':
-				if (value) {
-					if (value.constructor === Date) {
-						transition = nextTransition.date64 || createTypeTransition(nextTransition, DATE, 8);
-						targetView.setFloat64(position, value.getTime(), true);
-						position += 8;
-					} else {
-						queuedReferences.push(key, value, keyIndex);
-					}
-					break;
-				} else { // null
-					nextTransition = anyType(nextTransition, position, targetView, -10); // match CBOR with this
-					if (nextTransition) {
-						transition = nextTransition;
-						position = updatedPosition;
-					} else queuedReferences.push(key, value, keyIndex);
-				}
-				break;
-			case 'boolean':
-				transition = nextTransition.num8 || nextTransition.ascii8 || createTypeTransition(nextTransition, NUMBER, 1);
-				target[position++] = value ? 0xf9 : 0xf8; // match CBOR with these
-				break;
-			case 'undefined':
-				nextTransition = anyType(nextTransition, position, targetView, -9); // match CBOR with this
-				if (nextTransition) {
-					transition = nextTransition;
-					position = updatedPosition;
-				} else queuedReferences.push(key, value, keyIndex);
-				break;
-			default:
-				queuedReferences.push(key, value, keyIndex);
-		}
-		keyIndex++;
-	}
-
-	for (let i = 0, l = queuedReferences.length; i < l;) {
-		let key = queuedReferences[i++];
-		let value = queuedReferences[i++];
-		let propertyIndex = queuedReferences[i++];
-		let nextTransition = transition[key];
-		if (!nextTransition) {
-			transition[key] = nextTransition = {
-				key,
-				parent: transition,
-				enumerationOffset: propertyIndex - keyIndex,
-				ascii0: null,
-				ascii8: null,
-				num8: null,
-				string16: null,
-				object16: null,
-				num32: null,
-				float64: null
-			};
-		}
-		let newPosition;
-		if (value) {
-			/*if (typeof value === 'string') { // TODO: we could re-enable long strings
-				if (position + value.length * 3 > safeEnd) {
-					target = makeRoom(position + value.length * 3);
-					position -= start;
-					targetView = target.dataView;
-					start = 0;
-				}
-				newPosition = position + target.utf8Write(value, position, 0xffffffff);
-			} else { */
-			let size;
-			refOffset = refPosition - refsStartPosition;
-			if (refOffset < 0xff00) {
-				transition = nextTransition.object16;
-				if (transition)
-					size = 2;
-				else if ((transition = nextTransition.object32))
-					size = 4;
-				else {
-					transition = createTypeTransition(nextTransition, OBJECT_DATA, 2);
-					size = 2;
-				}
-			} else {
-				transition = nextTransition.object32 || createTypeTransition(nextTransition, OBJECT_DATA, 4);
-				size = 4;
-			}
-			newPosition = pack(value, refPosition);
-			//}
-			if (typeof newPosition === 'object') {
-				// re-allocated
-				refPosition = newPosition.position;
-				targetView = newPosition.targetView;
-				target = newPosition.target;
-				refsStartPosition -= encodingStart;
-				position -= encodingStart;
-				start -= encodingStart;
-				encodingStart = 0;
-			} else
-				refPosition = newPosition;
-			if (size === 2) {
-				targetView.setUint16(position, refOffset, true);
-				position += 2;
-			} else {
-				targetView.setUint32(position, refOffset, true);
-				position += 4;
-			}
-		} else { // null or undefined
-			transition = nextTransition.object16 || createTypeTransition(nextTransition, OBJECT_DATA, 2);
-			targetView.setInt16(position, value === null ? -10 : -9, true);
-			position += 2;
-		}
-		keyIndex++;
-	}
-
-
-	let recordId = transition[RECORD_SYMBOL];
-	if (recordId == null) {
-		recordId = packr.typedStructs.length;
-		let structure = [];
-		let nextTransition = transition;
-		let key, type;
-		while ((type = nextTransition.__type) !== undefined) {
-			let size = nextTransition.__size;
-			nextTransition = nextTransition.__parent;
-			key = nextTransition.key;
-			let property = [type, size, key];
-			if (nextTransition.enumerationOffset)
-				property.push(nextTransition.enumerationOffset);
-			structure.push(property);
-			nextTransition = nextTransition.parent;
-		}
-		structure.reverse();
-		transition[RECORD_SYMBOL] = recordId;
-		packr.typedStructs[recordId] = structure;
-		pack(null, 0, true); // special call to notify that structures have been updated
-	}
-
-
-	switch (headerSize) {
-		case 1:
-			if (recordId >= 0x10) return 0;
-			target[start] = recordId + 0x20;
-			break;
-		case 2:
-			if (recordId >= 0x100) return 0;
-			target[start] = 0x38;
-			target[start + 1] = recordId;
-			break;
-		case 3:
-			if (recordId >= 0x10000) return 0;
-			target[start] = 0x39;
-			targetView.setUint16(start + 1, recordId, true);
-			break;
-		case 4:
-			if (recordId >= 0x1000000) return 0;
-			targetView.setUint32(start, (recordId << 8) + 0x3a, true);
-			break;
-	}
-
-	if (position < refsStartPosition) {
-		if (refsStartPosition === refPosition)
-			return position; // no refs
-		// adjust positioning
-		target.copyWithin(position, refsStartPosition, refPosition);
-		refPosition += position - refsStartPosition;
-		typedStructs.lastStringStart = position - start;
-	} else if (position > refsStartPosition) {
-		if (refsStartPosition === refPosition)
-			return position; // no refs
-		typedStructs.lastStringStart = position - start;
-		return writeStruct(object, target, encodingStart, start, structures, makeRoom, pack, packr);
-	}
-	return refPosition;
-}
-function anyType(transition, position, targetView, value) {
-	let nextTransition;
-	if ((nextTransition = transition.ascii8 || transition.num8)) {
-		targetView.setInt8(position, value, true);
-		updatedPosition = position + 1;
-		return nextTransition;
-	}
-	if ((nextTransition = transition.string16 || transition.object16)) {
-		targetView.setInt16(position, value, true);
-		updatedPosition = position + 2;
-		return nextTransition;
-	}
-	if (nextTransition = transition.num32) {
-		targetView.setUint32(position, 0xe0000100 + value, true);
-		updatedPosition = position + 4;
-		return nextTransition;
-	}
-	// transition.float64
-	if (nextTransition = transition.num64) {
-		targetView.setFloat64(position, NaN, true);
-		targetView.setInt8(position, value);
-		updatedPosition = position + 8;
-		return nextTransition;
-	}
-	updatedPosition = position;
-	// TODO: can we do an "any" type where we defer the decision?
-	return;
-}
-function createTypeTransition(transition, type, size) {
-	let typeName = TYPE_NAMES[type] + (size << 3);
-	let newTransition = transition[typeName] || (transition[typeName] = Object.create(null));
-	newTransition.__type = type;
-	newTransition.__size = size;
-	newTransition.__parent = transition;
-	return newTransition;
-}
-function onLoadedStructures(sharedData) {
-	if (!(sharedData instanceof Map))
-		return sharedData;
-	let typed = sharedData.get('typed') || [];
-	if (Object.isFrozen(typed))
-		typed = typed.map(structure => structure.slice(0));
-	let named = sharedData.get('named');
-	let transitions = Object.create(null);
-	for (let i = 0, l = typed.length; i < l; i++) {
-		let structure = typed[i];
-		let transition = transitions;
-		for (let [type, size, key] of structure) {
-			let nextTransition = transition[key];
-			if (!nextTransition) {
-				transition[key] = nextTransition = {
-					key,
-					parent: transition,
-					enumerationOffset: 0,
-					ascii0: null,
-					ascii8: null,
-					num8: null,
-					string16: null,
-					object16: null,
-					num32: null,
-					float64: null,
-					date64: null,
-				};
-			}
-			transition = createTypeTransition(nextTransition, type, size);
-		}
-		transition[RECORD_SYMBOL] = i;
-	}
-	typed.transitions = transitions;
-	this.typedStructs = typed;
-	this.lastTypedStructuresLength = typed.length;
-	return named;
-}
-var sourceSymbol = Symbol.for('source');
-function readStruct(src, position, srcEnd, unpackr) {
-	let recordId = src[position++] - 0x20;
-	if (recordId >= 24) {
-		switch(recordId) {
-			case 24: recordId = src[position++]; break;
-			// little endian:
-			case 25: recordId = src[position++] + (src[position++] << 8); break;
-			case 26: recordId = src[position++] + (src[position++] << 8) + (src[position++] << 16); break;
-			case 27: recordId = src[position++] + (src[position++] << 8) + (src[position++] << 16) + (src[position++] << 24); break;
-		}
-	}
-	let structure = unpackr.typedStructs && unpackr.typedStructs[recordId];
-	if (!structure) {
-		// copy src buffer because getStructures will override it
-		src = Uint8Array.prototype.slice.call(src, position, srcEnd);
-		srcEnd -= position;
-		position = 0;
-		if (!unpackr.getStructures)
-			throw new Error(`Reference to shared structure ${recordId} without getStructures method`);
-		unpackr._mergeStructures(unpackr.getStructures());
-		if (!unpackr.typedStructs)
-			throw new Error('Could not find any shared typed structures');
-		unpackr.lastTypedStructuresLength = unpackr.typedStructs.length;
-		structure = unpackr.typedStructs[recordId];
-		if (!structure)
-			throw new Error('Could not find typed structure ' + recordId);
-	}
-	var construct = structure.construct;
-	var fullConstruct = structure.fullConstruct;
-	if (!construct) {
-		construct = structure.construct = function LazyObject() {
-		};
-		fullConstruct = structure.fullConstruct = function LoadedObject() {
-		};
-		fullConstruct.prototype = unpackr.structPrototype || {};
-		var prototype = construct.prototype = unpackr.structPrototype ? Object.create(unpackr.structPrototype) : {};
-		let properties = [];
-		let currentOffset = 0;
-		let lastRefProperty;
-		for (let i = 0, l = structure.length; i < l; i++) {
-			let definition = structure[i];
-			let [ type, size, key, enumerationOffset ] = definition;
-			if (key === '__proto__')
-				key = '__proto_';
-			let property = {
-				key,
-				offset: currentOffset,
-			};
-			if (enumerationOffset)
-				properties.splice(i + enumerationOffset, 0, property);
-			else
-				properties.push(property);
-			let getRef;
-			switch(size) { // TODO: Move into a separate function
-				case 0: getRef = () => 0; break;
-				case 1:
-					getRef = (source, position) => {
-						let ref = source.bytes[position + property.offset];
-						return ref >= 0xf6 ? toConstant(ref) : ref;
-					};
-					break;
-				case 2:
-					getRef = (source, position) => {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						let ref = dataView.getUint16(position + property.offset, true);
-						return ref >= 0xff00 ? toConstant(ref & 0xff) : ref;
-					};
-					break;
-				case 4:
-					getRef = (source, position) => {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						let ref = dataView.getUint32(position + property.offset, true);
-						return ref >= 0xffffff00 ? toConstant(ref & 0xff) : ref;
-					};
-					break;
-			}
-			property.getRef = getRef;
-			currentOffset += size;
-			let get;
-			switch(type) {
-				case ASCII:
-					if (lastRefProperty && !lastRefProperty.next)
-						lastRefProperty.next = property;
-					lastRefProperty = property;
-					property.multiGetCount = 0;
-					get = function(source) {
-						let src = source.bytes;
-						let position = source.position;
-						let refStart = currentOffset + position;
-						let ref = getRef(source, position);
-						if (typeof ref !== 'number') return ref;
-
-						let end, next = property.next;
-						while(next) {
-							end = next.getRef(source, position);
-							if (typeof end === 'number')
-								break;
-							else
-								end = null;
-							next = next.next;
-						}
-						if (end == null)
-							end = source.bytesEnd - refStart;
-						if (source.srcString) {
-							return source.srcString.slice(ref, end);
-						}
-						/*if (property.multiGetCount > 0) {
-							let asciiEnd;
-							next = firstRefProperty;
-							let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-							do {
-								asciiEnd = dataView.getUint16(source.position + next.offset, true);
-								if (asciiEnd < 0xff00)
-									break;
-								else
-									asciiEnd = null;
-							} while((next = next.next));
-							if (asciiEnd == null)
-								asciiEnd = source.bytesEnd - refStart
-							source.srcString = src.toString('latin1', refStart, refStart + asciiEnd);
-							return source.srcString.slice(ref, end);
-						}
-						if (source.prevStringGet) {
-							source.prevStringGet.multiGetCount += 2;
-						} else {
-							source.prevStringGet = property;
-							property.multiGetCount--;
-						}*/
-						return readString(src, ref + refStart, end - ref);
-						//return src.toString('latin1', ref + refStart, end + refStart);
-					};
-					break;
-				case UTF8: case OBJECT_DATA:
-					if (lastRefProperty && !lastRefProperty.next)
-						lastRefProperty.next = property;
-					lastRefProperty = property;
-					get = function(source) {
-						let position = source.position;
-						let refStart = currentOffset + position;
-						let ref = getRef(source, position);
-						if (typeof ref !== 'number') return ref;
-						let src = source.bytes;
-						let end, next = property.next;
-						while(next) {
-							end = next.getRef(source, position);
-							if (typeof end === 'number')
-								break;
-							else
-								end = null;
-							next = next.next;
-						}
-						if (end == null)
-							end = source.bytesEnd - refStart;
-						if (type === UTF8) {
-							return src.toString('utf8', ref + refStart, end + refStart);
-						} else {
-							currentSource = source;
-							try {
-								return unpackr.unpack(src, { start: ref + refStart, end: end + refStart });
-							} finally {
-								currentSource = null;
-							}
-						}
-					};
-					break;
-				case NUMBER:
-					switch(size) {
-						case 4:
-							get = function (source) {
-								let src = source.bytes;
-								let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-								let position = source.position + property.offset;
-								let value = dataView.getInt32(position, true);
-								if (value < 0x20000000) {
-									if (value > -520093696)
-										return value;
-									if (value > -536870912)
-										return toConstant(value & 0xff);
-								}
-								let fValue = dataView.getFloat32(position, true);
-								// this does rounding of numbers that were encoded in 32-bit float to nearest significant decimal digit that could be preserved
-								let multiplier = mult10[((src[position + 3] & 0x7f) << 1) | (src[position + 2] >> 7)];
-								return ((multiplier * fValue + (fValue > 0 ? 0.5 : -0.5)) >> 0) / multiplier;
-							};
-							break;
-						case 8:
-							get = function (source) {
-								let src = source.bytes;
-								let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-								let value = dataView.getFloat64(source.position + property.offset, true);
-								if (isNaN(value)) {
-									let byte = src[source.position + property.offset];
-									if (byte >= 0xf6)
-										return toConstant(byte);
-								}
-								return value;
-							};
-							break;
-						case 1:
-							get = function (source) {
-								let src = source.bytes;
-								let value = src[source.position + property.offset];
-								return value < 0xf6 ? value : toConstant(value);
-							};
-							break;
-					}
-					break;
-				case DATE:
-					get = function (source) {
-						let src = source.bytes;
-						let dataView = src.dataView || (src.dataView = new DataView(src.buffer, src.byteOffset, src.byteLength));
-						return new Date(dataView.getFloat64(source.position + property.offset, true));
-					};
-					break;
-
-			}
-			property.get = get;
-		}
-		// TODO: load the srcString for faster string decoding on toJSON
-		if (evalSupported) {
-			let objectLiteralProperties = [];
-			let args = [];
-			let i = 0;
-			let hasInheritedProperties;
-			for (let property of properties) { // assign in enumeration order
-				if (unpackr.alwaysLazyProperty && unpackr.alwaysLazyProperty(property.key)) {
-					// these properties are not eagerly evaluated and this can be used for creating properties
-					// that are not serialized as JSON
-					hasInheritedProperties = true;
-					continue;
-				}
-				Object.defineProperty(prototype, property.key, { get: withSource(property.get), enumerable: true });
-				let valueFunction = 'v' + i++;
-				args.push(valueFunction);
-				objectLiteralProperties.push('o[' + JSON.stringify(property.key) + ']=' + valueFunction + '(s)');
-			}
-			if (hasInheritedProperties) {
-				objectLiteralProperties.push('__proto__:this');
-			}
-			let toObject = (new Function(...args, 'var c=this;return function(s){var o=new c();' + objectLiteralProperties.join(';') + ';return o;}')).apply(fullConstruct, properties.map(prop => prop.get));
-			Object.defineProperty(prototype, 'toJSON', {
-				value(omitUnderscoredProperties) {
-					return toObject.call(this, this[sourceSymbol]);
-				}
-			});
-		} else {
-			Object.defineProperty(prototype, 'toJSON', {
-				value(omitUnderscoredProperties) {
-					// return an enumerable object with own properties to JSON stringify
-					let resolved = {};
-					for (let i = 0, l = properties.length; i < l; i++) {
-						// TODO: check alwaysLazyProperty
-						let key = properties[i].key;
-
-						resolved[key] = this[key];
-					}
-					return resolved;
-				},
-				// not enumerable or anything
-			});
-		}
-	}
-	var instance = new construct();
-	instance[sourceSymbol] = {
-		bytes: src,
-		position,
-		srcString: '',
-		bytesEnd: srcEnd
-	};
-	return instance;
-}
-function toConstant(code) {
-	switch(code) {
-		case 0xf6: return null;
-		case 0xf7: return undefined;
-		case 0xf8: return false;
-		case 0xf9: return true;
-	}
-	throw new Error('Unknown constant');
-}
-function withSource(get) {
-	return function() {
-		return get(this[sourceSymbol]);
-	}
-}
-
-function saveState() {
-	if (currentSource) {
-		currentSource.bytes = Uint8Array.prototype.slice.call(currentSource.bytes, currentSource.position, currentSource.bytesEnd);
-		currentSource.position = 0;
-		currentSource.bytesEnd = currentSource.bytes.length;
-	}
-}
-function prepareStructures(structures, packr) {
-	if (packr.typedStructs) {
-		let structMap = new Map();
-		structMap.set('named', structures);
-		structMap.set('typed', packr.typedStructs);
-		structures = structMap;
-	}
-	let lastTypedStructuresLength = packr.lastTypedStructuresLength || 0;
-	structures.isCompatible = existing => {
-		let compatible = true;
-		if (existing instanceof Map) {
-			let named = existing.get('named') || [];
-			if (named.length !== (packr.lastNamedStructuresLength || 0))
-				compatible = false;
-			let typed = existing.get('typed') || [];
-			if (typed.length !== lastTypedStructuresLength)
-				compatible = false;
-		} else if (existing instanceof Array || Array.isArray(existing)) {
-			if (existing.length !== (packr.lastNamedStructuresLength || 0))
-				compatible = false;
-		}
-		if (!compatible)
-			packr._mergeStructures(existing);
-		return compatible;
-	};
-	packr.lastTypedStructuresLength = packr.typedStructs && packr.typedStructs.length;
-	return structures;
-}
-
-setReadStruct(readStruct, onLoadedStructures, saveState);
-
 const nativeAccelerationDisabled = process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED !== undefined && process.env.MSGPACKR_NATIVE_ACCELERATION_DISABLED.toLowerCase() === 'true';
 
 if (!nativeAccelerationDisabled) {
@@ -214553,7 +213763,7 @@ if (!nativeAccelerationDisabled) {
 	}
 }
 
-const version$1 = '5.76.5';
+const version$1 = '5.76.6';
 
 /**
  * Includes all the scripts needed by the queue and jobs.
@@ -226164,6 +225374,12 @@ const overrideMessage = [
     'and will be overridden by BullMQ.',
 ].join(' ');
 const deprecationMessage = 'BullMQ: Your redis options maxRetriesPerRequest must be null.';
+const clusterReconnectPromise = Symbol('bullmqClusterReconnectPromise');
+const clusterPatchedForBlocking = Symbol('bullmqClusterPatchedForBlocking');
+const clusterOriginalBzpopmin = Symbol('bullmqClusterOriginalBzpopmin');
+const clusterWrappedBzpopmin = Symbol('bullmqClusterWrappedBzpopmin');
+const clusterPatchRefCount = Symbol('bullmqClusterPatchRefCount');
+const clusterClosingRefCount = Symbol('bullmqClusterClosingRefCount');
 class RedisConnection extends EventEmitter {
     constructor(opts, extraOptions) {
         super();
@@ -226175,6 +225391,7 @@ class RedisConnection extends EventEmitter {
         this.status = 'initializing';
         this.dbType = 'redis';
         this.packageVersion = version$1;
+        this.disabledBlockingClusterReconnect = false;
         // Set extra options defaults
         this.extraOptions = Object.assign({ shared: false, blocking: true, skipVersionCheck: false, skipWaitingForReady: false }, extraOptions);
         if (!isRedisInstance(opts)) {
@@ -226312,6 +225529,7 @@ class RedisConnection extends EventEmitter {
         // ioredis treats connection errors as a different event ('close')
         this._client.on('close', this.handleClientClose);
         this._client.on('ready', this.handleClientReady);
+        this.patchBlockingClusterClient();
         if (!this.extraOptions.skipWaitingForReady) {
             await RedisConnection.waitUntilReady(this._client);
         }
@@ -226338,6 +225556,128 @@ class RedisConnection extends EventEmitter {
         }
         return this._client;
     }
+    patchBlockingClusterClient() {
+        const client = this._client;
+        const blockingClient = client;
+        if (!this.extraOptions.blocking ||
+            !isRedisCluster(client) ||
+            typeof blockingClient.bzpopmin !== 'function') {
+            return;
+        }
+        blockingClient[clusterPatchRefCount] =
+            (blockingClient[clusterPatchRefCount] || 0) + 1;
+        this.patchedBlockingClusterClient = blockingClient;
+        if (blockingClient[clusterPatchedForBlocking]) {
+            return;
+        }
+        const bzpopmin = blockingClient.bzpopmin;
+        const wrappedBzpopmin = async (...args) => {
+            await RedisConnection.reconnectClusterIfNeeded(blockingClient);
+            try {
+                return await bzpopmin.apply(blockingClient, args);
+            }
+            catch (error) {
+                const commandError = error;
+                if (RedisConnection.shouldReconnectClusterAfterError(blockingClient, commandError)) {
+                    try {
+                        await RedisConnection.reconnectCluster(blockingClient);
+                    }
+                    catch (_a) {
+                        // Preserve the original command failure if best-effort recovery fails.
+                    }
+                }
+                throw commandError;
+            }
+        };
+        blockingClient[clusterOriginalBzpopmin] = bzpopmin;
+        blockingClient[clusterWrappedBzpopmin] = wrappedBzpopmin;
+        blockingClient[clusterPatchedForBlocking] = true;
+        blockingClient.bzpopmin = wrappedBzpopmin;
+    }
+    disableBlockingClusterReconnect() {
+        const client = this.patchedBlockingClusterClient;
+        if (!client || this.disabledBlockingClusterReconnect) {
+            return;
+        }
+        client[clusterClosingRefCount] = (client[clusterClosingRefCount] || 0) + 1;
+        this.disabledBlockingClusterReconnect = true;
+    }
+    releaseBlockingClusterClientPatch() {
+        const client = this.patchedBlockingClusterClient;
+        if (!client) {
+            return;
+        }
+        if (this.disabledBlockingClusterReconnect) {
+            const closingRefCount = (client[clusterClosingRefCount] || 1) - 1;
+            if (closingRefCount > 0) {
+                client[clusterClosingRefCount] = closingRefCount;
+            }
+            else {
+                delete client[clusterClosingRefCount];
+            }
+            this.disabledBlockingClusterReconnect = false;
+        }
+        const patchRefCount = (client[clusterPatchRefCount] || 1) - 1;
+        if (patchRefCount > 0) {
+            client[clusterPatchRefCount] = patchRefCount;
+            this.patchedBlockingClusterClient = undefined;
+            return;
+        }
+        if (client[clusterOriginalBzpopmin] &&
+            client.bzpopmin === client[clusterWrappedBzpopmin]) {
+            client.bzpopmin = client[clusterOriginalBzpopmin];
+        }
+        delete client[clusterPatchRefCount];
+        delete client[clusterClosingRefCount];
+        delete client[clusterOriginalBzpopmin];
+        delete client[clusterWrappedBzpopmin];
+        delete client[clusterPatchedForBlocking];
+        this.patchedBlockingClusterClient = undefined;
+    }
+    static isClusterWithEmptyNodes(client) {
+        return typeof client.nodes === 'function' && client.nodes().length === 0;
+    }
+    static isReconnectingDisabled(client) {
+        const patchRefCount = client[clusterPatchRefCount] || 0;
+        const closingRefCount = client[clusterClosingRefCount] || 0;
+        return (patchRefCount === 0 ||
+            closingRefCount >= patchRefCount ||
+            client.status === 'end' ||
+            client.status === 'closing');
+    }
+    static async reconnectClusterIfNeeded(client) {
+        if (!RedisConnection.isReconnectingDisabled(client) &&
+            RedisConnection.isClusterWithEmptyNodes(client)) {
+            await RedisConnection.reconnectCluster(client);
+        }
+    }
+    static shouldReconnectClusterAfterError(client, error) {
+        var _a, _b;
+        if (RedisConnection.isReconnectingDisabled(client)) {
+            return false;
+        }
+        const message = [
+            error.message,
+            (_a = error.cause) === null || _a === void 0 ? void 0 : _a.message,
+            (_b = error.lastNodeError) === null || _b === void 0 ? void 0 : _b.message,
+        ].join(' ');
+        return (RedisConnection.isClusterWithEmptyNodes(client) ||
+            /Command timed out|Failed to refresh slots cache/i.test(message));
+    }
+    static async reconnectCluster(client) {
+        if (RedisConnection.isReconnectingDisabled(client)) {
+            return;
+        }
+        if (!client[clusterReconnectPromise]) {
+            client[clusterReconnectPromise] = (async () => {
+                client.disconnect(false);
+                await client.connect();
+            })().finally(() => {
+                client[clusterReconnectPromise] = null;
+            });
+        }
+        await client[clusterReconnectPromise];
+    }
     async disconnect(wait = true) {
         const client = await this.client;
         if (client.status !== 'end') {
@@ -226372,6 +225712,7 @@ class RedisConnection extends EventEmitter {
             const status = this.status;
             this.status = 'closing';
             this.closing = true;
+            this.disableBlockingClusterReconnect();
             try {
                 if (status === 'ready') {
                     // Not sure if we need to wait for this
@@ -226395,6 +225736,7 @@ class RedisConnection extends EventEmitter {
                 }
             }
             finally {
+                this.releaseBlockingClusterClientPatch();
                 this._client.off('error', this.handleClientError);
                 this._client.off('close', this.handleClientClose);
                 this._client.off('ready', this.handleClientReady);
@@ -249771,9 +249113,15 @@ var optionsFromGlobalZodRegistry = /* @__PURE__ */ __name(() => {
 
 // src/runCLI.ts
 var DEFAULT_HEALTH_CHECK_PORT = 9090;
+function defaultScrapePortForActors(actors) {
+  const primary = actors[0];
+  const key = primary === "rewardRedemption" ? "rewardRedemptionApi" : primary;
+  return DefaultMetricsScrapePorts[key] ?? DefaultMetricsScrapePorts.producer;
+}
+__name(defaultScrapePortForActors, "defaultScrapePortForActors");
 var configuration;
 var skipInsecureConfirm = false;
-var version = isDefined("1.21.0") ? "1.21.0" : "unknown";
+var version = isDefined("1.21.2") ? "1.21.2" : "unknown";
 function getConfiguration() {
   return configuration;
 }
@@ -249819,7 +249167,8 @@ async function getLocatorsFromConfig(actors, configuration2) {
   if (collision) throw collision;
   const walletReport = await initializeResolvedWalletReport(actors, configuration2);
   logger.info(formatWalletReport(walletReport));
-  const context = await contextFromConfigWithoutLocator(config2, logger, "xl1-cli", version);
+  const serviceName = actors.length === 1 ? `xl1-${actors[0]}` : "xl1-cli";
+  const context = await contextFromConfigWithoutLocator(config2, logger, serviceName, version, defaultScrapePortForActors(actors));
   if (skipInsecureConfirm) {
     logger.warn("Insecure genesis reward wallet is active. Interactive confirmation skipped via --skip-insecure-confirm.");
   }