@peerbit/document 15.0.14 → 15.0.16

package/src/callback-detachment.ts

@@ -1,3 +1,4 @@
+import type { PublicSignKey, SignatureWithKey } from "@peerbit/crypto";
 import * as indexerTypes from "@peerbit/indexer-interface";
 import { Entry } from "@peerbit/log";
 import {
@@ -8,6 +9,402 @@ import {
 	PutWithKeyOperation,
 } from "./operation.js";
 
+type LazyPropertyFactories = Map<PropertyKey, () => unknown>;
+
+const isPromiseLike = (value: unknown): value is PromiseLike<unknown> =>
+	!!value &&
+	(typeof value === "object" || typeof value === "function") &&
+	typeof (value as { then?: unknown }).then === "function";
+
+const mapMaybePromise = (
+	value: unknown,
+	map: (value: any) => unknown,
+): unknown => (isPromiseLike(value) ? value.then(map) : map(value));
+
+const copyOptionalBytes = (
+	bytes: Uint8Array | undefined,
+): Uint8Array | undefined =>
+	bytes == null ? undefined : new Uint8Array(bytes);
+
+const preserveArrayIntegrity = <T>(source: readonly T[], copy: T[]): T[] => {
+	if (Object.isFrozen(source)) {
+		Object.freeze(copy);
+	} else if (Object.isSealed(source)) {
+		Object.seal(copy);
+	} else if (!Object.isExtensible(source)) {
+		Object.preventExtensions(copy);
+	}
+	return copy;
+};
+
+const detachArray = <T>(
+	values: readonly T[],
+	detach: (value: T) => T = (value) => value,
+): T[] => preserveArrayIntegrity(values, values.map(detach));
+
+const getInheritedPropertyDescriptor = (
+	value: object,
+	key: PropertyKey,
+): PropertyDescriptor | undefined => {
+	let prototype = Object.getPrototypeOf(value) as object | null;
+	while (prototype) {
+		const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+		if (descriptor) {
+			return descriptor;
+		}
+		prototype = Object.getPrototypeOf(prototype) as object | null;
+	}
+	return undefined;
+};
+
+/**
+ * Clone an object without resolving selected nested values. For normal
+ * objects the selected fields become callback-local lazy accessors. The clone
+ * receives the source's frozen/sealed/non-extensible state only after those
+ * accessors are installed, so a no-touch callback never resolves lazy source
+ * fields.
+ */
+const cloneWithLazyProperties = <T extends object>(
+	value: T,
+	factories: LazyPropertyFactories,
+): T => {
+	const descriptors = Object.getOwnPropertyDescriptors(value) as Record<
+		PropertyKey,
+		PropertyDescriptor
+	>;
+	const extensible = Object.isExtensible(value);
+	for (const [key, factory] of factories) {
+		const ownDescriptor = descriptors[key];
+		const descriptor =
+			ownDescriptor ?? getInheritedPropertyDescriptor(value, key);
+		let resolved = false;
+		let detachedValue: unknown;
+		const writable = descriptor
+			? (ownDescriptor != null || extensible) &&
+				("value" in descriptor
+					? descriptor.writable !== false
+					: descriptor.set != null)
+			: extensible;
+		descriptors[key] = {
+			configurable: descriptor?.configurable ?? true,
+			enumerable: descriptor?.enumerable ?? true,
+			get() {
+				if (!resolved) {
+					detachedValue = factory();
+					resolved = true;
+				}
+				return detachedValue;
+			},
+			...(writable
+				? {
+						set(nextValue: unknown) {
+							detachedValue = nextValue;
+							resolved = true;
+						},
+					}
+				: {}),
+		};
+	}
+	const clone = Object.create(Object.getPrototypeOf(value), descriptors) as T;
+	if (Object.isFrozen(value)) {
+		Object.freeze(clone);
+	} else if (Object.isSealed(value)) {
+		Object.seal(clone);
+	} else if (!Object.isExtensible(value)) {
+		Object.preventExtensions(clone);
+	}
+	return clone;
+};
+
+const addOwnByteFactories = (
+	value: object,
+	factories: LazyPropertyFactories,
+): void => {
+	const descriptors = Object.getOwnPropertyDescriptors(value) as Record<
+		PropertyKey,
+		PropertyDescriptor
+	>;
+	for (const key of Reflect.ownKeys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (descriptor && "value" in descriptor) {
+			const bytes = descriptor.value;
+			if (bytes instanceof Uint8Array) {
+				factories.set(key, () => new Uint8Array(bytes));
+			}
+		}
+	}
+};
+
+const addOwnArrayFactories = (
+	value: object,
+	factories: LazyPropertyFactories,
+): void => {
+	const descriptors = Object.getOwnPropertyDescriptors(value) as Record<
+		PropertyKey,
+		PropertyDescriptor
+	>;
+	for (const key of Reflect.ownKeys(descriptors)) {
+		const descriptor = descriptors[key];
+		if (
+			descriptor &&
+			"value" in descriptor &&
+			Array.isArray(descriptor.value)
+		) {
+			const array = descriptor.value as unknown[];
+			factories.set(key, () =>
+				detachArray(array, (item) =>
+					item instanceof Uint8Array ? new Uint8Array(item) : item,
+				),
+			);
+		}
+	}
+};
+
+const detachedCallbackEntryLikes = new WeakSet<object>();
+
+const createEntryDetachmentContext = () => {
+	let metadata: WeakMap<object, object> | undefined;
+	let clocks: WeakMap<object, object> | undefined;
+	let timestamps: WeakMap<object, object> | undefined;
+	let signatures: WeakMap<object, object> | undefined;
+	let publicKeys: WeakMap<object, object> | undefined;
+	let entryLikes: WeakMap<object, object> | undefined;
+	let arrays: WeakMap<object, unknown[]> | undefined;
+
+	const detachValues = <T>(
+		values: readonly T[],
+		detach: (value: T) => T = (value) => value,
+	): T[] => {
+		const cached = arrays?.get(values);
+		if (cached) {
+			return cached as T[];
+		}
+		const clone = detachArray(values, detach);
+		(arrays ??= new WeakMap()).set(values, clone);
+		return clone;
+	};
+
+	const detachTimestamp = <T>(value: T): T => {
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		const cached = timestamps?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		const clone = cloneWithLazyProperties(value, factories);
+		(timestamps ??= new WeakMap()).set(value, clone);
+		return clone;
+	};
+
+	const detachClock = <T>(value: T): T => {
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		const cached = clocks?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		if (Reflect.has(value, "id") && !factories.has("id")) {
+			factories.set("id", () =>
+				copyOptionalBytes(
+					Reflect.get(value, "id", value) as Uint8Array | undefined,
+				),
+			);
+		}
+		if (Reflect.has(value, "timestamp")) {
+			factories.set("timestamp", () =>
+				detachTimestamp(Reflect.get(value, "timestamp", value)),
+			);
+		}
+		const clone = cloneWithLazyProperties(value, factories);
+		(clocks ??= new WeakMap()).set(value, clone);
+		return clone;
+	};
+
+	const detachMeta = <T>(value: T): T => {
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		const cached = metadata?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		if (Reflect.has(value, "data") && !factories.has("data")) {
+			factories.set("data", () =>
+				copyOptionalBytes(
+					Reflect.get(value, "data", value) as Uint8Array | undefined,
+				),
+			);
+		}
+		if (Reflect.has(value, "clock")) {
+			factories.set("clock", () =>
+				detachClock(Reflect.get(value, "clock", value)),
+			);
+		}
+		if (Reflect.has(value, "next")) {
+			factories.set("next", () => {
+				const next = Reflect.get(value, "next", value);
+				return Array.isArray(next) ? detachValues(next) : next;
+			});
+		}
+		const clone = cloneWithLazyProperties(value, factories);
+		(metadata ??= new WeakMap()).set(value, clone);
+		return clone;
+	};
+
+	const detachPublicKey = <T>(value: T): T => {
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		const cached = publicKeys?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		const clone = cloneWithLazyProperties(value, factories);
+		(publicKeys ??= new WeakMap()).set(value, clone);
+		return clone;
+	};
+
+	const detachSignature = <T>(value: T): T => {
+		if (!value || typeof value !== "object") {
+			return value;
+		}
+		const cached = signatures?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		if (Reflect.has(value, "publicKey")) {
+			factories.set("publicKey", () =>
+				detachPublicKey(Reflect.get(value, "publicKey", value)),
+			);
+		}
+		const clone = cloneWithLazyProperties(value, factories);
+		(signatures ??= new WeakMap()).set(value, clone);
+		return clone;
+	};
+
+	const detachSignatures = (
+		values: readonly SignatureWithKey[],
+	): SignatureWithKey[] => detachValues(values, detachSignature);
+
+	const detachPublicKeys = (
+		values: readonly PublicSignKey[],
+	): PublicSignKey[] => detachValues(values, detachPublicKey);
+
+	const detachEntryLike = <T extends object>(value: T): T => {
+		if (detachedCallbackEntryLikes.has(value)) {
+			return value;
+		}
+		const cached = entryLikes?.get(value);
+		if (cached) {
+			return cached as T;
+		}
+		const factories: LazyPropertyFactories = new Map();
+		addOwnByteFactories(value, factories);
+		addOwnArrayFactories(value, factories);
+		if (Reflect.has(value, "meta")) {
+			factories.set("meta", () =>
+				detachMeta(Reflect.get(value, "meta", value)),
+			);
+		}
+		for (const methodName of ["getMetaBytes", "getHashDigestBytes"] as const) {
+			const method = Reflect.get(value, methodName, value);
+			if (typeof method === "function") {
+				factories.set(
+					methodName,
+					() =>
+						(...args: unknown[]) =>
+							mapMaybePromise(
+								Reflect.apply(method, value, args),
+								copyOptionalBytes,
+							),
+				);
+			}
+		}
+		const clone = cloneWithLazyProperties(value, factories);
+		(entryLikes ??= new WeakMap()).set(value, clone);
+		detachedCallbackEntryLikes.add(clone);
+		return clone;
+	};
+
+	return {
+		detachArray: detachValues,
+		detachClock,
+		detachEntryLike,
+		detachMeta,
+		detachPublicKeys,
+		detachSignatures,
+	};
+};
+
+type EntryDetachmentContext = ReturnType<typeof createEntryDetachmentContext>;
+type EntryDetachmentContextProvider = () => EntryDetachmentContext;
+
+const detachPreparedAppendJoinFactsForCallback = (
+	facts: object,
+	canonicalEntry: Entry<any>,
+	callbackEntry: Entry<any>,
+	getContext: EntryDetachmentContextProvider,
+): object => {
+	const factories: LazyPropertyFactories = new Map();
+	addOwnByteFactories(facts, factories);
+	if (Reflect.has(facts, "bytes")) {
+		factories.set("bytes", () =>
+			copyOptionalBytes(
+				Reflect.get(facts, "bytes", facts) as Uint8Array | undefined,
+			),
+		);
+	}
+	if (Reflect.has(facts, "meta")) {
+		factories.set("meta", () =>
+			getContext().detachMeta(Reflect.get(facts, "meta", facts)),
+		);
+	}
+	const getShallowEntry = Reflect.get(facts, "getShallowEntry", facts);
+	if (typeof getShallowEntry === "function") {
+		factories.set("getShallowEntry", () => (...args: unknown[]) => {
+			const shallow = Reflect.apply(getShallowEntry, facts, args) as unknown;
+			return shallow && typeof shallow === "object"
+				? getContext().detachEntryLike(shallow)
+				: shallow;
+		});
+	}
+	const materializeEntry = Reflect.get(facts, "materializeEntry", facts);
+	if (typeof materializeEntry === "function") {
+		factories.set(
+			"materializeEntry",
+			() =>
+				(...args: unknown[]) =>
+					mapMaybePromise(
+						Reflect.apply(materializeEntry, facts, args),
+						(materialized) =>
+							materialized === canonicalEntry
+								? callbackEntry
+								: materialized instanceof Entry
+									? detachEntryPayloadForCallbackWithContext(
+											materialized,
+											getContext,
+										)
+									: materialized && typeof materialized === "object"
+										? getContext().detachEntryLike(materialized)
+										: materialized,
+					),
+		);
+	}
+	return cloneWithLazyProperties(facts, factories);
+};
+
 /**
  * Borsh byte fields are input-buffer views. Clone only fields that can expose
  * verified operation bytes while retaining the operation's exact prototype,
@@ -176,13 +573,16 @@ export const detachCanPerformCallbackProperties = <
 };
 
 /**
- * Return an Entry view whose public payload accessors cannot expose the
- * verified payload buffer to application callbacks. The byte copy is lazy:
- * callbacks that only inspect hashes, clocks, or signers allocate nothing.
+ * Return an Entry view whose public accessors cannot expose verified payload,
+ * metadata, signature, public-key, or hash-digest buffers to application
+ * callbacks. Nested copies remain lazy, including metadata byte fields.
  */
 const detachedCallbackEntries = new WeakSet<object>();
 
-export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
+const detachEntryPayloadForCallbackWithContext = <T>(
+	entry: Entry<T>,
+	getContext: EntryDetachmentContextProvider,
+): Entry<T> => {
 	if (detachedCallbackEntries.has(entry)) {
 		return entry;
 	}
@@ -252,6 +652,23 @@ export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
 			if (property === "payload") {
 				return copyPayload(entry.payload);
 			}
+			if (property === "meta") {
+				return getContext().detachMeta(Reflect.get(target, property, target));
+			}
+			if (property === "next") {
+				const next = Reflect.get(target, property, target);
+				return Array.isArray(next) ? getContext().detachArray(next) : next;
+			}
+			if (property === "signatures") {
+				return getContext().detachSignatures(
+					Reflect.get(target, property, target),
+				);
+			}
+			if (property === "publicKeys") {
+				return getContext().detachPublicKeys(
+					Reflect.get(target, property, target),
+				);
+			}
 			if (
 				property === "getPayload" &&
 				typeof (entry as Entry<T> & { getPayload?: unknown }).getPayload ===
@@ -262,9 +679,83 @@ export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
 			if (property === "getPayloadValue") {
 				return getPayloadValue;
 			}
+			if (property === "getMeta") {
+				const getMeta = Reflect.get(target, property, target);
+				if (typeof getMeta === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(
+							Reflect.apply(getMeta, target, args),
+							getContext().detachMeta,
+						);
+				}
+			}
+			if (property === "getClock") {
+				const getClock = Reflect.get(target, property, target);
+				if (typeof getClock === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(
+							Reflect.apply(getClock, target, args),
+							getContext().detachClock,
+						);
+				}
+			}
+			if (property === "getNext") {
+				const getNext = Reflect.get(target, property, target);
+				if (typeof getNext === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(Reflect.apply(getNext, target, args), (next) =>
+							Array.isArray(next) ? getContext().detachArray(next) : next,
+						);
+				}
+			}
+			if (property === "getSignatures") {
+				const getSignatures = Reflect.get(target, property, target);
+				if (typeof getSignatures === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(
+							Reflect.apply(getSignatures, target, args),
+							getContext().detachSignatures,
+						);
+				}
+			}
+			if (property === "getPublicKeys") {
+				const getPublicKeys = Reflect.get(target, property, target);
+				if (typeof getPublicKeys === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(
+							Reflect.apply(getPublicKeys, target, args),
+							getContext().detachPublicKeys,
+						);
+				}
+			}
+			if (property === "getMetaBytes" || property === "getHashDigestBytes") {
+				const getBytes = Reflect.get(target, property, target);
+				if (typeof getBytes === "function") {
+					return (...args: unknown[]) =>
+						mapMaybePromise(
+							Reflect.apply(getBytes, target, args),
+							copyOptionalBytes,
+						);
+				}
+			}
+			if (property === "__peerbitNext") {
+				const next = Reflect.get(target, property, target);
+				return Array.isArray(next) ? getContext().detachArray(next) : next;
+			}
 			if (property === "getStorageBytes") {
 				return () => new Uint8Array(entry.getStorageBytes());
 			}
+			if (property === "toShallow") {
+				const toShallow = Reflect.get(target, property, target);
+				if (typeof toShallow === "function") {
+					return (...args: unknown[]) => {
+						const shallow = Reflect.apply(toShallow, target, args) as unknown;
+						return shallow && typeof shallow === "object"
+							? getContext().detachEntryLike(shallow)
+							: shallow;
+					};
+				}
+			}
 			if (property === "valueOf") {
 				return () => callbackEntry;
 			}
@@ -275,11 +766,35 @@ export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
 						return callbackEntry;
 					}
 					return (detachedMaterialized ??=
-						detachEntryPayloadForCallback(materialized));
+						detachEntryPayloadForCallbackWithContext(materialized, getContext));
 				};
 			}
 			if (property === "toSignable") {
-				return () => detachEntryPayloadForCallback(entry.toSignable());
+				return () =>
+					detachEntryPayloadForCallbackWithContext(
+						entry.toSignable(),
+						getContext,
+					);
+			}
+			if (property === "toPreparedAppendJoinFacts") {
+				const toPreparedAppendJoinFacts = Reflect.get(target, property, target);
+				if (typeof toPreparedAppendJoinFacts === "function") {
+					return (...args: unknown[]) => {
+						const facts = Reflect.apply(
+							toPreparedAppendJoinFacts,
+							target,
+							args,
+						) as unknown;
+						return facts && typeof facts === "object"
+							? detachPreparedAppendJoinFactsForCallback(
+									facts,
+									target,
+									callbackEntry,
+									getContext,
+								)
+							: facts;
+					};
+				}
 			}
 			if (property === "init") {
 				return (properties: Parameters<Entry<T>["init"]>[0]) => {
@@ -306,3 +821,28 @@ export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
 	detachedCallbackEntries.add(callbackEntry);
 	return callbackEntry;
 };
+
+export const detachEntryPayloadForCallback = <T>(entry: Entry<T>): Entry<T> => {
+	let context: EntryDetachmentContext | undefined;
+	return detachEntryPayloadForCallbackWithContext(
+		entry,
+		() => (context ??= createEntryDetachmentContext()),
+	);
+};
+
+/** Detach full, shallow, and replicated entries at document callback edges. */
+export const detachEntryForCallback = <T>(entry: T): T => {
+	if (!entry || typeof entry !== "object") {
+		return entry;
+	}
+	return (
+		entry instanceof Entry
+			? detachEntryPayloadForCallback(entry)
+			: createEntryDetachmentContext().detachEntryLike(entry)
+	) as T;
+};
+
+/** Give arbitrary document transforms signer objects they cannot retain/mutate. */
+export const detachPublicKeysForCallback = (
+	keys: readonly PublicSignKey[],
+): PublicSignKey[] => createEntryDetachmentContext().detachPublicKeys(keys);

package/src/domain.ts

@@ -9,7 +9,7 @@ import {
 	type ReplicationDomain,
 	type SharedLog,
 } from "@peerbit/shared-log";
-import { detachEntryPayloadForCallback } from "./callback-detachment.js";
+import { detachEntryForCallback } from "./callback-detachment.js";
 import { type Operation, isPutOperation } from "./operation.js";
 import type { DocumentIndex } from "./search.js";
 
@@ -96,8 +96,7 @@ export const createDocumentDomain =
 		let maxValue = args.resolution === "u32" ? MAX_U32 : MAX_U64;
 		const detachEntry = (
 			entry: ShallowEntry | Entry<Operation> | EntryReplicated<any>,
-		) =>
-			entry instanceof Entry ? detachEntryPayloadForCallback(entry) : entry;
+		) => detachEntryForCallback(entry);
 		let fromEntry = (args as FromEntry<InferR<DB>>).fromEntry
 			? (entry: ShallowEntry | Entry<Operation> | EntryReplicated<any>) =>
 					(args as FromEntry<InferR<DB>>).fromEntry!(detachEntry(entry))