zidane-ui 9.0.4 → 9.1.3

package/src/chat/headless/sidebar/rows.ts

@@ -1,229 +0,0 @@
-/**
- * The sidebar's rows: zidane-ui's session-list model (sort, date / state /
- * project grouping, collapse, "show more") over the app's sessions, plus the
- * app's own layer on top: the Per host view's one section per host, and the
- * sections the list renders (`nestSidebarRows`).
- */
-import type { HostView } from '../hosts';
-import {
-  buildSessionRows,
-  type SessionGroupBy as ListGroupBy,
-  type SessionListOptions,
-  type SessionListRow,
-} from '../session-list';
-import type { SidebarGroupBy, SidebarListSession, SidebarSortBy } from './types';
-
-/**
- * The project a session is listed under: its repository's root, else its folder (`''`: none).
- *
- * @param session - Its folder and project root.
- */
-export function projectPathOf(session: Pick<SidebarListSession, 'projectRoot' | 'cwd'>): string {
-  return session.projectRoot || session.cwd;
-}
-
-/** One row of the sidebar: a session-list row (a header may name its host) or a host's section header. */
-export type SidebarRow<S extends SidebarListSession = SidebarListSession> =
-  | Exclude<SessionListRow<S>, { kind: 'header' }>
-  /** A group header; a server's folder names its server (`hostId`), shown as a chip. */
-  | (Extract<SessionListRow<S>, { kind: 'header' }> & { hostId?: string })
-  /**
-   * A host's section in the Per host view (This computer, then each saved
-   * server): its name and connection status. Collapsing it hides every
-   * group under it.
-   */
-  | { kind: 'host'; id: string; host: HostView; collapsed: boolean; count: number };
-
-/**
- * Views whose groups are folders: Per directory, and each host's section in Per host.
- *
- * @param groupBy - The view.
- */
-export function groupsByFolder(groupBy: SidebarGroupBy): boolean {
-  return groupBy === 'project' || groupBy === 'host';
-}
-
-const EMPTY_SET: ReadonlySet<string> = new Set();
-
-/** The directory-less bucket's label ("pure chat" sessions, no project). */
-export const CHATS_BUCKET = 'Chats';
-
-/** The list options {@link buildSidebarRows} passes through. */
-export type BuildSidebarRowsOptions = Pick<
-  SessionListOptions<SidebarListSession>,
-  'collapsedGroups' | 'showMoreExpanded' | 'idPrefix' | 'pinnedProjects'
->;
-
-/**
- * Orchestration on: the main session is pulled out (pinned above the list).
- * Off: the main is not a chat; it is hidden, not regrouped.
- *
- * @param sessions - The listed sessions.
- * @param orchestrationEnabled - Orchestration is on.
- */
-export function partitionMainSession<S extends SidebarListSession>(
-  sessions: readonly S[],
-  orchestrationEnabled: boolean,
-): { main: S | null; rest: S[] } {
-  if (!orchestrationEnabled) return { main: null, rest: sessions.filter((s) => s.isMain !== true) };
-  const main = sessions.find((s) => s.isMain === true) ?? null;
-  return main ? { main, rest: sessions.filter((s) => s.id !== main.id) } : { main: null, rest: sessions.slice() };
-}
-
-/**
- * The sidebar's rows over the kit's session-list model: favorites, git repositories and the project of each session.
- *
- * @param sessions - The sessions to list.
- * @param groupBy - The session-list grouping.
- * @param sortBy - The order inside a group.
- * @param options - Collapsed groups, expanded "show more", id prefix, pinned projects.
- * @param project - The project a session groups under (defaults to {@link projectPathOf}).
- */
-export function buildSidebarRows<S extends SidebarListSession>(
-  sessions: S[],
-  groupBy: ListGroupBy,
-  sortBy: SidebarSortBy,
-  options: BuildSidebarRowsOptions = {},
-  project: (session: S) => string = projectPathOf,
-): SidebarRow<S>[] {
-  return buildSessionRows(sessions, {
-    ...options,
-    groupBy,
-    sortBy,
-    project,
-    isGitRepo: (s) => s.isGitRepo === true,
-    isFavorite: (s) => s.favorite === true,
-  });
-}
-
-/*
- * Outside Per host every host shares one list, so a server's folder is keyed
- * with its host: the same path on two hosts is two groups. The list model
- * labels a folder by its last segment, so the host goes at the end
- * (`api<SEP>box`): server folders never take a local folder's name, and the
- * suffix is swapped for the server's name once the rows are built.
- */
-const HOST_SEP = '\u0000';
-
-function hostFolderKey(session: SidebarListSession): string {
-  const path = projectPathOf(session);
-  if (!session.hostId || !path) return path;
-  return `${path.replace(/\/+$/, '') || '/'}${HOST_SEP}${session.hostId}`;
-}
-
-/** A server folder's header: the folder, its server as `hostId` (a chip), without the local folder affordances. */
-function serverFolderHeader<S extends SidebarListSession>(row: SidebarRow<S>): SidebarRow<S> {
-  if (row.kind !== 'header' || !row.fullPath?.includes(HOST_SEP)) return row;
-  const { fullPath, isGitRepo: _isGitRepo, ...rest } = row;
-  const hostId = fullPath.slice(fullPath.indexOf(HOST_SEP) + 1);
-  const folder = row.label.replace(`${HOST_SEP}${hostId}`, '') || '/';
-  return { ...rest, label: folder, hostId };
-}
-
-function withoutLocalPath<S extends SidebarListSession>(row: SidebarRow<S>): SidebarRow<S> {
-  if (row.kind !== 'header' || row.fullPath === undefined) {
-    return row;
-  }
-
-  const { fullPath: _fullPath, isGitRepo: _isGitRepo, ...rest } = row;
-  return rest;
-}
-
-/**
- * The sidebar's rows over every host. Per host: This computer's section
- * first, then each saved server's, each host's sessions grouped per folder
- * under its header. Any other view lists every host in one list, a server's
- * folder headers naming the server. Sessions of a server no longer saved are
- * not listed.
- *
- * @param sessions - The sessions to list.
- * @param hosts - This machine and each saved server, in order.
- * @param groupBy - The view.
- * @param sortBy - The order inside a group.
- * @param options - Collapsed groups, expanded "show more", pinned projects.
- */
-export function buildHostSidebarRows<S extends SidebarListSession>(
-  sessions: S[],
-  hosts: readonly HostView[],
-  groupBy: SidebarGroupBy,
-  sortBy: SidebarSortBy,
-  options: BuildSidebarRowsOptions = {},
-): SidebarRow<S>[] {
-  const servers = new Map(hosts.filter((host) => host.kind === 'server').map((host) => [host.id, host.name]));
-
-  if (groupBy !== 'host') {
-    const listed = sessions.filter((s) => !s.hostId || servers.has(s.hostId));
-    const rows = buildSidebarRows(listed, groupBy, sortBy, options, hostFolderKey);
-    return servers.size > 0 ? rows.map(serverFolderHeader) : rows;
-  }
-
-  const local = sessions.filter((s) => !s.hostId);
-  const collapsedGroups = options.collapsedGroups ?? EMPTY_SET;
-  const out: SidebarRow<S>[] = [];
-
-  for (const host of hosts) {
-    const own = host.kind === 'local' ? local : sessions.filter((s) => s.hostId === host.id);
-    const id = `host-${host.id}`;
-    const collapsed = collapsedGroups.has(id);
-    out.push({ kind: 'host', id, host, collapsed, count: own.length });
-
-    if (!collapsed) {
-      // Pins are this computer's folders: a server's list ignores them.
-      const { pinnedProjects: _pinnedProjects, ...rest } = options;
-      const rows = buildSidebarRows(own, 'project', sortBy, {
-        ...(host.kind === 'local' ? options : rest),
-        idPrefix: `${host.id}:`,
-      });
-      // A server's folders are not on this machine: no icon keying, no "new session here".
-      out.push(...(host.kind === 'server' ? rows.map(withoutLocalPath) : rows));
-    }
-  }
-
-  return out;
-}
-
-type SectionHeader<S extends SidebarListSession> = Extract<SidebarRow<S>, { kind: 'header' } | { kind: 'host' }>;
-
-/**
- * What the sidebar list renders: a session or "show more" row, or a section,
- * a header and the rows under it, drawn as its own `<ul>` so the header
- * sticks while they scroll by and the next section pushes it out.
- */
-export type SidebarNode<S extends SidebarListSession = SidebarListSession> =
-  | Extract<SidebarRow<S>, { kind: 'session' } | { kind: 'showMore' }>
-  | { kind: 'section'; id: string; header: SectionHeader<S>; children: SidebarNode<S>[] };
-
-/**
- * The flat rows as nested sections: a host's section holds its groups, a
- * group's holds its rows. Rows before any header (a flat view) stay at the
- * top level, and so do a flat view's rows after its Favorites.
- *
- * @param rows - The flat rows.
- */
-export function nestSidebarRows<S extends SidebarListSession>(rows: readonly SidebarRow<S>[]): SidebarNode<S>[] {
-  const top: SidebarNode<S>[] = [];
-  let host: Extract<SidebarNode<S>, { kind: 'section' }> | null = null;
-  let group: Extract<SidebarNode<S>, { kind: 'section' }> | null = null;
-
-  for (const row of rows) {
-    if (row.kind === 'host') {
-      host = { kind: 'section', id: row.id, header: row, children: [] };
-      group = null;
-      top.push(host);
-      continue;
-    }
-    if (row.kind === 'header') {
-      group = { kind: 'section', id: row.id, header: row, children: [] };
-      (host?.children ?? top).push(group);
-      continue;
-    }
-    if (group?.header.kind === 'header' && group.header.favorites && row.kind === 'session' && !row.favorites) {
-      group = null;
-    }
-    const parent = group ?? host;
-    if (parent) parent.children.push(row);
-    else top.push(row);
-  }
-
-  return top;
-}

