@dxos/react-ui-attention 0.9.0 → 0.9.1-main.c7dcc2e112

package/dist/lib/node-esm/chunk-HWN7KJDX.mjs

@@ -0,0 +1,436 @@
+import { createRequire } from 'node:module';const require = createRequire(import.meta.url);
+
+// src/attention.ts
+import { Atom } from "@effect-atom/atom-react";
+var AttentionManager = class {
+  _registry;
+  _map = /* @__PURE__ */ new Map();
+  _currentAtom;
+  constructor(_registry, initial = []) {
+    this._registry = _registry;
+    this._currentAtom = Atom.make([]).pipe(Atom.keepAlive);
+    if (initial.length > 0) {
+      this.update(initial);
+    }
+  }
+  /**
+  * Atom for the currently attended element IDs.
+  */
+  get current() {
+    return this._currentAtom;
+  }
+  /**
+  * Gets the currently attended element IDs.
+  */
+  getCurrent() {
+    return this._registry.get(this._currentAtom);
+  }
+  /**
+  * Subscribe to changes in the current attention IDs.
+  */
+  subscribeCurrent(cb) {
+    this._registry.get(this._currentAtom);
+    return this._registry.subscribe(this._currentAtom, () => {
+      cb(this._registry.get(this._currentAtom));
+    });
+  }
+  /**
+  * All tracked qualified IDs.
+  */
+  keys() {
+    return Array.from(this._map.keys());
+  }
+  /**
+  * Get the attention state for a given qualified ID.
+  */
+  get(id) {
+    const atom = this._getAtom(id);
+    return this._registry.get(atom);
+  }
+  /**
+  * Subscribe to changes in the attention state for a given qualified ID.
+  */
+  subscribe(id, cb) {
+    const atom = this._getAtom(id);
+    this._registry.get(atom);
+    return this._registry.subscribe(atom, () => {
+      cb(this._registry.get(atom));
+    });
+  }
+  _getAtom(id) {
+    const existing = this._map.get(id);
+    if (existing) {
+      return existing;
+    }
+    const newAtom = Atom.make({
+      hasAttention: false,
+      isAncestor: false,
+      isRelated: false
+    }).pipe(Atom.keepAlive);
+    this._map.set(id, newAtom);
+    return newAtom;
+  }
+  /**
+  * Update the currently attended element.
+  * Takes the array of qualified IDs collected from the DOM; the first element is the primary attended item.
+  * Ancestry is derived from the progressive prefixes of the primary ID.
+  * Relatedness is derived from the segment ID: any tracked key whose last `/` segment matches the
+  * attended ID's segment ID is marked `isRelated`. Additionally, if the primary ID is a linked segment
+  * (starts with `~`), its immediate parent gets `isRelated` alongside `isAncestor`.
+  *
+  * @internal
+  */
+  update(nextIds) {
+    const primaryId = nextIds[0];
+    if (!primaryId) {
+      return;
+    }
+    const currentIds = this.getCurrent();
+    const prevPrimaryId = currentIds[0];
+    if (prevPrimaryId) {
+      const prevPrefixes = expandAttendableId(prevPrimaryId);
+      for (const prefix of prevPrefixes) {
+        this._set(prefix, {});
+      }
+      const prevSegmentId = getSegmentId(prevPrimaryId);
+      for (const key of this.keys()) {
+        if (getSegmentId(key) === prevSegmentId) {
+          this._set(key, {});
+        }
+      }
+    }
+    this._registry.set(this._currentAtom, nextIds);
+    const prefixes = expandAttendableId(primaryId);
+    const prefixSet = new Set(prefixes);
+    const linkedParent = isLinkedSegment(primaryId) ? getParentId(primaryId) : void 0;
+    for (const prefix of prefixes) {
+      if (prefix === primaryId) {
+        this._set(prefix, {
+          hasAttention: true
+        });
+      } else if (prefix === linkedParent) {
+        this._set(prefix, {
+          isAncestor: true,
+          isRelated: true
+        });
+      } else {
+        this._set(prefix, {
+          isAncestor: true
+        });
+      }
+    }
+    const segmentId = getSegmentId(primaryId);
+    for (const key of this.keys()) {
+      if (!prefixSet.has(key) && getSegmentId(key) === segmentId) {
+        this._set(key, {
+          isRelated: true
+        });
+      }
+    }
+  }
+  _set(id, attention) {
+    const atom = this._getAtom(id);
+    this._registry.set(atom, {
+      hasAttention: attention.hasAttention ?? false,
+      isAncestor: attention.isAncestor ?? false,
+      isRelated: attention.isRelated ?? false
+    });
+  }
+};
+var getAttendables = (selector, cursor, acc = []) => {
+  const closestAttendable = cursor.closest(selector);
+  if (closestAttendable) {
+    const attendableId = closestAttendable.getAttribute("data-attendable-id");
+    if (!attendableId) {
+      const trigger = document.querySelector(`[aria-controls="${closestAttendable.getAttribute("id")}"]`);
+      if (!trigger) {
+        return acc;
+      } else {
+        return getAttendables(selector, trigger, acc);
+      }
+    } else {
+      acc.push(attendableId);
+      return !closestAttendable.parentElement ? acc : getAttendables(selector, closestAttendable.parentElement, acc);
+    }
+  }
+  return [
+    ...new Set(acc)
+  ];
+};
+var LINKED_PREFIX = "~";
+var expandAttendableId = (qualifiedId) => {
+  const segments = qualifiedId.split("/");
+  return segments.map((_, index) => segments.slice(0, index + 1).join("/"));
+};
+var isLinkedSegment = (qualifiedId) => {
+  const lastSegment = qualifiedId.split("/").pop() ?? "";
+  return lastSegment.startsWith(LINKED_PREFIX);
+};
+var linkedSegment = (variant) => `${LINKED_PREFIX}${variant}`;
+var getLinkedVariant = (qualifiedId) => {
+  const lastSegment = qualifiedId.split("/").pop() ?? "";
+  return lastSegment.startsWith(LINKED_PREFIX) ? lastSegment.slice(LINKED_PREFIX.length) : lastSegment;
+};
+var getParentId = (qualifiedId) => {
+  if (!qualifiedId) {
+    return void 0;
+  }
+  const lastSlash = qualifiedId.lastIndexOf("/");
+  return lastSlash > 0 ? qualifiedId.slice(0, lastSlash) : void 0;
+};
+var getSegmentId = (qualifiedId) => {
+  return qualifiedId.split("/").pop() ?? qualifiedId;
+};
+
+// src/view-state/view-state.ts
+var defineViewState = (def) => def;
+var ViewStateManager = class {
+  #registry;
+  #backends;
+  constructor({ registry, backends }) {
+    this.#registry = registry;
+    this.#backends = backends;
+  }
+  /** Reactive atom for `(aspect, contextId)`; pass to `registry.get` inside derived atoms/hooks. */
+  atom(aspect, contextId) {
+    return this.#backends[aspect.backend].atom(aspect, contextId);
+  }
+  get(aspect, contextId) {
+    return this.#registry.get(this.atom(aspect, contextId));
+  }
+  set(aspect, contextId, value) {
+    const backend = this.#backends[aspect.backend];
+    this.#registry.set(backend.atom(aspect, contextId), value);
+    backend.persist?.(aspect, contextId, value);
+  }
+  update(aspect, contextId, fn) {
+    this.set(aspect, contextId, fn(this.get(aspect, contextId)));
+  }
+  subscribe(aspect, contextId, cb) {
+    const atom = this.atom(aspect, contextId);
+    return this.#registry.subscribe(atom, () => cb(this.#registry.get(atom)));
+  }
+  contexts(aspect) {
+    return this.#backends[aspect.backend].contexts(aspect);
+  }
+};
+
+// src/view-state/backends.ts
+import { Atom as Atom2 } from "@effect-atom/atom-react";
+import * as Schema from "effect/Schema";
+var cacheKey = (aspect, contextId) => `${aspect.key}:${contextId}`;
+var MemoryBackend = class {
+  #atoms = /* @__PURE__ */ new Map();
+  atom(aspect, contextId) {
+    const key = cacheKey(aspect, contextId);
+    let atom = this.#atoms.get(key);
+    if (!atom) {
+      atom = Atom2.make(aspect.defaultValue());
+      this.#atoms.set(key, atom);
+    }
+    return atom;
+  }
+  contexts(aspect) {
+    const prefix = `${aspect.key}:`;
+    return [
+      ...this.#atoms.keys()
+    ].filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));
+  }
+};
+var STORAGE_PREFIX = "dxos:view-state:";
+var storageKeyFor = (aspect, contextId) => `${STORAGE_PREFIX}${aspect.key}:${contextId}`;
+var safeLocalStorage = () => {
+  try {
+    return globalThis.localStorage;
+  } catch {
+    return void 0;
+  }
+};
+var LocalBackend = class {
+  #registry;
+  // Absent in non-browser contexts (SSR/tests without injection); the backend then degrades to
+  // ephemeral, in-memory behaviour rather than crashing on a missing `localStorage`.
+  #storage;
+  #atoms = /* @__PURE__ */ new Map();
+  // Reverse map: storage key -> (aspect, contextId) so `storage` events can target the right atom.
+  #byStorageKey = /* @__PURE__ */ new Map();
+  #storageListener;
+  constructor({ registry, storage }) {
+    this.#registry = registry;
+    this.#storage = storage ?? safeLocalStorage();
+    if (this.#storage && typeof globalThis.addEventListener === "function") {
+      this.#storageListener = (event) => {
+        if (!event.key || !event.key.startsWith(STORAGE_PREFIX)) {
+          return;
+        }
+        const entry = this.#byStorageKey.get(event.key);
+        const atom = entry && this.#atoms.get(cacheKey(entry.aspect, entry.contextId));
+        if (entry && atom) {
+          this.#registry.set(atom, this.#read(entry.aspect, event.key));
+        }
+      };
+      globalThis.addEventListener("storage", this.#storageListener);
+    }
+  }
+  atom(aspect, contextId) {
+    const key = cacheKey(aspect, contextId);
+    let atom = this.#atoms.get(key);
+    if (!atom) {
+      const storageKey = storageKeyFor(aspect, contextId);
+      atom = Atom2.make(this.#read(aspect, storageKey));
+      this.#atoms.set(key, atom);
+      this.#byStorageKey.set(storageKey, {
+        aspect,
+        contextId
+      });
+    }
+    return atom;
+  }
+  persist(aspect, contextId, value) {
+    this.#storage?.setItem(storageKeyFor(aspect, contextId), JSON.stringify(Schema.encodeSync(aspect.schema)(value)));
+  }
+  contexts(aspect) {
+    if (!this.#storage) {
+      const prefix2 = `${aspect.key}:`;
+      return [
+        ...this.#atoms.keys()
+      ].filter((key) => key.startsWith(prefix2)).map((key) => key.slice(prefix2.length));
+    }
+    const prefix = storageKeyFor(aspect, "");
+    const ids = [];
+    for (let index = 0; index < this.#storage.length; index++) {
+      const key = this.#storage.key(index);
+      if (key?.startsWith(prefix)) {
+        ids.push(key.slice(prefix.length));
+      }
+    }
+    return ids;
+  }
+  dispose() {
+    if (this.#storageListener && typeof globalThis.removeEventListener === "function") {
+      globalThis.removeEventListener("storage", this.#storageListener);
+    }
+    this.#atoms.clear();
+    this.#byStorageKey.clear();
+  }
+  #read(aspect, storageKey) {
+    const raw = this.#storage?.getItem(storageKey);
+    if (raw == null) {
+      return aspect.defaultValue();
+    }
+    try {
+      return Schema.decodeUnknownSync(aspect.schema)(JSON.parse(raw));
+    } catch {
+      return aspect.defaultValue();
+    }
+  }
+};
+var createDefaultBackends = (registry) => ({
+  memory: new MemoryBackend(),
+  local: new LocalBackend({
+    registry
+  })
+});
+
+// src/selection.ts
+import * as Match from "effect/Match";
+import * as Schema2 from "effect/Schema";
+var SelectionSchema = Schema2.Union(Schema2.Struct({
+  mode: Schema2.Literal("single"),
+  id: Schema2.optional(Schema2.String)
+}).pipe(Schema2.mutable), Schema2.Struct({
+  mode: Schema2.Literal("multi"),
+  ids: Schema2.Array(Schema2.String).pipe(Schema2.mutable)
+}).pipe(Schema2.mutable), Schema2.Struct({
+  mode: Schema2.Literal("range"),
+  from: Schema2.optional(Schema2.String),
+  to: Schema2.optional(Schema2.String)
+}).pipe(Schema2.mutable), Schema2.Struct({
+  mode: Schema2.Literal("multi-range"),
+  ranges: Schema2.Array(Schema2.Struct({
+    from: Schema2.String,
+    to: Schema2.String
+  })).pipe(Schema2.mutable)
+}).pipe(Schema2.mutable)).pipe(Schema2.mutable);
+var defaultSelection = Match.type().pipe(Match.withReturnType(), Match.when("single", () => ({
+  mode: "single"
+})), Match.when("multi", () => ({
+  mode: "multi",
+  ids: []
+})), Match.when("range", () => ({
+  mode: "range"
+})), Match.when("multi-range", () => ({
+  mode: "multi-range",
+  ranges: []
+})), Match.exhaustive);
+var selectionAspect = defineViewState({
+  key: "selection",
+  backend: "memory",
+  schema: SelectionSchema,
+  defaultValue: () => ({
+    mode: "multi",
+    ids: []
+  })
+});
+var resolveSelection = (selection, mode) => {
+  const value = selection?.mode === mode ? selection : defaultSelection(mode);
+  return Match.type().pipe(Match.when({
+    mode: "single"
+  }, (s) => s.id), Match.when({
+    mode: "multi"
+  }, (s) => s.ids), Match.when({
+    mode: "range"
+  }, (s) => s.from && s.to ? {
+    from: s.from,
+    to: s.to
+  } : void 0), Match.when({
+    mode: "multi-range"
+  }, (s) => s.ranges), Match.exhaustive)(value);
+};
+var toggleSelection = (selection, id) => {
+  const ids = selection?.mode === "multi" ? selection.ids : [];
+  return {
+    mode: "multi",
+    ids: ids.includes(id) ? ids.filter((existing) => existing !== id) : [
+      ...ids,
+      id
+    ]
+  };
+};
+var getSelectionSet = (manager, contextId) => {
+  const ids = new Set(contextId ? [
+    contextId
+  ] : []);
+  for (const context of manager.contexts(selectionAspect)) {
+    const selection = manager.get(selectionAspect, context);
+    if (selection.mode === "multi") {
+      for (const id of selection.ids) {
+        ids.add(id);
+      }
+    }
+  }
+  return ids;
+};
+
+export {
+  AttentionManager,
+  getAttendables,
+  expandAttendableId,
+  isLinkedSegment,
+  linkedSegment,
+  getLinkedVariant,
+  getParentId,
+  getSegmentId,
+  defineViewState,
+  ViewStateManager,
+  MemoryBackend,
+  LocalBackend,
+  createDefaultBackends,
+  SelectionSchema,
+  defaultSelection,
+  selectionAspect,
+  resolveSelection,
+  toggleSelection,
+  getSelectionSet
+};
+//# sourceMappingURL=chunk-HWN7KJDX.mjs.map

