@dxos/util 0.5.9-main.f099efe → 0.5.9-next.73dcc17

package/dist/lib/browser/index.mjs

@@ -199,6 +199,60 @@ var createSetDispatch = ({ handlers }) => {
   });
 };
 
+// packages/common/util/src/circular-buffer.ts
+import { invariant as invariant4 } from "@dxos/invariant";
+var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/common/util/src/circular-buffer.ts";
+var CircularBuffer = class {
+  constructor(size) {
+    this._nextIndex = 0;
+    this._elementCount = 0;
+    invariant4(size >= 1, void 0, {
+      F: __dxlog_file4,
+      L: 13,
+      S: this,
+      A: [
+        "size >= 1",
+        ""
+      ]
+    });
+    this._buffer = new Array(size);
+  }
+  push(element) {
+    this._buffer[this._nextIndex] = element;
+    this._nextIndex = (this._nextIndex + 1) % this._buffer.length;
+    this._elementCount = Math.min(this._buffer.length, this._elementCount + 1);
+  }
+  getLast() {
+    if (this._elementCount === 0) {
+      return void 0;
+    }
+    if (this._nextIndex === 0) {
+      return this._buffer[this._buffer.length - 1];
+    }
+    return this._buffer[this._nextIndex - 1];
+  }
+  [Symbol.iterator]() {
+    return this.values();
+  }
+  *values() {
+    if (this._elementCount === 0) {
+      return;
+    }
+    if (this._elementCount < this._buffer.length) {
+      for (let i = 0; i < this._elementCount; i++) {
+        yield this._buffer[i];
+      }
+      return;
+    }
+    for (let i = this._nextIndex; i < this._buffer.length; i++) {
+      yield this._buffer[i];
+    }
+    for (let i = 0; i < this._nextIndex; i++) {
+      yield this._buffer[i];
+    }
+  }
+};
+
 // packages/common/util/src/complex.ts
 import { inspect } from "@dxos/node-std/util";
 import { inspectObject, raise } from "@dxos/debug";
@@ -364,188 +418,42 @@ var makeMap = (keyProjection) => class BoundComplexMap extends ComplexMap {
   }
 };
 
+// packages/common/util/src/explicit-resource-management-polyfill.ts
+Symbol.dispose ??= Symbol("Symbol.dispose");
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
+
+// packages/common/util/src/defer.ts
+var defer = (fn) => new DeferGuard(fn);
+var DeferGuard = class {
+  /**
+  * @internal
+  */
+  constructor(_fn) {
+    this._fn = _fn;
+  }
+  [Symbol.dispose]() {
+    const result = this._fn();
+    if (result instanceof Promise) {
+      throw new Error("Async functions in defer are not supported. Use deferAsync instead.");
+    }
+  }
+};
+var deferAsync = (fn) => new DeferAsyncGuard(fn);
+var DeferAsyncGuard = class {
+  /**
+  * @internal
+  */
+  constructor(_fn) {
+    this._fn = _fn;
+  }
+  async [Symbol.asyncDispose]() {
+    await this._fn();
+  }
+};
+
 // packages/common/util/src/defer-function.ts
 var deferFunction = (fnProvider) => (...args) => fnProvider()(...args);
 
