@peerbit/document 15.0.13 → 15.0.15

package/dist/src/callback-detachment.d.ts

@@ -0,0 +1,19 @@
+import type { PublicSignKey } from "@peerbit/crypto";
+import { Entry } from "@peerbit/log";
+import { type Operation } from "./operation.js";
+/**
+ * Borsh byte fields are input-buffer views. Clone only fields that can expose
+ * verified operation bytes while retaining the operation's exact prototype,
+ * subclass fields, symbols, and property descriptors.
+ */
+export declare const detachOperationBytes: <T extends Operation>(operation: T) => T;
+export declare const detachCanPerformCallbackProperties: <T extends {
+    operation: Operation;
+    entry: Entry<any>;
+}>(properties: T) => T;
+export declare const detachEntryPayloadForCallback: <T>(entry: Entry<T>) => Entry<T>;
+/** Detach full, shallow, and replicated entries at document callback edges. */
+export declare const detachEntryForCallback: <T>(entry: T) => T;
+/** Give arbitrary document transforms signer objects they cannot retain/mutate. */
+export declare const detachPublicKeysForCallback: (keys: readonly PublicSignKey[]) => PublicSignKey[];
+//# sourceMappingURL=callback-detachment.d.ts.map

package/dist/src/callback-detachment.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"callback-detachment.d.ts","sourceRoot":"","sources":["../../src/callback-detachment.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,aAAa,EAAoB,MAAM,iBAAiB,CAAC;AAEvE,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,OAAO,EAGN,KAAK,SAAS,EAGd,MAAM,gBAAgB,CAAC;AA8YxB;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,GAAI,CAAC,SAAS,SAAS,EAAE,WAAW,CAAC,KAAG,CAgDxE,CAAC;AAkGF,eAAO,MAAM,kCAAkC,GAC9C,CAAC,SAAS;IAAE,SAAS,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,KAAK,CAAC,GAAG,CAAC,CAAA;CAAE,EAErD,YAAY,CAAC,KACX,CAUF,CAAC;AA4PF,eAAO,MAAM,6BAA6B,GAAI,CAAC,EAAE,OAAO,KAAK,CAAC,CAAC,CAAC,KAAG,KAAK,CAAC,CAAC,CAMzE,CAAC;AAEF,+EAA+E;AAC/E,eAAO,MAAM,sBAAsB,GAAI,CAAC,EAAE,OAAO,CAAC,KAAG,CASpD,CAAC;AAEF,mFAAmF;AACnF,eAAO,MAAM,2BAA2B,GACvC,MAAM,SAAS,aAAa,EAAE,KAC5B,aAAa,EAA2D,CAAC"}

package/dist/src/callback-detachment.js