package/dist/lib/node-esm/chunk-HWN7KJDX.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/attention.ts", "../../../src/view-state/view-state.ts", "../../../src/view-state/backends.ts", "../../../src/selection.ts"],
+  "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { Atom, type Registry } from '@effect-atom/atom-react';\n\nexport type Attention = {\n  hasAttention: boolean;\n  isAncestor: boolean;\n  isRelated: boolean;\n};\n\n/**\n * Manages attention state for an application.\n * Attention keys are slash-qualified graph IDs; ancestry is derived from progressive prefixes.\n */\nexport class AttentionManager {\n  private readonly _map = new Map<string, Atom.Writable<Attention>>();\n  private readonly _currentAtom: Atom.Writable<string[]>;\n\n  constructor(\n    private readonly _registry: Registry.Registry,\n    initial: string[] = [],\n  ) {\n    this._currentAtom = Atom.make<string[]>([]).pipe(Atom.keepAlive);\n    if (initial.length > 0) {\n      this.update(initial);\n    }\n  }\n\n  /**\n   * Atom for the currently attended element IDs.\n   */\n  get current(): Atom.Atom<string[]> {\n    return this._currentAtom;\n  }\n\n  /**\n   * Gets the currently attended element IDs.\n   */\n  getCurrent(): readonly string[] {\n    return this._registry.get(this._currentAtom);\n  }\n\n  /**\n   * Subscribe to changes in the current attention IDs.\n   */\n  subscribeCurrent(cb: (current: readonly string[]) => void): () => void {\n    this._registry.get(this._currentAtom);\n    return this._registry.subscribe(this._currentAtom, () => {\n      cb(this._registry.get(this._currentAtom));\n    });\n  }\n\n  /**\n   * All tracked qualified IDs.\n   */\n  keys(): string[] {\n    return Array.from(this._map.keys());\n  }\n\n  /**\n   * Get the attention state for a given qualified ID.\n   */\n  get(id: string): Attention {\n    const atom = this._getAtom(id);\n    return this._registry.get(atom);\n  }\n\n  /**\n   * Subscribe to changes in the attention state for a given qualified ID.\n   */\n  subscribe(id: string, cb: (attention: Attention) => void): () => void {\n    const atom = this._getAtom(id);\n    this._registry.get(atom);\n    return this._registry.subscribe(atom, () => {\n      cb(this._registry.get(atom));\n    });\n  }\n\n  private _getAtom(id: string): Atom.Writable<Attention> {\n    const existing = this._map.get(id);\n    if (existing) {\n      return existing;\n    }\n\n    const newAtom = Atom.make<Attention>({ hasAttention: false, isAncestor: false, isRelated: false }).pipe(\n      Atom.keepAlive,\n    );\n    this._map.set(id, newAtom);\n    return newAtom;\n  }\n\n  /**\n   * Update the currently attended element.\n   * Takes the array of qualified IDs collected from the DOM; the first element is the primary attended item.\n   * Ancestry is derived from the progressive prefixes of the primary ID.\n   * Relatedness is derived from the segment ID: any tracked key whose last `/` segment matches the\n   * attended ID's segment ID is marked `isRelated`. Additionally, if the primary ID is a linked segment\n   * (starts with `~`), its immediate parent gets `isRelated` alongside `isAncestor`.\n   *\n   * @internal\n   */\n  update(nextIds: string[]): void {\n    const primaryId = nextIds[0];\n    if (!primaryId) {\n      return;\n    }\n\n    const currentIds = this.getCurrent();\n    const prevPrimaryId = currentIds[0];\n    // Clear previous attention state: ancestors, primary, and related keys.\n    if (prevPrimaryId) {\n      const prevPrefixes = expandAttendableId(prevPrimaryId);\n      for (const prefix of prevPrefixes) {\n        this._set(prefix, {});\n      }\n      const prevSegmentId = getSegmentId(prevPrimaryId);\n      for (const key of this.keys()) {\n        if (getSegmentId(key) === prevSegmentId) {\n          this._set(key, {});\n        }\n      }\n    }\n\n    this._registry.set(this._currentAtom, nextIds);\n\n    // Set ancestors and primary.\n    const prefixes = expandAttendableId(primaryId);\n    const prefixSet = new Set(prefixes);\n    const linkedParent = isLinkedSegment(primaryId) ? getParentId(primaryId) : undefined;\n\n    for (const prefix of prefixes) {\n      if (prefix === primaryId) {\n        this._set(prefix, { hasAttention: true });\n      } else if (prefix === linkedParent) {\n        this._set(prefix, { isAncestor: true, isRelated: true });\n      } else {\n        this._set(prefix, { isAncestor: true });\n      }\n    }\n\n    // Set related keys: any tracked key sharing the same segment ID.\n    const segmentId = getSegmentId(primaryId);\n    for (const key of this.keys()) {\n      if (!prefixSet.has(key) && getSegmentId(key) === segmentId) {\n        this._set(key, { isRelated: true });\n      }\n    }\n  }\n\n  private _set(id: string, attention: Partial<Attention>): void {\n    const atom = this._getAtom(id);\n    this._registry.set(atom, {\n      hasAttention: attention.hasAttention ?? false,\n      isAncestor: attention.isAncestor ?? false,\n      isRelated: attention.isRelated ?? false,\n    });\n  }\n}\n\n/**\n * Accumulates all attendable IDs between the element provided and the root, inclusive.\n * Each `data-attendable-id` value is treated as a single qualified ID (no splitting).\n */\nexport const getAttendables = (selector: string, cursor: Element, acc: string[] = []): string[] => {\n  // Find the closest element with `data-attendable-id`, if any; start from cursor and move up the DOM tree.\n  const closestAttendable = cursor.closest(selector);\n  if (closestAttendable) {\n    const attendableId = closestAttendable.getAttribute('data-attendable-id');\n    if (!attendableId) {\n      // This has an id of an aria-controls elsewhere on the page, move cursor to that trigger.\n      const trigger = document.querySelector(`[aria-controls=\"${closestAttendable.getAttribute('id')}\"]`);\n      if (!trigger) {\n        return acc;\n      } else {\n        return getAttendables(selector, trigger, acc);\n      }\n    } else {\n      acc.push(attendableId);\n      return !closestAttendable.parentElement ? acc : getAttendables(selector, closestAttendable.parentElement, acc);\n    }\n  }\n\n  return [...new Set(acc)];\n};\n\nexport type AttendableId = { attendableId?: string };\n\nexport type Related = { related?: boolean };\n\n/**\n * Prefix for linked segments. A linked segment's attention state is shared with its parent:\n * when a linked node has attention, the parent is marked as both ancestor and related.\n */\nconst LINKED_PREFIX = '~';\n\n/**\n * Decompose a qualified graph ID into progressive prefixes for ancestry tracking.\n * e.g. `root/a/b/c` yields `['root', 'root/a', 'root/a/b', 'root/a/b/c']`.\n */\nexport const expandAttendableId = (qualifiedId: string): string[] => {\n  const segments = qualifiedId.split('/');\n  return segments.map((_, index) => segments.slice(0, index + 1).join('/'));\n};\n\n/**\n * Whether the last segment of a qualified ID is a linked segment (starts with `~`).\n * Linked segments share their attention state with the parent node.\n */\nexport const isLinkedSegment = (qualifiedId: string): boolean => {\n  const lastSegment = qualifiedId.split('/').pop() ?? '';\n  return lastSegment.startsWith(LINKED_PREFIX);\n};\n\n/**\n * Build a linked segment ID from a variant name (e.g., `'settings'` -> `'~settings'`).\n * Nodes identified by linked segments share their attention state with the parent node.\n */\nexport const linkedSegment = (variant: string): string => `${LINKED_PREFIX}${variant}`;\n\n/**\n * Extract the variant name from the last segment of a qualified ID, stripping the linked prefix.\n * e.g. `'root/space/obj/~settings'` -> `'settings'`.\n * If the segment is not linked (no `~` prefix), returns the segment as-is.\n */\nexport const getLinkedVariant = (qualifiedId: string): string => {\n  const lastSegment = qualifiedId.split('/').pop() ?? '';\n  return lastSegment.startsWith(LINKED_PREFIX) ? lastSegment.slice(LINKED_PREFIX.length) : lastSegment;\n};\n\n/**\n * Get the parent qualified ID (everything before the last `/` segment).\n */\nexport const getParentId = (qualifiedId: string | undefined): string | undefined => {\n  if (!qualifiedId) {\n    return undefined;\n  }\n\n  const lastSlash = qualifiedId.lastIndexOf('/');\n  return lastSlash > 0 ? qualifiedId.slice(0, lastSlash) : undefined;\n};\n\n/**\n * Extract the segment ID (last segment) of a qualified ID.\n */\nexport const getSegmentId = (qualifiedId: string): string => {\n  return qualifiedId.split('/').pop() ?? qualifiedId;\n};\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { type Atom, type Registry } from '@effect-atom/atom-react';\nimport type * as Schema from 'effect/Schema';\n\n/**\n * Persistence backend identifier. `personal` (ECHO/personal-space) is reserved for a future backend.\n */\nexport type BackendName = 'memory' | 'local';\n\n/**\n * Declares a kind of per-context UI state. The value type `T` is inferred from the schema.\n */\nexport interface AspectDef<T> {\n  readonly key: string;\n  readonly backend: BackendName;\n  // Encoded type is intentionally unconstrained: persisted backends serialize `T` through the\n  // schema to an arbitrary wire form, and only the decoded `T` matters to consumers.\n  readonly schema: Schema.Schema<T, any>;\n  readonly defaultValue: () => T;\n}\n\n/**\n * Identity helper that pins the value type from the schema while keeping the literal `key`/`backend`.\n */\nexport const defineViewState = <T>(def: AspectDef<T>): AspectDef<T> => def;\n\n/**\n * A backend produces a reactive, writable atom for each `(aspect, contextId)` pair. Backends may\n * hydrate asynchronously (an ECHO backend would), yielding `aspect.defaultValue()` until loaded;\n * the memory and local backends resolve synchronously.\n */\nexport interface ViewStateBackend {\n  /** Stable atom for the pair; created (and seeded) on first access, cached thereafter. */\n  atom: <T>(aspect: AspectDef<T>, contextId: string) => Atom.Writable<T>;\n  /** Persist a value after the atom is updated. No-op for in-memory backends. */\n  persist?: <T>(aspect: AspectDef<T>, contextId: string, value: T) => void;\n  /** Context ids that currently hold a value for the aspect. */\n  contexts: <T>(aspect: AspectDef<T>) => string[];\n  /** Release listeners/timers (used by tests; app-lifetime managers do not call this). */\n  dispose?: () => void;\n}\n\nexport interface ViewStateManagerOptions {\n  readonly registry: Registry.Registry;\n  readonly backends: Record<BackendName, ViewStateBackend>;\n}\n\n/**\n * Routes per-context UI state to the backend declared by each aspect. Reads/writes go through the\n * effect-atom registry so React hooks and graph atoms observe changes uniformly.\n */\nexport class ViewStateManager {\n  readonly #registry: Registry.Registry;\n  readonly #backends: Record<BackendName, ViewStateBackend>;\n\n  constructor({ registry, backends }: ViewStateManagerOptions) {\n    this.#registry = registry;\n    this.#backends = backends;\n  }\n\n  /** Reactive atom for `(aspect, contextId)`; pass to `registry.get` inside derived atoms/hooks. */\n  atom<T>(aspect: AspectDef<T>, contextId: string): Atom.Writable<T> {\n    return this.#backends[aspect.backend].atom(aspect, contextId);\n  }\n\n  get<T>(aspect: AspectDef<T>, contextId: string): T {\n    return this.#registry.get(this.atom(aspect, contextId));\n  }\n\n  set<T>(aspect: AspectDef<T>, contextId: string, value: T): void {\n    const backend = this.#backends[aspect.backend];\n    this.#registry.set(backend.atom(aspect, contextId), value);\n    backend.persist?.(aspect, contextId, value);\n  }\n\n  update<T>(aspect: AspectDef<T>, contextId: string, fn: (prev: T) => T): void {\n    this.set(aspect, contextId, fn(this.get(aspect, contextId)));\n  }\n\n  subscribe<T>(aspect: AspectDef<T>, contextId: string, cb: (value: T) => void): () => void {\n    const atom = this.atom(aspect, contextId);\n    return this.#registry.subscribe(atom, () => cb(this.#registry.get(atom)));\n  }\n\n  contexts<T>(aspect: AspectDef<T>): string[] {\n    return this.#backends[aspect.backend].contexts(aspect);\n  }\n}\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { Atom, type Registry } from '@effect-atom/atom-react';\nimport * as Schema from 'effect/Schema';\n\nimport { type AspectDef, type BackendName, type ViewStateBackend } from './view-state';\n\n// Only the stable `key` string is needed to form the map key; avoids variance issues with AspectDef<T>.\nconst cacheKey = (aspect: { key: string }, contextId: string) => `${aspect.key}:${contextId}`;\n\n/** In-memory backend: state is ephemeral and scoped to the session (never persisted). */\nexport class MemoryBackend implements ViewStateBackend {\n  readonly #atoms = new Map<string, Atom.Writable<unknown>>();\n\n  atom<T>(aspect: AspectDef<T>, contextId: string): Atom.Writable<T> {\n    const key = cacheKey(aspect, contextId);\n    let atom = this.#atoms.get(key);\n    if (!atom) {\n      atom = Atom.make<unknown>(aspect.defaultValue());\n      this.#atoms.set(key, atom);\n    }\n    // Cast bridges the per-aspect value type erased by the shared atom map; safe by construction.\n    return atom as Atom.Writable<T>;\n  }\n\n  contexts<T>(aspect: AspectDef<T>): string[] {\n    const prefix = `${aspect.key}:`;\n    return [...this.#atoms.keys()].filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));\n  }\n}\n\nconst STORAGE_PREFIX = 'dxos:view-state:';\n\nconst storageKeyFor = (aspect: { key: string }, contextId: string) => `${STORAGE_PREFIX}${aspect.key}:${contextId}`;\n\n// Accessing `globalThis.localStorage` can throw a SecurityError in sandboxed iframes or when\n// storage is blocked; degrade to in-memory behaviour instead of crashing.\nconst safeLocalStorage = (): Storage | undefined => {\n  try {\n    return globalThis.localStorage;\n  } catch {\n    return undefined;\n  }\n};\n\nexport interface LocalBackendOptions {\n  readonly registry: Registry.Registry;\n  /** Injectable for tests; defaults to `window.localStorage`. */\n  readonly storage?: Storage;\n}\n\n/** localStorage-backed backend: seeds atoms from storage, persists on set, syncs across tabs. */\nexport class LocalBackend implements ViewStateBackend {\n  readonly #registry: Registry.Registry;\n  // Absent in non-browser contexts (SSR/tests without injection); the backend then degrades to\n  // ephemeral, in-memory behaviour rather than crashing on a missing `localStorage`.\n  readonly #storage: Storage | undefined;\n  readonly #atoms = new Map<string, Atom.Writable<unknown>>();\n  // Reverse map: storage key -> (aspect, contextId) so `storage` events can target the right atom.\n  readonly #byStorageKey = new Map<string, { aspect: AspectDef<unknown>; contextId: string }>();\n  #storageListener?: (event: StorageEvent) => void;\n\n  constructor({ registry, storage }: LocalBackendOptions) {\n    this.#registry = registry;\n    this.#storage = storage ?? safeLocalStorage();\n    if (this.#storage && typeof globalThis.addEventListener === 'function') {\n      this.#storageListener = (event) => {\n        if (!event.key || !event.key.startsWith(STORAGE_PREFIX)) {\n          return;\n        }\n        const entry = this.#byStorageKey.get(event.key);\n        const atom = entry && this.#atoms.get(cacheKey(entry.aspect, entry.contextId));\n        if (entry && atom) {\n          this.#registry.set(atom, this.#read(entry.aspect, event.key));\n        }\n      };\n      globalThis.addEventListener('storage', this.#storageListener);\n    }\n  }\n\n  atom<T>(aspect: AspectDef<T>, contextId: string): Atom.Writable<T> {\n    const key = cacheKey(aspect, contextId);\n    let atom = this.#atoms.get(key);\n    if (!atom) {\n      const storageKey = storageKeyFor(aspect, contextId);\n      atom = Atom.make<unknown>(this.#read(aspect, storageKey));\n      this.#atoms.set(key, atom);\n      // Cast erases the per-aspect value type so the reverse map can hold aspects of any `T`; the\n      // stored aspect is only used to re-read/decode its own value, so the erasure is safe.\n      this.#byStorageKey.set(storageKey, { aspect: aspect as AspectDef<unknown>, contextId });\n    }\n    // Cast bridges the per-aspect value type erased by the shared atom map; safe by construction.\n    return atom as Atom.Writable<T>;\n  }\n\n  persist<T>(aspect: AspectDef<T>, contextId: string, value: T): void {\n    this.#storage?.setItem(storageKeyFor(aspect, contextId), JSON.stringify(Schema.encodeSync(aspect.schema)(value)));\n  }\n\n  contexts<T>(aspect: AspectDef<T>): string[] {\n    if (!this.#storage) {\n      // No persistent storage: fall back to the in-memory atoms (mirrors `atom()`'s ephemeral path).\n      const prefix = `${aspect.key}:`;\n      return [...this.#atoms.keys()].filter((key) => key.startsWith(prefix)).map((key) => key.slice(prefix.length));\n    }\n    const prefix = storageKeyFor(aspect, '');\n    const ids: string[] = [];\n    for (let index = 0; index < this.#storage.length; index++) {\n      const key = this.#storage.key(index);\n      if (key?.startsWith(prefix)) {\n        ids.push(key.slice(prefix.length));\n      }\n    }\n    return ids;\n  }\n\n  dispose(): void {\n    if (this.#storageListener && typeof globalThis.removeEventListener === 'function') {\n      globalThis.removeEventListener('storage', this.#storageListener);\n    }\n    // Allow safe reuse after disposal: drop cached atoms and their reverse-key entries.\n    this.#atoms.clear();\n    this.#byStorageKey.clear();\n  }\n\n  #read<T>(aspect: AspectDef<T>, storageKey: string): T {\n    const raw = this.#storage?.getItem(storageKey);\n    if (raw == null) {\n      return aspect.defaultValue();\n    }\n    try {\n      return Schema.decodeUnknownSync(aspect.schema)(JSON.parse(raw));\n    } catch {\n      // Tolerate stale/corrupt entries (e.g. a prior schema shape) by falling back to the default.\n      return aspect.defaultValue();\n    }\n  }\n}\n\nexport const createDefaultBackends = (registry: Registry.Registry): Record<BackendName, ViewStateBackend> => ({\n  memory: new MemoryBackend(),\n  local: new LocalBackend({ registry }),\n});\n", "//\n// Copyright 2025 DXOS.org\n//\n\nimport * as Match from 'effect/Match';\nimport * as Schema from 'effect/Schema';\n\nimport { type AspectDef, type ViewStateManager, defineViewState } from './view-state';\n\nexport type SelectionMode = 'single' | 'multi' | 'range' | 'multi-range';\n\nexport const SelectionSchema = Schema.Union(\n  Schema.Struct({\n    mode: Schema.Literal('single'),\n    id: Schema.optional(Schema.String),\n  }).pipe(Schema.mutable),\n  Schema.Struct({\n    mode: Schema.Literal('multi'),\n    ids: Schema.Array(Schema.String).pipe(Schema.mutable),\n  }).pipe(Schema.mutable),\n  Schema.Struct({\n    mode: Schema.Literal('range'),\n    from: Schema.optional(Schema.String),\n    to: Schema.optional(Schema.String),\n  }).pipe(Schema.mutable),\n  Schema.Struct({\n    mode: Schema.Literal('multi-range'),\n    ranges: Schema.Array(Schema.Struct({ from: Schema.String, to: Schema.String })).pipe(Schema.mutable),\n  }).pipe(Schema.mutable),\n).pipe(Schema.mutable);\n\nexport type Selection = Schema.Schema.Type<typeof SelectionSchema>;\n\nexport const defaultSelection = Match.type<SelectionMode>().pipe(\n  Match.withReturnType<Selection>(),\n  Match.when('single', () => ({ mode: 'single' })),\n  Match.when('multi', () => ({ mode: 'multi', ids: [] })),\n  Match.when('range', () => ({ mode: 'range' })),\n  Match.when('multi-range', () => ({ mode: 'multi-range', ranges: [] })),\n  Match.exhaustive,\n);\n\nexport type SelectionResult<T extends SelectionMode> = T extends 'single'\n  ? string | undefined\n  : T extends 'multi'\n    ? string[]\n    : T extends 'range'\n      ? { from: string; to: string } | undefined\n      : T extends 'multi-range'\n        ? { from: string; to: string }[]\n        : never;\n\n/** Selection state for a context, stored in memory (ephemeral, per-device session). */\nexport const selectionAspect: AspectDef<Selection> = defineViewState<Selection>({\n  key: 'selection',\n  backend: 'memory',\n  schema: SelectionSchema,\n  defaultValue: () => ({ mode: 'multi', ids: [] }),\n});\n\n/**\n * Extract the typed result for `mode` from a stored selection value, returning the requested\n * mode's default when the stored value is absent or holds a different mode.\n */\nexport const resolveSelection = <T extends SelectionMode>(\n  selection: Selection | undefined,\n  mode: T,\n): SelectionResult<T> => {\n  const value = selection?.mode === mode ? selection : defaultSelection(mode);\n  // Cast required because TypeScript cannot relate the `Match` result to the generic `T`.\n  return Match.type<Selection>().pipe(\n    Match.when({ mode: 'single' }, (s) => s.id),\n    Match.when({ mode: 'multi' }, (s) => s.ids),\n    Match.when({ mode: 'range' }, (s) => (s.from && s.to ? { from: s.from, to: s.to } : undefined)),\n    Match.when({ mode: 'multi-range' }, (s) => s.ranges),\n    Match.exhaustive,\n  )(value) as SelectionResult<T>;\n};\n\n/** Toggle `id` within a multi selection; resets to a multi selection if the current value differs. */\nexport const toggleSelection = (selection: Selection | undefined, id: string): Selection => {\n  const ids = selection?.mode === 'multi' ? selection.ids : [];\n  return { mode: 'multi', ids: ids.includes(id) ? ids.filter((existing) => existing !== id) : [...ids, id] };\n};\n\n/** Union of all multi-selected ids across every selection context, plus an optional explicit id. */\nexport const getSelectionSet = (manager: ViewStateManager, contextId?: string): Set<string> => {\n  const ids = new Set<string>(contextId ? [contextId] : []);\n  for (const context of manager.contexts(selectionAspect)) {\n    const selection = manager.get(selectionAspect, context);\n    if (selection.mode === 'multi') {\n      for (const id of selection.ids) {\n        ids.add(id);\n      }\n    }\n  }\n  return ids;\n};\n"],
+  "mappings": "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",
+  "names": ["Atom", "AttentionManager", "_map", "Map", "_currentAtom", "_registry", "initial", "make", "pipe", "keepAlive", "length", "update", "current", "getCurrent", "get", "subscribeCurrent", "cb", "subscribe", "keys", "Array", "from", "id", "atom", "_getAtom", "existing", "newAtom", "hasAttention", "isAncestor", "isRelated", "set", "nextIds", "primaryId", "currentIds", "prevPrimaryId", "prevPrefixes", "expandAttendableId", "prefix", "_set", "prevSegmentId", "getSegmentId", "key", "prefixes", "prefixSet", "Set", "linkedParent", "isLinkedSegment", "getParentId", "undefined", "segmentId", "has", "attention", "getAttendables", "selector", "cursor", "acc", "closestAttendable", "closest", "attendableId", "getAttribute", "trigger", "document", "querySelector", "push", "parentElement", "LINKED_PREFIX", "qualifiedId", "segments", "split", "map", "_", "index", "slice", "join", "lastSegment", "pop", "startsWith", "linkedSegment", "variant", "getLinkedVariant", "lastSlash", "lastIndexOf", "defineViewState", "def", "ViewStateManager", "registry", "backends", "atom", "aspect", "contextId", "backend", "get", "set", "value", "persist", "update", "fn", "subscribe", "cb", "contexts", "Atom", "Schema", "cacheKey", "aspect", "contextId", "key", "MemoryBackend", "Map", "atom", "get", "make", "defaultValue", "set", "contexts", "prefix", "keys", "filter", "startsWith", "map", "slice", "length", "STORAGE_PREFIX", "storageKeyFor", "safeLocalStorage", "globalThis", "localStorage", "undefined", "LocalBackend", "registry", "storage", "addEventListener", "event", "entry", "storageKey", "persist", "value", "setItem", "JSON", "stringify", "encodeSync", "schema", "ids", "index", "push", "dispose", "removeEventListener", "clear", "raw", "getItem", "decodeUnknownSync", "parse", "createDefaultBackends", "memory", "local", "Match", "Schema", "SelectionSchema", "Union", "Struct", "mode", "Literal", "id", "optional", "String", "pipe", "mutable", "ids", "Array", "from", "to", "ranges", "defaultSelection", "type", "withReturnType", "when", "exhaustive", "selectionAspect", "defineViewState", "key", "backend", "schema", "defaultValue", "resolveSelection", "selection", "value", "s", "undefined", "toggleSelection", "includes", "filter", "existing", "getSelectionSet", "manager", "contextId", "Set", "context", "contexts", "get", "add"]
+}