-// packages/common/util/src/to-fallback.ts
-var idEmoji = [
-  // When changing this set, please check the result in a console or e.g. RunKit (https://runkit.com/thure/642214441dd6ae000855a8de)
-  // Emoji sometimes use a combination of code points, and some code points aren't visible on their own, so by adding or deleting you may unintentionally create non-visible items.
-  // This set was chosen from the characters in Unicode Emoji v15.0 based on the following criteria:
-  // – not people or isolated anthropomorphic faces
-  // – not flags
-  // – more concrete than abstract
-  // – less culturally specific
-  // – less easily confused with another emoji in the set
-  // – requires less special knowledge to identify
-  // – less likely to evoke negative feelings (no meat, no drugs, no weapons, etc)
-  // – less common as a signifier in UX
-  // NOTE that this is intentionally an array of strings because of the way emoji graphemes work.
-  "\u{1F479}",
-  "\u{1F47B}",
-  "\u{1F47D}",
-  "\u{1F916}",
-  "\u{1F383}",
-  "\u{1F9BE}",
-  "\u{1F9BF}",
-  "\u{1F9B7}",
-  "\u{1F463}",
-  "\u{1F441}\uFE0F",
-  "\u{1F9F6}",
-  "\u{1F451}",
-  "\u{1F412}",
-  "\u{1F986}",
-  "\u{1F989}",
-  "\u{1F434}",
-  "\u{1F984}",
-  "\u{1F41D}",
-  "\u{1F98B}",
-  "\u{1F41E}",
-  "\u{1FAB2}",
-  "\u{1F422}",
-  "\u{1F98E}",
-  "\u{1F995}",
-  "\u{1F991}",
-  "\u{1F980}",
-  "\u{1F420}",
-  "\u{1F42C}",
-  "\u{1F40B}",
-  "\u{1F9AD}",
-  "\u{1F405}",
-  "\u{1F406}",
-  "\u{1F993}",
-  "\u{1F98D}",
-  "\u{1F9A7}",
-  "\u{1F418}",
-  "\u{1F42B}",
-  "\u{1F992}",
-  "\u{1F998}",
-  "\u{1F9AC}",
-  "\u{1F416}",
-  "\u{1F40F}",
-  "\u{1F98C}",
-  "\u{1F415}",
-  "\u{1F408}",
-  "\u{1F413}",
-  "\u{1F99A}",
-  "\u{1F99C}",
-  "\u{1F9A2}",
-  "\u{1F9A9}",
-  "\u{1F9A6}",
-  "\u{1F401}",
-  "\u{1F43F}\uFE0F",
-  "\u{1F335}",
-  "\u{1F332}",
-  "\u{1F333}",
-  "\u{1FAB5}",
-  "\u{1F331}",
-  "\u{1F341}",
-  "\u{1FABA}",
-  "\u{1F344}",
-  "\u{1F41A}",
-  "\u{1FAB8}",
-  "\u{1FAA8}",
-  "\u{1F33E}",
-  "\u{1F337}",
-  "\u{1F33B}",
-  "\u2600\uFE0F",
-  "\u{1F319}",
-  "\u{1FA90}",
-  "\u2B50\uFE0F",
-  "\u26A1\uFE0F",
-  "\u2604\uFE0F",
-  "\u{1F525}",
-  "\u{1F308}",
-  "\u2601\uFE0F",
-  "\u{1F4A7}",
-  "\u26F1\uFE0F",
-  "\u{1F30A}",
-  "\u{1F34E}",
-  "\u{1F34B}",
-  "\u{1F349}",
-  "\u{1F347}",
-  "\u{1FAD0}",
-  "\u{1F348}",
-  "\u{1F352}",
-  "\u{1F351}",
-  "\u{1F96D}",
-  "\u{1F34D}",
-  "\u{1F965}",
-  "\u{1F95D}",
-  "\u{1F951}",
-  "\u{1F336}\uFE0F",
-  "\u{1F33D}",
-  "\u{1F955}",
-  "\u{1F36C}",
-  "\u{1F95C}",
-  "\u{1FAD6}",
-  "\u2615\uFE0F",
-  "\u{1F375}",
-  "\u{1F9CA}",
-  "\u{1F9C2}",
-  "\u{1F3D4}\uFE0F",
-  "\u2693\uFE0F",
-  "\u{1F6DF}",
-  "\u{1F3DD}\uFE0F",
-  "\u{1F6F6}",
-  "\u{1F680}",
-  "\u{1F6F0}\uFE0F",
-  "\u26F2\uFE0F",
-  "\u{1F3F0}",
-  "\u{1F6B2}",
-  "\u26FA\uFE0F",
-  "\u{1F399}\uFE0F",
-  "\u{1F9F2}",
-  "\u2699\uFE0F",
-  "\u{1F529}",
-  "\u{1F52E}",
-  "\u{1F52D}",
-  "\u{1F52C}",
-  "\u{1F9EC}",
-  "\u{1F321}\uFE0F",
-  "\u{1F9FA}",
-  "\u{1F6CE}\uFE0F",
-  "\u{1F511}",
-  "\u{1FA91}",
-  "\u{1F9F8}",
-  "\u{1F388}",
-  "\u{1F380}",
-  "\u{1F38A}",
-  "\u267B\uFE0F",
-  "\u{1F3B5}"
-];
-var idHue = [
-  "red",
-  // 'orange' as const, /* More shades in these palettes are considered “ugly” */
-  "amber",
-  // 'yellow' as const, /* More shades in these palettes are considered “ugly” */
-  "lime",
-  "green",
-  "emerald",
-  "teal",
-  "cyan",
-  // 'sky' as const, /* Omitted since it is quite similar to the primary accent palette */
-  // 'blue' as const, /* Omitted since it is quite similar to the primary accent palette */
-  // 'indigo' as const, /* Omitted since it is quite similar to the primary accent palette */
-  "violet",
-  "purple",
-  "fuchsia",
-  "pink",
-  "rose"
-];
-var keyToEmoji = (key) => hexToEmoji(key.toHex());
-var hexToEmoji = (hex) => toEmoji(parseInt(hex, 16));
-var toEmoji = (hash) => idEmoji[hash % idEmoji.length];
-var keyToHue = (key) => hexToHue(key.toHex());
-var hexToHue = (hex) => toHue(parseInt(hex, 16));
-var toHue = (hash) => idHue[hash % idHue.length];
-var keyToFallback = (key) => hexToFallback(key.toHex());
-var hexToFallback = (hex) => toFallback(parseInt(hex, 16));
-var toFallback = (hash) => ({
-  emoji: toEmoji(hash),
-  hue: toHue(hash)
-});
-
 // packages/common/util/src/entry.ts
 var entry = (map, key) => new MapEntry(map, key);
 var MapEntry = class {
@@ -574,6 +482,9 @@ var MapEntry = class {
   }
 };
 