package/src/chat/headless/sidebar/types.ts

@@ -1,61 +0,0 @@
-/**
- * The session sidebar's shared vocabulary: the row a session list shows, the
- * five filter axes and the per-space view. React-free.
- */
-import type { ChatSessionStatus } from '../host';
-
-/**
- * One session as the sidebar lists it: the chat session plus where it runs
- * (folder, host, space). An app's own row type extends it.
- */
-export interface SidebarListSession {
-  /** The session's key. */
-  id: string;
-  /** What the row shows. */
-  title: string;
-  /** Whether a run is going, and how the last one ended. */
-  status: ChatSessionStatus;
-  /** Epoch ms. */
-  createdAt: number;
-  /** Epoch ms of the last activity. */
-  updatedAt: number;
-  /** The folder its tools run in. */
-  cwd: string;
-  /** The repository or project folder it belongs to, when known. */
-  projectRoot?: string;
-  /** The remote host it lives on; undefined on this machine. */
-  hostId?: string;
-  /** The space it belongs to; undefined in the default space. */
-  spaceId?: string;
-  /** The orchestration main session. */
-  isMain?: boolean;
-  /** Its folder is a git repository. */
-  isGitRepo?: boolean;
-  /** Starred: listed under Favorites. */
-  favorite?: boolean;
-  /** Archived: listed only under the archived filter. */
-  archived?: boolean;
-}
-
-/** Which sessions the list reads: the archive axis is the one the host filters. */
-export type SessionArchiveFilter = 'active' | 'archived' | 'all';
-/** Only sessions touched within the last day, 3, 7 or 30 days. */
-export type SessionActivityFilter = 'all' | '1d' | '3d' | '7d' | '30d';
-/** How the sidebar groups its rows: the session list's groupings plus one section per host. */
-export type SidebarGroupBy = 'none' | 'date' | 'state' | 'project' | 'host';
-/** How the sidebar orders sessions inside a group. */
-export type SidebarSortBy = 'recency' | 'createdTime' | 'alphabetical';
-
-/** The five filter axes, kept per space. */
-export interface SidebarView {
-  /** Active, archived or every session. */
-  archive: SessionArchiveFilter;
-  /** A project's folder name, or null for every project. */
-  project: string | null;
-  /** Only sessions touched recently. */
-  activity: SessionActivityFilter;
-  /** How the rows group. */
-  groupBy: SidebarGroupBy;
-  /** How the rows sort inside a group. */
-  sortBy: SidebarSortBy;
-}

