zidane-ui 9.1.1 → 9.1.4

package/src/chat/headless/chip-views.ts

@@ -1,215 +0,0 @@
-/**
- * The chip hover cards' views: what was read for a commit, a referenced chat,
- * a skill or a command, turned into the shared card's
- * `ExtensionReferenceView` (`ChipCard`), so every kind lays out the same. Pure:
- * the reads are `ChatHost.chips` (`transcript/chip-details.ts`), the words are
- * the labels passed in.
- */
-import { fmtTokens, type ExtensionReferenceView } from 'zidane/chat/pure';
-
-import type { ChatLabels } from './labels';
-import { relativeTime } from './session-list';
-import type {
-  ChatCommandFacts,
-  ChatCommit,
-  ChatContextFacts,
-  ChatSessionFacts,
-  ChatSkillFacts,
-} from './transcript-host';
-
-/** The labels the views read. */
-export type ChipViewLabels = Pick<
-  ChatLabels,
-  | 'chipFactChanges'
-  | 'chipFactDate'
-  | 'chipFactModel'
-  | 'chipFactContext'
-  | 'chipFactPrompts'
-  | 'chipFactTurns'
-  | 'chipFactBranch'
-  | 'chipFactUpdated'
-  | 'chipFactAliases'
-  | 'chipFactSize'
-  | 'chipTokens'
-  | 'chipSessionRunning'
-  | 'chipSessionError'
-  | 'chipUntitledChat'
-  | 'justNow'
-  | 'months'
->;
-
-/**
- * A sha chip's card: the short sha, the subject as its title, the author, the change size and the age.
- *
- * @param labels - The chat labels (the facts' names).
- * @param sha - The sha as the chip shows it.
- * @param info - The commit, once read (`null`: unknown).
- * @param href - The commit's page.
- * @param now - The time ages are measured from.
- */
-export function commitView(
-  labels: ChipViewLabels,
-  sha: string,
-  info: ChatCommit | null | undefined,
-  href: string | undefined,
-  now = Date.now(),
-): ExtensionReferenceView {
-  return {
-    label: (info?.sha ?? sha).slice(0, 7),
-    icon: { gui: 'i-ph-git-commit' },
-    tone: 'muted',
-    ...(info?.subject ? { title: info.subject } : {}),
-    ...(href ? { href } : {}),
-    ...(info
-      ? {
-          card: {
-            ...(info.author ? { subtitle: info.author } : {}),
-            facts: [
-              {
-                label: labels.chipFactChanges,
-                value: `+${info.added} −${info.removed}`,
-                diff: { added: info.added, removed: info.removed, files: info.files },
-              },
-              ...(info.authoredAt
-                ? [{ label: labels.chipFactDate, value: relativeTime(info.authoredAt, now, labels) }]
-                : []),
-            ],
-          },
-        }
-      : {}),
-  };
-}
-
-const normalizeId = (id: string) => id.replace(/-/g, '').toLowerCase();
-
-/**
- * The chat a `#token` names: the one session whose id starts with it.
- *
- * @param sessions - The sessions a token can name.
- * @param token - The chip's text (`#3f2a`).
- */
-export function sessionForToken<S extends { id: string }>(sessions: readonly S[], token: string): S | null {
-  const needle = token.replace(/^#/, '').toLowerCase();
-  if (!needle) return null;
-  const hits = sessions.filter((s) => normalizeId(s.id).startsWith(needle));
-  return hits.length === 1 ? hits[0]! : null;
-}
-
-/**
- * A `#chat` chip's card: the title, the project, the model and context gauge, prompts and turns, the age.
- *
- * @param labels - The chat labels (the facts' names).
- * @param token - The chip's text.
- * @param session - The chat it names (`null`: none).
- * @param context - Its context gauge, once read.
- * @param now - The time ages are measured from.
- */
-export function sessionView(
-  labels: ChipViewLabels,
-  token: string,
-  session: ChatSessionFacts | null,
-  context: ChatContextFacts | null,
-  now = Date.now(),
-): ExtensionReferenceView {
-  const label = token.startsWith('#') ? token : `#${token}`;
-  if (!session) return { label, icon: { gui: 'i-ph-chats' }, tone: 'muted' };
-  const status =
-    session.status === 'running'
-      ? { text: labels.chipSessionRunning, tone: 'accent' as const }
-      : session.status === 'error'
-        ? { text: labels.chipSessionError, tone: 'danger' as const }
-        : undefined;
-  const project = (session.project ?? '').split('/').filter(Boolean).pop();
-  const model = context?.modelId ?? session.modelId;
-  const facts = [
-    ...(model ? [{ label: labels.chipFactModel, value: model }] : []),
-    ...(context && context.usedLabel !== '0'
-      ? [
-          {
-            label: labels.chipFactContext,
-            value: `${context.usedLabel} / ${context.windowLabel} (${Math.round(context.fraction * 100)}%)`,
-          },
-        ]
-      : []),
-    { label: labels.chipFactPrompts, value: String(session.prompts ?? 0) },
-    { label: labels.chipFactTurns, value: String(session.turns ?? 0) },
-    ...(session.branch ? [{ label: labels.chipFactBranch, value: session.branch }] : []),
-    { label: labels.chipFactUpdated, value: relativeTime(session.updatedAt, now, labels) },
-  ];
-  return {
-    label,
-    icon: { gui: 'i-ph-chats' },
-    tone: status?.tone ?? 'muted',
-    ...(status ? { status: status.text } : {}),
-    title: session.title || labels.chipUntitledChat,
-    card: { ...(project ? { subtitle: project } : {}), facts },
-  };
-}
-
-/**
- * A skill's name in its chip text (`/review`, `$review`, `review`).
- *
- * @param text - The chip's text.
- */
-export const skillName = (text: string) => text.replace(/^[^\w]+/, '');
-
-/** Same heuristic as the harness' `estimateTokens` (4 bytes a token). */
-const estimateTokens = (text: string) => Math.ceil(text.length / 4);
-
-/**
- * A skill chip's card: the description and the size in tokens.
- *
- * @param labels - The chat labels (the facts' names).
- * @param text - The chip's text.
- * @param skill - The skill it names (`null`: none).
- */
-export function skillView(labels: ChipViewLabels, text: string, skill: ChatSkillFacts | null): ExtensionReferenceView {
-  const label = skillName(text);
-  if (!skill) return { label, icon: { gui: 'i-ph-book-bookmark' }, tone: 'accent' };
-  const tokens = estimateTokens(skill.instructions ?? '');
-  const source = skill.source && skill.source !== 'inline' ? skill.source : undefined;
-  return {
-    label: skill.name,
-    icon: { gui: 'i-ph-book-bookmark' },
-    tone: 'accent',
-    ...(source ? { status: source } : {}),
-    card: {
-      facts: [{ label: labels.chipFactSize, value: labels.chipTokens(fmtTokens(tokens)) }],
-      ...(skill.description ? { body: skill.description } : {}),
-    },
-  };
-}
-
-/**
- * The command a chip names (`/fix conflicts` → `fix`).
- *
- * @param text - The chip's text.
- */
-export const commandName = (text: string) => /^\/?([\w][\w:.-]*)/.exec(text.trim())?.[1] ?? '';
-
-/**
- * A command chip's card: the description and the aliases.
- *
- * @param labels - The chat labels (the facts' names).
- * @param text - The chip's text.
- * @param command - The command it names (`null`: none).
- */
-export function commandView(
-  labels: ChipViewLabels,
-  text: string,
-  command: ChatCommandFacts | null,
-): ExtensionReferenceView {
-  const label = text.trim().startsWith('/') ? text.trim() : `/${text.trim()}`;
-  if (!command) return { label, icon: { gui: 'i-ph-terminal-window' }, tone: 'accent' };
-  const aliases = (command.aliases ?? []).map((a) => `/${a}`).join(', ');
-  return {
-    label,
-    icon: { gui: 'i-ph-terminal-window' },
-    tone: 'accent',
-    ...(command.group ? { status: command.group } : {}),
-    card: {
-      ...(aliases ? { facts: [{ label: labels.chipFactAliases, value: aliases }] } : {}),
-      ...(command.description ? { body: command.description } : {}),
-    },
-  };
-}

package/src/chat/headless/composer/attachment-dedupe.ts

@@ -1,50 +0,0 @@
-/**
- * One drop or paste can hand the same file over twice (CleanShot X does), and
- * a file can be dropped again while its first copy is staged or still being
- * read. A file is the same one when its name, size and modification time
- * match; a staged attachment without that key (pushed from elsewhere, restored
- * from a draft) matches on name and size.
- */
-
-/** What identifies a dropped or pasted file. */
-export interface FileIdentity {
-  name: string;
-  size: number;
-  lastModified: number;
-}
-
-/** An attachment already in the composer: `fileKey` when it came from a file. */
-export interface StagedIdentity {
-  name: string;
-  size: number;
-  fileKey?: string;
-}
-
-export function attachmentFileKey(file: FileIdentity): string {
-  return `${file.name}\u0000${file.size}\u0000${file.lastModified}`;
-}
-
-/**
- * `files` minus repeats within the batch and files already staged or in flight.
- *
- * @param files - The batch, in order; the first copy of a repeat is kept.
- * @param staged - The composer's attachments.
- * @param pending - Keys of files still being read.
- */
-export function freshAttachmentFiles<T extends FileIdentity>(
-  files: readonly T[],
-  staged: readonly StagedIdentity[],
-  pending: ReadonlySet<string> = new Set(),
-): T[] {
-  const seen = new Set(pending);
-  for (const att of staged) if (att.fileKey) seen.add(att.fileKey);
-  const keyless = new Set(staged.filter((att) => !att.fileKey).map((att) => `${att.name}\u0000${att.size}`));
-  const fresh: T[] = [];
-  for (const file of files) {
-    const key = attachmentFileKey(file);
-    if (seen.has(key) || keyless.has(`${file.name}\u0000${file.size}`)) continue;
-    seen.add(key);
-    fresh.push(file);
-  }
-  return fresh;
-}

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

@@ -1,16 +0,0 @@
-/** The `/` command catalog's lookups, shared by the composer, its badges and the send path. */
-import { parseCommandInvocation } from 'zidane/chat/pure';
-
-import type { CommandSummary } from './host';
-
-/**
- * The command `token` (a name or an alias, without the slash) names in `commands`, or `undefined`.
- *
- * @param commands - The catalog.
- * @param token - What follows the `/`.
- */
-export function findCommand(commands: readonly CommandSummary[], token: string): CommandSummary | undefined {
-  const name = /\s/.test(token) ? undefined : parseCommandInvocation(`/${token}`, commands)?.name;
-
-  return name === undefined ? undefined : commands.find((c) => c.name === name);
-}

package/src/chat/headless/composer/composer-sources.ts

@@ -1,150 +0,0 @@
-/**
- * The composer's completion sources (`ComposerHost.completions`) and how
- * the Chatbox reads them. `@` files, `/` commands and `#` chats are read
- * when asked for (their popover opens; a typed `/name` needs its badge):
- * nothing is fetched while they stay closed, an invalidation (an agent's
- * write, a session change) only stales them, and the next read refetches.
- * A read waits a moment for that refetch (`@foo` right after the agent wrote
- * foo.ts), then answers with the last list while it runs. `/` skills and
- * extension completion providers stay subscribed (`use-composer-sources.ts`):
- * the submit path and the editor need them, and they rarely change.
- */
-import type { ChatReferenceEntry } from 'zidane/chat/pure';
-
-import type { CommandSummary, ComposerCompletions, FileEntry } from './host';
-
-/** How long a read of a stale list waits for its refetch before answering with the last list. */
-const FRESH_WAIT_MS = 150;
-
-/** A list read on demand. */
-export interface LazyList<T> {
-  /** The last list read (empty before the first); starts the first read of this scope. */
-  peek(): readonly T[];
-  /**
-   * The list: the first read of a scope waits for it; later ones wait up to
-   * `FRESH_WAIT_MS` for a stale one's refetch, then answer the last.
-   */
-  read(): Promise<readonly T[]>;
-}
-
-/** Where the composer reads: its folder (`''`: folderless, rooted at HOME), the session's file root, its server. */
-export interface ComposerListScope {
-  /** The composer's folder (`''`: folderless). */
-  folderPath: string;
-  /** Where `@` lists files when it isn't the folder (a sandbox's root). */
-  fileRoot: string | null;
-  /** The server the session runs on, `null` for this computer. */
-  hostId: string | null;
-}
-
-/** The composer's lazily read completion lists, for one scope at a time. */
-export interface ComposerLists {
-  /** `@` files. */
-  files: LazyList<FileEntry>;
-  /** `/` commands. */
-  commands: LazyList<CommandSummary>;
-  /** `#` chats. */
-  chats: LazyList<ChatReferenceEntry>;
-  /** A new folder, file root or server (`null`: none): every list starts over. */
-  setScope(scope: ComposerListScope | null): void;
-}
-
-interface ScopedList<T> extends LazyList<T> {
-  reset(): void;
-}
-
-/** `onChange`: a read brought a different list. */
-function lazyList<R, T>(
-  label: string,
-  fetch: () => Promise<R> | null,
-  toList: (raw: R) => readonly T[],
-  onChange?: () => void,
-): ScopedList<T> {
-  let list: readonly T[] = [];
-  let raw: R | undefined;
-  let loaded: Promise<void> | null = null;
-  let generation = 0;
-  const load = (): Promise<void> => {
-    const current = fetch();
-    if (!current) return Promise.resolve();
-    const mine = generation;
-    return current.then(
-      (next) => {
-        // A fresh read keeps its identity (`ipc-resource.ts`): the same list is not rebuilt.
-        if (mine !== generation || next === raw) return;
-        raw = next;
-        list = toList(next);
-        onChange?.();
-      },
-      (err: unknown) => console.warn(`[composer] couldn't list ${label}`, err),
-    );
-  };
-  return {
-    peek() {
-      loaded ??= load();
-      return list;
-    },
-    async read() {
-      const first = loaded;
-      const refresh = load();
-      loaded ??= refresh;
-      // A fresh list resolves at once (no IPC); only a refetch can hold the read, and only briefly.
-      if (!first) await refresh;
-      else await Promise.race([refresh, first.then(() => new Promise((r) => setTimeout(r, FRESH_WAIT_MS)))]);
-      return list;
-    },
-    reset() {
-      generation += 1;
-      list = [];
-      raw = undefined;
-      loaded = null;
-    },
-  };
-}
-
-/**
- * The lists over a host's completions. `onCommands`: the command list changed (a typed `/name` may become, or
- * stop being, a badge).
- *
- * @param completions - The host's catalogs (absent: every list stays empty).
- * @param onCommands - Called when the command list changes.
- */
-export function createComposerLists(
-  completions: ComposerCompletions | undefined,
-  onCommands: () => void,
-): ComposerLists {
-  let scope: ComposerListScope | null = null;
-  // A server's folder is a path on the server: its files come through the session's file root only.
-  const filesRoot = (s: ComposerListScope) => s.fileRoot ?? (s.hostId ? null : s.folderPath);
-  const files = lazyList(
-    'files',
-    () => {
-      const root = scope && filesRoot(scope);
-      return scope && root !== null && completions?.files ? completions.files(root, scope.hostId) : null;
-    },
-    (entries: readonly FileEntry[]) => entries,
-  );
-  const commands = lazyList(
-    'commands',
-    () =>
-      scope && completions?.commands ? completions.commands({ cwd: scope.folderPath, hostId: scope.hostId }) : null,
-    (entries: readonly CommandSummary[]) => entries,
-    onCommands,
-  );
-  const chats = lazyList(
-    'chats',
-    () => (scope && completions?.chats ? completions.chats() : null),
-    (entries: readonly ChatReferenceEntry[]) => entries,
-  );
-  return {
-    files,
-    commands,
-    chats,
-    setScope(next) {
-      scope = next;
-      files.reset();
-      commands.reset();
-      chats.reset();
-    },
-  };
-}

package/src/chat/headless/composer/conversation-badges.ts

@@ -1,227 +0,0 @@
-/**
- * The composer's badges for one conversation, as data (`ConversationBadges`
- * adds the clicks and the user's order):
- *
- *   inbox     a plan or questions wait on the user: highlighted, first
- *   todos     the agent's list, done of total (`Settings.showTodoIndicator`)
- *   queue     messages sent during the run, waiting for it to end
- *   work      tool calls and background tasks you can stop (Running work)
- *   extension badges: the `composer.badges` slot items (`ctx.add(Slot, …)`),
- *            their default slot 100, at most 8 per extension
- *
- * Built-ins keep their side panel tab's icon, and a click opens that tab;
- * Running opens the Running work dialog instead (`opensWork`). React-free,
- * so it is tested in the node environment; the words are the composer's
- * labels.
- */
-import type { InteractionRequest, TodosSnapshot } from 'zidane/chat';
-import { INBOX_PANEL_ID, QUEUE_PANEL_ID, TODOS_PANEL_ID } from 'zidane/chat/pure';
-import type { RunningWorkItem } from 'zidane/ipc';
-
-import type { ExtensionItem } from '../../../extensions/headless/wire';
-
-import type { ComposerChromeLabels } from './labels-chrome';
-
-/** One badge of the strip, as data (the kit's `ComposerBadge` without its click). */
-export interface ConversationBadgeData {
-  /** Stable id: keys the badge and the user's order. */
-  id: string;
-  /** What it says. */
-  label: string;
-  /** Its icon class. */
-  icon?: string;
-  /** A spinner in place of the icon. */
-  loader?: boolean;
-  /** Its count. */
-  count?: string;
-  /** How the count speaks. */
-  countTone?: 'neutral';
-  /** Its tone. */
-  tone?: 'muted' | 'subtle' | 'accent' | 'success' | 'warn' | 'danger';
-  /** It asks for attention. */
-  highlight?: boolean;
-  /** Its tooltip. */
-  title?: string;
-  /** Its default slot. */
-  order?: number;
-}
-
-/** A badge and what a click opens: a panel, the Running work dialog, or nothing (`panel: null`). */
-export interface ConversationBadge extends ConversationBadgeData {
-  /** The panel a click opens, `null` for none. */
-  panel: string | null;
-  /** A click opens the Running work dialog. */
-  opensWork?: true;
-  /** A click runs this extension command (a `composer.badges` slot item's `command`). */
-  command?: string;
-}
-
-/** What the Inbox badge reads of the conversation's pending requests. */
-export interface InboxSummary {
-  /** How many requests wait. */
-  count: number;
-  /** The oldest: the one the badge names. */
-  head: InteractionRequest;
-  /** Raised by a run going on now, not rehydrated from an earlier process. */
-  live: boolean;
-}
-
-/** What the strip is built from. */
-export interface ConversationBadgeInput {
-  /** The pending requests, `null` for none. */
-  inbox: InboxSummary | null;
-  /** The agent's todo list. */
-  todos: TodosSnapshot | null;
-  /** `Settings.showTodoIndicator`. */
-  showTodos: boolean;
-  /** Messages in the conversation's queue. */
-  queued: number;
-  /** Its running work, as the badge shows it (`useSustainedWork`). */
-  work: readonly RunningWorkItem[];
-  /** The `composer.badges` slot items shown with the conversation (`slotItems`), lowest order first. */
-  slotBadges?: readonly ExtensionItem<'slot'>[];
-  /** The conversation's panels (the catalog's ids): an extension badge opens one of them or nothing. */
-  panels: ReadonlySet<string>;
-}
-
-/** Default slots: the built-ins lead, extensions sit at the kit's default (100). */
-const BADGE_ORDER = { inbox: 0, todos: 10, queue: 20, work: 30 } as const;
-
-/** How many badges one extension shows in one composer (zidane's `MAX_COMPOSER_BADGES`). */
-export const MAX_EXTENSION_COMPOSER_BADGES = 8;
-
-/**
- * The badges to show, in their default order (the kit's
- * `orderComposerBadges` applies the user's).
- *
- * @param input - The conversation's state.
- * @param labels - The words.
- */
-export function conversationBadges(input: ConversationBadgeInput, labels: ComposerChromeLabels): ConversationBadge[] {
-  const out: ConversationBadge[] = [];
-  if (input.inbox) out.push(inboxBadge(input.inbox, labels));
-  const todos = input.showTodos && input.todos ? todosBadge(input.todos, labels) : null;
-  if (todos) out.push(todos);
-  if (input.queued > 0) {
-    out.push({
-      id: 'queue',
-      label: labels.badgeQueued,
-      icon: 'i-ph-queue',
-      count: String(input.queued),
-      title: labels.badgeQueuedTitle(input.queued),
-      order: BADGE_ORDER.queue,
-      panel: QUEUE_PANEL_ID,
-    });
-  }
-  if (input.work.length > 0) out.push(workBadge(input.work, labels));
-  const shown = new Map<string, number>();
-  const room = (extension: string) => {
-    const n = shown.get(extension) ?? 0;
-    if (n >= MAX_EXTENSION_COMPOSER_BADGES) return false;
-    shown.set(extension, n + 1);
-    return true;
-  };
-  for (const entry of input.slotBadges ?? []) {
-    if (room(entry.extension)) out.push(slotBadge(entry, input.panels));
-  }
-  return out;
-}
-
-function workBadge(work: readonly RunningWorkItem[], labels: ComposerChromeLabels): ConversationBadge {
-  const names = work.slice(0, 3).map((item) => item.label);
-  const more = work.length - names.length;
-  return {
-    id: 'work',
-    label: labels.badgeRunning,
-    icon: 'i-ph-lightning',
-    tone: 'accent',
-    count: String(work.length),
-    title: labels.badgeRunningTitle(names, more, work.length),
-    order: BADGE_ORDER.work,
-    panel: null,
-    opensWork: true,
-  };
-}
-
-function inboxBadge({ count, head, live }: InboxSummary, labels: ComposerChromeLabels): ConversationBadge {
-  const { label, title } =
-    head.kind === 'plan'
-      ? { label: labels.badgePlan, title: labels.badgePlanTitle(head.payload.title) }
-      : head.kind === 'question'
-        ? {
-            label: labels.badgeQuestions(head.payload.questions.length),
-            title: labels.badgeQuestionsTitle(head.payload.questions.length),
-          }
-        : { label: labels.badgeWaiting, title: labels.badgeWaitingTitle };
-  return {
-    id: 'inbox',
-    label,
-    icon: 'i-ph-tray',
-    highlight: true,
-    // One request reads in the label; more are counted.
-    ...(count > 1 ? { count: String(count) } : {}),
-    title: live ? title : labels.badgeFromPrevious(title),
-    order: BADGE_ORDER.inbox,
-    panel: INBOX_PANEL_ID,
-  };
-}
-
-function todosBadge(snap: TodosSnapshot, labels: ComposerChromeLabels): ConversationBadge | null {
-  // The live list, else the last one (kept after the agent clears it).
-  const archived = snap.todos.length === 0;
-  const list = archived ? snap.archive : snap.todos;
-  if (list.length === 0) return null;
-  const done = list.filter((t) => t.status === 'completed' || t.status === 'cancelled').length;
-  const progress = labels.badgeTodosProgress(done, list.length);
-  const current = archived
-    ? null
-    : (snap.inProgress ?? list.find((t) => t.status === 'in_progress') ?? list.find((t) => t.status === 'pending'));
-  return {
-    id: 'todos',
-    label: labels.badgeTodos,
-    icon: 'i-ph-list-checks',
-    count: `${done}/${list.length}`,
-    title: current ? labels.badgeTodosCurrent(current.content, progress) : labels.badgeTodosLast(progress),
-    order: BADGE_ORDER.todos,
-    panel: TODOS_PANEL_ID,
-  };
-}
-
-function slotBadge(entry: ExtensionItem<'slot'>, panels: ReadonlySet<string>): ConversationBadge {
-  const { item, extension } = entry;
-  return {
-    // The entry's key is unique across the host and stable for the item's life: it keys the user's order.
-    id: `slot:${entry.key}`,
-    label: item.text ?? '',
-    ...(item.count !== undefined ? { count: item.count } : {}),
-    // An extension's count is its own (`neutral`); a highlight speaks in `attention`.
-    ...(item.highlight ? { highlight: true } : { countTone: 'neutral' as const }),
-    ...(item.icon?.gui ? { icon: item.icon.gui } : {}),
-    ...(item.tone ? { tone: item.tone } : {}),
-    ...(item.loader ? { loader: true } : {}),
-    title: item.title ?? extension,
-    order: item.order,
-    panel: resolveBadgePanel(item.panel, extension, panels),
-    ...(item.command ? { command: item.command } : {}),
-  };
-}
-
-/**
- * The panel an extension badge names, among the conversation's panels: the
- * extension's own (a bare id), a full `<extension>/<id>`, or a built-in.
- * `null` when it names none of them.
- *
- * @param panel - What the badge named.
- * @param extension - The extension that set the badge.
- * @param panels - The conversation's panel ids.
- */
-export function resolveBadgePanel(
-  panel: string | undefined,
-  extension: string,
-  panels: ReadonlySet<string>,
-): string | null {
-  if (!panel) return null;
-  const own = `${extension}/${panel}`;
-  if (!panel.includes('/') && panels.has(own)) return own;
-  return panels.has(panel) ? panel : null;
-}