+// packages/common/util/src/for-each-async.ts
+var forEachAsync = (items, fn) => Promise.all(items.map(fn));
+
 // packages/common/util/src/human-hash.ts
 import { PublicKey } from "@dxos/keys";
 var DEFAULT_WORDLIST = [
@@ -917,6 +828,61 @@ var exponentialBackoffInterval = (cb, initialInterval) => {
   return () => clearTimeout(timeoutId);
 };
 
+// packages/common/util/src/map.ts
+var defaultMap = (map, key, def) => {
+  let value = map.get(key);
+  if (value === void 0) {
+    value = typeof def === "function" ? def() : def;
+    map.set(key, value);
+  }
+  return value;
+};
+
+// packages/common/util/src/instance-id.ts
+var symbol = Symbol.for("dxos.instance-contexts");
+var instanceContexts = globalThis[symbol] ??= /* @__PURE__ */ new WeakMap();
+var getPrototypeSpecificInstanceId = (instance) => {
+  const prototype = Object.getPrototypeOf(instance);
+  const instanceCtx = defaultMap(instanceContexts, prototype, () => ({
+    nextId: 0,
+    instanceIds: /* @__PURE__ */ new WeakMap()
+  }));
+  let id = instanceCtx.instanceIds.get(instance);
+  if (id === void 0) {
+    id = instanceCtx.nextId++;
+    instanceCtx.instanceIds.set(instance, id);
+  }
+  return id;
+};
+var getDebugName = (instance) => {
+  if (instance == null) {
+    return "null";
+  }
+  const prototype = Object.getPrototypeOf(instance);
+  return `${prototype.constructor.name}#${getPrototypeSpecificInstanceId(instance)}`;
+};
+
+// packages/common/util/src/join-tables.ts
+var joinTables = (leftColumn, rightColumn, left, right) => {
+  const map = /* @__PURE__ */ new Map();
+  const used = /* @__PURE__ */ new Set();
+  for (const row of right) {
+    map.set(row[rightColumn], row);
+  }
+  const result = [];
+  for (const row of left) {
+    const right2 = map.get(row[leftColumn]);
+    used.add(right2);
+    result.push(Object.assign(right2 ?? {}, row));
+  }
+  for (const row of right) {
+    if (!used.has(row)) {
+      result.push(row);
+    }
+  }
+  return result;
+};
+
 // packages/common/util/src/json.ts
 import { inspect as inspect2 } from "@dxos/node-std/util";
 import { PublicKey as PublicKey2 } from "@dxos/keys";
@@ -1011,36 +977,109 @@ var jsonlogify = (value, depth = 0, visitedObjects = /* @__PURE__ */ new WeakSet
         return value.toJSON();
       } else {
         const res = {};
-        for (const key of Object.keys(value)) {
-          res[key] = jsonlogify(value[key], depth + 1, visitedObjects);
+        for (const key of Object.keys(value)) {
+          res[key] = jsonlogify(value[key], depth + 1, visitedObjects);
+        }
+        return res;
+      }
+    } finally {
+      visitedObjects.delete(value);
+    }
+  } else {
+    return value;
+  }
+};
+var jsonKeyReplacer = (options = {}) => (key, value) => {
+  if (typeof value === "string") {
+    const key2 = PublicKey2.fromHex(value);
+    if (key2.toHex() === value) {
+      return options.humanize ? humanize(key2) : options.truncate ? key2.truncate() : key2.toHex();
+    }
+  }
+  return value;
+};
+
+// packages/common/util/src/map-values.ts
+var mapValues = (obj, fn) => {
+  const result = {};
+  Object.keys(obj).forEach((key) => {
+    result[key] = fn(obj[key], key);
+  });
+  return result;
+};
+var deepMapValues = (value, fn) => {
+  return new DeepMapper(fn).map(value);
+};
+var DeepMapper = class {
+  constructor(_fn) {
+    this._fn = _fn;
+    this._cyclic = /* @__PURE__ */ new Map();
+    this._recurse = (value) => {
+      if (this._cyclic.has(value)) {
+        return this._cyclic.get(value);
+      }
+      if (Array.isArray(value)) {
+        const res = new Array(value.length);
+        this._cyclic.set(value, res);
+        for (let i = 0; i < value.length; i++) {
+          res[i] = this.map(value[i]);
+        }
+        return res;
+      } else if (value !== null && typeof value === "object") {
+        const res = {};
+        this._cyclic.set(value, res);
+        for (const key in value) {
+          res[key] = this.map(value[key]);
+        }
+        return res;
+      } else {
+        return value;
+      }
+    };
+  }
+  map(value) {
+    if (this._cyclic.has(value)) {
+      return this._cyclic.get(value);
+    }
+    return this._fn(value, this._recurse);
+  }
+};
+var deepMapValuesAsync = (value, fn) => {
+  return new DeepMapperAsync(fn).map(value);
+};
+var DeepMapperAsync = class {
+  constructor(_fn) {
+    this._fn = _fn;
+    this._cyclic = /* @__PURE__ */ new Map();
+    this._recurse = async (value) => {
+      if (this._cyclic.has(value)) {
+        return this._cyclic.get(value);
+      }
+      if (Array.isArray(value)) {
+        const res = new Array(value.length);
+        this._cyclic.set(value, res);
+        for (let i = 0; i < value.length; i++) {
+          res[i] = await this.map(value[i]);
+        }
+        return res;
+      } else if (value !== null && typeof value === "object") {
+        const res = {};
+        this._cyclic.set(value, res);
+        for (const key in value) {
+          res[key] = await this.map(value[key]);
         }
         return res;
+      } else {
+        return value;
       }
-    } finally {
-      visitedObjects.delete(value);
-    }
-  } else {
-    return value;
+    };
   }
