@dxos/util 0.5.9-next.a50ff17 → 0.6.0

package/dist/lib/node/index.cjs

@@ -35,6 +35,8 @@ __export(node_exports, {
   ComplexSet: () => ComplexSet,
   HumanHasher: () => HumanHasher,
   MapEntry: () => MapEntry,
+  ParamKeyAnnotation: () => ParamKeyAnnotation,
+  Params: () => Params,
   Tracer: () => Tracer,
   WeakDictionary: () => WeakDictionary,
   accessBy: () => accessBy,
@@ -123,12 +125,14 @@ var import_invariant = require("@dxos/invariant");
 var import_node_util = __toESM(require("node:util"));
 var import_invariant2 = require("@dxos/invariant");
 var import_invariant3 = require("@dxos/invariant");
+var import_invariant4 = require("@dxos/invariant");
 var import_node_util2 = require("node:util");
 var import_debug = require("@dxos/debug");
 var import_keys = require("@dxos/keys");
 var import_node_util3 = require("node:util");
 var import_keys2 = require("@dxos/keys");
-var import_invariant4 = require("@dxos/invariant");
+var import_schema = require("@effect/schema");
+var import_xcase = require("xcase");
 var diff = (previous, next, comparator) => {
   const remaining = [
     ...previous
@@ -307,6 +311,57 @@ var createSetDispatch = ({ handlers }) => {
     }
   });
 };
+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;
+    (0, import_invariant4.invariant)(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];
+    }
+  }
+};
 var MAX_SERIALIZATION_LENGTH = 10;
 var ComplexSet = class {
   // prettier-ignore
@@ -468,203 +523,55 @@ var makeMap = (keyProjection) => class BoundComplexMap extends ComplexMap {
     super(keyProjection, entries);
   }
 };
