use-everywhere 1.0.0 → 1.0.2

package/dist/use-peers-RhIB77TV.cjs

@@ -0,0 +1,380 @@
+'use client';
+let react = require("react");
+let _use_everywhere_core = require("@use-everywhere/core");
+//#region src/dev.ts
+let inDev = false;
+try {
+	inDev = process.env.NODE_ENV !== "production";
+} catch {}
+const warned = /* @__PURE__ */ new Set();
+const DOCS = "https://rxova.org/packages/use-everywhere/errors";
+/**
+* Stamp a diagnostic with its code and the page that explains it. Core's twin
+* of this, for the same reason the twin of `devWarn` exists — see above.
+*
+* Codes are permanent, and a retired one is never reused: an old build in
+* somebody's browser is still emitting it. Core owns UE1xxx, this package
+* UE2xxx.
+*/
+function diagnostic(code, message) {
+	return `[use-everywhere] ${code}: ${message}\n  → ${DOCS}/#${code.toLowerCase()}`;
+}
+/** Warn once per distinct message, development only. */
+function devWarn(code, message) {
+	if (!inDev) return;
+	const line = diagnostic(code, message);
+	if (warned.has(line)) return;
+	warned.add(line);
+	console.warn(line);
+}
+/** The initial each key was first registered with. Populated only in development — dynamic keys would otherwise grow it without bound. */
+const seenInitials = /* @__PURE__ */ new Map();
+/**
+* Catch two callers registering one key with different defaults. The first
+* registration wins and the second is silently discarded, which is the kind of
+* disagreement that surfaces much later as "why is this value not what I set".
+*/
+function warnOnInitialMismatch(storeName, key, initial) {
+	if (!inDev) return;
+	const id = `${storeName} ${key}`;
+	if (!seenInitials.has(id)) {
+		seenInitials.set(id, initial);
+		return;
+	}
+	const first = seenInitials.get(id);
+	const comparable = (v) => v === null || typeof v !== "object";
+	if (comparable(first) && comparable(initial) && !Object.is(first, initial)) devWarn("UE2001", `useSharedState('${key}') was called with different initial values (${String(first)} and ${String(initial)}). The first registration wins, so the second is ignored. Define the default once — createStoreHooks, or a shared constant.`);
+}
+const EMPTY = Object.freeze({});
+const NO_PEERS$1 = Object.freeze([]);
+const noop = () => {};
+const unsubscribe = () => noop;
+/**
+* One frozen object serving as store, presence and leader. Their surfaces do
+* not collide, and a server render never distinguishes two inert engines by
+* identity — so this is a single shared constant rather than three allocations
+* in every bundle that imports a hook.
+*/
+const INERT = Object.freeze({
+	clientId: "",
+	hydrated: Promise.resolve(),
+	state: EMPTY,
+	getVersions: () => EMPTY,
+	set: noop,
+	subscribeKey: unsubscribe,
+	registerKey: noop,
+	getSnapshot: () => EMPTY,
+	getPeers: () => NO_PEERS$1,
+	setMetadata: noop,
+	resign: noop,
+	setEligible: noop,
+	subscribe: unsubscribe,
+	close: noop
+});
+const createServerStore = () => INERT;
+const createServerPresence = () => INERT;
+/**
+* Leadership needs its own snapshot shape, so it wraps the shared constant.
+* `waitForLeadership` never settles on a server: there is no election to win,
+* and resolving would run leader-only work during a render that is about to be
+* thrown away. A pending promise is the honest answer.
+*/
+const NO_LEADER = Object.freeze({
+	leaderId: null,
+	isLeader: false
+});
+const NEVER = () => new Promise(() => {});
+const createServerLeader = () => ({
+	...INERT,
+	strategy: "heartbeat",
+	getSnapshot: () => NO_LEADER,
+	waitForLeadership: NEVER
+});
+/**
+* A reducer carries its initial value, so it allocates too. `dispatch` is a
+* no-op: a server render has no peers to order anything with, and an action
+* applied here would show a value the browser is about to disagree with.
+*/
+const createServerReducer = (initial) => ({
+	...INERT,
+	getSnapshot: () => initial,
+	dispatch: noop,
+	pendingCount: () => 0
+});
+/** Channels carry their name, so this is the one double that allocates. */
+const createServerChannel = (name) => ({
+	...INERT,
+	name,
+	post: noop,
+	on: unsubscribe
+});
+//#endregion
+//#region src/registry.ts
+const stores = /* @__PURE__ */ new Map();
+const presences = /* @__PURE__ */ new Map();
+const channels = /* @__PURE__ */ new Map();
+const leaders = /* @__PURE__ */ new Map();
+const storeConfig = /* @__PURE__ */ new Map();
+/**
+* Checked per call, not captured once: a module evaluated during SSR and a
+* module evaluated in the browser are different module instances, so there is
+* no cache to invalidate — but reading it lazily keeps the bundler from
+* folding the branch away in a build that serves both.
+*/
+const isServer = () => typeof window === "undefined";
+/** Per-scope store creation: what leaves this tab and what is let back in. */
+const scopeOptions = {
+	everywhere: {},
+	tabs: { accept: (meta) => meta.kind !== "worker" },
+	tab: { transport: () => new _use_everywhere_core.NoopTransport() }
+};
+/** Imperative access to the store behind useSharedState (patch logs, non-React code). */
+function getSharedStore(name = _use_everywhere_core.DEFAULT_NAME, scope = "everywhere") {
+	return getStore(name, scope);
+}
+/**
+* Options to build a store with when it is first needed. Registered by
+* createStoreHooks at module scope and consumed by getStore on creation — which is
+* what lets persistence be declared in one place without constructing anything
+* on import.
+*/
+/**
+* A configuration's shape, ignoring the adapter's identity. Hot Module
+* Replacement re-evaluates the defining module and builds a *new* adapter
+* object each time, so identity comparison would call every hot edit a
+* conflict; what actually matters is whether the store would be built
+* differently.
+*/
+function configSignature(options) {
+	const persist = options?.persist;
+	if (!persist) return "none";
+	return `persist:${persist.keys?.join(",") ?? "*"}:${persist.debounceMs ?? "default"}:v${persist.version ?? 0}`;
+}
+function configureStore(name, scope, options) {
+	const key = `${scope} ${name}`;
+	if (stores.has(key)) {
+		if (configSignature(storeConfig.get(key)) === configSignature(options)) return;
+		if (process.env.NODE_ENV !== "production") devWarn("UE2002", `createStoreHooks('${name}') ran after that store was already created, with different options. The live store keeps the configuration it was built with. Move createStoreHooks to module scope, before any component reads the store.`);
+		return;
+	}
+	storeConfig.set(key, options);
+}
+function getStore(name, scope = "everywhere") {
+	const key = `${scope} ${name}`;
+	let store = stores.get(key);
+	if (!store) {
+		store = isServer() ? createServerStore() : (0, _use_everywhere_core.createSharedStore)(name, {}, {
+			...scopeOptions[scope],
+			...storeConfig.get(key)
+		});
+		stores.set(key, store);
+	}
+	return store;
+}
+/**
+* One Presence per name per tab.
+*
+* `includeSelf` is part of the key rather than the options, because it changes
+* what the roster *is*: two components on one name disagreeing about it would
+* otherwise silently get whichever answer was built first.
+*/
+function getPresence(name, includeSelf = false) {
+	const key = includeSelf ? `self ${name}` : name;
+	let presence = presences.get(key);
+	if (!presence) {
+		presence = isServer() ? createServerPresence() : (0, _use_everywhere_core.createPresence)(name, { includeSelf });
+		presences.set(key, presence);
+	}
+	return presence;
+}
+/**
+* One Leader per name per tab. Eligibility is deliberately *not* part of the
+* key: two Leaders on one name would share a bus and a clientId, and since a
+* post never loops back locally, neither would ever see the other's claims.
+* Timing options are first-wins, like every other engine here.
+*/
+function getLeader(name, options) {
+	let leader = leaders.get(name);
+	if (!leader) {
+		leader = isServer() ? createServerLeader() : (0, _use_everywhere_core.createLeader)(name, options);
+		leaders.set(name, leader);
+		if (options) leaderOptions.set(name, options);
+	} else if (options) warnOnLeaderOptionConflict(name, options);
+	return leader;
+}
+/** What the first caller elected with, so a later caller asking for different timings can be told it was ignored. */
+const leaderOptions = /* @__PURE__ */ new Map();
+function warnOnLeaderOptionConflict(name, options) {
+	const first = leaderOptions.get(name);
+	for (const key of ["heartbeatMs", "leaseMs"]) {
+		const requested = options[key];
+		if (requested !== void 0 && requested !== first?.[key]) {
+			if (process.env.NODE_ENV !== "production") devWarn("UE2003", `leader "${name}": ${key} ignored — the first useLeader/getLeader call fixes the election timings for this tab.`);
+		}
+	}
+}
+/**
+* Options to build a channel with when it is first needed. Registered by
+* defineChannel at module scope and consumed by getChannel on creation — the
+* same deferral createStoreHooks uses, so declaring a schema constructs nothing on
+* import.
+*/
+const channelConfig = /* @__PURE__ */ new Map();
+function configureChannel(name, options) {
+	if (channels.has(name)) {
+		const before = Object.keys(channelConfig.get(name)?.schema ?? {}).sort();
+		const after = Object.keys(options.schema ?? {}).sort();
+		if (before.join() === after.join()) return;
+		if (process.env.NODE_ENV !== "production") devWarn("UE2004", `defineChannel('${name}') ran after that channel was already created, with different options. The live channel keeps the configuration it was built with. Move defineChannel to module scope, before any component sends or receives on it.`);
+		return;
+	}
+	channelConfig.set(name, options);
+}
+const reducers = /* @__PURE__ */ new Map();
+/**
+* One reducer per name+key per tab, like every other engine here.
+*
+* The reducer is handed this tab's existing `Leader` rather than electing its
+* own: the leader is the sequencer, and a page that already has a seat for this
+* bus must not run a second election to get another one.
+*
+* The first caller's reducer function wins. A hook re-renders with a new
+* function identity every time, and swapping the fold under a history that has
+* already been applied would give this tab a different answer from its peers —
+* which is the one thing an ordered reducer exists to prevent.
+*/
+function getReducer(name, key, reducer, initial) {
+	const id = `${name} ${key}`;
+	let existing = reducers.get(id);
+	if (!existing) {
+		existing = isServer() ? createServerReducer(initial) : (0, _use_everywhere_core.createSharedReducer)(name, reducer, initial, {
+			key,
+			leader: getLeader(name)
+		});
+		reducers.set(id, existing);
+	}
+	return existing;
+}
+function getChannel(name) {
+	let channel = channels.get(name);
+	if (!channel) {
+		channel = isServer() ? createServerChannel(name) : (0, _use_everywhere_core.createChannel)(name, channelConfig.get(name));
+		channels.set(name, channel);
+	}
+	return channel;
+}
+//#endregion
+//#region src/use-peers.ts
+const NO_PEERS = Object.freeze([]);
+/**
+* The tabs/windows/workers currently alive on this origin.
+*
+* Each peer carries whatever it published about itself as `metadata` — see
+* {@link usePresenceMetadata} for publishing this client's.
+*/
+function usePeers(options) {
+	const presence = getPresence(options?.name ?? _use_everywhere_core.DEFAULT_NAME, options?.includeSelf ?? false);
+	return (0, react.useSyncExternalStore)((0, react.useCallback)((onChange) => presence.subscribe(onChange), [presence]), () => presence.getPeers(), () => NO_PEERS);
+}
+/**
+* This client's own id on the presence bus (matches patch origin ids).
+*
+* Read through useSyncExternalStore rather than returned straight from render,
+* because the id is minted per environment: a server would render one value and
+* the browser a different one, and any component that puts it in the DOM would
+* mismatch on hydration. The server snapshot is a constant empty string, which
+* React also uses for the client's hydrating render, so markup matches; the
+* real id arrives in the commit straight after. Treat `''` as "not known yet".
+*/
+function useClientId(options) {
+	const presence = getPresence(options?.name ?? _use_everywhere_core.DEFAULT_NAME);
+	return (0, react.useSyncExternalStore)((0, react.useCallback)(() => () => {}, [presence]), () => presence.clientId, () => "");
+}
+/**
+* Publish what this client wants peers to know about it — a display name, a tab
+* title, a cursor.
+*
+* Safe to call with a fresh object every render: the value is compared by
+* contents, so an unchanged one announces nothing and re-renders nobody.
+*
+* ```tsx
+* usePresenceMetadata({ name: user.name, editing: currentDocId });
+* ```
+*
+* Published in an effect rather than during render, because announcing is a
+* side effect on every other tab — and a render that React throws away must not
+* be one other tabs already saw.
+*/
+function usePresenceMetadata(metadata, options) {
+	const presence = getPresence(options?.name ?? _use_everywhere_core.DEFAULT_NAME, options?.includeSelf ?? false);
+	(0, react.useEffect)(() => {
+		presence.setMetadata(metadata);
+	}, [presence, metadata]);
+}
+//#endregion
+Object.defineProperty(exports, "configureChannel", {
+	enumerable: true,
+	get: function() {
+		return configureChannel;
+	}
+});
+Object.defineProperty(exports, "configureStore", {
+	enumerable: true,
+	get: function() {
+		return configureStore;
+	}
+});
+Object.defineProperty(exports, "getChannel", {
+	enumerable: true,
+	get: function() {
+		return getChannel;
+	}
+});
+Object.defineProperty(exports, "getLeader", {
+	enumerable: true,
+	get: function() {
+		return getLeader;
+	}
+});
+Object.defineProperty(exports, "getReducer", {
+	enumerable: true,
+	get: function() {
+		return getReducer;
+	}
+});
+Object.defineProperty(exports, "getSharedStore", {
+	enumerable: true,
+	get: function() {
+		return getSharedStore;
+	}
+});
+Object.defineProperty(exports, "getStore", {
+	enumerable: true,
+	get: function() {
+		return getStore;
+	}
+});
+Object.defineProperty(exports, "useClientId", {
+	enumerable: true,
+	get: function() {
+		return useClientId;
+	}
+});
+Object.defineProperty(exports, "usePeers", {
+	enumerable: true,
+	get: function() {
+		return usePeers;
+	}
+});
+Object.defineProperty(exports, "usePresenceMetadata", {
+	enumerable: true,
+	get: function() {
+		return usePresenceMetadata;
+	}
+});
+Object.defineProperty(exports, "warnOnInitialMismatch", {
+	enumerable: true,
+	get: function() {
+		return warnOnInitialMismatch;
+	}
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "use-everywhere",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "React hooks for state and messages shared across tabs, windows, and workers",
   "license": "MIT",
   "author": "Jonatan Kruszewski <jonakrusze@gmail.com>",
@@ -170,7 +170,7 @@
     }
   ],
   "dependencies": {
-    "@use-everywhere/core": "1.0.0"
+    "@use-everywhere/core": "1.0.2"
   },
   "peerDependencies": {
     "react": ">=18",
@@ -193,9 +193,10 @@
     "react": "^19.2.8",
     "react-dom": "^19.2.8",
     "size-limit": "^13.0.3",
-    "tsup": "^8.5.1",
+    "tsdown": "^0.23.0",
     "typescript": "^6.0.3",
-    "vitest": "^4.1.11"
+    "vitest": "^4.1.11",
+    "@repo/config": "0.0.0"
   },
   "typesVersions": {
     "*": {
@@ -211,7 +212,7 @@
     }
   },
   "scripts": {
-    "build": "tsup",
+    "build": "tsdown",
     "test": "vitest run --coverage",
     "typecheck": "tsc --noEmit",
     "size": "size-limit",

package/dist/chunk-YPQ6PLD5.js

@@ -1,259 +0,0 @@
-'use client';
-
-// src/registry.ts
-import {
-  createChannel,
-  createLeader,
-  createPresence,
-  createSharedReducer,
-  createSharedStore,
-  DEFAULT_NAME,
-  NoopTransport
-} from "@use-everywhere/core";
-
-// src/dev.ts
-var inDev = false;
-try {
-  inDev = process.env.NODE_ENV !== "production";
-} catch {
-}
-var warned = /* @__PURE__ */ new Set();
-var DOCS = "https://rxova.org/packages/use-everywhere/errors";
-function diagnostic(code, message) {
-  return `[use-everywhere] ${code}: ${message}
-  \u2192 ${DOCS}/#${code.toLowerCase()}`;
-}
-function devWarn(code, message) {
-  if (!inDev) return;
-  const line = diagnostic(code, message);
-  if (warned.has(line)) return;
-  warned.add(line);
-  console.warn(line);
-}
-var seenInitials = /* @__PURE__ */ new Map();
-function warnOnInitialMismatch(storeName, key, initial) {
-  if (!inDev) return;
-  const id = `${storeName} ${key}`;
-  if (!seenInitials.has(id)) {
-    seenInitials.set(id, initial);
-    return;
-  }
-  const first = seenInitials.get(id);
-  const comparable = (v) => v === null || typeof v !== "object";
-  if (comparable(first) && comparable(initial) && !Object.is(first, initial)) {
-    devWarn(
-      "UE2001",
-      `useSharedState('${key}') was called with different initial values (${String(first)} and ${String(initial)}). The first registration wins, so the second is ignored. Define the default once \u2014 createStoreHooks, or a shared constant.`
-    );
-  }
-}
-
-// src/server-stubs.ts
-var SERVER_CLIENT_ID = "";
-var EMPTY = Object.freeze({});
-var NO_PEERS = Object.freeze([]);
-var noop = () => {
-};
-var unsubscribe = () => noop;
-var INERT = Object.freeze({
-  clientId: SERVER_CLIENT_ID,
-  // store
-  //
-  // Resolved, unlike the leader's `waitForLeadership` below. A server render
-  // has nothing to restore and is documented to render defaults, so `await
-  // store.hydrated` must proceed — a never-settling promise would hang the
-  // render rather than describe it honestly.
-  hydrated: Promise.resolve(),
-  state: EMPTY,
-  getVersions: () => EMPTY,
-  set: noop,
-  subscribeKey: unsubscribe,
-  registerKey: noop,
-  // store + leader share getSnapshot; presence has getPeers
-  getSnapshot: () => EMPTY,
-  getPeers: () => NO_PEERS,
-  // presence
-  setMetadata: noop,
-  // leader
-  resign: noop,
-  setEligible: noop,
-  // common
-  subscribe: unsubscribe,
-  close: noop
-});
-var createServerStore = () => INERT;
-var createServerPresence = () => INERT;
-var NO_LEADER = Object.freeze({ leaderId: null, isLeader: false });
-var NEVER = () => new Promise(() => {
-});
-var createServerLeader = () => ({
-  ...INERT,
-  strategy: "heartbeat",
-  getSnapshot: () => NO_LEADER,
-  waitForLeadership: NEVER
-});
-var createServerReducer = (initial) => ({
-  ...INERT,
-  getSnapshot: () => initial,
-  dispatch: noop,
-  pendingCount: () => 0
-});
-var createServerChannel = (name) => ({ ...INERT, name, post: noop, on: unsubscribe });
-
-// src/registry.ts
-var stores = /* @__PURE__ */ new Map();
-var presences = /* @__PURE__ */ new Map();
-var channels = /* @__PURE__ */ new Map();
-var leaders = /* @__PURE__ */ new Map();
-var storeConfig = /* @__PURE__ */ new Map();
-var isServer = () => typeof window === "undefined";
-var scopeOptions = {
-  everywhere: {},
-  tabs: { accept: (meta) => meta.kind !== "worker" },
-  tab: { transport: () => new NoopTransport() }
-};
-function getSharedStore(name = DEFAULT_NAME, scope = "everywhere") {
-  return getStore(name, scope);
-}
-function configSignature(options) {
-  const persist = options?.persist;
-  if (!persist) return "none";
-  return `persist:${persist.keys?.join(",") ?? "*"}:${persist.debounceMs ?? "default"}:v${persist.version ?? 0}`;
-}
-function configureStore(name, scope, options) {
-  const key = `${scope} ${name}`;
-  if (stores.has(key)) {
-    if (configSignature(storeConfig.get(key)) === configSignature(options)) return;
-    if (process.env.NODE_ENV !== "production") {
-      devWarn(
-        "UE2002",
-        `createStoreHooks('${name}') ran after that store was already created, with different options. The live store keeps the configuration it was built with. Move createStoreHooks to module scope, before any component reads the store.`
-      );
-    }
-    return;
-  }
-  storeConfig.set(key, options);
-}
-function getStore(name, scope = "everywhere") {
-  const key = `${scope} ${name}`;
-  let store = stores.get(key);
-  if (!store) {
-    store = isServer() ? createServerStore() : createSharedStore(name, {}, { ...scopeOptions[scope], ...storeConfig.get(key) });
-    stores.set(key, store);
-  }
-  return store;
-}
-function getPresence(name, includeSelf = false) {
-  const key = includeSelf ? `self ${name}` : name;
-  let presence = presences.get(key);
-  if (!presence) {
-    presence = isServer() ? createServerPresence() : createPresence(name, { includeSelf });
-    presences.set(key, presence);
-  }
-  return presence;
-}
-function getLeader(name, options) {
-  let leader = leaders.get(name);
-  if (!leader) {
-    leader = isServer() ? createServerLeader() : createLeader(name, options);
-    leaders.set(name, leader);
-    if (options) leaderOptions.set(name, options);
-  } else if (options) {
-    warnOnLeaderOptionConflict(name, options);
-  }
-  return leader;
-}
-var leaderOptions = /* @__PURE__ */ new Map();
-function warnOnLeaderOptionConflict(name, options) {
-  const first = leaderOptions.get(name);
-  for (const key of ["heartbeatMs", "leaseMs"]) {
-    const requested = options[key];
-    if (requested !== void 0 && requested !== first?.[key]) {
-      if (process.env.NODE_ENV !== "production") {
-        devWarn(
-          "UE2003",
-          `leader "${name}": ${key} ignored \u2014 the first useLeader/getLeader call fixes the election timings for this tab.`
-        );
-      }
-    }
-  }
-}
-var channelConfig = /* @__PURE__ */ new Map();
-function configureChannel(name, options) {
-  if (channels.has(name)) {
-    const before = Object.keys(channelConfig.get(name)?.schema ?? {}).sort();
-    const after = Object.keys(options.schema ?? {}).sort();
-    if (before.join() === after.join()) return;
-    if (process.env.NODE_ENV !== "production") {
-      devWarn(
-        "UE2004",
-        `defineChannel('${name}') ran after that channel was already created, with different options. The live channel keeps the configuration it was built with. Move defineChannel to module scope, before any component sends or receives on it.`
-      );
-    }
-    return;
-  }
-  channelConfig.set(name, options);
-}
-var reducers = /* @__PURE__ */ new Map();
-function getReducer(name, key, reducer, initial) {
-  const id = `${name} ${key}`;
-  let existing = reducers.get(id);
-  if (!existing) {
-    existing = isServer() ? createServerReducer(initial) : createSharedReducer(name, reducer, initial, { key, leader: getLeader(name) });
-    reducers.set(id, existing);
-  }
-  return existing;
-}
-function getChannel(name) {
-  let channel = channels.get(name);
-  if (!channel) {
-    channel = isServer() ? createServerChannel(name) : createChannel(name, channelConfig.get(name));
-    channels.set(name, channel);
-  }
-  return channel;
-}
-
-// src/use-peers.ts
-import { useCallback, useEffect, useSyncExternalStore } from "react";
-var NO_PEERS2 = Object.freeze([]);
-function usePeers(options) {
-  const presence = getPresence(options?.name ?? DEFAULT_NAME, options?.includeSelf ?? false);
-  return useSyncExternalStore(
-    useCallback((onChange) => presence.subscribe(onChange), [presence]),
-    () => presence.getPeers(),
-    () => NO_PEERS2
-  );
-}
-function useClientId(options) {
-  const presence = getPresence(options?.name ?? DEFAULT_NAME);
-  return useSyncExternalStore(
-    // The id never changes for the life of a presence engine, so there is
-    // nothing to subscribe to — but uSES still needs the post-hydration read,
-    // which it performs when it attaches this subscription.
-    useCallback(() => () => {
-    }, [presence]),
-    () => presence.clientId,
-    () => SERVER_CLIENT_ID
-  );
-}
-function usePresenceMetadata(metadata, options) {
-  const presence = getPresence(options?.name ?? DEFAULT_NAME, options?.includeSelf ?? false);
-  useEffect(() => {
-    presence.setMetadata(metadata);
-  }, [presence, metadata]);
-}
-
-export {
-  warnOnInitialMismatch,
-  DEFAULT_NAME,
-  getSharedStore,
-  configureStore,
-  getStore,
-  getLeader,
-  configureChannel,
-  getReducer,
-  getChannel,
-  usePeers,
-  useClientId,
-  usePresenceMetadata
-};