package/src/chat/headless/sidebar/view.ts

@@ -1,296 +0,0 @@
-/**
- * The sidebar's view: the five filter axes (archive, project, activity,
- * group by, sort by) kept per space, the conversation last open in each
- * space, and the space the sidebar shows.
- *
- * Storage-first: a view reads from the app's Storage synchronously at
- * creation, so the first frame already has it. When the host keeps a copy
- * too (`ChatHost.sessions.views`, the desktop app's database), it is read
- * once and wins for every space this run has not changed yet; a space only
- * this device knows is written back to it.
- */
-import { DEFAULT_SPACE_ID } from 'zidane/chat/pure';
-
-import { writable, type Readable } from '../store';
-import type { SessionActivityFilter, SessionArchiveFilter, SidebarGroupBy, SidebarSortBy, SidebarView } from './types';
-
-/** A view nobody changed yet. */
-export const DEFAULT_SIDEBAR_VIEW: SidebarView = {
-  archive: 'active',
-  project: null,
-  activity: 'all',
-  groupBy: 'project',
-  sortBy: 'recency',
-};
-
-/** Where the views persist: one map of space id → view. */
-export const SIDEBAR_VIEW_KEY = 'zg-sidebar-view:v1';
-/** Where the shown space persists. */
-export const SIDEBAR_SPACE_KEY = 'zg-sidebar-space';
-
-/** A space's record as stored: its view, plus the conversation last open in it (`session`, when one was). */
-export type SidebarViewRecord = SidebarView & { session?: string };
-
-/** The views the host keeps for this user, next to the device's Storage. */
-export interface SidebarViewsHost {
-  /** Every saved view, keyed by space id (anything malformed is dropped). */
-  getViews(): Promise<unknown>;
-  /** Saves a space's record (its view and last open conversation). */
-  setView(spaceId: string, view: SidebarViewRecord): Promise<unknown>;
-  /** The space last shown, if any. */
-  getSpace(): Promise<unknown>;
-  /** Saves the space shown. */
-  setSpace(spaceId: string): Promise<unknown>;
-}
-
-const oneOf =
-  <T extends string>(members: readonly T[]) =>
-  (raw: string): T | undefined =>
-    members.includes(raw as T) ? (raw as T) : undefined;
-
-const parseArchive = oneOf<SessionArchiveFilter>(['active', 'archived', 'all']);
-const parseActivity = oneOf<SessionActivityFilter>(['all', '1d', '3d', '7d', '30d']);
-const parseGroupBy = oneOf<SidebarGroupBy>(['none', 'date', 'state', 'project', 'host']);
-const parseSortBy = oneOf<SidebarSortBy>(['recency', 'createdTime', 'alphabetical']);
-
-/**
- * A stored view, every axis checked; what is missing or unknown takes the default.
- *
- * @param raw - The stored value.
- */
-export function parseSidebarView(raw: unknown): SidebarView {
-  const o = raw && typeof raw === 'object' ? (raw as Record<string, unknown>) : {};
-  const str = (v: unknown) => (typeof v === 'string' ? v : '');
-  const d = DEFAULT_SIDEBAR_VIEW;
-  return {
-    archive: parseArchive(str(o.archive)) ?? d.archive,
-    project: typeof o.project === 'string' && o.project.length > 0 ? o.project : null,
-    activity: parseActivity(str(o.activity)) ?? d.activity,
-    groupBy: parseGroupBy(str(o.groupBy)) ?? d.groupBy,
-    sortBy: parseSortBy(str(o.sortBy)) ?? d.sortBy,
-  };
-}
-
-/** Views per space id. */
-export type SidebarViewMap = Record<string, SidebarView>;
-
-function viewsFrom(stored: unknown): SidebarViewMap | undefined {
-  if (!stored || typeof stored !== 'object' || Array.isArray(stored)) return undefined;
-  return Object.fromEntries(Object.entries(stored).map(([id, view]) => [id, parseSidebarView(view)]));
-}
-
-/** The conversation last open per space id. */
-export type SidebarLastSessions = Record<string, string>;
-
-function sessionsFrom(stored: unknown): SidebarLastSessions {
-  if (!stored || typeof stored !== 'object' || Array.isArray(stored)) return {};
-  return Object.fromEntries(
-    Object.entries(stored).flatMap(([id, record]) => {
-      const session = record && typeof record === 'object' ? (record as Record<string, unknown>).session : undefined;
-      return typeof session === 'string' && session.length > 0 ? [[id, session]] : [];
-    }),
-  );
-}
-
-function parseJson(raw: string | undefined): unknown {
-  if (raw === undefined) return undefined;
-  try {
-    return JSON.parse(raw) as unknown;
-  } catch {
-    return undefined;
-  }
-}
-
-/** One key per axis, from before the views were kept per space: read once into the default space, then removed. */
-const LEGACY_KEYS = {
-  archive: 'zg-sidebar-archive-filter',
-  project: 'zg-sidebar-project-filter',
-  activity: 'zg-sidebar-activity-filter',
-  groupBy: 'zg-sidebar-group-by',
-  sortBy: 'zg-sidebar-sort-by',
-} as const satisfies Record<keyof SidebarView, string>;
-
-/** The Storage the views persist in (`localStorage` in a browser). */
-export type SidebarViewsStorage = Pick<Storage, 'getItem' | 'setItem' | 'removeItem'>;
-
-function read(storage: SidebarViewsStorage | undefined, key: string): string | undefined {
-  try {
-    return storage?.getItem(key) ?? undefined;
-  } catch {
-    return undefined;
-  }
-}
-
-function write(storage: SidebarViewsStorage | undefined, key: string, value: string | null): void {
-  try {
-    if (value === null) storage?.removeItem(key);
-    else storage?.setItem(key, value);
-  } catch {
-    // Storage full or blocked: the view still holds for this run.
-  }
-}
-
-/**
- * The views the Storage holds: the per-space map, else the legacy per-axis keys as the default space's view.
- *
- * @param storage - Where the views persist; absent reads nothing.
- */
-export function readSidebarViews(storage: SidebarViewsStorage | undefined): SidebarViewMap {
-  const stored = viewsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
-  if (stored) return stored;
-  const legacy = Object.fromEntries(Object.entries(LEGACY_KEYS).map(([field, key]) => [field, read(storage, key)]));
-  return Object.values(legacy).some((v) => v !== undefined) ? { [DEFAULT_SPACE_ID]: parseSidebarView(legacy) } : {};
-}
-
-/** The sidebar's views and shown space, outside React. */
-export interface SidebarViews {
-  /** Every space's view. */
-  views: Readable<SidebarViewMap>;
-  /** The space the sidebar shows. */
-  space: Readable<string>;
-  /** The space's view (the default when it has none). */
-  viewOf(spaceId: string): SidebarView;
-  /** Change some axes of a space's view; persisted at once. */
-  patch(spaceId: string, patch: Partial<SidebarView>): void;
-  /** Show another space; persisted at once. */
-  setSpace(spaceId: string): void;
-  /** The conversation last open in a space, if one was. */
-  lastSessionOf(spaceId: string): string | null;
-  /** Remember the conversation open in a space; persisted at once (no-op when unchanged). */
-  rememberSession(spaceId: string, sessionId: string): void;
-  /** Forget a conversation in every space that remembers it (deleted, moved away). */
-  forgetSession(sessionId: string, exceptSpaceId?: string): void;
-  /** Read the host's copies once (no-op without a host). Call after creation. */
-  sync(): void;
-}
-
-/** Options of {@link createSidebarViews}. */
-export interface SidebarViewsOptions {
-  /** Where the views persist on this device. */
-  storage?: SidebarViewsStorage;
-  /** The host's copy (`ChatHost.sessions.views`). */
-  host?: SidebarViewsHost;
-  /** The space shown when none was saved. */
-  fallbackSpace?: string;
-  /** A host read or write failed. */
-  onError?: (what: 'views' | 'view' | 'space', error: unknown) => void;
-}
-
-/**
- * The views store: Storage first, the host's copy merged in once ({@link SidebarViews.sync}).
- *
- * @param options - Storage, host and fallback space.
- */
-export function createSidebarViews(options: SidebarViewsOptions = {}): SidebarViews {
-  const { storage, host, onError } = options;
-  const views = writable<SidebarViewMap>(readSidebarViews(storage));
-  let lastSessions: SidebarLastSessions = sessionsFrom(parseJson(read(storage, SIDEBAR_VIEW_KEY)));
-  const savedSpace = read(storage, SIDEBAR_SPACE_KEY);
-  const space = writable<string>(savedSpace || (options.fallbackSpace ?? DEFAULT_SPACE_ID));
-  /** Spaces whose view changed this run: the host's older copy never overwrites them. */
-  const changed = new Set<string>();
-  /** Spaces whose last open conversation changed this run, likewise. */
-  const reopened = new Set<string>();
-  let switched = false;
-  let synced = false;
-
-  const recordOf = (spaceId: string, view = views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW): SidebarViewRecord => {
-    const session = lastSessions[spaceId];
-    return session ? { ...view, session } : view;
-  };
-  const persistViews = (next: SidebarViewMap) => {
-    const ids = new Set([...Object.keys(next), ...Object.keys(lastSessions)]);
-    const records = Object.fromEntries([...ids].map((id) => [id, recordOf(id, next[id] ?? DEFAULT_SIDEBAR_VIEW)]));
-    write(storage, SIDEBAR_VIEW_KEY, JSON.stringify(records));
-    for (const key of Object.values(LEGACY_KEYS)) write(storage, key, null);
-  };
-  const saveView = (spaceId: string, view?: SidebarView) => {
-    host?.setView(spaceId, recordOf(spaceId, view)).catch((err: unknown) => onError?.('view', err));
-  };
-  const setLastSession = (spaceId: string, sessionId: string | null) => {
-    const next = { ...lastSessions };
-    if (sessionId) next[spaceId] = sessionId;
-    else delete next[spaceId];
-    lastSessions = next;
-    reopened.add(spaceId);
-  };
-  const saveSpace = (spaceId: string) => {
-    host?.setSpace(spaceId).catch((err: unknown) => onError?.('space', err));
-  };
-
-  return {
-    views,
-    space,
-    viewOf: (spaceId) => views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW,
-    patch(spaceId, patch) {
-      const view = { ...(views.get()[spaceId] ?? DEFAULT_SIDEBAR_VIEW), ...patch };
-      changed.add(spaceId);
-      const next = { ...views.get(), [spaceId]: view };
-      views.set(next);
-      persistViews(next);
-      saveView(spaceId, view);
-    },
-    setSpace(spaceId) {
-      switched = true;
-      space.set(spaceId);
-      write(storage, SIDEBAR_SPACE_KEY, spaceId);
-      saveSpace(spaceId);
-    },
-    lastSessionOf: (spaceId) => lastSessions[spaceId] ?? null,
-    rememberSession(spaceId, sessionId) {
-      if (lastSessions[spaceId] === sessionId) return;
-      setLastSession(spaceId, sessionId);
-      persistViews(views.get());
-      saveView(spaceId);
-    },
-    forgetSession(sessionId, exceptSpaceId) {
-      const spaces = Object.keys(lastSessions).filter((id) => id !== exceptSpaceId && lastSessions[id] === sessionId);
-      if (spaces.length === 0) return;
-      for (const id of spaces) setLastSession(id, null);
-      persistViews(views.get());
-      for (const id of spaces) saveView(id);
-    },
-    sync() {
-      if (!host || synced) return;
-      synced = true;
-      host
-        .getViews()
-        .then((stored) => {
-          const saved = viewsFrom(stored) ?? {};
-          const local = views.get();
-          // A space the host keeps takes its record whole (a missing \`session\` included), like its view.
-          const own = lastSessions;
-          const hostSessions = sessionsFrom(stored);
-          const merged: SidebarLastSessions = { ...own, ...hostSessions };
-          for (const id of Object.keys(saved)) if (!(id in hostSessions)) delete merged[id];
-          for (const id of reopened) {
-            if (own[id]) merged[id] = own[id];
-            else delete merged[id];
-          }
-          lastSessions = merged;
-          const next: SidebarViewMap = { ...local, ...saved };
-          for (const id of changed) {
-            const own = local[id];
-            if (own) next[id] = own;
-          }
-          for (const [id, view] of Object.entries(local)) if (!(id in saved)) saveView(id, view);
-          views.set(next);
-          persistViews(next);
-        })
-        .catch((err: unknown) => onError?.('views', err));
-      host
-        .getSpace()
-        .then((saved) => {
-          if (switched) return;
-          if (typeof saved === 'string' && saved.length > 0) {
-            space.set(saved);
-            write(storage, SIDEBAR_SPACE_KEY, saved);
-            return;
-          }
-          const own = read(storage, SIDEBAR_SPACE_KEY);
-          if (own) saveSpace(own);
-        })
-        .catch((err: unknown) => onError?.('space', err));
-    },
-  };
-}