-};
-var jsonKeyReplacer = (options = {}) => (key, value) => {
-  if (typeof value === "string") {
-    const key2 = PublicKey2.fromHex(value);
-    if (key2.toHex() === value) {
-      return options.humanize ? humanize(key2) : options.truncate ? key2.truncate() : key2.toHex();
+  map(value) {
+    if (this._cyclic.has(value)) {
+      return this._cyclic.get(value);
     }
+    return this._fn(value, this._recurse);
   }
-  return value;
-};
-
-// packages/common/util/src/map.ts
-var defaultMap = (map, key, def) => {
-  let value = map.get(key);
-  if (value === void 0) {
-    value = typeof def === "function" ? def() : def;
-    map.set(key, value);
-  }
-  return value;
 };
 
 // packages/common/util/src/order.ts
@@ -1070,6 +1109,55 @@ var inferRecordOrder = (objectMap, order = []) => {
   }, {}), objectMap);
 };
 
+// packages/common/util/src/params.ts
+import { AST } from "@effect/schema";
+import { decamelize } from "xcase";
+var ParamKeyAnnotationId = Symbol.for("@dxos/schema/annotation/ParamKeyAnnotation");
+var ParamKeyAnnotation = (value) => (self) => self.annotations({
+  [ParamKeyAnnotationId]: value
+});
+var Params = class {
+  constructor(_schema) {
+    this._schema = _schema;
+  }
+  /**
+  * Parse URL params.
+  * @param url
+  */
+  parse(url) {
+    return Object.entries(this._schema.fields).reduce((acc, [key, type]) => {
+      let v = url.searchParams.get(decamelize(key));
+      if (v == null) {
+        v = url.searchParams.get(key);
+      }
+      if (v != null) {
+        if (AST.isNumberKeyword(type.ast)) {
+          acc[key] = parseInt(v);
+        } else if (AST.isBooleanKeyword(type.ast)) {
+          acc[key] = v === "true" || v === "1";
+        } else {
+          acc[key] = v;
+        }
+      }
+      return acc;
+    }, {});
+  }
+  /**
+  * Update URL with params.
+  */
+  params(url, values) {
+    Object.entries(values).forEach(([key, value]) => {
+      const type = this._schema.fields[key];
+      if (type && value != null) {
+        const { value: alt } = AST.getAnnotation(ParamKeyAnnotationId)(type.ast);
+        const k = alt ?? decamelize(key);
+        url.searchParams.set(k, String(value));
+      }
+    });
+    return url;
+  }
+};
+
 // packages/common/util/src/platform.ts
 var isNode = () => typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 var mobileAndTabletCheck = () => {
@@ -1213,6 +1301,24 @@ var createBucketReducer = (period) => ({
   }
 });
 
