zidane-ui 9.0.4 → 9.1.3

package/src/terminal/headless/store.ts

@@ -1,621 +0,0 @@
-/**
- * The terminals, outside React: the drawer and the panel tab show the same
- * terminals, and output must not go through React state.
- *
- *   - `scopes`: per scope key (`terminalScopeKey`), the host's state and
- *     which terminal is active. Loaded with `host.state`, then kept current
- *     by the host's `sessionChanged` / `projectChanged` signals.
- *   - `views`: the live views per terminal. Output and reset signals go
- *     straight to them; each keeps its own cursor and acks.
- *   - On a relink (a daemon restarted, a connection came back) every scope
- *     reloads, and once connected every live view attaches again.
- *
- * Agent terminals arrive through `sessionChanged`; they never take focus.
- * When one starts while no placement shows the session's terminals, the
- * session gets a badge the drawer toggle shows. Agents never see project
- * terminals.
- *
- * A draft's terminals move into the session created from it (`adoptDraft`),
- * or back to the project (`releaseDraft`).
- *
- * `reveal` shows one terminal on request (a "Show terminal" action): it
- * takes the active slot, the placement it was revealed in takes focus
- * (`focus`), and a placement opening for it starts no shell of the user's
- * while it stays the one shown.
- */
-import type { TerminalHost, TerminalInfo, TerminalSessionState, TerminalTarget } from './host';
-import { createMemoryTerminalLayouts, type TerminalLayout, type TerminalLayouts } from './layout';
-import { scopeOfTerminalKey, terminalProjectKey, terminalScopeKey, type TerminalScope } from './scope';
-
-/** What a view does with the signals of the terminal it shows. */
-export interface TerminalViewSink {
-  /** Live output from `offset`. */
-  output(offset: number, data: string): void;
-  /** The view's content is replaced with the history up to `offset`. */
-  reset(offset: number, data: string): void;
-  /** The link came back: attach again from scratch. */
-  reattach(): void;
-}
-
-/** Where a scope's terminals show: the drawer under the chat, or the side panel's Terminal tab. */
-export type TerminalPlacement = 'drawer' | 'panel';
-
-/** A terminal revealed on request, for the placement it was revealed in to focus once (`takeFocus`). */
-export interface TerminalFocusRequest {
-  /** The terminal. */
-  terminalId: string;
-  /** The placement that focuses it. */
-  placement: TerminalPlacement;
-  /** Increases with every request. */
-  seq: number;
-}
-
-/** One scope's terminals as the components read them. */
-export interface ScopeTerminals {
-  /** Null until the first `state` answers. */
-  state: TerminalSessionState | null;
-  /** The last failed call (open, restart, …), shown until the next success. */
-  error: string | null;
-  /** The active terminal. */
-  activeId: string | null;
-  /** Agent terminals that started while nothing showed terminals (sessions only). */
-  unseenAgent: number;
-  /** A revealed terminal waiting for its placement to focus it. */
-  focus: TerminalFocusRequest | null;
-}
-
-/** A grid size in cells. */
-export interface TerminalGrid {
-  /** Columns. */
-  cols: number;
-  /** Rows. */
-  rows: number;
-}
-
-const EMPTY: ScopeTerminals = { state: null, error: null, activeId: null, unseenAgent: 0, focus: null };
-
-const LOCAL_ENVIRONMENT = { kind: 'local', remote: false } as const;
-
-const errorText = (err: unknown): string => (err instanceof Error ? err.message : String(err));
-
-type ScopeRef = TerminalScope | string;
-const keyOf = (scope: ScopeRef): string => (typeof scope === 'string' ? scope : terminalScopeKey(scope));
-
-/** The terminal store: every scope's terminals, the live views, the layouts. */
-export class TerminalStore {
-  /** The host the store reads and acts through. */
-  readonly host: TerminalHost;
-  /** Where the per-scope layouts live: the host's, else in memory. */
-  readonly layouts: TerminalLayouts;
-  private scopes = new Map<string, ScopeTerminals>();
-  /** The scope behind each key, to reload it (a relink, a list from an unknown scope). */
-  private known = new Map<string, TerminalScope>();
-  private views = new Map<string, Set<TerminalViewSink>>();
-  private placements = new Map<string, number>();
-  /** Scopes whose Terminal panel tab is on screen (its body registers while visible). */
-  private panelShown = new Set<string>();
-  /** The terminal revealed per scope: no shell is auto-opened over it while it is the one shown. */
-  private revealed = new Map<string, string>();
-  /** Scopes whose drawer the user opened (the toggle), until the drawer's next auto-open uses it up. */
-  private drawerOpened = new Set<string>();
-  private focusSeq = 0;
-  private loading = new Map<string, Promise<void>>();
-  private opening = new Set<string>();
-  private listeners = new Set<() => void>();
-  private wired = false;
-
-  /**
-   * @param host - The terminal host.
-   */
-  constructor(host: TerminalHost) {
-    this.host = host;
-    this.layouts = host.layouts ?? createMemoryTerminalLayouts();
-  }
-
-  /**
-   * Registers a listener called after any scope changed. Returns its unsubscribe.
-   *
-   * @param listener - Called after each change.
-   */
-  subscribe = (listener: () => void): (() => void) => {
-    this.wire();
-    this.listeners.add(listener);
-    return () => {
-      this.listeners.delete(listener);
-    };
-  };
-
-  private emit() {
-    for (const l of this.listeners) l();
-  }
-
-  /**
-   * A scope's terminals (by its scope or key).
-   *
-   * @param scope - The scope or its key; `null` reads as none.
-   */
-  get = (scope: ScopeRef | null): ScopeTerminals => {
-    if (!scope) return EMPTY;
-    return this.scopes.get(keyOf(scope)) ?? EMPTY;
-  };
-
-  /**
-   * The terminal with this id, in whichever scope holds it.
-   *
-   * @param terminalId - The terminal.
-   */
-  terminal(terminalId: string): TerminalInfo | null {
-    for (const s of this.scopes.values()) {
-      const t = s.state?.terminals.find((x) => x.id === terminalId);
-      if (t) return t;
-    }
-    return null;
-  }
-
-  private remember(scope: TerminalScope): string {
-    const key = terminalScopeKey(scope);
-    this.known.set(key, scope);
-    return key;
-  }
-
-  /** The scope to reload a key with: the one last seen, else what the key itself says. */
-  private scopeFor(key: string): TerminalScope {
-    return this.known.get(key) ?? scopeOfTerminalKey(key);
-  }
-
-  private patch(key: string, patch: Partial<ScopeTerminals>) {
-    const prev = this.scopes.get(key) ?? EMPTY;
-    const next = { ...prev, ...patch };
-    if (next.state && (!next.activeId || !next.state.terminals.some((t) => t.id === next.activeId))) {
-      const list = next.state.terminals;
-      next.activeId = list.find((t) => t.owner === 'user')?.id ?? list[0]?.id ?? null;
-    }
-    this.scopes.set(key, next);
-    this.emit();
-  }
-
-  private wire() {
-    if (this.wired) return;
-    this.wired = true;
-    this.host.listen({
-      sessionChanged: (sessionId, terminals) => this.onChanged(sessionId, terminals),
-      projectChanged: (signal) => this.onProjectChanged(signal),
-      output: (s) => this.dispatch(s.terminalId, 'output', s.offset, s.data),
-      reset: (s) => this.dispatch(s.terminalId, 'reset', s.offset, s.data),
-      relink: (connected) => this.onRelink(connected),
-    });
-  }
-
-  private dispatch(terminalId: string, kind: 'output' | 'reset', offset: number, data: string) {
-    const views = this.views.get(terminalId);
-    if (!views) return;
-    for (const v of views) v[kind](offset, data);
-  }
-
-  private onRelink(connected: boolean) {
-    for (const key of this.scopes.keys()) void this.refresh(this.scopeFor(key));
-    if (connected) for (const set of this.views.values()) for (const v of set) v.reattach();
-  }
-
-  private onChanged(sessionId: string, terminals: TerminalInfo[]) {
-    const key = sessionId;
-    const prev = this.scopes.get(key) ?? EMPTY;
-    const known = new Set(prev.state?.terminals.map((t) => t.id) ?? []);
-    const startedByAgent = prev.state ? terminals.filter((t) => t.owner === 'agent' && !known.has(t.id)).length : 0;
-    const state: TerminalSessionState = prev.state
-      ? { ...prev.state, available: true, terminals }
-      : { available: true, environment: LOCAL_ENVIRONMENT, terminals };
-    const unseen = (this.placements.get(key) ?? 0) > 0 ? 0 : prev.unseenAgent + startedByAgent;
-    this.patch(key, { state, unseenAgent: unseen });
-    // First news of this session: the environment comes with the full state.
-    if (!prev.state) void this.refresh(this.scopeFor(key));
-  }
-
-  /** A project's or a draft's full list: the host machine's, no agent terminals to badge. */
-  private onProjectChanged(signal: { root: string; draftId?: string; terminals: TerminalInfo[] }) {
-    const key = terminalProjectKey(signal);
-    if (!this.known.has(key)) {
-      this.known.set(key, {
-        root: signal.root,
-        cwd: signal.root,
-        ...(signal.draftId ? { draft: signal.draftId } : {}),
-      });
-    }
-    const prev = this.scopes.get(key) ?? EMPTY;
-    const state: TerminalSessionState = prev.state
-      ? { ...prev.state, available: true, terminals: signal.terminals }
-      : { available: true, environment: LOCAL_ENVIRONMENT, terminals: signal.terminals };
-    this.patch(key, { state });
-  }
-
-  /**
-   * Loads the scope's state once (callers mount per scope).
-   *
-   * @param scope - The scope.
-   */
-  ensure(scope: TerminalScope): Promise<void> {
-    this.wire();
-    const key = this.remember(scope);
-    if (this.scopes.get(key)?.state) return Promise.resolve();
-    return this.refresh(scope);
-  }
-
-  /**
-   * Reads the scope's state again (one read in flight per scope).
-   *
-   * @param scope - The scope.
-   */
-  refresh(scope: TerminalScope): Promise<void> {
-    const key = this.remember(scope);
-    const inFlight = this.loading.get(key);
-    if (inFlight) return inFlight;
-    const run = this.host
-      .state(scope)
-      .then(
-        (state) => this.patch(key, { state }),
-        (err: unknown) =>
-          this.patch(key, {
-            state: { available: false, reason: errorText(err), environment: LOCAL_ENVIRONMENT, terminals: [] },
-          }),
-      )
-      .finally(() => this.loading.delete(key));
-    this.loading.set(key, run);
-    return run;
-  }
-
-  /**
-   * Makes `terminalId` the scope's active terminal.
-   *
-   * @param scope - The scope or its key.
-   * @param terminalId - The terminal.
-   */
-  setActive(scope: ScopeRef, terminalId: string): void {
-    const key = keyOf(scope);
-    if (this.get(key).activeId === terminalId) return;
-    this.patch(key, { activeId: terminalId });
-  }
-
-  /** The grid the scope's terminal area last measured: new terminals start at it. */
-  private fitted = new Map<string, TerminalGrid>();
-  /**
-   * Remembers the grid the scope's terminal area fits: new terminals start at it.
-   *
-   * @param scope - The scope.
-   * @param size - The grid, or `null` (not laid out: keeps the last one).
-   */
-  setFittedSize(scope: TerminalScope, size: TerminalGrid | null): void {
-    if (size) this.fitted.set(terminalScopeKey(scope), size);
-  }
-
-  /**
-   * Opens a terminal for the user when a placement is opened on a scope with
-   * none of theirs (none at all, or only the agent's). The drawer opens one
-   * only when the user opened it (`toggleDrawer`). A drawer open because the
-   * scope copied its project's layout, or left open before a relaunch, starts
-   * no shell: otherwise every session visited would keep one. Skipped while
-   * another open is in flight (the keybinding opens the drawer and a terminal
-   * at once).
-   *
-   * @param scope - The scope.
-   * @param placement - The placement that opened.
-   * @param measure - Measures the grid the area fits, once the state is in.
-   */
-  async autoOpen(
-    scope: TerminalScope,
-    placement: TerminalPlacement,
-    measure?: () => TerminalGrid | null,
-  ): Promise<void> {
-    await this.ensure(scope);
-    const key = terminalScopeKey(scope);
-    const s = this.get(key);
-    if (!s.state?.available || this.opening.has(key)) return;
-    if (placement === 'drawer' && !this.drawerOpened.delete(key)) return;
-    if (s.state.terminals.some((t) => t.owner === 'user')) return;
-    // The user asked to see one terminal (`reveal`), not to get a new one.
-    const revealed = this.revealed.get(key);
-    if (revealed && revealed === s.activeId && s.state.terminals.some((t) => t.id === revealed)) return;
-    // Measured now, after the state load laid the area out.
-    await this.open(scope, undefined, measure?.() ?? undefined);
-  }
-
-  /**
-   * Opens a terminal and makes it active. Resolves `null` when it failed (see `error`).
-   *
-   * @param scope - The scope.
-   * @param target - A session's terminal: in its environment or on the user's machine. Ignored without a session.
-   * @param size - The first grid. Default: the last one fitted, else 80×24.
-   */
-  async open(scope: TerminalScope, target?: TerminalTarget, size?: TerminalGrid): Promise<TerminalInfo | null> {
-    const key = this.remember(scope);
-    size ??= this.fitted.get(key) ?? { cols: 80, rows: 24 };
-    this.opening.add(key);
-    try {
-      const info = await this.host.open(scope, {
-        ...(scope.session && target ? { target } : {}),
-        cols: size.cols,
-        rows: size.rows,
-      });
-      const s = this.get(key);
-      const terminals = s.state?.terminals.some((t) => t.id === info.id)
-        ? s.state.terminals
-        : [...(s.state?.terminals ?? []), info];
-      this.patch(key, {
-        activeId: info.id,
-        error: null,
-        ...(s.state ? { state: { ...s.state, terminals } } : {}),
-      });
-      return info;
-    } catch (err) {
-      this.patch(key, { error: errorText(err) });
-      return null;
-    } finally {
-      this.opening.delete(key);
-    }
-  }
-
-  private async act(scope: ScopeRef, run: (() => Promise<unknown>) | undefined) {
-    if (!run) return;
-    const key = keyOf(scope);
-    try {
-      await run();
-      if (this.get(key).error) this.patch(key, { error: null });
-    } catch (err) {
-      this.patch(key, { error: errorText(err) });
-    }
-  }
-
-  /**
-   * Closes a terminal.
-   *
-   * @param scope - The scope or its key (where an error shows).
-   * @param terminalId - The terminal.
-   */
-  close = (scope: ScopeRef, terminalId: string): Promise<void> => this.act(scope, () => this.host.close(terminalId));
-  /**
-   * Restarts a terminal's process.
-   *
-   * @param scope - The scope or its key (where an error shows).
-   * @param terminalId - The terminal.
-   */
-  restart = (scope: ScopeRef, terminalId: string): Promise<void> =>
-    this.act(scope, this.host.restart && (() => this.host.restart!(terminalId)));
-  /**
-   * Hides a terminal from the agent, or shows it again.
-   *
-   * @param scope - The scope or its key (where an error shows).
-   * @param terminalId - The terminal.
-   * @param hidden - Hide it.
-   */
-  setHidden = (scope: ScopeRef, terminalId: string, hidden: boolean): Promise<void> =>
-    this.act(scope, this.host.setHidden && (() => this.host.setHidden!(terminalId, hidden)));
-  /**
-   * Clears the scope's error.
-   *
-   * @param scope - The scope or its key.
-   */
-  dismissError = (scope: ScopeRef): void => this.patch(keyOf(scope), { error: null });
-
-  /**
-   * Hands the draft's terminals to the session created from it. Shown in the
-   * session at once (the host's lists follow); a failed hand-over (or a host
-   * that cannot hand over) gives them back to the project, never leaving them
-   * tied to a draft nobody shows.
-   *
-   * @param draft - The draft's scope.
-   * @param session - The session's scope.
-   */
-  async adoptDraft(draft: TerminalScope, session: TerminalScope): Promise<void> {
-    const draftId = draft.draft;
-    if (!draftId) return;
-    const sessionId = session.session;
-    if (!sessionId || !this.host.adoptDraft) return this.releaseDraft(draftId);
-    let adopted: string[];
-    try {
-      ({ adopted } = await this.host.adoptDraft(draftId, sessionId));
-    } catch {
-      return this.releaseDraft(draftId);
-    }
-    this.moveAdopted(terminalScopeKey(draft), this.remember(session), sessionId, new Set(adopted));
-  }
-
-  /** The adopted terminals leave the draft's list for the session's, with the active one and the fitted grid. */
-  private moveAdopted(from: string, to: string, sessionId: string, adopted: ReadonlySet<string>) {
-    const source = this.get(from);
-    const moved = (source.state?.terminals ?? [])
-      .filter((t) => adopted.has(t.id))
-      .map(({ scope: _scope, ...t }) => ({ ...t, sessionId }));
-    const fitted = this.fitted.get(from);
-    if (fitted && !this.fitted.has(to)) this.fitted.set(to, fitted);
-    if (moved.length === 0) return;
-    if (source.state) {
-      this.patch(from, {
-        state: { ...source.state, terminals: source.state.terminals.filter((t) => !adopted.has(t.id)) },
-      });
-    }
-    const target = this.get(to);
-    const ids = new Set(target.state?.terminals.map((t) => t.id) ?? []);
-    const terminals = [...(target.state?.terminals ?? []), ...moved.filter((t) => !ids.has(t.id))];
-    const activeId = source.activeId && adopted.has(source.activeId) ? source.activeId : target.activeId;
-    this.patch(to, {
-      activeId,
-      state: target.state
-        ? { ...target.state, terminals }
-        : { available: true, environment: LOCAL_ENVIRONMENT, terminals },
-    });
-    // Not loaded yet: the session's own state (environment, remote) still comes from the host.
-    if (!target.state) void this.refresh(this.scopeFor(to));
-  }
-
-  /**
-   * Gives the draft's terminals back to the project (a discarded draft). Never rejects.
-   *
-   * @param draftId - The draft.
-   */
-  async releaseDraft(draftId: string): Promise<void> {
-    try {
-      await this.host.releaseDraft?.(draftId);
-    } catch {
-      // Best effort: the host releases a page's drafts when it goes away.
-    }
-  }
-
-  /**
-   * Registers a live view of `terminalId`; returns its unregister.
-   *
-   * @param terminalId - The terminal it shows.
-   * @param view - What it does with the terminal's signals.
-   */
-  addView(terminalId: string, view: TerminalViewSink): () => void {
-    this.wire();
-    let set = this.views.get(terminalId);
-    if (!set) this.views.set(terminalId, (set = new Set()));
-    set.add(view);
-    return () => {
-      set.delete(view);
-      if (set.size === 0 && this.views.get(terminalId) === set) this.views.delete(terminalId);
-    };
-  }
-
-  /**
-   * A placement (drawer, panel tab) is showing the scope's terminals; clears the badge. Returns its unregister.
-   *
-   * @param scope - The scope or its key.
-   */
-  showPlacement(scope: ScopeRef): () => void {
-    const key = keyOf(scope);
-    this.placements.set(key, (this.placements.get(key) ?? 0) + 1);
-    if (this.get(key).unseenAgent) this.patch(key, { unseenAgent: 0 });
-    return () => {
-      const n = (this.placements.get(key) ?? 1) - 1;
-      if (n > 0) {
-        this.placements.set(key, n);
-        return;
-      }
-      this.placements.delete(key);
-      // Nothing shows the revealed terminal anymore: the next placement opens as usual.
-      this.revealed.delete(key);
-    };
-  }
-
-  /**
-   * The side panel's Terminal tab shows the scope's terminals, on screen; returns its unregister.
-   *
-   * @param scope - The scope or its key.
-   */
-  showPanel(scope: ScopeRef): () => void {
-    const key = keyOf(scope);
-    this.panelShown.add(key);
-    return () => {
-      this.panelShown.delete(key);
-    };
-  }
-
-  /**
-   * Whether the side panel's Terminal tab is on screen for the scope.
-   *
-   * @param scope - The scope or its key.
-   */
-  panelOnScreen(scope: ScopeRef): boolean {
-    return this.panelShown.has(keyOf(scope));
-  }
-
-  /**
-   * Makes `terminalId` the active terminal, focused by `placement`, with no
-   * shell auto-opened over it (`revealTerminal` picks the placement).
-   *
-   * @param scope - The scope or its key.
-   * @param terminalId - The terminal.
-   * @param placement - The placement that focuses it.
-   */
-  reveal(scope: ScopeRef, terminalId: string, placement: TerminalPlacement): void {
-    const key = keyOf(scope);
-    this.revealed.set(key, terminalId);
-    this.focusSeq += 1;
-    this.patch(key, { activeId: terminalId, focus: { terminalId, placement, seq: this.focusSeq } });
-  }
-
-  /**
-   * The placement took focus request `seq`: drop it (a newer request stays).
-   *
-   * @param scope - The scope or its key.
-   * @param seq - The request taken.
-   */
-  takeFocus(scope: ScopeRef, seq: number): void {
-    const key = keyOf(scope);
-    if (this.get(key).focus?.seq === seq) this.patch(key, { focus: null });
-  }
-
-  /**
-   * The scope's layout (drawer, order, agent filter).
-   *
-   * @param scope - The scope.
-   */
-  layout(scope: TerminalScope): TerminalLayout {
-    return this.layouts.get(scope);
-  }
-
-  /**
-   * Changes the scope's layout.
-   *
-   * @param scope - The scope.
-   * @param patch - The fields to change.
-   */
-  updateLayout(scope: TerminalScope, patch: Partial<TerminalLayout>): void {
-    this.layouts.update(scope, patch);
-  }
-
-  /**
-   * Shows or hides the scope's drawer.
-   *
-   * @param scope - The scope.
-   */
-  toggleDrawer(scope: TerminalScope): void {
-    const open = !this.layouts.get(scope).terminalOpen;
-    if (open) this.drawerOpened.add(terminalScopeKey(scope));
-    else this.drawerOpened.delete(terminalScopeKey(scope));
-    this.layouts.update(scope, { terminalOpen: open });
-  }
-
-  /**
-   * Opens the drawer and a new terminal in it.
-   *
-   * @param scope - The scope.
-   */
-  openInDrawer(scope: TerminalScope): void {
-    this.layouts.update(scope, { terminalOpen: true });
-    void this.open(scope);
-  }
-
-  /**
-   * Shows one of the scope's terminals, focused: in the side panel's Terminal
-   * tab when it is on screen, else in the drawer, opened for it. Opening the
-   * drawer this way starts no shell of the user's, and the strip shows the
-   * agent's terminals again when it hid the one revealed.
-   *
-   * @param scope - The scope.
-   * @param terminalId - The terminal.
-   */
-  revealTerminal(scope: TerminalScope, terminalId: string): void {
-    const layout = this.layouts.get(scope);
-    const placement = this.panelOnScreen(scope) ? 'panel' : 'drawer';
-    const hidden = layout.terminalHideAgent && this.terminal(terminalId)?.owner === 'agent';
-    // The reveal first: the drawer mounting from the layout change must find it (no shell auto-opened).
-    this.reveal(scope, terminalId, placement);
-    if (hidden || (placement === 'drawer' && !layout.terminalOpen)) {
-      this.layouts.update(scope, {
-        ...(hidden ? { terminalHideAgent: false } : {}),
-        ...(placement === 'drawer' ? { terminalOpen: true } : {}),
-      });
-    }
-  }
-}
-
-/**
- * Creates the {@link TerminalStore} over a host. An app creates one per page
- * and hands it to `TerminalProvider` (code outside React reads it too).
- *
- * @param host - The terminal host.
- */
-export function createTerminalStore(host: TerminalHost): TerminalStore {
-  return new TerminalStore(host);
-}