package/src/chat/headless/site-icons.ts

@@ -1,51 +0,0 @@
-/**
- * Site icons for link badges, one request per origin for the whole page
- * (`ChatHost.siteIcons`). An app builds one over its fetcher and shares it,
- * so every badge of a site shares the answer, and badges drawn outside React
- * (an editor's decorations) hear when one lands.
- */
-import type { ChatSiteIcons } from './transcript-host';
-
-/**
- * The `http(s)` origin a link's icon belongs to, or `null` when it has none.
- *
- * @param url - The link's address.
- */
-export function siteOrigin(url: string): string | null {
-  try {
-    const { protocol, origin, hostname } = new URL(url);
-    return (protocol === 'http:' || protocol === 'https:') && hostname ? origin : null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * Creates the site icon cache over a fetcher.
- *
- * @param fetch - Loads an origin's icon as a data URL; `null` when it has none.
- */
-export function createSiteIcons(fetch: (origin: string) => Promise<string | null>): ChatSiteIcons {
-  const icons = new Map<string, string | null>();
-  const inflight = new Set<string>();
-  const listeners = new Set<() => void>();
-  return {
-    get: (origin) => icons.get(origin) ?? null,
-    request(origin) {
-      if (icons.has(origin) || inflight.has(origin)) return;
-      inflight.add(origin);
-      void Promise.resolve()
-        .then(() => fetch(origin))
-        .catch(() => null)
-        .then((icon) => {
-          inflight.delete(origin);
-          icons.set(origin, icon);
-          if (icon) listeners.forEach((listener) => listener());
-        });
-    },
-    subscribe(listener) {
-      listeners.add(listener);
-      return () => listeners.delete(listener);
-    },
-  };
-}