+// packages/common/util/src/safe-await.ts
+var safeAwaitAll = async (source, taskFactory, onError) => {
+  const failedItems = [];
+  await Promise.all([
+    ...source
+  ].map(async (item, idx) => {
+    try {
+      await taskFactory(item);
+    } catch (err) {
+      if (onError) {
+        onError(err, item, idx);
+      }
+      failedItems.push(item);
+    }
+  }));
+  return failedItems;
+};
+
 // packages/common/util/src/safe-instanceof.ts
 var instanceTag = Symbol("instanceTag");
 var safeInstanceof = (tag) => (target) => {
@@ -1258,6 +1364,192 @@ var compareMulti = (sorters) => (a, b) => {
   return sort();
 };
 
+// packages/common/util/src/throw-unhandled-error.ts
+var throwUnhandledError = (error) => {
+  queueMicrotask(() => {
+    throw error;
+  });
+};
+
+// packages/common/util/src/to-fallback.ts
+var idEmoji = [
+  // When changing this set, please check the result in a console or e.g. RunKit (https://runkit.com/thure/642214441dd6ae000855a8de)
+  // Emoji sometimes use a combination of code points, and some code points aren't visible on their own, so by adding or deleting you may unintentionally create non-visible items.
+  // This set was chosen from the characters in Unicode Emoji v15.0 based on the following criteria:
+  // – not people or isolated anthropomorphic faces
+  // – not flags
+  // – more concrete than abstract
+  // – less culturally specific
+  // – less easily confused with another emoji in the set
+  // – requires less special knowledge to identify
+  // – less likely to evoke negative feelings (no meat, no drugs, no weapons, etc)
+  // – less common as a signifier in UX
+  // NOTE that this is intentionally an array of strings because of the way emoji graphemes work.
+  "\u{1F479}",
+  "\u{1F47B}",
+  "\u{1F47D}",
+  "\u{1F916}",
+  "\u{1F383}",
+  "\u{1F9BE}",
+  "\u{1F9BF}",
+  "\u{1F9B7}",
+  "\u{1F463}",
+  "\u{1F441}\uFE0F",
+  "\u{1F9F6}",
+  "\u{1F451}",
+  "\u{1F412}",
+  "\u{1F986}",
+  "\u{1F989}",
+  "\u{1F434}",
+  "\u{1F984}",
+  "\u{1F41D}",
+  "\u{1F98B}",
+  "\u{1F41E}",
+  "\u{1FAB2}",
+  "\u{1F422}",
+  "\u{1F98E}",
+  "\u{1F995}",
+  "\u{1F991}",
+  "\u{1F980}",
+  "\u{1F420}",
+  "\u{1F42C}",
+  "\u{1F40B}",
+  "\u{1F9AD}",
+  "\u{1F405}",
+  "\u{1F406}",
+  "\u{1F993}",
+  "\u{1F98D}",
+  "\u{1F9A7}",
+  "\u{1F418}",
+  "\u{1F42B}",
+  "\u{1F992}",
+  "\u{1F998}",
+  "\u{1F9AC}",
+  "\u{1F416}",
+  "\u{1F40F}",
+  "\u{1F98C}",
+  "\u{1F415}",
+  "\u{1F408}",
+  "\u{1F413}",
+  "\u{1F99A}",
+  "\u{1F99C}",
+  "\u{1F9A2}",
+  "\u{1F9A9}",
+  "\u{1F9A6}",
+  "\u{1F401}",
+  "\u{1F43F}\uFE0F",
+  "\u{1F335}",
+  "\u{1F332}",
+  "\u{1F333}",
+  "\u{1FAB5}",
+  "\u{1F331}",
+  "\u{1F341}",
+  "\u{1FABA}",
+  "\u{1F344}",
+  "\u{1F41A}",
+  "\u{1FAB8}",
+  "\u{1FAA8}",
+  "\u{1F33E}",
+  "\u{1F337}",
+  "\u{1F33B}",
+  "\u2600\uFE0F",
+  "\u{1F319}",
+  "\u{1FA90}",
+  "\u2B50\uFE0F",
+  "\u26A1\uFE0F",
+  "\u2604\uFE0F",
+  "\u{1F525}",
+  "\u{1F308}",
+  "\u2601\uFE0F",
+  "\u{1F4A7}",
+  "\u26F1\uFE0F",
+  "\u{1F30A}",
+  "\u{1F34E}",
+  "\u{1F34B}",
+  "\u{1F349}",
+  "\u{1F347}",
+  "\u{1FAD0}",
+  "\u{1F348}",
+  "\u{1F352}",
+  "\u{1F351}",
+  "\u{1F96D}",
+  "\u{1F34D}",
+  "\u{1F965}",
+  "\u{1F95D}",
+  "\u{1F951}",
+  "\u{1F336}\uFE0F",
+  "\u{1F33D}",
+  "\u{1F955}",
+  "\u{1F36C}",
+  "\u{1F95C}",
+  "\u{1FAD6}",
+  "\u2615\uFE0F",
+  "\u{1F375}",
+  "\u{1F9CA}",
+  "\u{1F9C2}",
+  "\u{1F3D4}\uFE0F",
+  "\u2693\uFE0F",
+  "\u{1F6DF}",
+  "\u{1F3DD}\uFE0F",
+  "\u{1F6F6}",
+  "\u{1F680}",
+  "\u{1F6F0}\uFE0F",
+  "\u26F2\uFE0F",
+  "\u{1F3F0}",
+  "\u{1F6B2}",
+  "\u26FA\uFE0F",
+  "\u{1F399}\uFE0F",
+  "\u{1F9F2}",
+  "\u2699\uFE0F",
+  "\u{1F529}",
+  "\u{1F52E}",
+  "\u{1F52D}",
+  "\u{1F52C}",
+  "\u{1F9EC}",
+  "\u{1F321}\uFE0F",
+  "\u{1F9FA}",
+  "\u{1F6CE}\uFE0F",
+  "\u{1F511}",
+  "\u{1FA91}",
+  "\u{1F9F8}",
+  "\u{1F388}",
+  "\u{1F380}",
+  "\u{1F38A}",
+  "\u267B\uFE0F",
+  "\u{1F3B5}"
+];
+var idHue = [
+  "red",
+  // 'orange' as const, /* More shades in these palettes are considered “ugly” */
+  "amber",
+  // 'yellow' as const, /* More shades in these palettes are considered “ugly” */
+  "lime",
+  "green",
+  "emerald",
+  "teal",
+  "cyan",
+  // 'sky' as const, /* Omitted since it is quite similar to the primary accent palette */
+  // 'blue' as const, /* Omitted since it is quite similar to the primary accent palette */
+  // 'indigo' as const, /* Omitted since it is quite similar to the primary accent palette */
+  "violet",
+  "purple",
+  "fuchsia",
+  "pink",
+  "rose"
+];
+var keyToEmoji = (key) => hexToEmoji(key.toHex());
+var hexToEmoji = (hex) => toEmoji(parseInt(hex, 16));
+var toEmoji = (hash) => idEmoji[hash % idEmoji.length];
+var keyToHue = (key) => hexToHue(key.toHex());
+var hexToHue = (hex) => toHue(parseInt(hex, 16));
+var toHue = (hash) => idHue[hash % idHue.length];
+var keyToFallback = (key) => hexToFallback(key.toHex());
+var hexToFallback = (hex) => toFallback(parseInt(hex, 16));
+var toFallback = (hash) => ({
+  emoji: toEmoji(hash),
+  hue: toHue(hash)
+});
+
 // packages/common/util/src/tracer.ts
 var Tracer = class {
   constructor() {
@@ -1361,36 +1653,9 @@ var safeParseInt = (value, defaultValue) => {
   }
 };
 
-// packages/common/util/src/instance-id.ts
-var symbol = Symbol.for("dxos.instance-contexts");
-var instanceContexts = globalThis[symbol] ??= /* @__PURE__ */ new WeakMap();
-var getPrototypeSpecificInstanceId = (instance) => {
-  const prototype = Object.getPrototypeOf(instance);
-  const instanceCtx = defaultMap(instanceContexts, prototype, () => ({
-    nextId: 0,
-    instanceIds: /* @__PURE__ */ new WeakMap()
-  }));
-  let id = instanceCtx.instanceIds.get(instance);
-  if (id === void 0) {
-    id = instanceCtx.nextId++;
-    instanceCtx.instanceIds.set(instance, id);
-  }
-  return id;
-};
-var getDebugName = (instance) => {
-  if (instance == null) {
-    return "null";
-  }
-  const prototype = Object.getPrototypeOf(instance);
-  return `${prototype.constructor.name}#${getPrototypeSpecificInstanceId(instance)}`;
-};
-
 // packages/common/util/src/sum.ts
 var sum = (values) => values.reduce((a, b) => a + b, 0);
 
-// packages/common/util/src/for-each-async.ts
-var forEachAsync = (items, fn) => Promise.all(items.map(fn));
-
 // packages/common/util/src/weak.ts
 var WeakDictionary = class {
   constructor(entries) {
@@ -1485,222 +1750,6 @@ var WeakDictionary = class {
     this._finalization.unregister(value);
   }
 };
-
-// packages/common/util/src/map-values.ts
-var mapValues = (obj, fn) => {
-  const result = {};
-  Object.keys(obj).forEach((key) => {
-    result[key] = fn(obj[key], key);
-  });
-  return result;
-};
-var deepMapValues = (value, fn) => {
-  return new DeepMapper(fn).map(value);
-};
-var DeepMapper = class {
-  constructor(_fn) {
-    this._fn = _fn;
-    this._cyclic = /* @__PURE__ */ new Map();
-    this._recurse = (value) => {
-      if (this._cyclic.has(value)) {
-        return this._cyclic.get(value);
-      }
-      if (Array.isArray(value)) {
-        const res = new Array(value.length);
-        this._cyclic.set(value, res);
-        for (let i = 0; i < value.length; i++) {
-          res[i] = this.map(value[i]);
-        }
-        return res;
-      } else if (value !== null && typeof value === "object") {
-        const res = {};
-        this._cyclic.set(value, res);
-        for (const key in value) {
-          res[key] = this.map(value[key]);
-        }
-        return res;
-      } else {
-        return value;
-      }
-    };
-  }
-  map(value) {
-    if (this._cyclic.has(value)) {
-      return this._cyclic.get(value);
-    }
-    return this._fn(value, this._recurse);
-  }
-};
-var deepMapValuesAsync = (value, fn) => {
-  return new DeepMapperAsync(fn).map(value);
-};
-var DeepMapperAsync = class {
-  constructor(_fn) {
-    this._fn = _fn;
-    this._cyclic = /* @__PURE__ */ new Map();
-    this._recurse = async (value) => {
-      if (this._cyclic.has(value)) {
-        return this._cyclic.get(value);
-      }
-      if (Array.isArray(value)) {
-        const res = new Array(value.length);
-        this._cyclic.set(value, res);
-        for (let i = 0; i < value.length; i++) {
-          res[i] = await this.map(value[i]);
-        }
-        return res;
-      } else if (value !== null && typeof value === "object") {
-        const res = {};
-        this._cyclic.set(value, res);
-        for (const key in value) {
-          res[key] = await this.map(value[key]);
-        }
-        return res;
-      } else {
-        return value;
-      }
-    };
-  }
-  map(value) {
-    if (this._cyclic.has(value)) {
-      return this._cyclic.get(value);
-    }
-    return this._fn(value, this._recurse);
-  }
-};
-
-// packages/common/util/src/explicit-resource-management-polyfill.ts
-Symbol.dispose ??= Symbol("Symbol.dispose");
-Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
-
-// packages/common/util/src/defer.ts
-var defer = (fn) => new DeferGuard(fn);
-var DeferGuard = class {
-  /**
-  * @internal
-  */
-  constructor(_fn) {
-    this._fn = _fn;
-  }
-  [Symbol.dispose]() {
-    const result = this._fn();
-    if (result instanceof Promise) {
-      throw new Error("Async functions in defer are not supported. Use deferAsync instead.");
-    }
-  }
-};
-var deferAsync = (fn) => new DeferAsyncGuard(fn);
-var DeferAsyncGuard = class {
-  /**
-  * @internal
-  */
-  constructor(_fn) {
-    this._fn = _fn;
-  }
-  async [Symbol.asyncDispose]() {
-    await this._fn();
-  }
-};
-
-// packages/common/util/src/circular-buffer.ts
-import { invariant as invariant4 } from "@dxos/invariant";
-var __dxlog_file4 = "/home/runner/work/dxos/dxos/packages/common/util/src/circular-buffer.ts";
-var CircularBuffer = class {
-  constructor(size) {
-    this._nextIndex = 0;
-    this._elementCount = 0;
-    invariant4(size >= 1, void 0, {
-      F: __dxlog_file4,
-      L: 13,
-      S: this,
-      A: [
-        "size >= 1",
-        ""
-      ]
-    });
-    this._buffer = new Array(size);
-  }
-  push(element) {
-    this._buffer[this._nextIndex] = element;
-    this._nextIndex = (this._nextIndex + 1) % this._buffer.length;
-    this._elementCount = Math.min(this._buffer.length, this._elementCount + 1);
-  }
-  getLast() {
-    if (this._elementCount === 0) {
-      return void 0;
-    }
-    if (this._nextIndex === 0) {
-      return this._buffer[this._buffer.length - 1];
-    }
-    return this._buffer[this._nextIndex - 1];
-  }
-  [Symbol.iterator]() {
-    return this.values();
-  }
-  *values() {
-    if (this._elementCount === 0) {
-      return;
-    }
-    if (this._elementCount < this._buffer.length) {
-      for (let i = 0; i < this._elementCount; i++) {
-        yield this._buffer[i];
-      }
-      return;
-    }
-    for (let i = this._nextIndex; i < this._buffer.length; i++) {
-      yield this._buffer[i];
-    }
-    for (let i = 0; i < this._nextIndex; i++) {
-      yield this._buffer[i];
-    }
-  }
-};
-
-// packages/common/util/src/join-tables.ts
-var joinTables = (leftColumn, rightColumn, left, right) => {
-  const map = /* @__PURE__ */ new Map();
-  const used = /* @__PURE__ */ new Set();
-  for (const row of right) {
-    map.set(row[rightColumn], row);
-  }
-  const result = [];
-  for (const row of left) {
-    const right2 = map.get(row[leftColumn]);
-    used.add(right2);
-    result.push(Object.assign(right2 ?? {}, row));
-  }
-  for (const row of right) {
-    if (!used.has(row)) {
-      result.push(row);
-    }
-  }
-  return result;
-};
-
-// packages/common/util/src/throw-unhandled-error.ts
-var throwUnhandledError = (error) => {
-  queueMicrotask(() => {
-    throw error;
-  });
-};
-
-// packages/common/util/src/safe-await.ts
-var safeAwaitAll = async (source, taskFactory, onError) => {
-  const failedItems = [];
-  await Promise.all([
-    ...source
-  ].map(async (item, idx) => {
-    try {
-      await taskFactory(item);
-    } catch (err) {
-      if (onError) {
-        onError(err, item, idx);
-      }
-      failedItems.push(item);
-    }
-  }));
-  return failedItems;
-};
 export {
   BitField,
   Callback,
@@ -1709,6 +1758,8 @@ export {
   ComplexSet,
   HumanHasher,
   MapEntry,
+  ParamKeyAnnotation,
+  Params,
   Tracer,
   WeakDictionary,
   accessBy,