@unyt/datex 0.0.5 → 0.0.7

package/esm/dif/dif-handler.js

@@ -0,0 +1,688 @@
+var __classPrivateFieldGet = (this && this.__classPrivateFieldGet) || function (receiver, state, kind, f) {
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a getter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot read private member from an object whose class did not declare it");
+    return kind === "m" ? f : kind === "a" ? f.call(receiver) : f ? f.value : state.get(receiver);
+};
+var __classPrivateFieldSet = (this && this.__classPrivateFieldSet) || function (receiver, state, value, kind, f) {
+    if (kind === "m") throw new TypeError("Private method is not writable");
+    if (kind === "a" && !f) throw new TypeError("Private accessor was defined without a setter");
+    if (typeof state === "function" ? receiver !== state || !f : !state.has(receiver)) throw new TypeError("Cannot write private member to an object whose class did not declare it");
+    return (kind === "a" ? f.call(receiver, value) : f ? f.value = value : state.set(receiver, value)), value;
+};
+var _DIFHandler_runtime, _DIFHandler_handle, _DIFHandler_transceiver_id, _DIFHandler_cache, _DIFHandler_observers;
+import * as dntShim from "../_dnt.shims.js";
+import { Ref } from "../refs/ref.js";
+import { Endpoint } from "../runtime/special-core-types.js";
+import { CoreTypeAddress, CoreTypeAddressRanges, DIFReferenceMutability, DIFUpdateKind, } from "./definitions.js";
+import { difValueContainerToDisplayString } from "./display.js";
+export class DIFHandler {
+    get _observers() {
+        return __classPrivateFieldGet(this, _DIFHandler_observers, "f");
+    }
+    get _handle() {
+        return __classPrivateFieldGet(this, _DIFHandler_handle, "f");
+    }
+    get _transceiver_id() {
+        return __classPrivateFieldGet(this, _DIFHandler_transceiver_id, "f");
+    }
+    /**
+     * Creates a new DIFHandler instance.
+     * @param runtime - The JSRuntime instance for executing Datex scripts.
+     * @param pointerCache - The PointerCache instance for managing object pointers. If not provided, a new PointerCache will be created.
+     */
+    constructor(runtime) {
+        /** The JSRuntime interface for the underlying Datex Core runtime */
+        _DIFHandler_runtime.set(this, void 0);
+        _DIFHandler_handle.set(this, void 0);
+        // always 0 for now - potentially used for multi DIF transceivers using the same underlying runtime
+        _DIFHandler_transceiver_id.set(this, 0);
+        /** The pointer cache for storing and reusing object instances on the JS side
+         * The observerId is only set if the pointer is being observed (if not final).
+         */
+        _DIFHandler_cache.set(this, new Map());
+        _DIFHandler_observers.set(this, new Map());
+        __classPrivateFieldSet(this, _DIFHandler_runtime, runtime, "f");
+        __classPrivateFieldSet(this, _DIFHandler_handle, runtime.dif(), "f");
+    }
+    /**
+     * Executes a Datex script asynchronously and returns a Promise that resolves to a DIFContainer.
+     * @param datexScript - The Datex script source code to execute.
+     * @param values - An optional array of values to inject into the script.
+     * @returns A Promise that resolves to the execution result as a DIFContainer.
+     * @throws If an error occurs during execution.
+     */
+    executeDIF(datexScript, values = []) {
+        return __classPrivateFieldGet(this, _DIFHandler_runtime, "f").execute(datexScript, this.convertToDIFValues(values));
+    }
+    /**
+     * Executes a Datex script synchronously and returns the result as a DIFContainer.
+     * @param datexScript - The Datex script source code to execute.
+     * @param values - An optional array of values to inject into the script.
+     * @returns The execution result as a DIFContainer.
+     * @throws If an error occurs during execution.
+     */
+    executeSyncDIF(datexScript, values = []) {
+        return __classPrivateFieldGet(this, _DIFHandler_runtime, "f").execute_sync(datexScript, this.convertToDIFValues(values));
+    }
+    /**
+     * Creates a new pointer for the specified value.
+     * @param difValue - The DIFValue value to create a pointer for.
+     * @param allowedType - The allowed type for the pointer.
+     * @param mutability - The mutability of the pointer.
+     * @returns The created pointer address.
+     */
+    createPointer(difValue, allowedType = null, mutability) {
+        return __classPrivateFieldGet(this, _DIFHandler_handle, "f").create_pointer(difValue, allowedType, mutability);
+    }
+    /**
+     * Creates a new pointer that points to an existing address.
+     * @param address - The address to create a reference pointer for.
+     * @param allowedType - The allowed type for the pointer.
+     * @param mutability - The mutability of the pointer.
+     * @returns A Promise that resolves to the created pointer address.
+     */
+    createRefPointer(address, allowedType = null, mutability) {
+        return __classPrivateFieldGet(this, _DIFHandler_handle, "f").create_pointer(address, allowedType, mutability);
+    }
+    /**
+     * Updates the DIF value at the specified address.
+     * @param address - The address of the DIF value to update.
+     * @param dif - The DIFUpdate object containing the update information.
+     */
+    updatePointer(address, dif) {
+        __classPrivateFieldGet(this, _DIFHandler_handle, "f").update(__classPrivateFieldGet(this, _DIFHandler_transceiver_id, "f"), address, dif);
+    }
+    /**
+     * Registers an observer callback for changes to the DIF value at the specified address
+     * directly on the DATEX core runtime.
+     * This method should only be used internally, since it comes with additional overhead.
+     * For normal use cases, use the observePointer method instead.
+     * The callback will be invoked whenever the value at the address is updated.
+     * @param address - The address of the DIF value to observe.
+     * @param callback - The callback function to invoke on updates.
+     * @returns An observer ID that can be used to unregister the observer.
+     * @throws If the pointer is final.
+     */
+    observePointerBindDirect(address, callback, options = { relay_own_updates: false }) {
+        return __classPrivateFieldGet(this, _DIFHandler_runtime, "f").dif().observe_pointer(__classPrivateFieldGet(this, _DIFHandler_transceiver_id, "f"), address, options, callback);
+    }
+    /**
+     * Updates the observe options for a registered observer.
+     * @param address - The address of the DIF value being observed.
+     * @param observerId - The observer ID returned by the observePointer method.
+     * @param options - The new observe options to apply.
+     */
+    updateObserverOptions(address, observerId, options) {
+        __classPrivateFieldGet(this, _DIFHandler_runtime, "f").dif().update_observer_options(address, observerId, options);
+    }
+    /**
+     * Enables propagation of own updates for a registered observer.
+     * @param address - The address of the DIF value being observed.
+     * @param observerId - The observer ID returned by the observePointer method.
+     */
+    enableOwnUpdatesPropagation(address, observerId) {
+        this.updateObserverOptions(address, observerId, {
+            relay_own_updates: true,
+        });
+    }
+    /**
+     * Disables propagation of own updates for a registered observer.
+     * @param address - The address of the DIF value being observed.
+     * @param observerId - The observer ID returned by the observePointer method.
+     */
+    disableOwnUpdatesPropagation(address, observerId) {
+        this.updateObserverOptions(address, observerId, {
+            relay_own_updates: false,
+        });
+    }
+    /**
+     * Unregisters an observer that was registered directly on the DATEX core runtime
+     * with the observePointerBindDirect method.
+     * For internal use only.
+     * @param address - The address of the DIF value being observed.
+     * @param observerId - The observer ID returned by the observePointer method.
+     */
+    unobservePointerBindDirect(address, observerId) {
+        __classPrivateFieldGet(this, _DIFHandler_runtime, "f").dif().unobserve_pointer(address, observerId);
+    }
+    /**
+     * Registers a local observer callback for changes to the DIF value at the specified address.
+     * The callback will be invoked whenever the value at the address is updated.
+     * In contrast to observePointerBindDirect, this method does not register the observer
+     * directly on the DATEX core runtime, but keeps it local in the JS side, which prevents
+     * unnecessary overhead from additional cross-language calls.
+     * @param address - The address of the DIF value to observe.
+     * @param callback - The callback function to invoke on updates.
+     * @returns An observer ID that can be used to unregister the observer.
+     * @throws If the pointer is final.
+     */
+    observePointer(address, callback) {
+        let cached = __classPrivateFieldGet(this, _DIFHandler_cache, "f").get(address);
+        if (!cached) {
+            // first resolve the pointer to make sure it's loaded in the cache
+            this.resolvePointerAddressSync(address);
+            cached = __classPrivateFieldGet(this, _DIFHandler_cache, "f").get(address);
+        }
+        // make sure the pointer is not final (no observer)
+        if (cached.observerId === null) {
+            throw new Error(`Cannot observe final reference $${address}`);
+        }
+        // directly add to observers map
+        let observers = __classPrivateFieldGet(this, _DIFHandler_observers, "f").get(address);
+        if (!observers) {
+            observers = new Map();
+            __classPrivateFieldGet(this, _DIFHandler_observers, "f").set(address, observers);
+            // first local observer for this address - enable own updates propagation
+            this.enableOwnUpdatesPropagation(address, cached.observerId);
+        }
+        // FIXME make this more robust for delete/re-add cases
+        const observerId = observers.size + 1;
+        observers.set(observerId, callback);
+        return observerId;
+    }
+    /**
+     * Unregisters an observer that was registered with the observePointer method.
+     * @param address - The address of the DIF value being observed.
+     * @param observerId - The observer ID returned by the observePointer method.
+     * @returns True if the observer was successfully unregistered, false otherwise.
+     */
+    unobservePointer(address, observerId) {
+        const observers = __classPrivateFieldGet(this, _DIFHandler_observers, "f").get(address);
+        if (observers) {
+            observers.delete(observerId);
+            if (observers.size === 0) {
+                // no local observers left - disable own updates propagation and remove from map
+                const cached = __classPrivateFieldGet(this, _DIFHandler_cache, "f").get(address);
+                if (cached?.observerId) {
+                    this.disableOwnUpdatesPropagation(address, cached.observerId);
+                }
+                else {
+                    console.error(`No observer found for address ${address}`);
+                }
+                return __classPrivateFieldGet(this, _DIFHandler_observers, "f").delete(address);
+            }
+        }
+        return false;
+    }
+    /**
+     * Resolves a DIFValue to its corresponding JS value.
+     * This function handles core types and custom types (not yet implemented).
+     * It returns the resolved value as the specified type T.
+     * @param value
+     */
+    resolveDIFValue(value) {
+        console.log("RESOLVE", value);
+        let type = value.type;
+        if (type === undefined) {
+            if (Array.isArray(value.value)) {
+                if (Array.isArray(value.value[0])) {
+                    type = CoreTypeAddress.map;
+                }
+                else {
+                    type = CoreTypeAddress.list;
+                }
+            }
+            else {
+                return value.value;
+            }
+        }
+        console.log(type, value);
+        // null, boolean and text types values are just returned as is
+        if (type === CoreTypeAddress.boolean ||
+            type == CoreTypeAddress.text ||
+            type === CoreTypeAddress.null) {
+            return value.value;
+        } // small integers are interpreted as JS numbers
+        else if (typeof type === "string" && (type == CoreTypeAddress.integer ||
+            this.isPointerAddressInAdresses(type, CoreTypeAddressRanges.small_signed_integers) ||
+            this.isPointerAddressInAdresses(type, CoreTypeAddressRanges.small_unsigned_integers))) {
+            return Number(value.value);
+        } // big integers are interpreted as JS BigInt
+        else if (typeof type === "string" && (this.isPointerAddressInAdresses(type, CoreTypeAddressRanges.big_signed_integers) ||
+            this.isPointerAddressInAdresses(type, CoreTypeAddressRanges.big_unsigned_integers))) {
+            return BigInt(value.value);
+        } // decimal types are interpreted as JS numbers
+        else if (typeof type === "string" &&
+            this.isPointerAddressInAdresses(type, CoreTypeAddressRanges.decimals)) {
+            return Number(value.value);
+        } // endpoint types are resolved to Endpoint instances
+        else if (type === CoreTypeAddress.endpoint) {
+            return Endpoint.get(value.value);
+        }
+        else if (type === CoreTypeAddress.list) {
+            return this.promiseAllOrSync(value.value.map((v) => this.resolveDIFValueContainer(v)));
+        } // map types are resolved from a DIFObject (aka JS Map) or Array of key-value pairs to a JS object
+        else if (type === CoreTypeAddress.map) {
+            if (Array.isArray(value.value)) {
+                const resolvedMap = new Map();
+                for (const [key, val] of value.value) {
+                    // TODO: currently always converting to an object here, but this should be a Map per default
+                    resolvedMap.set(this.resolveDIFValueContainer(key), this.resolveDIFValueContainer(val));
+                }
+                // TODO: map promises
+                return resolvedMap;
+            }
+            else {
+                const resolvedObj = {};
+                for (const [key, val] of Object.entries(value.value)) {
+                    // TODO: currently always converting to an object here, but this should be a Map per default
+                    resolvedObj[key] = this.resolveDIFValueContainer(val);
+                }
+                return this.promiseFromObjectOrSync(resolvedObj);
+            }
+        }
+        else {
+            // custom types not implemented yet
+            throw new Error("Custom type resolution not implemented yet");
+        }
+    }
+    /**
+     * Converts an array of Promises or resolved values to either a Promise of an array of resolved values,
+     * or an array of resolved values if all values are already resolved.
+     */
+    promiseAllOrSync(values) {
+        if (values.some((v) => v instanceof Promise)) {
+            return Promise.all(values);
+        }
+        else {
+            return values;
+        }
+    }
+    /**
+     * Converts an object with values that may be Promises to either a Promise of an object with resolved values,
+     * or an object with resolved values if all values are already resolved.
+     */
+    promiseFromObjectOrSync(values) {
+        const valueArray = Object.values(values);
+        if (valueArray.some((v) => v instanceof Promise)) {
+            return Promise.all(valueArray).then((resolvedValues) => {
+                const resolvedObj = {};
+                let i = 0;
+                for (const key of Object.keys(values)) {
+                    resolvedObj[key] = resolvedValues[i++];
+                }
+                return resolvedObj;
+            });
+        }
+        else {
+            return values;
+        }
+    }
+    /**
+     * Maps a value or Promise of a value to another value or Promise of a value using the provided onfulfilled function.
+     */
+    mapPromise(value, onfulfilled) {
+        if (value instanceof Promise) {
+            return value.then(onfulfilled);
+        }
+        else {
+            return onfulfilled(value);
+        }
+    }
+    /**
+     * Resolves a DIFValueContainer (either a DIFValue or a pointer address) to its corresponding JS value.
+     * If the container contains pointers that are not yet loaded in memory, it returns a Promise that resolves to the value.
+     * Otherwise, it returns the resolved value directly.
+     * @param value - The DIFValueContainer to resolve.
+     * @returns The resolved value as type T, or a Promise that resolves to type T.
+     */
+    resolveDIFValueContainer(value) {
+        if (typeof value !== "string") {
+            return this.resolveDIFValue(value);
+        }
+        else {
+            return this.resolvePointerAddress(value);
+        }
+    }
+    /**
+     * Synchronous version of resolveDIFValueContainer.
+     * This method can only be used if the value only contains pointer addresses that are already loaded in memory -
+     * otherwise, use the asynchronous `resolveDIFValueContainer` method instead.
+     * @param value - The DIFValueContainer to resolve.
+     * @returns The resolved value as type T.
+     * @throws If the resolution would require asynchronous operations.
+     */
+    resolveDIFValueContainerSync(value) {
+        const result = this.resolveDIFValueContainer(value);
+        if (result instanceof Promise) {
+            throw new Error("resolveDIFValueContainerSync cannot return a Promise. Use resolveDIFValueContainer() instead.");
+        }
+        return result;
+    }
+    /**
+     * Resolves a pointer address to its corresponding JS value.
+     * If the pointer address is not yet loaded in memory, it returns a Promise that resolves to the value.
+     * Otherwise, it returns the resolved value directly.
+     * @param address - The pointer address to resolve.
+     * @returns The resolved value as type T, or a Promise that resolves to type T.
+     */
+    resolvePointerAddress(address) {
+        // check cache first
+        const cached = this.getCachedPointer(address);
+        if (cached) {
+            return cached;
+        }
+        // if not in cache, resolve from runtime
+        const reference = __classPrivateFieldGet(this, _DIFHandler_handle, "f").resolve_pointer_address(address);
+        return this.mapPromise(reference, (reference) => {
+            const value = this.resolveDIFValueContainer(reference.value);
+            return this.mapPromise(value, (v) => {
+                // init pointer
+                this.initPointer(address, v, reference.mut, reference.allowed_type);
+                return v;
+            });
+        });
+    }
+    /**
+     * Resolves a pointer address to its corresponding JS value synchronously.
+     * If the pointer address is not yet loaded in memory, it returns a Promise that resolves to the value.
+     * Otherwise, it returns the resolved value directly.
+     * @param address - The pointer address to resolve.
+     * @returns The resolved value as type T, or a Promise that resolves to type T.
+     * @throws If the resolution would require asynchronous operations.
+     */
+    resolvePointerAddressSync(address) {
+        // check cache first
+        const cached = this.getCachedPointer(address);
+        if (cached) {
+            return cached;
+        }
+        // if not in cache, resolve from runtime
+        const entry = __classPrivateFieldGet(this, _DIFHandler_handle, "f")
+            .resolve_pointer_address_sync(address);
+        const value = this.resolveDIFValueContainerSync(entry.value);
+        this.initPointer(address, value, entry.mut, entry.allowed_type);
+        return value;
+    }
+    /**
+     * Converts an array of JS values to an array of DIFValues.
+     * If the input is null, it returns null.
+     * @param values
+     */
+    convertToDIFValues(values) {
+        return values?.map((value) => this.convertJSValueToDIFValue(value)) ||
+            null;
+    }
+    /**
+     * Returns true if the given address is within the specified address range.
+     */
+    isPointerAddressInAdresses(address, range) {
+        return range.has(address);
+    }
+    /**
+     * Initializes a pointer with the given value and mutability, by
+     * adding a proxy wrapper if necessary, and setting up observation and caching on the JS side.
+     */
+    initPointer(ptrAddress, value, mutability, allowedType = null) {
+        const refValue = this.wrapJSValueInProxy(value, ptrAddress, allowedType);
+        // if not final, observe  to keep the pointer 'live' and receive updates
+        let observerId = null;
+        if (mutability !== DIFReferenceMutability.Final) {
+            observerId = this.observePointerBindDirect(ptrAddress, (update) => {
+                // if source_id is not own transceiver id, handle pointer update
+                if (update.source_id !== __classPrivateFieldGet(this, _DIFHandler_transceiver_id, "f")) {
+                    this.handlePointerUpdate(ptrAddress, update.data);
+                }
+                // call all local observers
+                const observers = __classPrivateFieldGet(this, _DIFHandler_observers, "f").get(ptrAddress);
+                if (observers) {
+                    for (const cb of observers.values()) {
+                        try {
+                            cb(update.data);
+                        }
+                        catch (e) {
+                            console.error("Error in pointer observer callback", e);
+                        }
+                    }
+                }
+                console.debug("Pointer update received", update);
+            });
+        }
+        this.cacheWrappedPointerValue(ptrAddress, refValue, observerId);
+        return refValue;
+    }
+    /**
+     * Handles a pointer update received from the DATEX core runtime.
+     * If the pointer is cached and has a dereferenceable value, it updates the value.
+     * @param address - The address of the pointer being updated.
+     * @param update - The DIFUpdateData containing the update information.
+     * @returns True if the pointer was found and updated, false otherwise.
+     */
+    handlePointerUpdate(address, update) {
+        const cached = __classPrivateFieldGet(this, _DIFHandler_cache, "f").get(address);
+        if (!cached)
+            return false;
+        const deref = cached.val.deref();
+        if (!deref)
+            return false;
+        if (deref instanceof Ref && update.kind === DIFUpdateKind.Replace) {
+            deref.updateValueSilently(this.resolveDIFValueContainerSync(update.value));
+        }
+        // TODO: handle generic updates for values (depending on type interface definition)
+        return true;
+    }
+    /**
+     * Caches the given pointer value with the given address in the JS side cache.
+     * The pointer must already be wrapped if necessary.
+     */
+    cacheWrappedPointerValue(address, value, observerId) {
+        __classPrivateFieldGet(this, _DIFHandler_cache, "f").set(address, {
+            val: new dntShim.WeakRef(value),
+            observerId,
+        });
+        // register finalizer to clean up the cache and free the pointer in the runtime
+        // when the object is garbage collected
+        const finalizationRegistry = new FinalizationRegistry((address) => {
+            __classPrivateFieldGet(this, _DIFHandler_cache, "f").delete(address);
+            // remove local observers
+            __classPrivateFieldGet(this, _DIFHandler_observers, "f").delete(address);
+            // if observer is active, unregister it
+            if (observerId !== null) {
+                this.unobservePointerBindDirect(address, observerId);
+            }
+        });
+        finalizationRegistry.register(value, address);
+    }
+    getCachedPointer(address) {
+        const cached = __classPrivateFieldGet(this, _DIFHandler_cache, "f").get(address);
+        if (cached) {
+            const deref = cached.val.deref();
+            if (deref) {
+                return deref;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Creates a new pointer containg the given JS value.
+     * The returned value is a proxy object that behaves like the original object,
+     * but also propagates changes between JS and the DATEX runtime.
+     */
+    createPointerFromJSValue(value, allowedType = null, mutability = DIFReferenceMutability.Mutable) {
+        const difValue = this.convertJSValueToDIFValue(value);
+        console.log("DIF", difValueContainerToDisplayString(difValue));
+        const ptrAddress = this.createPointer(difValue, allowedType, mutability);
+        // get inferred allowed type from pointer if not explicitly set
+        if (!allowedType) {
+            allowedType = __classPrivateFieldGet(this, _DIFHandler_handle, "f").resolve_pointer_address_sync(ptrAddress).allowed_type;
+        }
+        return this.initPointer(ptrAddress, value, mutability, allowedType); // TODO: map to correct pointer wrapper type
+    }
+    wrapJSValueInProxy(value, pointerAddress, _type = null) {
+        // primitive values are always wrapped in a Ref proxy
+        if (value === null || value === undefined ||
+            typeof value === "boolean" ||
+            typeof value === "number" || typeof value === "bigint" ||
+            typeof value === "string") {
+            return new Ref(value, pointerAddress, this);
+        }
+        else if (value instanceof Map) {
+            return this.proxifyJSMap(value, pointerAddress);
+        }
+        else if (typeof value === "object") {
+            return this.wrapJSObjectInProxy(value);
+        }
+        else {
+            return value;
+        }
+    }
+    isRef(value) {
+        return value instanceof Ref;
+    }
+    proxifyJSMap(map, pointerAddress) {
+        const originalSet = map.set;
+        const originalDelete = map.delete;
+        const originalClear = map.clear;
+        // deno-lint-ignore no-this-alias
+        const self = this;
+        Object.defineProperties(map, {
+            set: {
+                value: function (key, value) {
+                    self.updatePointer(pointerAddress, {
+                        kind: DIFUpdateKind.Set,
+                        key: {
+                            kind: "value",
+                            value: self.convertJSValueToDIFValue(key),
+                        },
+                        value: self.convertJSValueToDIFValue(value),
+                    });
+                    return originalSet.call(this, key, value);
+                },
+                configurable: true,
+                writable: true,
+            },
+            delete: {
+                value: function (key) {
+                    self.updatePointer(pointerAddress, {
+                        kind: DIFUpdateKind.Remove,
+                        key: {
+                            kind: "value",
+                            value: self.convertJSValueToDIFValue(key),
+                        },
+                    });
+                    const result = originalDelete.call(this, key);
+                    return result;
+                },
+                configurable: true,
+                writable: true,
+            },
+            clear: {
+                value: function () {
+                    self.updatePointer(pointerAddress, {
+                        kind: DIFUpdateKind.Clear,
+                    });
+                    const result = originalClear.call(this);
+                    return result;
+                },
+                configurable: true,
+                writable: true,
+            },
+        });
+        return map;
+    }
+    wrapJSObjectInProxy(value) {
+        // deno-lint-ignore no-this-alias
+        const self = this;
+        return new Proxy(value, {
+            get(target, prop, receiver) {
+                const val = Reflect.get(target, prop, receiver);
+                if (val && typeof val === "object" && !self.isRef(val)) {
+                    return self.wrapJSObjectInProxy(val);
+                }
+                return val;
+            },
+            set(target, prop, newValue, receiver) {
+                const oldValue = Reflect.get(target, prop, receiver);
+                if (!self.isRef(oldValue)) {
+                    throw new Error(`Cannot modify non-Ref property "${String(prop)}"`);
+                }
+                oldValue.value = newValue;
+                return true;
+            },
+            deleteProperty() {
+                throw new Error("Cannot delete properties from a Refs-only object");
+            },
+            defineProperty() {
+                throw new Error("Cannot define new properties on a Refs-only object");
+            },
+        });
+    }
+    /// Returns the pointer address for the given value if it is already cached, or null otherwise.
+    /// TODO: optimize by using a reverse map or direct Symbols on the objects
+    /// But this is probably not important for normal use cases
+    getPointerAddressForValue(value) {
+        for (const [address, entry] of __classPrivateFieldGet(this, _DIFHandler_cache, "f")) {
+            const deref = entry.val.deref();
+            if (deref === value) {
+                return address;
+            }
+        }
+        return null;
+    }
+    /**
+     * Converts a given JS value to its DIFValue representation.
+     */
+    convertJSValueToDIFValue(value) {
+        // assuming core values
+        // TODO: handle custom types
+        if (value === null) {
+            return {
+                value: null,
+            };
+        }
+        else if (typeof value === "boolean") {
+            return {
+                value,
+            };
+        }
+        else if (typeof value === "number") {
+            return {
+                value,
+            };
+        }
+        else if (typeof value === "bigint") {
+            return {
+                type: CoreTypeAddress.integer_big,
+                value: value.toString(), // convert bigint to string for DIFValue
+            };
+        }
+        else if (typeof value === "string") {
+            return {
+                value,
+            };
+        }
+        else if (value instanceof Endpoint) {
+            return {
+                type: CoreTypeAddress.endpoint,
+                value: value.toString(),
+            };
+        }
+        else if (Array.isArray(value)) {
+            return {
+                value: value.map((v) => this.convertJSValueToDIFValue(v)),
+            };
+        }
+        else if (value instanceof Map) {
+            const map = value.entries().map(([k, v]) => [
+                this.convertJSValueToDIFValue(k),
+                this.convertJSValueToDIFValue(v),
+            ]).toArray();
+            return {
+                type: CoreTypeAddress.map,
+                value: map,
+            };
+        }
+        else if (typeof value === "object") {
+            const map = {};
+            for (const [key, val] of Object.entries(value)) {
+                map[key] = this.convertJSValueToDIFValue(val);
+            }
+            return {
+                type: CoreTypeAddress.map,
+                value: map,
+            };
+        }
+        throw new Error("Unsupported type for conversion to DIFValue");
+    }
+}
+_DIFHandler_runtime = new WeakMap(), _DIFHandler_handle = new WeakMap(), _DIFHandler_transceiver_id = new WeakMap(), _DIFHandler_cache = new WeakMap(), _DIFHandler_observers = new WeakMap();