@automerge/automerge-repo-react-hooks 2.5.3 → 2.6.0-subduction.0

package/dist/index.js

@@ -2146,969 +2146,103 @@ const useLocalAwareness = ({
   return [localState, setState];
 };
 
-// Properties of the document root object
-const STATE = Symbol.for("_am_meta"); // symbol used to hide application metadata on automerge objects
-const TRACE = Symbol.for("_am_trace"); // used for debugging
-const OBJECT_ID = Symbol.for("_am_objectId"); // symbol used to hide the object id on automerge objects
-const IS_PROXY = Symbol.for("_am_isProxy"); // symbol used to test if the document is a proxy object
-const CLEAR_CACHE = Symbol.for("_am_clearCache"); // symbol used to tell a proxy object to clear its cache
-const UINT = Symbol.for("_am_uint");
-const INT = Symbol.for("_am_int");
-const F64 = Symbol.for("_am_f64");
-const COUNTER = Symbol.for("_am_counter");
-const IMMUTABLE_STRING = Symbol.for("_am_immutableString");
+BigInt("9223372036854775807"); // 2n ** 63n - 1n;
 
-/**
- * The most basic CRDT: an integer value that can be changed only by
- * incrementing and decrementing. Since addition of integers is commutative,
- * the value trivially converges.
- */
-class Counter {
-    constructor(value) {
-        this.value = value || 0;
-        Reflect.defineProperty(this, COUNTER, { value: true });
+let wasm;
+
+let cachedTextDecoder = new TextDecoder('utf-8', { ignoreBOM: true, fatal: true });
+
+cachedTextDecoder.decode();
+
+const cachedTextEncoder = new TextEncoder();
+
+if (!('encodeInto' in cachedTextEncoder)) {
+    cachedTextEncoder.encodeInto = function (arg, view) {
+        const buf = cachedTextEncoder.encode(arg);
+        view.set(buf);
+        return {
+            read: arg.length,
+            written: buf.length
+        };
+    };
+}
+
+function takeFromExternrefTable0(idx) {
+    const value = wasm.__wbindgen_export_4.get(idx);
+    wasm.__externref_table_dealloc(idx);
+    return value;
+}
+
+(typeof FinalizationRegistry === 'undefined')
+    ? { }
+    : new FinalizationRegistry(ptr => wasm.__wbg_automerge_free(ptr >>> 0, 1));
+
+const SyncStateFinalization = (typeof FinalizationRegistry === 'undefined')
+    ? { register: () => {}, unregister: () => {} }
+    : new FinalizationRegistry(ptr => wasm.__wbg_syncstate_free(ptr >>> 0, 1));
+
+class SyncState {
+
+    static __wrap(ptr) {
+        ptr = ptr >>> 0;
+        const obj = Object.create(SyncState.prototype);
+        obj.__wbg_ptr = ptr;
+        SyncStateFinalization.register(obj, obj.__wbg_ptr, obj);
+        return obj;
     }
-    /**
-     * A peculiar JavaScript language feature from its early days: if the object
-     * `x` has a `valueOf()` method that returns a number, you can use numerical
-     * operators on the object `x` directly, such as `x + 1` or `x < 4`.
-     * This method is also called when coercing a value to a string by
-     * concatenating it with another string, as in `x + ''`.
-     * https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Object/valueOf
-     */
-    valueOf() {
-        return this.value;
+
+    __destroy_into_raw() {
+        const ptr = this.__wbg_ptr;
+        this.__wbg_ptr = 0;
+        SyncStateFinalization.unregister(this);
+        return ptr;
     }
-    /**
-     * Returns the counter value as a decimal string. If `x` is a counter object,
-     * this method is called e.g. when you do `['value: ', x].join('')` or when
-     * you use string interpolation: `value: ${x}`.
-     */
-    toString() {
-        return this.valueOf().toString();
+
+    free() {
+        const ptr = this.__destroy_into_raw();
+        wasm.__wbg_syncstate_free(ptr, 0);
     }
     /**
-     * Returns the counter value, so that a JSON serialization of an Automerge
-     * document represents the counter simply as an integer.
+     * @returns {Heads}
      */
-    toJSON() {
-        return this.value;
+    get sharedHeads() {
+        const ret = wasm.syncstate_sharedHeads(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Increases the value of the counter by `delta`. If `delta` is not given,
-     * increases the value of the counter by 1.
-     *
-     * Will throw an error if used outside of a change callback.
+     * @returns {Heads}
      */
-    increment(_delta) {
-        throw new Error("Counters should not be incremented outside of a change callback");
+    get lastSentHeads() {
+        const ret = wasm.syncstate_lastSentHeads(this.__wbg_ptr);
+        return ret;
     }
     /**
-     * Decreases the value of the counter by `delta`. If `delta` is not given,
-     * decreases the value of the counter by 1.
-     *
-     * Will throw an error if used outside of a change callback.
+     * @param {Heads} heads
      */
-    decrement(_delta) {
-        throw new Error("Counters should not be decremented outside of a change callback");
-    }
-}
-/**
- * An instance of this class is used when a counter is accessed within a change
- * callback.
- */
-class WriteableCounter extends Counter {
-    constructor(value, context, path, objectId, key) {
-        super(value);
-        this.context = context;
-        this.path = path;
-        this.objectId = objectId;
-        this.key = key;
-    }
-    /**
-     * Increases the value of the counter by `delta`. If `delta` is not given,
-     * increases the value of the counter by 1.
-     */
-    increment(delta) {
-        delta = typeof delta === "number" ? delta : 1;
-        this.context.increment(this.objectId, this.key, delta);
-        this.value += delta;
-        return this.value;
+    set lastSentHeads(heads) {
+        const ret = wasm.syncstate_set_lastSentHeads(this.__wbg_ptr, heads);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Decreases the value of the counter by `delta`. If `delta` is not given,
-     * decreases the value of the counter by 1.
+     * @param {Heads} hashes
      */
-    decrement(delta) {
-        return this.increment(typeof delta === "number" ? -delta : -1);
-    }
-}
-/**
- * Returns an instance of `WriteableCounter` for use in a change callback.
- * `context` is the proxy context that keeps track of the mutations.
- * `objectId` is the ID of the object containing the counter, and `key` is
- * the property name (key in map, or index in list) where the counter is
- * located.
- */
-function getWriteableCounter(value, context, path, objectId, key) {
-    return new WriteableCounter(value, context, path, objectId, key);
-}
-//module.exports = { Counter, getWriteableCounter }
-
-var _a;
-class ImmutableString {
-    constructor(val) {
-        // Used to detect whether a value is a ImmutableString object rather than using an instanceof check
-        this[_a] = true;
-        this.val = val;
+    set sentHashes(hashes) {
+        const ret = wasm.syncstate_set_sentHashes(this.__wbg_ptr, hashes);
+        if (ret[1]) {
+            throw takeFromExternrefTable0(ret[0]);
+        }
     }
     /**
-     * Returns the content of the ImmutableString object as a simple string
+     * @returns {SyncState}
      */
-    toString() {
-        return this.val;
-    }
-    toJSON() {
-        return this.val;
+    clone() {
+        const ret = wasm.syncstate_clone(this.__wbg_ptr);
+        return SyncState.__wrap(ret);
     }
 }
-_a = IMMUTABLE_STRING;
-
-function parseListIndex(key) {
-    if (typeof key === "string" && /^[0-9]+$/.test(key))
-        key = parseInt(key, 10);
-    if (typeof key !== "number") {
-        return key;
-    }
-    if (key < 0 || isNaN(key) || key === Infinity || key === -Infinity) {
-        throw new RangeError("A list index must be positive, but you passed " + key);
-    }
-    return key;
-}
-function valueAt(target, prop) {
-    const { context, objectId, path } = target;
-    const value = context.getWithType(objectId, prop);
-    if (value === null) {
-        return;
-    }
-    const datatype = value[0];
-    const val = value[1];
-    switch (datatype) {
-        case undefined:
-            return;
-        case "map":
-            return mapProxy(context, val, [...path, prop]);
-        case "list":
-            return listProxy(context, val, [...path, prop]);
-        case "text":
-            return context.text(val);
-        case "str":
-            return new ImmutableString(val);
-        case "uint":
-            return val;
-        case "int":
-            return val;
-        case "f64":
-            return val;
-        case "boolean":
-            return val;
-        case "null":
-            return null;
-        case "bytes":
-            return val;
-        case "timestamp":
-            return val;
-        case "counter": {
-            const counter = getWriteableCounter(val, context, path, objectId, prop);
-            return counter;
-        }
-        default:
-            throw RangeError(`datatype ${datatype} unimplemented`);
-    }
-}
-function import_value(value, path, context) {
-    const type = typeof value;
-    switch (type) {
-        case "object":
-            if (value == null) {
-                return [null, "null"];
-            }
-            else if (value[UINT]) {
-                return [value.value, "uint"];
-            }
-            else if (value[INT]) {
-                return [value.value, "int"];
-            }
-            else if (value[F64]) {
-                return [value.value, "f64"];
-            }
-            else if (value[COUNTER]) {
-                return [value.value, "counter"];
-            }
-            else if (value instanceof Date) {
-                return [value.getTime(), "timestamp"];
-            }
-            else if (isImmutableString(value)) {
-                return [value.toString(), "str"];
-            }
-            else if (value instanceof Uint8Array) {
-                return [value, "bytes"];
-            }
-            else if (value instanceof Array) {
-                return [value, "list"];
-            }
-            else if (Object.prototype.toString.call(value) === "[object Object]") {
-                return [value, "map"];
-            }
-            else if (isSameDocument(value, context)) {
-                throw new RangeError("Cannot create a reference to an existing document object");
-            }
-            else {
-                throw new RangeError(`Cannot assign unknown object: ${value}`);
-            }
-        case "boolean":
-            return [value, "boolean"];
-        case "number":
-            if (Number.isInteger(value)) {
-                return [value, "int"];
-            }
-            else {
-                return [value, "f64"];
-            }
-        case "string":
-            return [value, "text"];
-        case "undefined":
-            throw new RangeError([
-                `Cannot assign undefined value at ${printPath(path)}, `,
-                "because `undefined` is not a valid JSON data type. ",
-                "You might consider setting the property's value to `null`, ",
-                "or using `delete` to remove it altogether.",
-            ].join(""));
-        default:
-            throw new RangeError([
-                `Cannot assign ${type} value at ${printPath(path)}. `,
-                `All JSON primitive datatypes (object, array, string, number, boolean, null) `,
-                `are supported in an Automerge document; ${type} values are not. `,
-            ].join(""));
-    }
-}
-// When we assign a value to a property in a proxy we recursively walk through
-// the value we are assigning and copy it into the document. This is generally
-// desirable behaviour. However, a very common bug is to accidentally assign a
-// value which is already in the document to another key within the same
-// document, this often leads to surprising behaviour where users expected to
-// _move_ the object, but it is instead copied. To avoid this we check if the
-// value is from the same document and if it is we throw an error, this means
-// we require an explicit Object.assign call to copy the object, thus avoiding
-// the footgun
-function isSameDocument(val, context) {
-    var _b, _c;
-    // Date is technically an object, but immutable, so allowing people to assign
-    // a date from one place in the document to another place in the document is
-    // not likely to be a bug
-    if (val instanceof Date) {
-        return false;
-    }
-    // this depends on __wbg_ptr being the wasm pointer
-    // a new version of wasm-bindgen will break this
-    // but the tests should expose the break
-    if (val && ((_c = (_b = val[STATE]) === null || _b === void 0 ? void 0 : _b.handle) === null || _c === void 0 ? void 0 : _c.__wbg_ptr) === context.__wbg_ptr) {
-        return true;
-    }
-    return false;
-}
-const MapHandler = {
-    get(target, key) {
-        const { context, objectId, cache } = target;
-        if (key === Symbol.toStringTag) {
-            return target[Symbol.toStringTag];
-        }
-        if (key === OBJECT_ID)
-            return objectId;
-        if (key === IS_PROXY)
-            return true;
-        if (key === TRACE)
-            return target.trace;
-        if (key === STATE)
-            return { handle: context };
-        if (!cache[key]) {
-            cache[key] = valueAt(target, key);
-        }
-        return cache[key];
-    },
-    set(target, key, val) {
-        const { context, objectId, path } = target;
-        target.cache = {}; // reset cache on set
-        if (isSameDocument(val, context)) {
-            throw new RangeError("Cannot create a reference to an existing document object");
-        }
-        if (key === TRACE) {
-            target.trace = val;
-            return true;
-        }
-        if (key === CLEAR_CACHE) {
-            return true;
-        }
-        const [value, datatype] = import_value(val, [...path, key], context);
-        switch (datatype) {
-            case "list": {
-                const list = context.putObject(objectId, key, []);
-                const proxyList = listProxy(context, list, [...path, key]);
-                for (let i = 0; i < value.length; i++) {
-                    proxyList[i] = value[i];
-                }
-                break;
-            }
-            case "text": {
-                context.putObject(objectId, key, value);
-                break;
-            }
-            case "map": {
-                const map = context.putObject(objectId, key, {});
-                const proxyMap = mapProxy(context, map, [...path, key]);
-                for (const key in value) {
-                    proxyMap[key] = value[key];
-                }
-                break;
-            }
-            default:
-                context.put(objectId, key, value, datatype);
-        }
-        return true;
-    },
-    deleteProperty(target, key) {
-        const { context, objectId } = target;
-        target.cache = {}; // reset cache on delete
-        context.delete(objectId, key);
-        return true;
-    },
-    has(target, key) {
-        const value = this.get(target, key);
-        return value !== undefined;
-    },
-    getOwnPropertyDescriptor(target, key) {
-        // const { context, objectId } = target
-        const value = this.get(target, key);
-        if (typeof value !== "undefined") {
-            return {
-                configurable: true,
-                enumerable: true,
-                value,
-            };
-        }
-    },
-    ownKeys(target) {
-        const { context, objectId } = target;
-        // FIXME - this is a tmp workaround until fix the dupe key bug in keys()
-        const keys = context.keys(objectId);
-        return [...new Set(keys)];
-    },
-};
-const ListHandler = {
-    get(target, index) {
-        const { context, objectId } = target;
-        index = parseListIndex(index);
-        if (index === Symbol.hasInstance) {
-            return (instance) => {
-                return Array.isArray(instance);
-            };
-        }
-        if (index === Symbol.toStringTag) {
-            return target[Symbol.toStringTag];
-        }
-        if (index === OBJECT_ID)
-            return objectId;
-        if (index === IS_PROXY)
-            return true;
-        if (index === TRACE)
-            return target.trace;
-        if (index === STATE)
-            return { handle: context };
-        if (index === "length")
-            return context.length(objectId);
-        if (typeof index === "number") {
-            return valueAt(target, index);
-        }
-        else {
-            return listMethods(target)[index];
-        }
-    },
-    set(target, index, val) {
-        const { context, objectId, path } = target;
-        index = parseListIndex(index);
-        if (isSameDocument(val, context)) {
-            throw new RangeError("Cannot create a reference to an existing document object");
-        }
-        if (index === CLEAR_CACHE) {
-            return true;
-        }
-        if (index === TRACE) {
-            target.trace = val;
-            return true;
-        }
-        if (typeof index == "string") {
-            throw new RangeError("list index must be a number");
-        }
-        const [value, datatype] = import_value(val, [...path, index], context);
-        switch (datatype) {
-            case "list": {
-                let list;
-                if (index >= context.length(objectId)) {
-                    list = context.insertObject(objectId, index, []);
-                }
-                else {
-                    list = context.putObject(objectId, index, []);
-                }
-                const proxyList = listProxy(context, list, [...path, index]);
-                proxyList.splice(0, 0, ...value);
-                break;
-            }
-            case "text": {
-                if (index >= context.length(objectId)) {
-                    context.insertObject(objectId, index, value);
-                }
-                else {
-                    context.putObject(objectId, index, value);
-                }
-                break;
-            }
-            case "map": {
-                let map;
-                if (index >= context.length(objectId)) {
-                    map = context.insertObject(objectId, index, {});
-                }
-                else {
-                    map = context.putObject(objectId, index, {});
-                }
-                const proxyMap = mapProxy(context, map, [...path, index]);
-                for (const key in value) {
-                    proxyMap[key] = value[key];
-                }
-                break;
-            }
-            default:
-                if (index >= context.length(objectId)) {
-                    context.insert(objectId, index, value, datatype);
-                }
-                else {
-                    context.put(objectId, index, value, datatype);
-                }
-        }
-        return true;
-    },
-    deleteProperty(target, index) {
-        const { context, objectId } = target;
-        index = parseListIndex(index);
-        const elem = context.get(objectId, index);
-        if (elem != null && elem[0] == "counter") {
-            throw new TypeError("Unsupported operation: deleting a counter from a list");
-        }
-        context.delete(objectId, index);
-        return true;
-    },
-    has(target, index) {
-        const { context, objectId } = target;
-        index = parseListIndex(index);
-        if (typeof index === "number") {
-            return index < context.length(objectId);
-        }
-        return index === "length";
-    },
-    getOwnPropertyDescriptor(target, index) {
-        const { context, objectId } = target;
-        if (index === "length")
-            return { writable: true, value: context.length(objectId) };
-        if (index === OBJECT_ID)
-            return { configurable: false, enumerable: false, value: objectId };
-        index = parseListIndex(index);
-        const value = valueAt(target, index);
-        return { configurable: true, enumerable: true, value };
-    },
-    getPrototypeOf(target) {
-        return Object.getPrototypeOf(target);
-    },
-    ownKeys( /*target*/) {
-        const keys = [];
-        // uncommenting this causes assert.deepEqual() to fail when comparing to a pojo array
-        // but not uncommenting it causes for (i in list) {} to not enumerate values properly
-        //const {context, objectId } = target
-        //for (let i = 0; i < target.context.length(objectId); i++) { keys.push(i.toString()) }
-        keys.push("length");
-        return keys;
-    },
-};
-Object.assign({}, ListHandler, {
-    get(target, index) {
-        const { context, objectId } = target;
-        index = parseListIndex(index);
-        if (index === Symbol.hasInstance) {
-            return (instance) => {
-                return Array.isArray(instance);
-            };
-        }
-        if (index === Symbol.toStringTag) {
-            return target[Symbol.toStringTag];
-        }
-        if (index === OBJECT_ID)
-            return objectId;
-        if (index === IS_PROXY)
-            return true;
-        if (index === TRACE)
-            return target.trace;
-        if (index === STATE)
-            return { handle: context };
-        if (index === "length")
-            return context.length(objectId);
-        if (typeof index === "number") {
-            return valueAt(target, index);
-        }
-        else {
-            return textMethods(target)[index] || listMethods(target)[index];
-        }
-    },
-    getPrototypeOf( /*target*/) {
-        return Object.getPrototypeOf(new Text());
-    },
-});
-function mapProxy(context, objectId, path) {
-    const target = {
-        context,
-        objectId,
-        path: path || [],
-        cache: {},
-    };
-    const proxied = {};
-    Object.assign(proxied, target);
-    const result = new Proxy(proxied, MapHandler);
-    // conversion through unknown is necessary because the types are so different
-    return result;
-}
-function listProxy(context, objectId, path) {
-    const target = {
-        context,
-        objectId,
-        path: path || [],
-        cache: {},
-    };
-    const proxied = [];
-    Object.assign(proxied, target);
-    // eslint-disable-next-line @typescript-eslint/ban-ts-comment
-    // @ts-ignore
-    return new Proxy(proxied, ListHandler);
-}
-function listMethods(target) {
-    const { context, objectId, path } = target;
-    const methods = {
-        at(index) {
-            return valueAt(target, index);
-        },
-        deleteAt(index, numDelete) {
-            if (typeof numDelete === "number") {
-                context.splice(objectId, index, numDelete);
-            }
-            else {
-                context.delete(objectId, index);
-            }
-            return this;
-        },
-        fill(val, start, end) {
-            const [value, datatype] = import_value(val, [...path, start], context);
-            const length = context.length(objectId);
-            start = parseListIndex(start || 0);
-            end = parseListIndex(end || length);
-            for (let i = start; i < Math.min(end, length); i++) {
-                if (datatype === "list" || datatype === "map") {
-                    context.putObject(objectId, i, value);
-                }
-                else if (datatype === "text") {
-                    context.putObject(objectId, i, value);
-                }
-                else {
-                    context.put(objectId, i, value, datatype);
-                }
-            }
-            return this;
-        },
-        indexOf(searchElement, start = 0) {
-            const length = context.length(objectId);
-            for (let i = start; i < length; i++) {
-                const valueWithType = context.getWithType(objectId, i);
-                if (!valueWithType) {
-                    continue;
-                }
-                const [valType, value] = valueWithType;
-                // Either the target element is an object, and we return if we have found
-                // the same object or it is a primitive value and we return if it matches
-                // the current value
-                const isObject = ["map", "list", "text"].includes(valType);
-                if (!isObject) {
-                    // If the element is not an object, then check if the value is equal to the target
-                    if (value === searchElement) {
-                        return i;
-                    }
-                    else {
-                        continue;
-                    }
-                }
-                // if it's an object, but the type of the search element is a string, then we
-                // need to check if the object is a text object with the same value as the search element
-                if (valType === "text" && typeof searchElement === "string") {
-                    if (searchElement === valueAt(target, i)) {
-                        return i;
-                    }
-                }
-                // The only possible match now is if the searchElement is an object already in the
-                // automerge document with the same object ID as the value
-                if (searchElement[OBJECT_ID] === value) {
-                    return i;
-                }
-            }
-            return -1;
-        },
-        insertAt(index, ...values) {
-            this.splice(index, 0, ...values);
-            return this;
-        },
-        pop() {
-            const length = context.length(objectId);
-            if (length == 0) {
-                return undefined;
-            }
-            const last = valueAt(target, length - 1);
-            context.delete(objectId, length - 1);
-            return last;
-        },
-        push(...values) {
-            const len = context.length(objectId);
-            this.splice(len, 0, ...values);
-            return context.length(objectId);
-        },
-        shift() {
-            if (context.length(objectId) == 0)
-                return;
-            const first = valueAt(target, 0);
-            context.delete(objectId, 0);
-            return first;
-        },
-        splice(index, del, ...vals) {
-            index = parseListIndex(index);
-            // if del is undefined, delete until the end of the list
-            if (typeof del !== "number") {
-                del = context.length(objectId) - index;
-            }
-            del = parseListIndex(del);
-            for (const val of vals) {
-                if (isSameDocument(val, context)) {
-                    throw new RangeError("Cannot create a reference to an existing document object");
-                }
-            }
-            const result = [];
-            for (let i = 0; i < del; i++) {
-                const value = valueAt(target, index);
-                if (value !== undefined) {
-                    result.push(value);
-                }
-                context.delete(objectId, index);
-            }
-            const values = vals.map((val, index) => {
-                try {
-                    return import_value(val, [...path], context);
-                }
-                catch (e) {
-                    if (e instanceof RangeError) {
-                        throw new RangeError(`${e.message} (at index ${index} in the input)`);
-                    }
-                    else {
-                        throw e;
-                    }
-                }
-            });
-            for (const [value, datatype] of values) {
-                switch (datatype) {
-                    case "list": {
-                        const list = context.insertObject(objectId, index, []);
-                        const proxyList = listProxy(context, list, [...path, index]);
-                        proxyList.splice(0, 0, ...value);
-                        break;
-                    }
-                    case "text": {
-                        context.insertObject(objectId, index, value);
-                        break;
-                    }
-                    case "map": {
-                        const map = context.insertObject(objectId, index, {});
-                        const proxyMap = mapProxy(context, map, [...path, index]);
-                        for (const key in value) {
-                            proxyMap[key] = value[key];
-                        }
-                        break;
-                    }
-                    default:
-                        context.insert(objectId, index, value, datatype);
-                }
-                index += 1;
-            }
-            return result;
-        },
-        unshift(...values) {
-            this.splice(0, 0, ...values);
-            return context.length(objectId);
-        },
-        entries() {
-            let i = 0;
-            const iterator = {
-                next: () => {
-                    const value = valueAt(target, i);
-                    if (value === undefined) {
-                        return { value: undefined, done: true };
-                    }
-                    else {
-                        return { value: [i++, value], done: false };
-                    }
-                },
-                [Symbol.iterator]() {
-                    return this;
-                },
-            };
-            return iterator;
-        },
-        keys() {
-            let i = 0;
-            const len = context.length(objectId);
-            const iterator = {
-                next: () => {
-                    if (i < len) {
-                        return { value: i++, done: false };
-                    }
-                    return { value: undefined, done: true };
-                },
-                [Symbol.iterator]() {
-                    return this;
-                },
-            };
-            return iterator;
-        },
-        values() {
-            let i = 0;
-            const iterator = {
-                next: () => {
-                    const value = valueAt(target, i++);
-                    if (value === undefined) {
-                        return { value: undefined, done: true };
-                    }
-                    else {
-                        return { value, done: false };
-                    }
-                },
-                [Symbol.iterator]() {
-                    return this;
-                },
-            };
-            return iterator;
-        },
-        toArray() {
-            const list = [];
-            let value;
-            do {
-                value = valueAt(target, list.length);
-                if (value !== undefined) {
-                    list.push(value);
-                }
-            } while (value !== undefined);
-            return list;
-        },
-        map(f) {
-            return this.toArray().map(f);
-        },
-        toString() {
-            return this.toArray().toString();
-        },
-        toLocaleString() {
-            return this.toArray().toLocaleString();
-        },
-        forEach(f) {
-            return this.toArray().forEach(f);
-        },
-        // todo: real concat function is different
-        concat(other) {
-            return this.toArray().concat(other);
-        },
-        every(f) {
-            return this.toArray().every(f);
-        },
-        filter(f) {
-            return this.toArray().filter(f);
-        },
-        find(f) {
-            let index = 0;
-            for (const v of this) {
-                if (f(v, index)) {
-                    return v;
-                }
-                index += 1;
-            }
-        },
-        findIndex(f) {
-            let index = 0;
-            for (const v of this) {
-                if (f(v, index)) {
-                    return index;
-                }
-                index += 1;
-            }
-            return -1;
-        },
-        includes(elem) {
-            return this.find(e => e === elem) !== undefined;
-        },
-        join(sep) {
-            return this.toArray().join(sep);
-        },
-        reduce(f, initialValue) {
-            return this.toArray().reduce(f, initialValue);
-        },
-        reduceRight(f, initialValue) {
-            return this.toArray().reduceRight(f, initialValue);
-        },
-        lastIndexOf(search, fromIndex = +Infinity) {
-            // this can be faster
-            return this.toArray().lastIndexOf(search, fromIndex);
-        },
-        slice(index, num) {
-            return this.toArray().slice(index, num);
-        },
-        some(f) {
-            let index = 0;
-            for (const v of this) {
-                if (f(v, index)) {
-                    return true;
-                }
-                index += 1;
-            }
-            return false;
-        },
-        [Symbol.iterator]: function* () {
-            let i = 0;
-            let value = valueAt(target, i);
-            while (value !== undefined) {
-                yield value;
-                i += 1;
-                value = valueAt(target, i);
-            }
-        },
-    };
-    return methods;
-}
-function textMethods(target) {
-    const { context, objectId } = target;
-    const methods = {
-        set(index, value) {
-            return (this[index] = value);
-        },
-        get(index) {
-            return this[index];
-        },
-        toString() {
-            return context.text(objectId).replace(//g, "");
-        },
-        toSpans() {
-            const spans = [];
-            let chars = "";
-            const length = context.length(objectId);
-            for (let i = 0; i < length; i++) {
-                const value = this[i];
-                if (typeof value === "string") {
-                    chars += value;
-                }
-                else {
-                    if (chars.length > 0) {
-                        spans.push(chars);
-                        chars = "";
-                    }
-                    spans.push(value);
-                }
-            }
-            if (chars.length > 0) {
-                spans.push(chars);
-            }
-            return spans;
-        },
-        toJSON() {
-            return this.toString();
-        },
-        indexOf(o, start = 0) {
-            const text = context.text(objectId);
-            return text.indexOf(o, start);
-        },
-        insertAt(index, ...values) {
-            if (values.every(v => typeof v === "string")) {
-                context.splice(objectId, index, 0, values.join(""));
-            }
-            else {
-                listMethods(target).insertAt(index, ...values);
-            }
-        },
-    };
-    return methods;
-}
-function printPath(path) {
-    // print the path as a json pointer
-    const jsonPointerComponents = path.map(component => {
-        // if its a number just turn it into a string
-        if (typeof component === "number") {
-            return component.toString();
-        }
-        else if (typeof component === "string") {
-            // otherwise we have to escape `/` and `~` characters
-            return component.replace(/~/g, "~0").replace(/\//g, "~1");
-        }
-    });
-    if (path.length === 0) {
-        return "";
-    }
-    else {
-        return "/" + jsonPointerComponents.join("/");
-    }
-}
-/*
- * Check if an object is a {@link ImmutableString}
- */
-function isImmutableString(obj) {
-    // We used to determine whether something was a ImmutableString by doing an instanceof check, but
-    // this doesn't work if the automerge module is loaded twice somehow. Instead, use the presence
-    // of a symbol to determine if something is a ImmutableString
-    return (typeof obj === "object" &&
-        obj !== null &&
-        Object.prototype.hasOwnProperty.call(obj, IMMUTABLE_STRING));
-}
-
-let wasm;
-
-const cachedTextEncoder = (typeof TextEncoder !== 'undefined' ? new TextEncoder('utf-8') : { encode: () => { throw Error('TextEncoder not available') } } );
-
-(typeof cachedTextEncoder.encodeInto === 'function'
-    ? function (arg, view) {
-    return cachedTextEncoder.encodeInto(arg, view);
-}
-    : function (arg, view) {
-    const buf = cachedTextEncoder.encode(arg);
-    view.set(buf);
-    return {
-        read: arg.length,
-        written: buf.length
-    };
-});
-
-const cachedTextDecoder = (typeof TextDecoder !== 'undefined' ? new TextDecoder('utf-8', { ignoreBOM: true, fatal: true }) : { decode: () => { throw Error('TextDecoder not available') } } );
-
-if (typeof TextDecoder !== 'undefined') { cachedTextDecoder.decode(); }
-(typeof FinalizationRegistry === 'undefined')
-    ? { }
-    : new FinalizationRegistry(ptr => wasm.__wbg_automerge_free(ptr >>> 0, 1));
-
-(typeof FinalizationRegistry === 'undefined')
-    ? { }
-    : new FinalizationRegistry(ptr => wasm.__wbg_syncstate_free(ptr >>> 0, 1));
+if (Symbol.dispose) SyncState.prototype[Symbol.dispose] = SyncState.prototype.free;
 
 (undefined && undefined.__rest) || function (s, e) {
     var t = {};
@@ -6241,13 +5375,6 @@ const REUSE_BUFFER_MODE = 512;
 const RESET_BUFFER_MODE = 1024;
 const THROW_ON_ITERABLE = 2048;
 
-/**
- * FinalizationRegistry for automatic cleanup of Ref instances.
- * This ensures subscriptions are cleaned up when Refs are garbage collected,
- * even if dispose() is never called.
- */
-new FinalizationRegistry(cleanup => cleanup());
-
 var sha256$1 = {exports: {}};
 
 var sha256 = sha256$1.exports;
@@ -6692,67 +5819,139 @@ const DEFAULT_HEARTBEAT_INTERVAL_MS = 15_000;
 const DEFAULT_PEER_TTL_MS = 3 * DEFAULT_HEARTBEAT_INTERVAL_MS;
 const PRESENCE_MESSAGE_MARKER = "__presence";
 
-/**
- * A grouped view of peer states.
- */
+function unique(items) {
+    return Array.from(new Set(items));
+}
+
 class PeerStateView {
     value;
     constructor(value) {
         this.value = value;
     }
     /**
-     * Get the presence state of all peers. By default, each peer is its own
-     * group, but presence activity can be aggregated by arbitrary criteria.
+     * Get all users.
+     *
+     * @returns Array of user presence {@link State}s
+     */
+    get users() {
+        const userIds = unique(Object.values(this.value).map(peerState => peerState.userId));
+        return userIds.map(u => this.getUserState(u));
+    }
+    /**
+     * Get all devices.
+     *
+     * @returns Array of device presence {@link State}s
+     */
+    get devices() {
+        const deviceIds = unique(Object.values(this.value).map(peerState => peerState.deviceId));
+        return deviceIds.map(d => this.getDeviceState(d));
+    }
+    /**
+     * Get all peers.
+     *
+     * @returns Array of peer presence {@link State}s
+     */
+    get peers() {
+        return Object.values(this.value);
+    }
+    /**
+     * Get all peer ids for this user.
+     *
+     * @param userId
+     * @returns Array of peer ids for this user
+     */
+    getUserPeers(userId) {
+        return Object.values(this.value)
+            .filter(peerState => peerState.userId === userId)
+            .map(peerState => peerState.peerId);
+    }
+    /**
+     * Get all peers for this device.
+     *
+     * @param deviceId
+     * @returns Array of peer ids for this device
+     */
+    getDevicePeers(deviceId) {
+        return Object.values(this.value)
+            .filter(peerState => peerState.deviceId === deviceId)
+            .map(peerState => peerState.peerId);
+    }
+    /**
+     * Return the most-recently-seen peer from this group.
      *
-     * @param opts
-     * @returns presence state for all groups
+     * @param peers
+     * @returns id of most recently seen peer
      */
-    getStates(opts) {
-        const groupingFn = opts?.groupingFn ?? peerIdentity;
-        const summaryFn = opts?.summaryFn ??
-            getLastActivePeer;
-        const statesByKey = Object.values(this.value).reduce((byKey, curr) => {
-            const key = groupingFn(curr);
-            if (!(key in byKey)) {
-                byKey[key] = [];
+    getLastSeenPeer(peers) {
+        let freshestLastSeenAt;
+        return peers.reduce((freshest, curr) => {
+            const lastSeenAt = this.value[curr]?.lastActiveAt;
+            if (!lastSeenAt) {
+                return freshest;
             }
-            byKey[key].push(curr);
-            return byKey;
-        }, {});
-        return Object.entries(statesByKey).reduce((result, [key, states]) => {
-            result[key] = summaryFn(states);
-            return result;
-        }, {});
+            if (!freshest || lastSeenAt > freshestLastSeenAt) {
+                freshestLastSeenAt = lastSeenAt;
+                return curr;
+            }
+            return freshest;
+        }, undefined);
     }
-}
-/**
- * Get the peerId of this peer.
- *
- * @param peer
- * @returns peer id
- */
-function peerIdentity(peer) {
-    return peer.peerId;
-}
-/**
- * Find the peer that most recently sent a state update.
- *
- * @param peers
- * @returns id of most recently active peer
- */
-function getLastActivePeer(peers) {
-    let freshestLastActiveAt;
-    return peers.reduce((freshest, curr) => {
-        const lastActiveAt = curr.lastActiveAt;
-        if (!lastActiveAt) {
+    /**
+     * Return the peer from this group that sent a state update most recently
+     *
+     * @param peers
+     * @returns id of most recently seen peer
+     */
+    getLastActivePeer(peers) {
+        let freshestLastActiveAt;
+        return peers.reduce((freshest, curr) => {
+            const lastActiveAt = this.value[curr]?.lastActiveAt;
+            if (!lastActiveAt) {
+                return freshest;
+            }
+            if (!freshest || lastActiveAt > freshestLastActiveAt) {
+                freshestLastActiveAt = lastActiveAt;
+                return curr;
+            }
             return freshest;
+        }, undefined);
+    }
+    /**
+     * Get current ephemeral state value for this user's most-recently-active
+     * peer.
+     *
+     * @param userId
+     * @returns user's {@link State}
+     */
+    getUserState(userId) {
+        const peers = this.getUserPeers(userId);
+        if (!peers) {
+            return undefined;
         }
-        if (!freshest || lastActiveAt > freshestLastActiveAt) {
-            freshestLastActiveAt = lastActiveAt;
-            return curr;
+        const peer = this.getLastActivePeer(peers);
+        if (!peer) {
+            return undefined;
         }
-        return freshest;
-    }, undefined);
+        return this.value[peer];
+    }
+    /**
+     * Get current ephemeral state value for this device's most-recently-active
+     * peer.
+     *
+     * @param deviceId
+     * @returns device's {@link State}
+     */
+    getDeviceState(deviceId) {
+        const peers = this.getDevicePeers(deviceId);
+        if (!peers) {
+            return undefined;
+        }
+        const peer = this.getLastActivePeer(peers);
+        if (!peer) {
+            return undefined;
+        }
+        return this.value[peer];
+    }
 }
 
 class PeerPresenceInfo {
@@ -6776,15 +5975,11 @@ class PeerPresenceInfo {
      * @param peerId
      */
     markSeen(peerId) {
-        if (!(peerId in this.#peerStates.value)) {
-            // Ignore heartbeats from peers we have not seen before: they will send a snapshot
-            return;
-        }
         this.#peerStates = new PeerStateView({
             ...this.#peerStates.value,
             [peerId]: {
                 ...this.#peerStates.value[peerId],
-                lastSeenAt: Date.now(),
+                lastSeen: Date.now(),
             },
         });
     }
@@ -6795,7 +5990,7 @@ class PeerPresenceInfo {
      * @param peerId
      * @param value
      */
-    update({ peerId, value }) {
+    update({ peerId, deviceId, userId, value, }) {
         const peerState = this.#peerStates.value[peerId];
         const existingState = peerState?.value ?? {};
         const now = Date.now();
@@ -6803,8 +5998,10 @@ class PeerPresenceInfo {
             ...this.#peerStates.value,
             [peerId]: {
                 peerId,
-                lastSeenAt: now,
+                deviceId,
+                userId,
                 lastActiveAt: now,
+                lastUpdateAt: now,
                 value: {
                     ...existingState,
                     ...value,
@@ -6828,15 +6025,9 @@ class PeerPresenceInfo {
      */
     prune() {
         const threshold = Date.now() - this.ttl;
-        const pruned = [];
-        this.#peerStates = new PeerStateView(Object.fromEntries(Object.entries(this.#peerStates.value).filter(([id, state]) => {
-            const keep = state.lastSeenAt >= threshold;
-            if (!keep) {
-                pruned.push(id);
-            }
-            return keep;
+        this.#peerStates = new PeerStateView(Object.fromEntries(Object.entries(this.#peerStates).filter(([, state]) => {
+            return state.lastActiveAt >= threshold;
         })));
-        return pruned;
     }
     /**
      * Get a snapshot of the current peer states
@@ -6859,6 +6050,8 @@ class PeerPresenceInfo {
  */
 class Presence extends EventEmitter {
     #handle;
+    deviceId;
+    userId;
     #peers;
     #localState;
     #heartbeatMs;
@@ -6873,11 +6066,13 @@ class Presence extends EventEmitter {
      * @param config see {@link PresenceConfig}
      * @returns
      */
-    constructor({ handle }) {
+    constructor({ handle, deviceId, userId, }) {
         super();
         this.#handle = handle;
         this.#peers = new PeerPresenceInfo(DEFAULT_PEER_TTL_MS);
         this.#localState = {};
+        this.userId = userId;
+        this.deviceId = deviceId;
     }
     /**
      * Start listening to ephemeral messages on the handle, broadcast initial
@@ -6901,6 +6096,7 @@ class Presence extends EventEmitter {
                 return;
             }
             const message = envelope[PRESENCE_MESSAGE_MARKER];
+            const { deviceId, userId } = message;
             if (!this.#peers.has(peerId)) {
                 this.announce();
             }
@@ -6916,11 +6112,15 @@ class Presence extends EventEmitter {
                 case "update":
                     this.#peers.update({
                         peerId,
+                        deviceId,
+                        userId,
                         value: { [message.channel]: message.value },
                     });
                     this.emit("update", {
                         type: "update",
                         peerId,
+                        deviceId,
+                        userId,
                         channel: message.channel,
                         value: message.value,
                     });
@@ -6928,11 +6128,15 @@ class Presence extends EventEmitter {
                 case "snapshot":
                     this.#peers.update({
                         peerId,
+                        deviceId,
+                        userId,
                         value: message.state,
                     });
                     this.emit("snapshot", {
                         type: "snapshot",
                         peerId,
+                        deviceId,
+                        userId,
                         state: message.state,
                     });
                     break;
@@ -7027,6 +6231,8 @@ class Presence extends EventEmitter {
     }
     doBroadcast(type, extra) {
         this.send({
+            userId: this.userId,
+            deviceId: this.deviceId,
             type,
             ...extra,
         });
@@ -7062,10 +6268,7 @@ class Presence extends EventEmitter {
         // to minimize variance between peer expiration, since the heartbeat frequency
         // is expected to be several times higher.
         this.#pruningInterval = setInterval(() => {
-            const pruned = this.#peers.prune();
-            if (pruned.length > 0) {
-                this.emit("pruning", { pruned });
-            }
+            this.#peers.prune();
         }, this.#heartbeatMs);
     }
     stopPruningPeers() {
@@ -7079,6 +6282,8 @@ class Presence extends EventEmitter {
 
 function usePresence({
   handle,
+  userId,
+  deviceId,
   initialState,
   heartbeatMs,
   peerTtlMs
@@ -7090,7 +6295,9 @@ function usePresence({
     peerTtlMs
   });
   const firstInitialState = useRef(initialState);
-  const [presence] = useState(() => new Presence({ handle }));
+  const [presence] = useState(
+    () => new Presence({ handle, userId, deviceId })
+  );
   useEffect(() => {
     presence.start({
       initialState: firstInitialState.current,
@@ -7100,26 +6307,10 @@ function usePresence({
     presence.on("snapshot", () => setPeerStates(presence.getPeerStates()));
     presence.on("update", () => setPeerStates(presence.getPeerStates()));
     presence.on("goodbye", () => setPeerStates(presence.getPeerStates()));
-    presence.on("pruning", () => setPeerStates(presence.getPeerStates()));
     return () => {
       presence.stop();
     };
-  }, [presence, firstInitialState, firstOpts]);
-  const start = useCallback(
-    (config) => {
-      const initialState2 = config?.initialState ?? presence.getLocalState();
-      const opts = {
-        ...firstOpts.current,
-        ...config,
-        initialState: initialState2
-      };
-      presence.start(opts);
-    },
-    [presence, firstOpts]
-  );
-  const stop = useCallback(() => {
-    presence.stop();
-  }, [presence]);
+  }, [presence, userId, deviceId, firstInitialState, firstOpts]);
   const update = useCallback(
     (channel, msg) => {
       presence.broadcast(channel, msg);
@@ -7131,9 +6322,7 @@ function usePresence({
   return {
     peerStates,
     localState,
-    update,
-    start,
-    stop
+    update
   };
 }