@shirudo/ddd-kit 3.0.0-rc.11 → 3.0.0-rc.12

package/dist/chunks/read-stream-pages.js

@@ -49,7 +49,7 @@ const sharedArrayBufferByteLengthGet = typeof SharedArrayBuffer === "undefined"
 const regExpSourceGet = intrinsicGetter(RegExp.prototype, "source");
 const booleanValueOf = Boolean.prototype.valueOf;
 const numberValueOf = Number.prototype.valueOf;
-const stringValueOf = String.prototype.valueOf;
+const stringValueOf$1 = String.prototype.valueOf;
 const bigIntValueOf = BigInt.prototype.valueOf;
 const functionToString = Function.prototype.toString;
 const PROBE_KEY = {};
@@ -197,6 +197,10 @@ function builtInTagWithoutInvokingAccessors(value) {
 	if (BUILT_IN_TAGS.has(tag) && hasBrand(value, tag)) return tag;
 	return descriptor === void 0 ? void 0 : builtInTagFromBrand(value);
 }
+/** The type name in a tag: `"Map"` for `"[object Map]"`. */
+function builtInTypeName(tag) {
+	return tag.slice(8, -1);
+}
 function builtInTagFromBrand(value) {
 	if (hasBrand(value, "[object Date]")) return "[object Date]";
 	if (hasBrand(value, "[object RegExp]")) return "[object RegExp]";
@@ -268,7 +272,7 @@ function hasBrand(obj, tag) {
 				numberValueOf.call(obj);
 				return true;
 			case "[object String]":
-				stringValueOf.call(obj);
+				stringValueOf$1.call(obj);
 				return true;
 			case "[object BigInt]":
 				bigIntValueOf.call(obj);
@@ -646,47 +650,106 @@ function deepEqualExcept(a, b, options) {
 }
 
 //#endregion
-//#region src/domain/value-object/value-object.ts
+//#region src/internal/cooperative-brand.ts
+/**
+* A cooperative brand marks an object that a kit constructor produced, so
+* a second loaded copy of the kit (duplicate npm dependency, dual CJS/ESM
+* load, plugin bundle) recognizes it. A module-private WeakSet cannot do
+* that: it is bound to one loaded copy. The brand is a `Symbol.for` key
+* with the value `true`. The property is non-enumerable, so it never
+* leaks into spreads, JSON, or equality, and non-writable and
+* non-configurable, so nothing edits it after the stamp.
+*
+* The probe reads the brand as an OWN property with exactly these
+* attributes and requires the carrier to be frozen. An object that
+* inherits a branded object through its prototype can carry mutable own
+* overrides; a branded object that is still open can change after the
+* stamp. Neither is what the constructor produced. Every stamp site
+* therefore freezes the carrier right after {@link stampCooperativeBrand}.
+*
+* The brand is forgeable BY DESIGN. It catches accidental hand-rolled
+* literals; it is not a security boundary against code in the same
+* process that fakes it on purpose.
+*
+* Internal utility (not exported from the package barrels).
+*/
+function stampCooperativeBrand(target, brand) {
+	Object.defineProperty(target, brand, {
+		value: true,
+		enumerable: false,
+		writable: false,
+		configurable: false
+	});
+}
+/**
+* Whether `value` carries `brand` as an own, non-enumerable, non-writable,
+* non-configurable `true` and is frozen. A Proxy trap that throws reads
+* as unbranded.
+*/
+function hasCooperativeBrand(value, brand) {
+	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
+	try {
+		const marker = Reflect.getOwnPropertyDescriptor(value, brand);
+		return marker?.value === true && marker.enumerable === false && marker.writable === false && marker.configurable === false && Object.isFrozen(value);
+	} catch {
+		return false;
+	}
+}
+
+//#endregion
+//#region src/internal/structural/shadowed-mutators.ts
 /**
 * `Object.freeze` does not protect internal slots: a frozen Date still
-* accepts `setTime`, a frozen Map still accepts `set`. To make the
-* "deeply immutable" guarantee real, the mutator methods are shadowed
-* with own throwing functions BEFORE the freeze. The shadows are
-* non-enumerable, so they are invisible to `Object.keys`/spread (deep
-* equality is unaffected) and `structuredClone` drops them (a `vo()`
-* round-trip never sees them).
+* accepts `setTime`, a frozen Map still accepts `set`. A deep freeze
+* therefore shadows these mutators with own throwing functions. The
+* shadows are non-enumerable, so they are invisible to `Object.keys` and
+* spread, and `structuredClone` drops them. A walk that checks a copy
+* accepts them as machinery, not data.
 */
-const DATE_MUTATORS = [
-	"setTime",
-	"setMilliseconds",
-	"setUTCMilliseconds",
-	"setSeconds",
-	"setUTCSeconds",
-	"setMinutes",
-	"setUTCMinutes",
-	"setHours",
-	"setUTCHours",
-	"setDate",
-	"setUTCDate",
-	"setMonth",
-	"setUTCMonth",
-	"setFullYear",
-	"setUTCFullYear",
-	"setYear"
-];
-const mutationThrowers = /* @__PURE__ */ new Map();
-const mapEntries$1 = Map.prototype.entries;
-const setValues$1 = Set.prototype.values;
-function mutationThrower(typeName, method) {
+const mutatorsByTag = /* @__PURE__ */ new Map([
+	["[object Date]", [
+		"setTime",
+		"setMilliseconds",
+		"setUTCMilliseconds",
+		"setSeconds",
+		"setUTCSeconds",
+		"setMinutes",
+		"setUTCMinutes",
+		"setHours",
+		"setUTCHours",
+		"setDate",
+		"setUTCDate",
+		"setMonth",
+		"setUTCMonth",
+		"setFullYear",
+		"setUTCFullYear",
+		"setYear"
+	]],
+	["[object Map]", [
+		"set",
+		"delete",
+		"clear"
+	]],
+	["[object Set]", [
+		"add",
+		"delete",
+		"clear"
+	]]
+]);
+const mutatorShadowBrand = Symbol.for("@shirudo/ddd-kit/mutator-shadow/v1");
+const shadows = /* @__PURE__ */ new Map();
+function shadowOf(typeName, method) {
 	const key = `${typeName}.${method}`;
-	let thrower = mutationThrowers.get(key);
-	if (!thrower) {
-		thrower = function throwFrozenMutation() {
+	let shadow = shadows.get(key);
+	if (shadow === void 0) {
+		shadow = function throwFrozenMutation() {
 			throw new TypeError(`Cannot call ${method}() on a ${typeName} inside a deeply frozen value`);
 		};
-		mutationThrowers.set(key, thrower);
+		stampCooperativeBrand(shadow, mutatorShadowBrand);
+		Object.freeze(shadow);
+		shadows.set(key, shadow);
 	}
-	return thrower;
+	return shadow;
 }
 const shadowDescriptor = {
 	value: void 0,
@@ -694,15 +757,36 @@ const shadowDescriptor = {
 	enumerable: false,
 	configurable: false
 };
-/** Returns whether the shadows were installed. */
-function shadowMutators(obj, typeName, methods) {
-	if (!Object.isExtensible(obj)) return false;
-	for (const method of methods) {
-		shadowDescriptor.value = mutationThrower(typeName, method);
-		Object.defineProperty(obj, method, shadowDescriptor);
+/**
+* Installs the mutator shadows on a Date, a Map, or a Set whose tag is
+* `tag`. Returns whether it installed them: a built-in of another kind has
+* no mutator shadows, and a non-extensible one cannot take them.
+*/
+function installMutatorShadows(object, tag) {
+	const mutators = mutatorsByTag.get(tag);
+	if (mutators === void 0 || !Object.isExtensible(object)) return false;
+	const typeName = builtInTypeName(tag);
+	for (const method of mutators) {
+		shadowDescriptor.value = shadowOf(typeName, method);
+		Object.defineProperty(object, method, shadowDescriptor);
 	}
 	return true;
 }
+/**
+* Whether the own property `key` of a built-in whose tag is `tag` is a
+* mutator shadow: a locked, non-enumerable function with the cooperative
+* brand of a shadow, under a mutator key of that built-in. The brand
+* catches accidents, not a forgery.
+*/
+function isMutatorShadow(tag, key, descriptor) {
+	const shadow = descriptor.value;
+	return (mutatorsByTag.get(tag)?.includes(key) ?? false) && typeof shadow === "function" && descriptor.enumerable === false && descriptor.writable === false && descriptor.configurable === false && hasCooperativeBrand(shadow, mutatorShadowBrand);
+}
+
+//#endregion
+//#region src/domain/value-object/value-object.ts
+const mapEntries$1 = Map.prototype.entries;
+const setValues$1 = Set.prototype.values;
 const VALUE_OBJECT_CLASS = Symbol.for("@shirudo/ddd-kit/value-object-class/v1");
 function recordValueObjectClass(instance, valueObjectClass) {
 	Object.defineProperty(instance, VALUE_OBJECT_CLASS, {
@@ -795,27 +879,14 @@ function freezeDeep(obj, walk) {
 	walk.inProgress.add(obj);
 	let sealed = true;
 	if (builtInTag === "[object Date]" || builtInTag === "[object Map]" || builtInTag === "[object Set]") {
-		let shadowed = KIT_SHADOWED.has(obj);
-		if (builtInTag === "[object Date]") shadowed = shadowMutators(obj, "Date", DATE_MUTATORS) || shadowed;
-		else if (builtInTag === "[object Map]") {
-			for (const [key, value] of obj) {
-				if (!freezeDeep(key, walk)) sealed = false;
-				if (!freezeDeep(value, walk)) sealed = false;
-			}
-			shadowed = shadowMutators(obj, "Map", [
-				"set",
-				"delete",
-				"clear"
-			]) || shadowed;
-		} else if (builtInTag === "[object Set]") {
+		if (builtInTag === "[object Map]") for (const [key, value] of obj) {
+			if (!freezeDeep(key, walk)) sealed = false;
+			if (!freezeDeep(value, walk)) sealed = false;
+		}
+		else if (builtInTag === "[object Set]") {
 			for (const member of obj) if (!freezeDeep(member, walk)) sealed = false;
-			shadowed = shadowMutators(obj, "Set", [
-				"add",
-				"delete",
-				"clear"
-			]) || shadowed;
 		}
-		if (shadowed) KIT_SHADOWED.add(obj);
+		if (installMutatorShadows(obj, builtInTag) || KIT_SHADOWED.has(obj)) KIT_SHADOWED.add(obj);
 		else sealed = false;
 	}
 	const keys = Reflect.ownKeys(obj);
@@ -1200,53 +1271,6 @@ var ValueObject = class {
 	}
 };
 
-//#endregion
-//#region src/internal/cooperative-brand.ts
-/**
-* A cooperative brand marks an object that a kit constructor produced, so
-* a second loaded copy of the kit (duplicate npm dependency, dual CJS/ESM
-* load, plugin bundle) recognizes it. A module-private WeakSet cannot do
-* that: it is bound to one loaded copy. The brand is a `Symbol.for` key
-* with the value `true`. The property is non-enumerable, so it never
-* leaks into spreads, JSON, or equality, and non-writable and
-* non-configurable, so nothing edits it after the stamp.
-*
-* The probe reads the brand as an OWN property with exactly these
-* attributes and requires the carrier to be frozen. An object that
-* inherits a branded object through its prototype can carry mutable own
-* overrides; a branded object that is still open can change after the
-* stamp. Neither is what the constructor produced. Every stamp site
-* therefore freezes the carrier right after {@link stampCooperativeBrand}.
-*
-* The brand is forgeable BY DESIGN. It catches accidental hand-rolled
-* literals; it is not a security boundary against code in the same
-* process that fakes it on purpose.
-*
-* Internal utility (not exported from the package barrels).
-*/
-function stampCooperativeBrand(target, brand) {
-	Object.defineProperty(target, brand, {
-		value: true,
-		enumerable: false,
-		writable: false,
-		configurable: false
-	});
-}
-/**
-* Whether `value` carries `brand` as an own, non-enumerable, non-writable,
-* non-configurable `true` and is frozen. A Proxy trap that throws reads
-* as unbranded.
-*/
-function hasCooperativeBrand(value, brand) {
-	if (value === null || typeof value !== "object" && typeof value !== "function") return false;
-	try {
-		const marker = Reflect.getOwnPropertyDescriptor(value, brand);
-		return marker?.value === true && marker.enumerable === false && marker.writable === false && marker.configurable === false && Object.isFrozen(value);
-	} catch {
-		return false;
-	}
-}
-
 //#endregion
 //#region src/internal/structural/detach-state.ts
 /**
@@ -1259,7 +1283,9 @@ function hasCooperativeBrand(value, brand) {
 * `DataCloneError`. An Error, a Promise, a WeakMap, or a WeakSet cannot be
 * detached at all. A SharedArrayBuffer and a view over one keep sharing
 * their memory. A Proxy fails in the walk or in the clone; a failure in
-* the clone is rethrown as a `TypeError` with the cause.
+* the clone is rethrown as a `TypeError` with the cause. An error that a
+* Proxy trap throws in the walk passes unchanged, so a coded error of the
+* caller keeps its code.
 *
 * The walk reads the graph through property descriptors and walks a Map
 * or a Set with the built-in iteration, so no accessor and no own iterator
@@ -1267,17 +1293,22 @@ function hasCooperativeBrand(value, brand) {
 * change the graph, and an accessor that a trap adds runs during the
 * clone. A second walk checks the clone, so a value that a trap swapped in
 * and the content of a built-in whose prototype was replaced are rejected
-* too. The walks also count the data properties of records and arrays. A
-* copy with another count throws, because a built-in whose prototype was
-* replaced loses its own properties in the copy. `subject` names the state
-* in the messages.
+* too. A trap that changes the graph after the first walk can still hide a
+* value that the copy drops: the walks catch accidents, not a hostile
+* Proxy. The second walk also follows the steps of the first walk: the kind
+* of each object and the key of each data property, in walk order. A copy
+* that differs throws, because a built-in whose prototype was replaced is
+* a built-in again in the copy and loses its own properties. `subject`
+* names the state in the messages.
 *
 * Plain objects (from any realm), arrays, Dates, Maps, Sets, bigints, and
 * typed arrays pass. A RegExp passes: pattern and flags survive the clone,
 * and `lastIndex` restores as 0. The scan state of a global or sticky
-* pattern is not domain data. A non-enumerable property on a built-in
-* passes: it is the built-in's own machinery (`lastIndex`), not data. A
-* non-enumerable symbol key passes anywhere: it is metadata by convention.
+* pattern is not domain data. On a built-in, the mutator shadows of a deep
+* freeze, the `lastIndex` of a RegExp, and the `length` of a boxed String
+* pass: they are machinery, not data. Every other non-enumerable property
+* throws. A non-enumerable symbol key passes anywhere: it is metadata by
+* convention.
 *
 * The concrete entity uses it for a detached read DTO of a plain-data
 * state. The snapshot model uses it for the captured DTO and the restored
@@ -1296,41 +1327,18 @@ function detachState(state, subject = "detachState: state") {
 function detachFreezableState(state, subject) {
 	return detach(state, subject, "freeze");
 }
-/**
-* Throws the `TypeError` of {@link detachFreezableState} and copies
-* nothing. A caller that has a clone already checks it with this, so the
-* rule is the same. Kit modules only.
-*/
-function assertFreezableState(state, subject) {
-	assertDetachable(state, "", {
-		seen: /* @__PURE__ */ new WeakSet(),
-		subject,
-		rule: "freeze",
-		dataProperties: 0
-	});
-}
 function detach(state, subject, rule) {
-	const original = {
-		seen: /* @__PURE__ */ new WeakSet(),
-		subject,
-		rule,
-		dataProperties: 0
-	};
-	assertDetachable(state, "", original);
+	const recording = new StepRecording();
+	assertDetachable(state, "", newWalk(subject, rule, recording));
 	let copy;
 	try {
 		copy = structuredClone(state);
 	} catch (cause) {
-		throw new TypeError(`${subject} holds a Proxy or a host object that cannot be cloned; map it to plain data`, { cause });
+		throw new TypeError(`${subject} holds a Proxy or a host object that cannot be cloned, or a view over a detached or shrunk buffer; the cause names the value; map it to plain data`, { cause });
 	}
-	const copied = {
-		seen: /* @__PURE__ */ new WeakSet(),
-		subject,
-		rule,
-		dataProperties: 0
-	};
-	assertDetachable(copy, "", copied);
-	if (copied.dataProperties !== original.dataProperties) throw new TypeError(`${subject} changed in the copy: the state has ${original.dataProperties} data properties and the copy has ${copied.dataProperties}; a built-in whose prototype was replaced loses its own properties in the copy, and a Proxy trap can change the graph; map it to plain data`);
+	const comparison = new StepComparison(recording, subject);
+	assertDetachable(copy, "", newWalk(subject, rule, comparison));
+	comparison.assertComplete();
 	return copy;
 }
 const INDEX_KEY = /^(0|[1-9]\d*)$/;
@@ -1341,8 +1349,76 @@ const BINARY_DATA_TAGS = /* @__PURE__ */ new Set([
 	"[object SharedArrayBuffer]"
 ]);
 const REGEXP_TAG = "[object RegExp]";
+const STRING_TAG = "[object String]";
 const mapEntries = Map.prototype.entries;
 const setValues = Set.prototype.values;
+const RECORD_STEP = Symbol("record");
+const ARRAY_STEP = Symbol("array");
+const builtInSteps = /* @__PURE__ */ new Map();
+function builtInStep(tag) {
+	let kind = builtInSteps.get(tag);
+	if (kind === void 0) {
+		kind = Symbol(tag);
+		builtInSteps.set(tag, kind);
+	}
+	return kind;
+}
+/**
+* The steps of the walk over the original, in walk order.
+*/
+var StepRecording = class {
+	steps = [];
+	take(next) {
+		this.steps.push(next);
+	}
+};
+/**
+* The walk over the copy compares each of its steps with the step of the
+* walk over the original at the same position. Structured clone keeps the
+* order of the keys, of Map entries, and of Set members, and it keeps
+* shared references, so the walk over an unchanged copy takes the same
+* steps. A step that differs, or a step that is missing, means that the
+* copy changed.
+*/
+var StepComparison = class {
+	recording;
+	subject;
+	#position = 0;
+	constructor(recording, subject) {
+		this.recording = recording;
+		this.subject = subject;
+	}
+	take(next, path) {
+		const expected = this.recording.steps[this.#position];
+		if (expected !== next) throwChangedInCopy(this.subject, path, expected, next);
+		this.#position += 1;
+	}
+	assertComplete() {
+		if (this.#position < this.recording.steps.length) throwChangedInCopy(this.subject, "", this.recording.steps[this.#position], void 0);
+	}
+};
+function newWalk(subject, rule, trace) {
+	return {
+		seen: /* @__PURE__ */ new WeakSet(),
+		subject,
+		rule,
+		trace
+	};
+}
+function step(walk, next, path) {
+	walk.trace.take(next, path);
+}
+function throwChangedInCopy(subject, path, expected, found) {
+	throw new TypeError(`${subject}${path} changed in the copy: the state has ${describeStep(expected)} there, and the copy has ${describeStep(found)}; a built-in whose prototype was replaced is a built-in again in the copy and loses its own properties, and a Proxy trap can change the graph; map it to plain data`);
+}
+function describeStep(step) {
+	if (step === void 0) return "nothing";
+	if (typeof step === "string") return `the key "${step}"`;
+	if (step === RECORD_STEP) return "a record";
+	if (step === ARRAY_STEP) return "an array";
+	const name = builtInTypeName(step.description);
+	return /^[AEIOU]/.test(name) ? `an ${name}` : `a ${name}`;
+}
 function assertDetachable(value, path, walk) {
 	if (typeof value === "function") throw new TypeError(`${walk.subject}${path} is a function; map it to plain data`);
 	if (typeof value === "symbol") throw new TypeError(`${walk.subject}${path} is a symbol; map it to plain data`);
@@ -1352,6 +1428,7 @@ function assertDetachable(value, path, walk) {
 	walk.seen.add(object);
 	if (Array.isArray(object)) {
 		if (!hasIntrinsicPrototypeChain(object, "Array")) throwClassInstance(object, path, walk.subject);
+		step(walk, ARRAY_STEP, path);
 		assertOwnPropertiesDetachable(object, path, walk, "array");
 		return;
 	}
@@ -1359,6 +1436,7 @@ function assertDetachable(value, path, walk) {
 	if (tag !== void 0) {
 		if (walk.rule === "freeze") assertFreezable(tag, path, walk.subject);
 		if (!hasIntrinsicPrototypeChain(object)) throwClassInstance(object, path, walk.subject);
+		step(walk, builtInStep(tag), path);
 		if (tag === "[object Map]") {
 			let index = 0;
 			for (const [key, entry] of mapEntries.call(object)) {
@@ -1372,25 +1450,30 @@ function assertDetachable(value, path, walk) {
 				assertDetachable(member, `${path}<set member #${index}>`, walk);
 				index++;
 			}
-		} else if (tag === "[object Promise]" || tag === "[object WeakMap]" || tag === "[object WeakSet]") throw new TypeError(`${walk.subject}${path} is a ${tag.slice(8, -1)} and cannot be detached`);
+		} else if (tag === "[object Promise]" || tag === "[object WeakMap]" || tag === "[object WeakSet]") throw new TypeError(`${walk.subject}${path} is a ${builtInTypeName(tag)} and cannot be detached`);
 		else if (tag === "[object Error]") throw new TypeError(`${walk.subject}${path} is an Error; map it to plain data`);
 		else if (sharesMemory(object, tag)) throw new TypeError(`${walk.subject}${path} is backed by a SharedArrayBuffer and the copy would share its memory; map it to plain data`);
-		assertOwnPropertiesDetachable(object, path, walk, "built-in");
+		assertOwnPropertiesDetachable(object, path, walk, tag);
 		return;
 	}
 	const prototype = Object.getPrototypeOf(object);
 	if (!(prototype === null || isIntrinsicConstructorPrototype(prototype, "Object") && Object.getPrototypeOf(prototype) === null)) throwClassInstance(object, path, walk.subject);
+	step(walk, RECORD_STEP, path);
 	assertOwnPropertiesDetachable(object, path, walk, "record");
 }
 /**
 * Audits the own properties the clone would copy or drop. The clone keeps
 * the enumerable own keys of a record and of an array, expandos included,
-* and drops every own key of another built-in. `length` on an array and
-* the non-enumerable keys of a built-in (`lastIndex`) are its own
-* machinery, not data. Index keys of a typed array or a boxed String are
-* its content and pass as such.
+* and drops every own key of another built-in. `length` on an array is
+* its own machinery, not data, and so are the keys that
+* {@link isBuiltInMachinery} names. The index keys of a built-in below its
+* content length are its content and pass as such. Another index key of a
+* built-in is an expando. `owner` is the kind of `object`: an array, a
+* record, or the tag of a built-in.
 */
-function assertOwnPropertiesDetachable(object, path, walk, kind) {
+function assertOwnPropertiesDetachable(object, path, walk, owner) {
+	const tag = owner === "array" || owner === "record" ? void 0 : owner;
+	const contentLength = tag === void 0 ? 0 : contentLengthOf(object, tag);
 	for (const key of Reflect.ownKeys(object)) {
 		const descriptor = Object.getOwnPropertyDescriptor(object, key);
 		if (descriptor === void 0) continue;
@@ -1398,20 +1481,41 @@ function assertOwnPropertiesDetachable(object, path, walk, kind) {
 			if (!descriptor.enumerable) continue;
 			throw new TypeError(`${walk.subject}${path} has a symbol-keyed property; map it to plain data`);
 		}
-		if (kind === "array" && key === "length") continue;
+		if (owner === "array" && key === "length") continue;
 		const isIndex = INDEX_KEY.test(key);
+		const memberPath = isIndex ? `${path}[${key}]` : `${path}.${key}`;
 		if (!descriptor.enumerable) {
-			if (kind === "built-in") continue;
-			throw new TypeError(`${walk.subject}${path}.${key} is not enumerable and the clone would drop it; map it to plain data`);
+			if (tag !== void 0 && isBuiltInMachinery(tag, key, descriptor)) continue;
+			throw new TypeError(`${walk.subject}${memberPath} is not enumerable and the clone would drop it; map it to plain data`);
 		}
-		if (kind === "built-in" && isIndex) continue;
-		const memberPath = isIndex ? `${path}[${key}]` : `${path}.${key}`;
+		if (tag !== void 0 && isIndex && Number(key) < contentLength) continue;
 		if (!("value" in descriptor)) throw new TypeError(`${walk.subject}${memberPath} is an accessor property; map it to plain data`);
-		if (kind === "built-in") throw new TypeError(`${walk.subject}${memberPath} is an expando on a ${constructorName(Object.getPrototypeOf(object)) ?? "built-in"} and the clone would drop it; map it to plain data`);
-		walk.dataProperties += 1;
+		if (tag !== void 0) throw new TypeError(`${walk.subject}${memberPath} is an expando on a ${constructorName(Object.getPrototypeOf(object)) ?? "built-in"} and the clone would drop it; map it to plain data`);
+		step(walk, key, memberPath);
 		assertDetachable(descriptor.value, memberPath, walk);
 	}
 }
+/**
+* Whether an own non-enumerable property of a built-in is machinery, not
+* data: a function that shadows a mutator of a frozen Date, Map, or Set,
+* the scan position of a RegExp, or the length of a boxed String. The
+* clone drops the shadow and rebuilds the other two from the internal
+* slots.
+*/
+function isBuiltInMachinery(tag, key, descriptor) {
+	return isMutatorShadow(tag, key, descriptor) || tag === REGEXP_TAG && key === "lastIndex" || tag === STRING_TAG && key === "length";
+}
+/**
+* The number of index keys that hold the content of a built-in: the
+* elements of a typed array and the characters of a boxed String.
+*/
+function contentLengthOf(object, tag) {
+	if (tag === "[object TypedArray]") return typedArrayLength.call(object);
+	if (tag === STRING_TAG) return stringValueOf.call(object).length;
+	return 0;
+}
+const typedArrayLength = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "length")?.get;
+const stringValueOf = String.prototype.valueOf;
 const typedArrayBuffer = Object.getOwnPropertyDescriptor(Object.getPrototypeOf(Uint8Array.prototype), "buffer")?.get;
 const dataViewBuffer = Object.getOwnPropertyDescriptor(DataView.prototype, "buffer")?.get;
 function sharesMemory(object, tag) {
@@ -1544,48 +1648,6 @@ function buildDomainEventFactory(options, createOperation) {
 * with {@link createDomainEventFactory} for custom policy.
 */
 const defaultDomainEventFactory = buildDomainEventFactory({}, "createDomainEvent");
-/**
-* Creates a domain event with default values.
-* Sets occurredAt to current date and schemaVersion to 1 if not provided.
-*
-* **Input ownership.** The event is deeply frozen, and `payload` and
-* `metadata` are deep-cloned first, so the caller's own objects are never
-* frozen in place and later mutation of them does not bleed into the
-* event (same contract as `vo()`). The clone follows the plain-data event
-* contract via `structuredClone`: functions, Promise, and WeakMap/WeakSet
-* values throw a `TypeError`; symbol-keyed properties are not carried
-* over. The clone is then checked with the rule of the in-memory event
-* store: an `Error`, a host object such as a `File`, a binary buffer, and
-* shared memory throw a `TypeError`. A class instance or an accessor becomes
-* plain data in the clone.
-*
-* **For aggregate-internal events, prefer `this.createEvent(...)` on
-* `StateStoredAggregate` / `EventSourcedAggregate`.** That helper auto-injects
-* `aggregateId` (from `this.id`) and `aggregateType` (from the
-* aggregate's declared `aggregateType` property), which downstream
-* consumers (outbox dispatchers, projection handlers, audit logs)
-* route by. The commit boundary validates that both fields are present
-* and throws if they are missing, so a direct `createDomainEvent(...)`
-* call inside an aggregate that forgets the options is caught at
-* runtime. Record pending decisions in the application
-* shell before repository persistence or outbox harvest.
-*
-* Use `createDomainEvent(...)` directly for events that don't belong to
-* an aggregate: system events, integration events, configuration events,
-* test fixtures. For those, set `aggregateId` / `aggregateType` in
-* `options` if downstream consumers expect routing metadata.
-*
-* @param type - The event type
-* @param payload - The event payload
-* @param options - Optional event configuration (including `aggregateId`
-*   and `aggregateType` for routing)
-* @returns A domain event
-*
-* @example
-* ```typescript
-* const event = createDomainEvent("OrderCreated", { orderId: "123" });
-* ```
-*/
 const RECORDED_EVENTS = /* @__PURE__ */ new WeakSet();
 const UNCOMMITTED_EVENTS = /* @__PURE__ */ new WeakSet();
 const FACTORY_OWNED_EVENT_STAMPS = /* @__PURE__ */ new WeakSet();
@@ -1792,25 +1854,12 @@ function isPlainRecordCopy(copy) {
 /**
 * Deep-clones caller-supplied event data (payload, metadata) before the
 * event is frozen, so a constructor never freezes or aliases the caller's
-* own object graph, and checks the clone with {@link assertFreezableState}.
-* A primitive needs no copy, but the check rejects a symbol. A class
-* instance or an accessor becomes plain data in the clone.
+* own object graph. {@link detachFreezableState} checks the data and the
+* clone; its JSDoc states the rule and its limits.
 */
 function cloneOwnedEventData(value, field, operation) {
-	if (typeof value === "function") throw new TypeError(`${operation}: ${field} must not be a function: domain events are plain data`);
-	if (value === null || typeof value !== "object") {
-		assertFreezableState(value, `${operation}: ${field}`);
-		return value;
-	}
-	let clone;
-	try {
-		clone = structuredClone(value);
-	} catch (cause) {
-		throw new TypeError(`${operation}: ${field} cannot be copied, because structuredClone failed (the cause names the value); domain events are plain data`, { cause });
-	}
-	assertNoHostileOwnProtoKey(clone, `Event ${field} of ${operation}`);
-	assertFreezableState(clone, `${operation}: ${field}`);
-	return clone;
+	if (value !== null && typeof value === "object") assertNoHostileOwnProtoKey(value, `Event ${field} of ${operation}`);
+	return detachFreezableState(value, `${operation}: ${field}`);
 }
 /**
 * Copies metadata from a source event to a new event.
@@ -2250,5 +2299,5 @@ function throwIfAborted(signal) {
 }
 
 //#endregion
-export { SnapshotTimeValidationError as A, voWithValidation as B, defaultDomainEventFactory as C, mintUncommittedDomainEvent as D, mergeMetadata as E, ValueObject as F, isBuiltInObject as G, deepOmit as H, deepFreeze as I, isIntrinsicConstructorPrototype as K, vo as L, detachState as M, hasCooperativeBrand as N, recordDomainEvent as O, stampCooperativeBrand as P, voEquals as R, createUncommittedDomainEvent as S, isUncommittedDomainEvent as T, deepEqual as U, deepEqualExcept as V, findPropertyDescriptor as W, adoptUncommittedDomainEvent as _, isDispatchTrackingOutbox as a, createDomainEventFactory as b, runBoundedExecution as c, assertPositiveInteger as d, assertPositiveSafeInteger as f, adoptRecordedDomainEvent as g, waitRejectingOnAbort as h, assertPageWithinWindow as i, detachFreezableState as j, DomainEventValidationError as k, MAX_TIMER_DELAY_MS as l, abortReason as m, readStreamPages as n, DEFAULT_EXECUTION_TIMEOUT_MS as o, assertTimerDelay as p, isWeakMap as q, assertPageNotEmpty as r, ownerSignalOf as s, pinTargetVersion as t, assertNonNegativeSafeInteger as u, copyMetadata as v, isRecordedDomainEvent as w, createDomainEventFromFacts as x, createDomainEvent as y, voEqualsExcept as z };
+export { SnapshotTimeValidationError as A, stampCooperativeBrand as B, defaultDomainEventFactory as C, mintUncommittedDomainEvent as D, mergeMetadata as E, vo as F, isBuiltInObject as G, deepOmit as H, voEquals as I, isIntrinsicConstructorPrototype as K, voEqualsExcept as L, detachState as M, ValueObject as N, recordDomainEvent as O, deepFreeze as P, voWithValidation as R, createUncommittedDomainEvent as S, isUncommittedDomainEvent as T, deepEqual as U, deepEqualExcept as V, findPropertyDescriptor as W, adoptUncommittedDomainEvent as _, isDispatchTrackingOutbox as a, createDomainEventFactory as b, runBoundedExecution as c, assertPositiveInteger as d, assertPositiveSafeInteger as f, adoptRecordedDomainEvent as g, waitRejectingOnAbort as h, assertPageWithinWindow as i, detachFreezableState as j, DomainEventValidationError as k, MAX_TIMER_DELAY_MS as l, abortReason as m, readStreamPages as n, DEFAULT_EXECUTION_TIMEOUT_MS as o, assertTimerDelay as p, isWeakMap as q, assertPageNotEmpty as r, ownerSignalOf as s, pinTargetVersion as t, assertNonNegativeSafeInteger as u, copyMetadata as v, isRecordedDomainEvent as w, createDomainEventFromFacts as x, createDomainEvent as y, hasCooperativeBrand as z };
 //# sourceMappingURL=read-stream-pages.js.map