package/src/terminal/index.ts

@@ -1,40 +0,0 @@
-/**
- * `zidane-ui/terminal`: the terminal surface (ghostty-web, loaded on first use),
- * its key encoding and its theme from the `--zg-*` tokens. The app connects it
- * to a pty through a `TerminalAdapter`.
- *
- * The terminal area over a `TerminalHost` (`zidane-ui/terminal/headless`):
- * `TerminalProvider`, the drawer under the chat (`TerminalDrawer`) and its
- * header toggle (`TerminalToggle`), the side panel's Terminal tab
- * (`TerminalPanelTab`), the panel both show (`TerminalPanel`) and one
- * view of a host's terminal (`HostTerminalSurface`).
- */
-export * from './ghostty';
-export * from './keys';
-export * from './TerminalSurface';
-export * from './theme';
-export { HostTerminalSurface, type HostTerminalSurfaceProps } from './HostTerminalSurface';
-export {
-  TERMINAL_HEIGHT,
-  TerminalDrawer,
-  TerminalPanelTab,
-  TerminalToggle,
-  type TerminalDrawerProps,
-  type TerminalPanelTabProps,
-  type TerminalToggleProps,
-} from './TerminalDrawer';
-export { TerminalPanel, terminalTitle, type TerminalPanelProps } from './TerminalPanel';
-export {
-  TerminalProvider,
-  useScopeTerminals,
-  useTerminalActions,
-  useTerminalLayout,
-  useTerminalStore,
-  useTerminalsEnabled,
-  type TerminalAppActions,
-  type TerminalExcerpt,
-  type TerminalProviderProps,
-  type TerminalTabHandlers,
-  type TerminalWaiting,
-} from './TerminalProvider';
-export { useTerminalLabels } from './useTerminalLabels';

