zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/composer/model-knobs.ts

@@ -1,179 +0,0 @@
-/**
- * Reasoning effort and model options (fast mode, …) remembered per model, in
- * the host's `prefs` (the desktop app: the `state.json` keys the TUI reads and
- * writes, `lastEffortByModel` and `lastModelOptionsByModel`). Every pick (in
- * a draft or a live session) updates them.
- *
- * A new chat starts from, first to last: what was picked in its draft, the
- * configured defaults (the space's, else the app's, whatever the model:
- * `defaultSessionKnobs`), the last values used with its model in either app,
- * then medium and no options.
- *
- * Outside React: the composer's draft pill and the send path read the same
- * values, and the send path reads them synchronously.
- */
-import type { SessionKnobs } from 'zidane/chat/pure';
-
-import type { ComposerEffort, ComposerPrefs, ComposerPrefsState } from './host-chrome';
-
-/** What the store holds. */
-export interface ModelKnobsMemory {
-  /** The last effort per model. */
-  effort: Record<string, ComposerEffort>;
-  /** The last enabled options per model. */
-  options: Record<string, Record<string, boolean>>;
-  /** The draft's own picks, until its chat is created (`clearDraft`). */
-  draft: { modelId: string; effort?: ComposerEffort; options?: Record<string, boolean> } | null;
-}
-
-/** An effort and the enabled options. */
-export interface ModelKnobs {
-  /** The reasoning effort. */
-  effort: ComposerEffort;
-  /** The enabled options (`{ fast: true }`). */
-  options: Record<string, boolean>;
-}
-
-/** The remembered knobs. */
-export interface ModelKnobsStore {
-  /** Reads the remembered picks from the prefs, once. */
-  load(): Promise<void>;
-  /** Registers a listener called after the memory changes. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-  /** The memory now (a new object on each change). */
-  snapshot(): ModelKnobsMemory;
-  /** The last effort and enabled options used with `modelId` (medium, none, when never set). */
-  remembered(modelId: string | null, from?: ModelKnobsMemory): ModelKnobs;
-  /** A new chat's starting effort and enabled options on `modelId` (see the header for the order). */
-  draft(modelId: string | null, configured: SessionKnobs | undefined, from?: ModelKnobsMemory): ModelKnobs;
-  /** Remembers an effort for a model. */
-  rememberEffort(modelId: string | null, effort: ComposerEffort): void;
-  /** Remembers the enabled options for a model. */
-  rememberModelOptions(modelId: string | null, options: Record<string, boolean>): void;
-  /** A pick in the draft's pill: this chat starts on it, and it is remembered for the model. */
-  pickDraftEffort(modelId: string | null, effort: ComposerEffort): void;
-  /** A pick of options in the draft's pill. */
-  pickDraftOptions(modelId: string | null, options: Record<string, boolean>): void;
-  /** The draft became a chat: the next one starts from the defaults again. */
-  clearDraft(): void;
-  /** Tests: forget everything, reload from the prefs on next use. */
-  reset(): void;
-}
-
-/** The enabled ids only: `{ fast: true }`, never `{ fast: false }`. */
-function enabledOnly(options: Record<string, boolean>): Record<string, boolean> {
-  return Object.fromEntries(Object.entries(options).filter(([, on]) => on === true));
-}
-
-/**
- * Creates the remembered knobs over a host's prefs.
- *
- * @param prefs - Where picks are remembered. Absent: they last for the page's life.
- */
-export function createModelKnobs(prefs: ComposerPrefs | undefined): ModelKnobsStore {
-  let memory: ModelKnobsMemory = { effort: {}, options: {}, draft: null };
-  let loaded: Promise<void> | null = null;
-  const listeners = new Set<() => void>();
-  const emit = () => {
-    for (const l of listeners) l();
-  };
-
-  /** Merge into the prefs without clobbering keys another writer (the TUI) set meanwhile. */
-  const persist = async (patch: (s: ComposerPrefsState) => ComposerPrefsState): Promise<void> => {
-    if (!prefs) return;
-    try {
-      const current = await prefs.get();
-      await prefs.set(patch(current ?? {}));
-    } catch {
-      // The pick still applies to this window; it just won't be remembered.
-    }
-  };
-
-  const store: ModelKnobsStore = {
-    load() {
-      loaded ??= Promise.resolve()
-        .then(() => prefs?.get() ?? null)
-        .then((s) => {
-          if (!s) return;
-          memory = {
-            effort: { ...(s.lastEffortByModel ?? {}), ...memory.effort },
-            options: { ...(s.lastModelOptionsByModel ?? {}), ...memory.options },
-            draft: memory.draft,
-          };
-          emit();
-        })
-        .catch(() => undefined);
-      return loaded;
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-    snapshot: () => memory,
-    remembered: (modelId, from = memory) => ({
-      effort: (modelId && from.effort[modelId]) || 'medium',
-      options: (modelId && from.options[modelId]) || {},
-    }),
-    draft(modelId, configured, from = memory) {
-      const picked = from.draft && from.draft.modelId === modelId ? from.draft : null;
-      return {
-        effort: picked?.effort ?? configured?.effort ?? ((modelId && from.effort[modelId]) || 'medium'),
-        options: picked?.options ?? configured?.modelOptions ?? ((modelId && from.options[modelId]) || {}),
-      };
-    },
-    rememberEffort(modelId, effort) {
-      if (!modelId) return;
-      memory = { ...memory, effort: { ...memory.effort, [modelId]: effort } };
-      emit();
-      void persist((s) => ({ lastEffortByModel: { ...(s.lastEffortByModel ?? {}), [modelId]: effort } }));
-    },
-    rememberModelOptions(modelId, options) {
-      if (!modelId) return;
-      const enabled = enabledOnly(options);
-      memory = { ...memory, options: { ...memory.options, [modelId]: enabled } };
-      emit();
-      void persist((s) => ({
-        lastModelOptionsByModel: { ...(s.lastModelOptionsByModel ?? {}), [modelId]: enabled },
-      }));
-    },
-    pickDraftEffort(modelId, effort) {
-      if (!modelId) return;
-      memory = { ...memory, draft: { ...(memory.draft?.modelId === modelId ? memory.draft : {}), modelId, effort } };
-      store.rememberEffort(modelId, effort);
-    },
-    pickDraftOptions(modelId, options) {
-      if (!modelId) return;
-      const enabled = enabledOnly(options);
-      memory = {
-        ...memory,
-        draft: { ...(memory.draft?.modelId === modelId ? memory.draft : {}), modelId, options: enabled },
-      };
-      store.rememberModelOptions(modelId, options);
-    },
-    clearDraft() {
-      if (!memory.draft) return;
-      memory = { ...memory, draft: null };
-      emit();
-    },
-    reset() {
-      memory = { effort: {}, options: {}, draft: null };
-      loaded = null;
-    },
-  };
-  return store;
-}
-
-const stores = new WeakMap<object, ModelKnobsStore>();
-const NO_PREFS = {};
-
-/**
- * The one {@link ModelKnobsStore} over a host's `prefs` (one shared in-memory store when it has none).
- *
- * @param prefs - The host's member.
- */
-export function modelKnobsOf(prefs: ComposerPrefs | undefined): ModelKnobsStore {
-  const key = prefs ?? NO_PREFS;
-  let store = stores.get(key);
-  if (!store) stores.set(key, (store = createModelKnobs(prefs)));
-  return store;
-}

package/src/chat/headless/composer/model-names.ts

@@ -1,145 +0,0 @@
-/**
- * Model names as the model picker shows them (`Opus 4.5`), for every surface
- * that names a model: the context orb, the transcript's receipt and worker
- * rows, session details, settings. One catalog (and the provider labels of
- * the sign-in report), read on the first reader and kept current. A model
- * the catalog doesn't know keeps its id, made readable; so does every model
- * while the catalog can't be listed.
- */
-import { modelDisplayName, nameFromModelId, type ModelNamer } from 'zidane/chat/pure';
-
-import type { ResourceSnapshot } from '../../../app/headless/resource';
-import type { Readable } from '../store';
-import type { ComposerModels } from './host-chrome';
-import type { ModelCatalogRow } from './models';
-
-/** How models and providers are named. */
-export interface ModelNames {
-  /** A model's name. */
-  model: ModelNamer;
-  /** A provider's label (`Anthropic`); its key when nothing names it. */
-  provider: (providerKey: string) => string;
-}
-
-/** A provider as the sign-in report lists it. */
-export interface ModelNamesProvider {
-  /** The provider's key. */
-  key: string;
-  /** Its label. */
-  label: string;
-}
-
-/** The live names. */
-export interface ModelNamesStore {
-  /** The names now (a new object when the catalog changes). */
-  get(): ModelNames;
-  /** Registers a listener (the first one starts reading). Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-}
-
-/**
- * A namer reading `catalog`: the entry of that provider first, then any provider listing the id.
- *
- * @param catalog - The catalog rows.
- */
-export function namerFor(
-  catalog: readonly Pick<ModelCatalogRow, 'providerKey' | 'modelId' | 'modelName'>[],
-): ModelNamer {
-  const exact = new Map<string, string>();
-  const anyProvider = new Map<string, Pick<ModelCatalogRow, 'providerKey' | 'modelName'>>();
-  for (const entry of catalog) {
-    exact.set(`${entry.providerKey}\u0000${entry.modelId}`, entry.modelName);
-    if (!anyProvider.has(entry.modelId)) anyProvider.set(entry.modelId, entry);
-  }
-  return (modelId, providerKey) => {
-    const name = providerKey ? exact.get(`${providerKey}\u0000${modelId}`) : undefined;
-    const fallback = name === undefined ? anyProvider.get(modelId) : undefined;
-    return modelDisplayName({
-      providerKey: providerKey ?? fallback?.providerKey,
-      modelId,
-      modelName: name ?? fallback?.modelName,
-    }).name;
-  };
-}
-
-/**
- * Creates the names over a catalog and, optionally, the sign-in report's providers.
- * Both are read for the store's life once a reader subscribes.
- *
- * @param catalog - The model catalog.
- * @param providers - The providers, signed in or not (labels for those with no model listed).
- */
-export function createModelNames(
-  catalog: Readable<
-    ResourceSnapshot<readonly Pick<ModelCatalogRow, 'providerKey' | 'providerLabel' | 'modelId' | 'modelName'>[]>
-  >,
-  providers?: Readable<ResourceSnapshot<readonly ModelNamesProvider[]>>,
-): ModelNamesStore {
-  let names: ModelNames = { model: nameFromModelId, provider: (key) => key };
-  let wired = false;
-  let rows: ReturnType<typeof catalog.get>['data'] | null = null;
-  let known: readonly ModelNamesProvider[] = [];
-  const listeners = new Set<() => void>();
-
-  const rebuild = () => {
-    if (!rows) return;
-    // Provider labels from the sign-in report too: it lists every provider, signed in or not.
-    const labels = new Map<string, string>([
-      ...known.map((p) => [p.key, p.label] as const),
-      ...rows.map((e) => [e.providerKey, e.providerLabel] as const),
-    ]);
-    names = { model: namerFor(rows), provider: (key) => labels.get(key) ?? key };
-    for (const listener of listeners) listener();
-  };
-  const wire = () => {
-    if (wired) return;
-    wired = true;
-    // Readers for the store's life: never unsubscribed.
-    const onCatalog = () => {
-      const { data } = catalog.get();
-      if (!data || data === rows) return;
-      rows = data;
-      rebuild();
-    };
-    catalog.subscribe(onCatalog);
-    onCatalog();
-    if (providers) {
-      const onProviders = () => {
-        const { data } = providers.get();
-        if (!data || data === known) return;
-        known = data;
-        rebuild();
-      };
-      providers.subscribe(onProviders);
-      onProviders();
-    }
-  };
-
-  return {
-    get: () => names,
-    subscribe(listener) {
-      wire();
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-  };
-}
-
-const stores = new WeakMap<ComposerModels, ModelNamesStore>();
-const BY_ID: ModelNamesStore = {
-  get: () => ({ model: nameFromModelId, provider: (key) => key }),
-  subscribe: () => () => undefined,
-};
-
-/**
- * The one {@link ModelNamesStore} over a host's `models` (this computer's catalog, and its providers when listed).
- * Without `models`, every model keeps its readable id.
- *
- * @param models - The host's member.
- */
-export function modelNamesOf(models: ComposerModels | undefined): ModelNamesStore {
-  if (!models) return BY_ID;
-  let store = stores.get(models);
-  if (!store) stores.set(models, (store = createModelNames(models.catalog(undefined, null), models.providers?.())));
-  return store;
-}

package/src/chat/headless/composer/model-picker-prefs.ts

@@ -1,90 +0,0 @@
-/**
- * Model picker preferences (`zg:model-picker:v1`): per device, like the
- * editor preferences. One live value the picker, its toggle and an app's
- * command palette entry share.
- */
-
-/** The Storage key the preferences live under. */
-export const MODEL_PICKER_STORAGE_KEY = 'zg:model-picker:v1';
-
-/** The model picker's preferences. */
-export interface ModelPickerPrefs {
-  /** The stored shape's version. */
-  version: 1;
-  /** List every model a provider serves, not only the newest of each family (`currentModelKeys`). */
-  showLegacy: boolean;
-}
-
-/** The preferences before any change. */
-export const DEFAULT_MODEL_PICKER_PREFS: ModelPickerPrefs = { version: 1, showLegacy: false };
-
-/**
- * Parses stored preferences; `undefined` when they are not JSON.
- *
- * @param raw - The stored string.
- */
-export function parseModelPickerPrefs(raw: string): ModelPickerPrefs | undefined {
-  try {
-    const o: unknown = JSON.parse(raw);
-    if (!o || typeof o !== 'object') return undefined;
-    const showLegacy = (o as { showLegacy?: unknown }).showLegacy;
-    return { version: 1, showLegacy: typeof showLegacy === 'boolean' ? showLegacy : false };
-  } catch {
-    return undefined;
-  }
-}
-
-/** The live preferences. */
-export interface ModelPickerPrefsStore {
-  /** The preferences now. */
-  get(): ModelPickerPrefs;
-  /** Changes them (and stores them). */
-  set(update: Partial<ModelPickerPrefs>): void;
-  /** Registers a listener called after they change. Returns the unsubscribe. */
-  subscribe(listener: () => void): () => void;
-}
-
-/** Where the preferences are stored. */
-export type ModelPickerPrefsStorage = Pick<Storage, 'getItem' | 'setItem'>;
-
-/**
- * Creates the preferences over a Storage, read on first use.
- *
- * @param storage - Where they are stored. Absent: `localStorage` when there is one, else memory only.
- */
-export function createModelPickerPrefs(storage?: ModelPickerPrefsStorage): ModelPickerPrefsStore {
-  const store = (): ModelPickerPrefsStorage | undefined =>
-    storage ?? (typeof localStorage === 'undefined' ? undefined : localStorage);
-  let state: ModelPickerPrefs | undefined;
-  const listeners = new Set<() => void>();
-  const read = (): ModelPickerPrefs | undefined => {
-    try {
-      const raw = store()?.getItem(MODEL_PICKER_STORAGE_KEY) ?? null;
-      return raw === null ? undefined : parseModelPickerPrefs(raw);
-    } catch {
-      return undefined;
-    }
-  };
-  const get = () => (state ??= read() ?? DEFAULT_MODEL_PICKER_PREFS);
-  return {
-    get,
-    set(update) {
-      const prev = get();
-      const next: ModelPickerPrefs = { ...prev, ...update, version: 1 };
-      if (next.showLegacy === prev.showLegacy) return;
-      state = next;
-      try {
-        store()?.setItem(MODEL_PICKER_STORAGE_KEY, JSON.stringify(next));
-      } catch {
-        // Non-fatal: the next launch falls back to the default.
-      }
-      for (const l of listeners) l();
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => {
-        listeners.delete(listener);
-      };
-    },
-  };
-}

package/src/chat/headless/composer/models.ts

@@ -1,86 +0,0 @@
-/**
- * The model rows the composer's pickers list, as a host hands them over: chat
- * models (`ModelCatalogRow`, with the options each declares), image models
- * (`ImageModelRow`) and a pick (`ModelPickRef`). React-free, so hosts type
- * their catalogs without the styled layer.
- */
-
-/** A model pick: provider, model and, when the provider has several, the stored account it runs on. */
-export interface ModelPickRef {
-  /** Key of the provider, for example `anthropic`. */
-  providerKey: string;
-  /** Model id within the provider. */
-  modelId: string;
-  /** Id of the stored account the pick runs on. Only set when the provider has several. */
-  account?: string;
-}
-
-/** One row of the catalog. */
-export interface ModelCatalogRow {
-  /** Key of the provider that serves the model. */
-  providerKey: string;
-  /** Provider name shown as the group heading. */
-  providerLabel: string;
-  /** The provider's stored account this row runs on, when it has several. Absent: its only one. */
-  account?: { id: string; label: string; active?: boolean };
-  /** Model id within the provider. */
-  modelId: string;
-  /** The catalog's display name (`Claude Opus 4.6`); the row shows its natural form (`Opus 4.6`). */
-  modelName: string;
-  /** Attribution for an aggregator's row (`anthropic` on OpenRouter). */
-  modelProvider?: string;
-  /** Context window in tokens, or `null` when unknown. */
-  contextWindow: number | null;
-  /** The model supports reasoning effort. */
-  supportsReasoning: boolean;
-  /** A typed id the catalog does not know: used as typed, no metadata. */
-  offCatalog?: boolean;
-  /** Short facts shown beside the name, before the window (`ChatModel.details`). */
-  details?: readonly string[];
-  /** An image model that takes reference images (to edit, or to match a style). */
-  references?: boolean;
-  /** An image model that can make a transparent background. */
-  transparency?: boolean;
-  /** Why the row cannot be picked with the current credentials. The row shows, greyed out, and picking it does nothing. */
-  unavailable?: string;
-  /** Pre-lowercased search text. Default: provider key and label, account, id, name, attribution. */
-  searchCorpus?: string;
-}
-
-/** One image model, as the host lists it. */
-export interface ImageModelRow {
-  /** The provider's key, for example `openai`. */
-  providerKey: string;
-  /** The provider's display name. */
-  providerLabel: string;
-  /** The model's id at the provider. */
-  modelId: string;
-  /** The model's display name. */
-  modelName: string;
-  /** The model takes reference images. */
-  references: boolean;
-  /** The model can return a transparent background. */
-  transparency: boolean;
-  /** The provider's credentials can generate with it. */
-  available: boolean;
-  /** Why it is not available. */
-  reason?: string;
-  /** The model `generate_image` uses while no default is picked. */
-  isDefault?: boolean;
-}
-
-/** A feature toggle a model declares (fast mode, …). */
-export interface ComposerModelOption {
-  /** The option's id, a key of the session's enabled options. */
-  id: string;
-  /** Its name. */
-  label: string;
-  /** What it does. */
-  description?: string;
-}
-
-/** A catalog row with the options its model declares: what `ComposerModels.catalog` lists. */
-export interface ComposerModelEntry extends ModelCatalogRow {
-  /** The feature toggles the model declares. Absent or empty: none. */
-  options?: readonly ComposerModelOption[];
-}

package/src/chat/headless/composer/new-session-defaults.ts

@@ -1,68 +0,0 @@
-/**
- * What a new session starts with, React-free: the model the host remembers
- * as the next new chat's (`lastProvider` / `lastModelByProvider` in the
- * prefs), the patch a new pick writes there, and what the effort picker has
- * to set for a model (nothing: no dialog).
- */
-import type { ComposerContextStatus, ComposerPrefsState } from './host-chrome';
-import type { ComposerModelOption, ModelPickRef } from './models';
-
-/**
- * The model remembered as the next new chat's, `null` when there is none.
- * The account comes as remembered: check the catalog still serves it.
- *
- * @param prefs - The remembered picks.
- */
-export function rememberedDefaultModel(prefs: ComposerPrefsState | null | undefined): ModelPickRef | null {
-  const providerKey = typeof prefs?.lastProvider === 'string' ? prefs.lastProvider : null;
-  const byProvider = prefs?.lastModelByProvider;
-  const modelId = providerKey && byProvider && typeof byProvider === 'object' ? byProvider[providerKey] : undefined;
-  if (!providerKey || typeof modelId !== 'string' || !modelId) return null;
-  const account = prefs?.lastAccountByProvider?.[providerKey];
-  return { providerKey, modelId, ...(typeof account === 'string' && account ? { account } : {}) };
-}
-
-/**
- * The prefs patch that remembers `pick` as the next new chat's model.
- *
- * @param current - The remembered picks now.
- * @param pick - The new default.
- */
-export function defaultModelPatch(
-  current: ComposerPrefsState | null | undefined,
-  pick: ModelPickRef,
-): ComposerPrefsState {
-  const { providerKey, modelId, account } = pick;
-  const lastModelByProvider = { ...(current?.lastModelByProvider ?? {}), [providerKey]: modelId };
-  const lastAccountByProvider: Partial<Record<string, string>> = { ...(current?.lastAccountByProvider ?? {}) };
-  if (account) lastAccountByProvider[providerKey] = account;
-  else delete lastAccountByProvider[providerKey];
-  return { lastProvider: providerKey, lastModelByProvider, lastAccountByProvider };
-}
-
-/** What the effort picker sets for a session's model. */
-export interface EffortPickerTarget {
-  /** The model has a reasoning effort knob. */
-  supportsReasoning: boolean;
-  /** The feature toggles it declares. */
-  options: readonly ComposerModelOption[];
-  /** The options on now. */
-  enabled: Record<string, boolean>;
-}
-
-/**
- * What the effort picker offers for a session, `null` when its model has
- * nothing to set (no dead-end dialog).
- *
- * @param status - The session's context status (`null` while unknown).
- * @param sessionOptions - The session's own enabled options, which win over the status's.
- */
-export function effortPickerTarget(
-  status: ComposerContextStatus | null | undefined,
-  sessionOptions?: Record<string, boolean>,
-): EffortPickerTarget | null {
-  const supportsReasoning = status?.supportsReasoning ?? false;
-  const options = status?.availableOptions ?? [];
-  if (!supportsReasoning && options.length === 0) return null;
-  return { supportsReasoning, options, enabled: sessionOptions ?? status?.modelOptions ?? {} };
-}

package/src/chat/headless/composer/prompt-suggestions.ts

@@ -1,72 +0,0 @@
-/**
- * The next-prompt suggestion per session (`ComposerHost.suggestions`): the
- * latest one the host offered, until a run or compaction starts or a prompt
- * is sent. One store per host, started on its first subscriber.
- */
-import type { ComposerSuggestions } from './host';
-
-/** A suggested next prompt. */
-export interface PromptSuggestion {
-  /** The run it followed. */
-  runId: string;
-  /** The suggested prompt. */
-  text: string;
-}
-
-/** The suggestions of every session, as {@link createPromptSuggestionStore} keeps them. */
-export interface PromptSuggestionStore {
-  /** The session's suggestion, `null` when it has none. */
-  get(sessionId: string): PromptSuggestion | null;
-  /** Calls `listener` when the session's suggestion changes. Returns the unsubscribe. */
-  subscribe(sessionId: string, listener: () => void): () => void;
-  /** Drops the session's suggestion. */
-  clear(sessionId: string): void;
-}
-
-/**
- * Creates a {@link PromptSuggestionStore} over a host's suggestions.
- *
- * @param source - The host's `suggestions` member.
- */
-export function createPromptSuggestionStore(source: ComposerSuggestions): PromptSuggestionStore {
-  const suggestions = new Map<string, PromptSuggestion>();
-  const listeners = new Map<string, Set<() => void>>();
-  let started = false;
-
-  const notify = (sessionId: string) => {
-    for (const listener of listeners.get(sessionId) ?? []) listener();
-  };
-  const clear = (sessionId: string) => {
-    if (!suggestions.delete(sessionId)) return;
-    notify(sessionId);
-  };
-  const start = () => {
-    if (started) return;
-    started = true;
-    source.onReady(({ sessionId, runId, text }) => {
-      const prev = suggestions.get(sessionId);
-      if (prev?.runId === runId && prev.text === text) return;
-      suggestions.set(sessionId, { runId, text });
-      notify(sessionId);
-    });
-    source.onStale?.(clear);
-  };
-
-  return {
-    get: (sessionId) => suggestions.get(sessionId) ?? null,
-    subscribe(sessionId, listener) {
-      start();
-      let group = listeners.get(sessionId);
-      if (!group) {
-        group = new Set();
-        listeners.set(sessionId, group);
-      }
-      group.add(listener);
-      return () => {
-        group.delete(listener);
-        if (group.size === 0 && listeners.get(sessionId) === group) listeners.delete(sessionId);
-      };
-    },
-    clear,
-  };
-}