-var deferFunction = (fnProvider) => (...args) => fnProvider()(...args);
-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)
-});
-var entry = (map, key) => new MapEntry(map, key);
-var MapEntry = class {
+Symbol.dispose ??= Symbol("Symbol.dispose");
+Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
+var defer = (fn) => new DeferGuard(fn);
+var DeferGuard = class {
   /**
   * @internal
   */
-  // prettier-ignore
-  constructor(_map, _key) {
-    this._map = _map;
-    this._key = _key;
-  }
-  get key() {
-    return this._key;
-  }
-  get value() {
-    return this._map.get(this._key);
+  constructor(_fn) {
+    this._fn = _fn;
   }
-  orInsert(value) {
-    if (!this._map.has(this._key)) {
-      this._map.set(this._key, value);
+  [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();
+  }
+};
+var deferFunction = (fnProvider) => (...args) => fnProvider()(...args);
+var entry = (map, key) => new MapEntry(map, key);
+var MapEntry = class {
+  /**
+  * @internal
+  */
+  // prettier-ignore
+  constructor(_map, _key) {
+    this._map = _map;
+    this._key = _key;
+  }
+  get key() {
+    return this._key;
+  }
+  get value() {
+    return this._map.get(this._key);
+  }
+  orInsert(value) {
+    if (!this._map.has(this._key)) {
+      this._map.set(this._key, value);
     }
     return this;
   }
@@ -672,6 +579,7 @@ var MapEntry = class {
     return entry(this.value, key);
   }
 };
+var forEachAsync = (items, fn) => Promise.all(items.map(fn));
 var DEFAULT_WORDLIST = [
   "ack",
   "alabama",
@@ -1010,6 +918,55 @@ var exponentialBackoffInterval = (cb, initialInterval) => {
   let timeoutId = setTimeout(repeat, interval);
   return () => clearTimeout(timeoutId);
 };
+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;
+};
+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)}`;
+};
+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;
+};
 var arraysEqual = (a, b) => {
   if (a.length !== b.length) {
     return false;
@@ -1118,13 +1075,86 @@ var jsonKeyReplacer = (options = {}) => (key, value) => {
   }
   return value;
 };
-var defaultMap = (map, key, def) => {
-  let value = map.get(key);
-  if (value === void 0) {
-    value = typeof def === "function" ? def() : def;
-    map.set(key, value);
+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);
   }
-  return value;
 };
 var inferObjectOrder = (objectMap, order = []) => {
   const orderedObjects = order.reduce((acc, id) => {
@@ -1151,6 +1181,51 @@ var inferRecordOrder = (objectMap, order = []) => {
     return acc;
   }, {}), objectMap);
 };
+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((0, import_xcase.decamelize)(key));
+      if (v == null) {
+        v = url.searchParams.get(key);
+      }
+      if (v != null) {
+        if (import_schema.AST.isNumberKeyword(type.ast)) {
+          acc[key] = parseInt(v);
+        } else if (import_schema.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 } = import_schema.AST.getAnnotation(ParamKeyAnnotationId)(type.ast);
+        const k = alt ?? (0, import_xcase.decamelize)(key);
+        url.searchParams.set(k, String(value));
+      }
+    });
+    return url;
+  }
+};
 var isNode = () => typeof process !== "undefined" && process.versions != null && process.versions.node != null;
 var mobileAndTabletCheck = () => {
   let check = false;
@@ -1286,6 +1361,22 @@ var createBucketReducer = (period) => ({
     return series;
   }
 });
+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;
+};
 var instanceTag = Symbol("instanceTag");
 var safeInstanceof = (tag) => (target) => {
   target.prototype[instanceTag] = tag;
@@ -1325,62 +1416,244 @@ var compareMulti = (sorters) => (a, b) => {
   };
   return sort();
 };
-var Tracer = class {
-  constructor() {
-    this._events = /* @__PURE__ */ new Map();
-    this._recording = false;
-  }
-  // TODO(burdon): Start/stop methods for recording data? By id?
-  //  Alternatively, enable subscriptions to track/compute series.
-  // TODO(burdon): Hierarchical traces?
-  get recording() {
-    return this._recording;
-  }
-  keys() {
-    return Array.from(this._events.keys());
-  }
-  get(id, filter) {
-    const events = this._events.get(id);
-    if (filter) {
-      return events?.filter((event) => Object.entries(filter).every(([key, value]) => event?.value[key] === value));
-    }
-    return events;
-  }
-  clear() {
-    this._events.clear();
-  }
-  start() {
-    this._recording = true;
-    return this;
-  }
-  stop() {
-    this._recording = false;
-    return this;
-  }
-  emit(id, value) {
-    this._post(this._createEvent(id, value));
-  }
-  mark(id, value) {
-    const event = this._createEvent(id, value);
-    const start = performance.now();
-    return {
-      start,
-      end: () => {
-        event.duration = performance.now() - start;
-        this._post(event);
-      }
-    };
-  }
-  _createEvent(id, value) {
-    const event = {
-      id,
-      timestamp: Date.now()
-    };
-    if (value !== void 0) {
-      event.value = value;
-    }
-    return event;
-  }
+var throwUnhandledError = (error) => {
+  queueMicrotask(() => {
+    throw error;
+  });
+};
+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)
+});
+var Tracer = class {
+  constructor() {
+    this._events = /* @__PURE__ */ new Map();
+    this._recording = false;
+  }
+  // TODO(burdon): Start/stop methods for recording data? By id?
+  //  Alternatively, enable subscriptions to track/compute series.
+  // TODO(burdon): Hierarchical traces?
+  get recording() {
+    return this._recording;
+  }
+  keys() {
+    return Array.from(this._events.keys());
+  }
+  get(id, filter) {
+    const events = this._events.get(id);
+    if (filter) {
+      return events?.filter((event) => Object.entries(filter).every(([key, value]) => event?.value[key] === value));
+    }
+    return events;
+  }
+  clear() {
+    this._events.clear();
+  }
+  start() {
+    this._recording = true;
+    return this;
+  }
+  stop() {
+    this._recording = false;
+    return this;
+  }
+  emit(id, value) {
+    this._post(this._createEvent(id, value));
+  }
+  mark(id, value) {
+    const event = this._createEvent(id, value);
+    const start = performance.now();
+    return {
+      start,
+      end: () => {
+        event.duration = performance.now() - start;
+        this._post(event);
+      }
+    };
+  }
+  _createEvent(id, value) {
+    const event = {
+      id,
+      timestamp: Date.now()
+    };
+    if (value !== void 0) {
+      event.value = value;
+    }
+    return event;
+  }
   _post(event) {
     if (this._recording) {
       defaultMap(this._events, event.id, []).push(event);
@@ -1424,30 +1697,7 @@ var safeParseInt = (value, defaultValue) => {
     return defaultValue;
   }
 };
-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)}`;
-};
 var sum = (values) => values.reduce((a, b) => a + b, 0);
-var forEachAsync = (items, fn) => Promise.all(items.map(fn));
 var WeakDictionary = class {
   constructor(entries) {
     this._internal = /* @__PURE__ */ new Map();
@@ -1541,207 +1791,6 @@ var WeakDictionary = class {
     this._finalization.unregister(value);
   }
 };
-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);
-  }
-};
-Symbol.dispose ??= Symbol("Symbol.dispose");
-Symbol.asyncDispose ??= Symbol("Symbol.asyncDispose");
-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();
-  }
-};
-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;
-    (0, import_invariant4.invariant)(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];
-    }
-  }
-};
-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;
-};
-var throwUnhandledError = (error) => {
-  queueMicrotask(() => {
-    throw error;
-  });
-};
-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;
-};
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   BitField,
@@ -1751,6 +1800,8 @@ var safeAwaitAll = async (source, taskFactory, onError) => {
   ComplexSet,
   HumanHasher,
   MapEntry,
+  ParamKeyAnnotation,
+  Params,
   Tracer,
   WeakDictionary,
   accessBy,