package/src/terminal/keys.ts

@@ -1,34 +0,0 @@
-/**
- * macOS text-editing keys in a terminal, the way Terminal.app and iTerm2's
- * "Natural Text Editing" preset send them: the bytes a shell's line editor
- * (zsh, bash/readline, fish) already understands by default.
- *
- *   ⌘⌫ delete to line start (^U)      ⌥⌫ delete word back (ESC DEL)
- *   ⌘⌦ delete to line end (^K)        ⌥⌦ delete word forward (ESC d)
- *   ⌘← / ⌘→ line start / end (^A / ^E)
- *   ⌥← / ⌥→ word back / forward (ESC b / ESC f)
- *
- * Returns `null` for everything else, which keeps its usual path.
- *
- * @param event - The key and modifiers of a keydown.
- */
-export function macTerminalKey(
-  event: Pick<KeyboardEvent, 'key' | 'metaKey' | 'altKey' | 'ctrlKey' | 'shiftKey'>,
-): string | null {
-  if (event.ctrlKey || event.shiftKey) return null;
-  const cmd = event.metaKey && !event.altKey;
-  const opt = event.altKey && !event.metaKey;
-  if (!cmd && !opt) return null;
-  switch (event.key) {
-    case 'Backspace':
-      return cmd ? '\x15' : '\x1b\x7f';
-    case 'Delete':
-      return cmd ? '\x0b' : '\x1bd';
-    case 'ArrowLeft':
-      return cmd ? '\x01' : '\x1bb';
-    case 'ArrowRight':
-      return cmd ? '\x05' : '\x1bf';
-    default:
-      return null;
-  }
-}