package/dist/lib/node-esm/index.mjs

@@ -2,20 +2,26 @@ import { createRequire } from 'node:module';const require = createRequire(import
 import {
   AttendableContainer,
   RootAttentionProvider,
-  SelectionProvider,
+  ViewStateProvider,
   useAttended,
   useAttention,
   useAttentionAttributes,
   useAttentionContext,
-  useSelected,
+  useSelection,
   useSelectionActions,
-  useSelectionManager
-} from "./chunk-ZTUVSH4P.mjs";
+  useViewState,
+  useViewStateActions,
+  useViewStateManager
+} from "./chunk-5JUZQDCR.mjs";
 import {
   AttentionManager,
-  SelectionManager,
+  LocalBackend,
+  MemoryBackend,
   SelectionSchema,
+  ViewStateManager,
+  createDefaultBackends,
   defaultSelection,
+  defineViewState,
   expandAttendableId,
   getAttendables,
   getLinkedVariant,
@@ -23,8 +29,11 @@ import {
   getSegmentId,
   getSelectionSet,
   isLinkedSegment,
-  linkedSegment
-} from "./chunk-6INLBC62.mjs";
+  linkedSegment,
+  resolveSelection,
+  selectionAspect,
+  toggleSelection
+} from "./chunk-HWN7KJDX.mjs";
 
 // src/components/AttentionGlyph/AttentionGlyph.tsx
 import React, { forwardRef, useMemo } from "react";