@@ -0,0 +1,605 @@
+import * as indexerTypes from "@peerbit/indexer-interface";
+import { Entry } from "@peerbit/log";
+import { DeleteByStringKeyOperation, DeleteOperation, PutOperation, PutWithKeyOperation, } from "./operation.js";
+const isPromiseLike = (value) => !!value &&
+    (typeof value === "object" || typeof value === "function") &&
+    typeof value.then === "function";
+const mapMaybePromise = (value, map) => (isPromiseLike(value) ? value.then(map) : map(value));
+const copyOptionalBytes = (bytes) => bytes == null ? undefined : new Uint8Array(bytes);
+const preserveArrayIntegrity = (source, copy) => {
+    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 = (values, detach = (value) => value) => preserveArrayIntegrity(values, values.map(detach));
+const getInheritedPropertyDescriptor = (value, key) => {
+    let prototype = Object.getPrototypeOf(value);
+    while (prototype) {
+        const descriptor = Reflect.getOwnPropertyDescriptor(prototype, key);
+        if (descriptor) {
+            return descriptor;
+        }
+        prototype = Object.getPrototypeOf(prototype);
+    }
+    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 = (value, factories) => {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    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;
+        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) {
+                        detachedValue = nextValue;
+                        resolved = true;
+                    },
+                }
+                : {}),
+        };
+    }
+    const clone = Object.create(Object.getPrototypeOf(value), descriptors);
+    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, factories) => {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    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, factories) => {
+    const descriptors = Object.getOwnPropertyDescriptors(value);
+    for (const key of Reflect.ownKeys(descriptors)) {
+        const descriptor = descriptors[key];
+        if (descriptor &&
+            "value" in descriptor &&
+            Array.isArray(descriptor.value)) {
+            const array = descriptor.value;
+            factories.set(key, () => detachArray(array, (item) => item instanceof Uint8Array ? new Uint8Array(item) : item));
+        }
+    }
+};
+const detachedCallbackEntryLikes = new WeakSet();
+const createEntryDetachmentContext = () => {
+    let metadata;
+    let clocks;
+    let timestamps;
+    let signatures;
+    let publicKeys;
+    let entryLikes;
+    let arrays;
+    const detachValues = (values, detach = (value) => value) => {
+        const cached = arrays?.get(values);
+        if (cached) {
+            return cached;
+        }
+        const clone = detachArray(values, detach);
+        (arrays ??= new WeakMap()).set(values, clone);
+        return clone;
+    };
+    const detachTimestamp = (value) => {
+        if (!value || typeof value !== "object") {
+            return value;
+        }
+        const cached = timestamps?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = new Map();
+        addOwnByteFactories(value, factories);
+        const clone = cloneWithLazyProperties(value, factories);
+        (timestamps ??= new WeakMap()).set(value, clone);
+        return clone;
+    };
+    const detachClock = (value) => {
+        if (!value || typeof value !== "object") {
+            return value;
+        }
+        const cached = clocks?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = new Map();
+        addOwnByteFactories(value, factories);
+        if (Reflect.has(value, "id") && !factories.has("id")) {
+            factories.set("id", () => copyOptionalBytes(Reflect.get(value, "id", value)));
+        }
+        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 = (value) => {
+        if (!value || typeof value !== "object") {
+            return value;
+        }
+        const cached = metadata?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = new Map();
+        addOwnByteFactories(value, factories);
+        if (Reflect.has(value, "data") && !factories.has("data")) {
+            factories.set("data", () => copyOptionalBytes(Reflect.get(value, "data", value)));
+        }
+        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 = (value) => {
+        if (!value || typeof value !== "object") {
+            return value;
+        }
+        const cached = publicKeys?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = new Map();
+        addOwnByteFactories(value, factories);
+        const clone = cloneWithLazyProperties(value, factories);
+        (publicKeys ??= new WeakMap()).set(value, clone);
+        return clone;
+    };
+    const detachSignature = (value) => {
+        if (!value || typeof value !== "object") {
+            return value;
+        }
+        const cached = signatures?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = 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) => detachValues(values, detachSignature);
+    const detachPublicKeys = (values) => detachValues(values, detachPublicKey);
+    const detachEntryLike = (value) => {
+        if (detachedCallbackEntryLikes.has(value)) {
+            return value;
+        }
+        const cached = entryLikes?.get(value);
+        if (cached) {
+            return cached;
+        }
+        const factories = 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"]) {
+            const method = Reflect.get(value, methodName, value);
+            if (typeof method === "function") {
+                factories.set(methodName, () => (...args) => 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,
+    };
+};
+const detachPreparedAppendJoinFactsForCallback = (facts, canonicalEntry, callbackEntry, getContext) => {
+    const factories = new Map();
+    addOwnByteFactories(facts, factories);
+    if (Reflect.has(facts, "bytes")) {
+        factories.set("bytes", () => copyOptionalBytes(Reflect.get(facts, "bytes", facts)));
+    }
+    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) => {
+            const shallow = Reflect.apply(getShallowEntry, facts, args);
+            return shallow && typeof shallow === "object"
+                ? getContext().detachEntryLike(shallow)
+                : shallow;
+        });
+    }
+    const materializeEntry = Reflect.get(facts, "materializeEntry", facts);
+    if (typeof materializeEntry === "function") {
+        factories.set("materializeEntry", () => (...args) => 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,
+ * subclass fields, symbols, and property descriptors.
+ */
+export const detachOperationBytes = (operation) => {
+    const cloneWithField = (value, key, replacement) => {
+        const descriptors = Object.getOwnPropertyDescriptors(value);
+        descriptors[key] = {
+            ...descriptors[key],
+            value: replacement,
+        };
+        const clone = Object.create(Object.getPrototypeOf(value), descriptors);
+        if (!Object.isExtensible(value)) {
+            Object.preventExtensions(clone);
+        }
+        return clone;
+    };
+    if (operation instanceof PutWithKeyOperation) {
+        return cloneWithField(operation, "data", new Uint8Array(operation.data));
+    }
+    if (operation instanceof PutOperation) {
+        return cloneWithField(operation, "data", new Uint8Array(operation.data));
+    }
+    if (operation instanceof DeleteOperation) {
+        const key = cloneWithField(operation.key, "key", operation.key instanceof indexerTypes.Uint8ArrayKey
+            ? new Uint8Array(operation.key.key)
+            : operation.key.key);
+        return cloneWithField(operation, "key", key);
+    }
+    if (operation instanceof DeleteByStringKeyOperation) {
+        return cloneWithField(operation, "key", operation.key);
+    }
+    return operation;
+};
+const lazyCallbackStates = new WeakMap();
+const isLazyCallbackProperty = (property) => property === "operation" || property === "entry";
+const settleCallbackProperty = (target, state, property) => {
+    state[`${property}Pending`] = false;
+    state[property] = undefined;
+    if (!state.operationPending && !state.entryPending) {
+        lazyCallbackStates.delete(target);
+    }
+};
+const materializeCallbackProperty = (target, property) => {
+    const state = lazyCallbackStates.get(target);
+    if (!state || !state[`${property}Pending`]) {
+        return;
+    }
+    const value = property === "operation"
+        ? detachOperationBytes(state.operation)
+        : detachEntryPayloadForCallback(state.entry);
+    Reflect.set(target, property, value, target);
+    settleCallbackProperty(target, state, property);
+};
+const lazyCallbackHandler = {
+    get(target, property, receiver) {
+        if (isLazyCallbackProperty(property)) {
+            materializeCallbackProperty(target, property);
+        }
+        return Reflect.get(target, property, receiver);
+    },
+    set(target, property, value) {
+        const updated = Reflect.set(target, property, value, target);
+        if (updated && isLazyCallbackProperty(property)) {
+            const state = lazyCallbackStates.get(target);
+            if (state) {
+                settleCallbackProperty(target, state, property);
+            }
+        }
+        return updated;
+    },
+    deleteProperty(target, property) {
+        const deleted = Reflect.deleteProperty(target, property);
+        if (deleted && isLazyCallbackProperty(property)) {
+            const state = lazyCallbackStates.get(target);
+            if (state) {
+                settleCallbackProperty(target, state, property);
+            }
+        }
+        return deleted;
+    },
+    defineProperty(target, property, descriptor) {
+        if (isLazyCallbackProperty(property)) {
+            const replacesValue = "value" in descriptor || "get" in descriptor || "set" in descriptor;
+            if (!replacesValue) {
+                materializeCallbackProperty(target, property);
+            }
+            const defined = Reflect.defineProperty(target, property, descriptor);
+            if (defined && replacesValue) {
+                const state = lazyCallbackStates.get(target);
+                if (state) {
+                    settleCallbackProperty(target, state, property);
+                }
+            }
+            return defined;
+        }
+        return Reflect.defineProperty(target, property, descriptor);
+    },
+    getOwnPropertyDescriptor(target, property) {
+        if (isLazyCallbackProperty(property)) {
+            materializeCallbackProperty(target, property);
+        }
+        return Reflect.getOwnPropertyDescriptor(target, property);
+    },
+};
+export const detachCanPerformCallbackProperties = (properties) => {
+    lazyCallbackStates.set(properties, {
+        operation: properties.operation,
+        entry: properties.entry,
+        operationPending: true,
+        entryPending: true,
+    });
+    Reflect.set(properties, "operation", undefined, properties);
+    Reflect.set(properties, "entry", undefined, properties);
+    return new Proxy(properties, lazyCallbackHandler);
+};
+/**
+ * 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();
+const detachEntryPayloadForCallbackWithContext = (entry, getContext) => {
+    if (detachedCallbackEntries.has(entry)) {
+        return entry;
+    }
+    let detachedPayload;
+    let detachedMaterialized;
+    let callbackEntry;
+    const boundMethods = new Map();
+    const copyPayload = (payload) => {
+        if (detachedPayload) {
+            return detachedPayload;
+        }
+        const data = new Uint8Array(payload.data);
+        const descriptors = Object.getOwnPropertyDescriptors(payload);
+        descriptors.data = {
+            ...descriptors.data,
+            value: data,
+        };
+        descriptors._value = {
+            configurable: true,
+            enumerable: false,
+            writable: true,
+            ...descriptors._value,
+            value: payload.isDecoded ? payload.encoding.decoder(data) : undefined,
+        };
+        detachedPayload = Object.create(Object.getPrototypeOf(payload), descriptors);
+        if (!Object.isExtensible(payload)) {
+            Object.preventExtensions(detachedPayload);
+        }
+        return detachedPayload;
+    };
+    const getPayload = async () => {
+        const entryWithPayloadMethod = entry;
+        if (typeof entryWithPayloadMethod.getPayload === "function") {
+            return copyPayload(await entryWithPayloadMethod.getPayload.call(entry));
+        }
+        const materialized = entry.toMaterialized();
+        if (materialized !== entry) {
+            const materializedWithPayloadMethod = materialized;
+            if (typeof materializedWithPayloadMethod.getPayload === "function") {
+                return copyPayload(await materializedWithPayloadMethod.getPayload.call(materialized));
+            }
+            return copyPayload(materialized.payload);
+        }
+        return copyPayload(entry.payload);
+    };
+    const getPayloadValue = async () => {
+        const payload = await getPayload();
+        return payload.isDecoded ? payload.value : payload.getValue();
+    };
+    callbackEntry = new Proxy(entry, {
+        get(target, property) {
+            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.getPayload ===
+                    "function") {
+                return getPayload;
+            }
+            if (property === "getPayloadValue") {
+                return getPayloadValue;
+            }
+            if (property === "getMeta") {
+                const getMeta = Reflect.get(target, property, target);
+                if (typeof getMeta === "function") {
+                    return (...args) => mapMaybePromise(Reflect.apply(getMeta, target, args), getContext().detachMeta);
+                }
+            }
+            if (property === "getClock") {
+                const getClock = Reflect.get(target, property, target);
+                if (typeof getClock === "function") {
+                    return (...args) => mapMaybePromise(Reflect.apply(getClock, target, args), getContext().detachClock);
+                }
+            }
+            if (property === "getNext") {
+                const getNext = Reflect.get(target, property, target);
+                if (typeof getNext === "function") {
+                    return (...args) => 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) => mapMaybePromise(Reflect.apply(getSignatures, target, args), getContext().detachSignatures);
+                }
+            }
+            if (property === "getPublicKeys") {
+                const getPublicKeys = Reflect.get(target, property, target);
+                if (typeof getPublicKeys === "function") {
+                    return (...args) => 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) => 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) => {
+                        const shallow = Reflect.apply(toShallow, target, args);
+                        return shallow && typeof shallow === "object"
+                            ? getContext().detachEntryLike(shallow)
+                            : shallow;
+                    };
+                }
+            }
+            if (property === "valueOf") {
+                return () => callbackEntry;
+            }
+            if (property === "toMaterialized") {
+                return () => {
+                    const materialized = entry.toMaterialized();
+                    if (materialized === entry) {
+                        return callbackEntry;
+                    }
+                    return (detachedMaterialized ??=
+                        detachEntryPayloadForCallbackWithContext(materialized, getContext));
+                };
+            }
+            if (property === "toSignable") {
+                return () => detachEntryPayloadForCallbackWithContext(entry.toSignable(), getContext);
+            }
+            if (property === "toPreparedAppendJoinFacts") {
+                const toPreparedAppendJoinFacts = Reflect.get(target, property, target);
+                if (typeof toPreparedAppendJoinFacts === "function") {
+                    return (...args) => {
+                        const facts = Reflect.apply(toPreparedAppendJoinFacts, target, args);
+                        return facts && typeof facts === "object"
+                            ? detachPreparedAppendJoinFactsForCallback(facts, target, callbackEntry, getContext)
+                            : facts;
+                    };
+                }
+            }
+            if (property === "init") {
+                return (properties) => {
+                    entry.init(properties);
+                    return callbackEntry;
+                };
+            }
+            const value = Reflect.get(target, property, target);
+            if (property === "constructor" || typeof value !== "function") {
+                return value;
+            }
+            const existing = boundMethods.get(property);
+            if (existing && existing.source === value) {
+                return existing.bound;
+            }
+            const bound = value.bind(target);
+            boundMethods.set(property, { source: value, bound });
+            return bound;
+        },
+        set(target, property, value) {
+            return Reflect.set(target, property, value, target);
+        },
+    });
+    detachedCallbackEntries.add(callbackEntry);
+    return callbackEntry;
+};
+export const detachEntryPayloadForCallback = (entry) => {
+    let context;
+    return detachEntryPayloadForCallbackWithContext(entry, () => (context ??= createEntryDetachmentContext()));
+};
+/** Detach full, shallow, and replicated entries at document callback edges. */
+export const detachEntryForCallback = (entry) => {
+    if (!entry || typeof entry !== "object") {
+        return entry;
+    }
+    return (entry instanceof Entry
+        ? detachEntryPayloadForCallback(entry)
+        : createEntryDetachmentContext().detachEntryLike(entry));
+};
+/** Give arbitrary document transforms signer objects they cannot retain/mutate. */
+export const detachPublicKeysForCallback = (keys) => createEntryDetachmentContext().detachPublicKeys(keys);
+//# sourceMappingURL=callback-detachment.js.map