@@ -171,13 +180,17 @@ export {
   AttendableContainer,
   AttentionGlyph,
   AttentionManager,
+  LocalBackend,
+  MemoryBackend,
   RootAttentionProvider,
-  SelectionManager,
-  SelectionProvider,
   SelectionSchema,
   Syncing,
+  ViewStateManager,
+  ViewStateProvider,
   advance,
+  createDefaultBackends,
   defaultSelection,
+  defineViewState,
   expandAttendableId,
   getAttendables,
   getLinkedVariant,
@@ -186,13 +199,18 @@ export {
   getSelectionSet,
   isLinkedSegment,
   linkedSegment,
+  resolveSelection,
+  selectionAspect,
+  toggleSelection,
   useArticleKeyboardNavigation,
   useAttended,
   useAttention,
   useAttentionAttributes,
   useAttentionContext,
-  useSelected,
+  useSelection,
   useSelectionActions,
-  useSelectionManager
+  useViewState,
+  useViewStateActions,
+  useViewStateManager
 };
 //# sourceMappingURL=index.mjs.map

package/dist/lib/node-esm/index.mjs.map

@@ -2,6 +2,6 @@
   "version": 3,
   "sources": ["../../../src/components/AttentionGlyph/AttentionGlyph.tsx", "../../../src/useArticleKeyboardNavigation.ts"],
   "sourcesContent": ["//\n// Copyright 2024 DXOS.org\n//\n\nimport { type Primitive } from '@radix-ui/react-primitive';\nimport React, { type CSSProperties, type ComponentPropsWithRef, forwardRef, useMemo } from 'react';\n\nimport { Icon, type ThemedClassName } from '@dxos/react-ui';\nimport { mx } from '@dxos/ui-theme';\n\nconst attentionGlyphStyles = mx(\n  'inline-block rounded-xs w-3 h-3 bg-transparent text-accent-text transition-colors',\n  '[[data-contains-attended=true]_&]:bg-attention-contains',\n  '[[data-attention=true]_&]:bg-accent-bg',\n  '[[data-attention=true]_&]:text-accent-fg',\n  '[[aria-current][data-attention=true]_&]:bg-accent-bg',\n  '[[aria-current][data-attention=true]_&]:text-accent-fg',\n  '[[aria-selected=\"true\"][data-attention=true]_&]:bg-accent-bg',\n  '[[aria-selected=\"true\"][data-attention=true]_&]:text-accent-fg',\n);\n\nconst presenceIconStyles = mx('w-3 h-3');\n\nconst PresenceOne = () => {\n  return (\n    <svg\n      width='12'\n      height='12'\n      viewBox='0 0 12 12'\n      className={presenceIconStyles}\n      fill='none'\n      xmlns='http://www.w3.org/2000/svg'\n    >\n      <circle cx='6' cy='6' r='2.5' fill='currentColor' />\n    </svg>\n  );\n};\n\nconst PresenceMany = () => {\n  return (\n    <svg\n      width='12'\n      height='12'\n      viewBox='0 0 12 12'\n      className={presenceIconStyles}\n      fill='none'\n      xmlns='http://www.w3.org/2000/svg'\n    >\n      <path\n        d='M6.75 8.27311C7.38815 7.72296 7.79212 6.90866 7.79212 6C7.79212 5.09134 7.38815 4.27704 6.75 3.72689C7.06722 3.58122 7.42019 3.5 7.79212 3.5C9.17283 3.5 10.2921 4.61929 10.2921 6C10.2921 7.38071 9.17283 8.5 7.79212 8.5C7.42019 8.5 7.06723 8.41878 6.75 8.27311Z'\n        fill='currentColor'\n      />\n      <circle cx='4.25' cy='6' r='2.5' fill='currentColor' />\n    </svg>\n  );\n};\n\nexport const Syncing = () => {\n  const animationProps = useMemo<CSSProperties>(\n    () => ({\n      // Synchronize animations.\n      animationDelay: `-${Date.now() % 2_000}ms`,\n    }),\n    [],\n  );\n\n  return (\n    <div role='status' className='flex items-center'>\n      <Icon\n        icon='ph--circle-notch--bold'\n        size={3}\n        style={animationProps}\n        classNames='text-subdued animate-[spin_2s_linear_infinite]'\n      />\n    </div>\n  );\n};\n\nexport type AttentionGlyphProps = {\n  attended?: boolean;\n  containsAttended?: boolean;\n  syncing?: boolean;\n  presence?: 'none' | 'one' | 'many';\n} & ThemedClassName<Omit<ComponentPropsWithRef<typeof Primitive.span>, 'children'>>;\n\nexport const AttentionGlyph = forwardRef<HTMLSpanElement, AttentionGlyphProps>(\n  ({ presence, attended, syncing, containsAttended, classNames, ...props }, forwardedRef) => {\n    const icon = syncing ? (\n      <Syncing />\n    ) : presence === 'many' ? (\n      <PresenceMany />\n    ) : presence === 'one' ? (\n      <PresenceOne />\n    ) : null;\n\n    return (\n      <div className='flex group' data-attention={attended} data-contains-attended={containsAttended}>\n        <span {...props} className={mx(attentionGlyphStyles, classNames)} ref={forwardedRef}>\n          {icon}\n        </span>\n      </div>\n    );\n  },\n);\n", "//\n// Copyright 2026 DXOS.org\n//\n\nimport { useEffect, useMemo } from 'react';\n\nimport { Keyboard } from '@dxos/keyboard';\n\nimport { useAttention } from './components';\n\n/**\n * Compute the id to select after pressing 'j' (delta = 1) or 'k' (delta = -1).\n * Clamps at the list ends — pressing 'j' on the last item keeps the last item\n * selected (vim-style), and 'k' on the first item keeps the first.\n *\n * When no current selection exists, returns the first id (for delta = 1) or the\n * last id (for delta = -1) so the user can enter the list with either key.\n */\nexport const advance = ({\n  ids,\n  currentId,\n  delta,\n}: {\n  ids: readonly string[];\n  currentId: string | undefined;\n  delta: 1 | -1;\n}): string | undefined => {\n  if (ids.length === 0) {\n    return undefined;\n  }\n\n  const idx = currentId ? ids.indexOf(currentId) : -1;\n  if (idx === -1) {\n    return delta === 1 ? ids[0] : ids[ids.length - 1];\n  }\n\n  const next = Math.max(0, Math.min(ids.length - 1, idx + delta));\n  return ids[next];\n};\n\nexport type UseArticleKeyboardNavigationOptions<T> = {\n  /** Stable id for the article (used as the keyboard context path). */\n  articleId: string;\n  /** Ordered list of selectable items as they appear in the article. */\n  items: readonly T[];\n  /** Currently-selected id, if any. */\n  currentId: string | undefined;\n  /** Extracts the id from an item. Defaults to `item.id`. */\n  getId?: (item: T) => string;\n  /** Called with the id to select when the user presses 'j' or 'k'. */\n  onSelect: (id: string) => void;\n};\n\n/**\n * Wire 'j' (next) and 'k' (previous) keyboard shortcuts for an article that\n * navigates a list of items (e.g., messages, events). Bindings are scoped to\n * the article's keyboard context so they only fire while the article has attention.\n *\n * Pass the items directly; ids are derived via `getId` (defaults to `item.id`).\n * Clamps at list boundaries. Active only when the article is attended.\n */\nexport const useArticleKeyboardNavigation: {\n  <T extends { id: string }>(options: UseArticleKeyboardNavigationOptions<T>): void;\n  <T>(options: UseArticleKeyboardNavigationOptions<T> & { getId: (item: T) => string }): void;\n} = <T>({ articleId, items, currentId, getId, onSelect }: UseArticleKeyboardNavigationOptions<T>): void => {\n  const { hasAttention } = useAttention(articleId);\n\n  // `getId` is optional only when `T extends { id: string }` (enforced by the overloads above),\n  // so the fallback is sound; the cast bridges the generic erased by the implementation signature.\n  const ids = useMemo(() => items.map((item) => (getId ? getId(item) : (item as { id: string }).id)), [items, getId]);\n\n  useEffect(() => {\n    if (!hasAttention) {\n      return;\n    }\n\n    const context = Keyboard.singleton.getContext(articleId);\n    const prevContext = Keyboard.singleton.getCurrentContext();\n    Keyboard.singleton.setCurrentContext(articleId);\n\n    const nextBinding = {\n      shortcut: 'j',\n      handler: () => {\n        const target = advance({ ids, currentId, delta: 1 });\n        if (target !== undefined) {\n          onSelect(target);\n        }\n      },\n      data: 'Next item',\n      disableInput: true,\n    };\n    const prevBinding = {\n      shortcut: 'k',\n      handler: () => {\n        const target = advance({ ids, currentId, delta: -1 });\n        if (target !== undefined) {\n          onSelect(target);\n        }\n      },\n      data: 'Previous item',\n      disableInput: true,\n    };\n\n    context.bind(nextBinding);\n    context.bind(prevBinding);\n\n    return () => {\n      context.unbind('j');\n      context.unbind('k');\n      // Restore the prior context if we were the ones who set it.\n      if (Keyboard.singleton.getCurrentContext() === articleId) {\n        Keyboard.singleton.setCurrentContext(prevContext);\n      }\n    };\n  }, [articleId, ids, currentId, onSelect, hasAttention]);\n};\n"],
-  "mappings": "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",
+  "mappings": "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",
   "names": ["React", "forwardRef", "useMemo", "Icon", "mx", "attentionGlyphStyles", "presenceIconStyles", "PresenceOne", "svg", "width", "height", "viewBox", "className", "fill", "xmlns", "circle", "cx", "cy", "r", "PresenceMany", "path", "d", "Syncing", "animationProps", "animationDelay", "Date", "now", "div", "role", "icon", "size", "style", "classNames", "AttentionGlyph", "presence", "attended", "syncing", "containsAttended", "props", "forwardedRef", "data-attention", "data-contains-attended", "span", "ref", "useEffect", "useMemo", "Keyboard", "advance", "ids", "currentId", "delta", "length", "undefined", "idx", "indexOf", "next", "Math", "max", "min", "useArticleKeyboardNavigation", "articleId", "items", "getId", "onSelect", "hasAttention", "useAttention", "useMemo", "map", "item", "id", "useEffect", "context", "Keyboard", "singleton", "getContext", "prevContext", "getCurrentContext", "setCurrentContext", "nextBinding", "shortcut", "handler", "target", "data", "disableInput", "prevBinding", "bind", "unbind"]
 }