zidane-ui 9.1.1 → 9.1.3

package/src/adapters/live.ts

@@ -1,270 +0,0 @@
-/**
- * The client half of zidane's live transcript, shared by every adapter: the
- * stores a `ChatHost` exposes (session list, transcripts, pending
- * interactions), fed by live events folded with `applyLiveEvent`
- * (`live-events.ts`, zidane's merge rule).
- *
- * The transcripts live in the session stream store (`SessionStreamStore`,
- * `chat/headless/streams/`), the one the desktop app runs on: events fold
- * and prompt echoes dedupe there. This module is a facade that keeps the
- * adapters' own rules on top of it, because they differ from the desktop
- * app's signal rules: a hydrate replaces the window wholesale and forgets
- * pending echoes (the store reconciles a page with the live window),
- * notifications go out at once (the store batches transcript events per
- * frame), a run's end neither appends an error row nor drops pending echoes,
- * and long messages split at the reducer's default size.
- */
-import type { InteractionRequest } from 'zidane/chat';
-
-import type {
-  ChatAttachment,
-  ChatEvent,
-  ChatInteraction,
-  ChatSession,
-  ChatSessionStatus,
-  Transcript,
-  TranscriptState,
-} from '../chat/headless/host';
-import { writable, type Readable, type Writable } from '../chat/headless/store';
-import { applyLiveEvent, finishLive } from '../chat/headless/streams/live-events';
-import { SessionStreamStore } from '../chat/headless/streams/store';
-import { transcriptSnapshot } from '../chat/headless/streams/transcript';
-
-export { applyLiveEvent, finishLive };
-
-/** One session's live transcript: its state store and the echo bookkeeping. */
-export interface LiveTranscript {
-  /** The session's transcript state, updated as events arrive. */
-  state: Writable<TranscriptState>;
-  /** Prompts this client echoed itself, waiting for the host's echo to drop (the store's pending-echo list). */
-  echoes: string[];
-}
-
-/** The client half of the live transcript: the stores a {@link ChatHost} exposes, fed by live events. Shared by every adapter. */
-export interface LiveState {
-  /** The session list store. */
-  sessions: Writable<readonly ChatSession[]>;
-  /** Created on first use; `onOpen` runs then (an adapter starts its stream there). */
-  transcript(sessionId: string): LiveTranscript;
-  /** The `Transcript` a host hands the components, with `onFirstSubscribe` / `onLastUnsubscribe` hooks. */
-  readable(sessionId: string, extra?: Pick<Transcript, 'loadEarlier'>): Transcript;
-  /** Replaces a session's events with a loaded history and marks it hydrated. `patch` sets other transcript state fields, such as `running`. */
-  hydrate(sessionId: string, events: readonly ChatEvent[], patch?: Partial<TranscriptState>): void;
-  /** A live event from the agent; `echo` marks the host repeating a prompt (dropped when this client echoed it). */
-  apply(sessionId: string, event: ChatEvent, echo?: boolean): void;
-  /** Show the user's prompt at once (with its attachment previews); the host's echo of it is then dropped. */
-  echoPrompt(sessionId: string, text: string, attachments?: readonly ChatAttachment[]): void;
-  /** A run started or ended; the session's status follows (`status` overrides: `'error'`, `'idle'` after an interrupt). */
-  setRunning(sessionId: string, running: boolean, status?: ChatSessionStatus): void;
-  /** Merges fields into a session in the list. A session the list does not hold is ignored. */
-  patchSession(sessionId: string, patch: Partial<ChatSession>): void;
-  /** The store of a session's pending interactions. */
-  pending(sessionId: string): Writable<readonly ChatInteraction[]>;
-  /** Every session's pending interactions, in arrival order. */
-  allPending: Readable<readonly ChatInteraction[]>;
-  /** Adds a pending request to a session. A request already pending is ignored. */
-  addInteraction(sessionId: string, request: InteractionRequest): void;
-  /** Removes a request from the pending interactions of every session. */
-  resolveInteraction(requestId: string): void;
-  /** The session a pending request belongs to. */
-  interactionSession(requestId: string): string | undefined;
-}
-
-/** Options for {@link createLiveState}. */
-export interface LiveStateOptions {
-  /** The sessions the list starts with. Default: none. */
-  sessions?: readonly ChatSession[];
-  /** Called with the session id when the first subscriber of its transcript arrives. An adapter starts the session's stream here. */
-  onOpen?: (sessionId: string) => void;
-  /** Called with the session id when the last subscriber of its transcript leaves. An adapter stops the session's stream here. */
-  onClose?: (sessionId: string) => void;
-  /**
-   * Forget the transcripts nobody reads: when a session's last subscriber leaves, every window goes but the
-   * open sessions', the running ones' and the 12 most recently opened. For an adapter that loads a transcript
-   * again in `onOpen`. Default: `false`.
-   */
-  evict?: boolean;
-}
-
-/** Closed sessions whose windows stay, most recent first: the desktop's prewarm window (`sidebar/directory.ts`) less the open one. */
-const RECENT_KEPT = 12;
-
-/**
- * Creates the stores a {@link ChatHost} exposes: the session list, per-session transcripts, and pending interactions.
- *
- * @param options - The initial sessions and the transcript open and close hooks.
- */
-export function createLiveState(options: LiveStateOptions = {}): LiveState {
-  const sessions = writable<readonly ChatSession[]>(options.sessions ?? []);
-  // Unbatched, and the reducer's default markdown split: see the module comment.
-  const store = new SessionStreamStore({ batch: false, markdown: {} });
-  const transcripts = new Map<string, LiveTranscript>();
-  const pendings = new Map<string, Writable<readonly ChatInteraction[]>>();
-  const allPending = writable<readonly ChatInteraction[]>([]);
-  const readables = new Map<string, Transcript>();
-  // Per session, not per readable: a readable made again after an eviction counts with the old one.
-  const subscribers = new Map<string, number>();
-  /** Recently opened sessions, the most recent last. */
-  const recent = new Set<string>();
-  const visit = (sessionId: string) => {
-    if (!options.evict) return;
-    recent.delete(sessionId);
-    recent.add(sessionId);
-    if (recent.size > RECENT_KEPT) recent.delete(recent.values().next().value!);
-  };
-  const evict = () => {
-    const keep = new Set([...recent, ...subscribers.keys()]);
-    store.evictExcept(keep);
-    // The store's own rule: running and mid-scrollback sessions stay.
-    for (const sessionId of new Set([...transcripts.keys(), ...readables.keys()])) {
-      if (keep.has(sessionId) || store.getRunningSnapshot(sessionId) || store.getPageSnapshot(sessionId).loadingEarlier)
-        continue;
-      transcripts.delete(sessionId);
-      readables.delete(sessionId);
-    }
-  };
-
-  const transcript = (sessionId: string) => {
-    let t = transcripts.get(sessionId);
-    if (!t) {
-      t = {
-        state: transcriptState(store, sessionId),
-        get echoes() {
-          return store.pendingEchoes(sessionId);
-        },
-        set echoes(next) {
-          const echoes = store.pendingEchoes(sessionId);
-          echoes.splice(0, echoes.length, ...next);
-        },
-      };
-      transcripts.set(sessionId, t);
-    }
-    return t;
-  };
-  const pending = (sessionId: string) => {
-    let p = pendings.get(sessionId);
-    if (!p) {
-      p = writable<readonly ChatInteraction[]>([]);
-      pendings.set(sessionId, p);
-    }
-    return p;
-  };
-  const patchSession = (sessionId: string, patch: Partial<ChatSession>) =>
-    sessions.set((all) =>
-      all.some((s) => s.id === sessionId) ? all.map((s) => (s.id === sessionId ? { ...s, ...patch } : s)) : all,
-    );
-
-  return {
-    sessions,
-    transcript,
-    readable(sessionId, extra) {
-      visit(sessionId);
-      let r = readables.get(sessionId);
-      if (r) return r;
-      const { state } = transcript(sessionId);
-      const store: Readable<TranscriptState> = {
-        get: state.get,
-        subscribe(onChange) {
-          const off = state.subscribe(onChange);
-          const count = subscribers.get(sessionId) ?? 0;
-          subscribers.set(sessionId, count + 1);
-          visit(sessionId);
-          if (count === 0) options.onOpen?.(sessionId);
-          let done = false;
-          return () => {
-            if (done) return;
-            done = true;
-            off();
-            const left = subscribers.get(sessionId)! - 1;
-            if (left > 0) {
-              subscribers.set(sessionId, left);
-              return;
-            }
-            subscribers.delete(sessionId);
-            options.onClose?.(sessionId);
-            if (options.evict) evict();
-          };
-        },
-      };
-      r = { ...store, ...(extra?.loadEarlier ? { loadEarlier: extra.loadEarlier } : {}) };
-      readables.set(sessionId, r);
-      return r;
-    },
-    hydrate(sessionId, events, patch) {
-      const t = transcript(sessionId);
-      t.echoes = [];
-      t.state.set((s) => ({ ...s, ...patch, events: [...events], hydrated: true }));
-    },
-    apply(sessionId, event, echo) {
-      transcript(sessionId);
-      // An echo this client is waiting for is consumed; anything else folds with `applyLiveEvent`.
-      store.applySignal({ kind: 'event', sessionId, event, ...(echo ? { echo } : {}) });
-    },
-    echoPrompt(sessionId, text, attachments) {
-      transcript(sessionId);
-      store.appendUserPrompt(sessionId, text, undefined, attachments ?? []);
-    },
-    setRunning(sessionId, running, status) {
-      const t = transcript(sessionId);
-      t.state.set((s) =>
-        s.running === running ? s : { ...s, running, events: running ? s.events : finishLive(s.events) },
-      );
-      patchSession(sessionId, { status: status ?? (running ? 'running' : 'completed'), updatedAt: Date.now() });
-    },
-    patchSession,
-    pending,
-    allPending,
-    addInteraction(sessionId, request) {
-      if (allPending.get().some((i) => i.requestId === request.id)) return;
-      const item = { requestId: request.id, sessionId, request };
-      pending(sessionId).set((all) => [...all, item]);
-      allPending.set((all) => [...all, item]);
-    },
-    resolveInteraction(requestId) {
-      for (const p of pendings.values()) {
-        if (p.get().some((i) => i.requestId === requestId))
-          p.set((all) => all.filter((i) => i.requestId !== requestId));
-      }
-      if (allPending.get().some((i) => i.requestId === requestId))
-        allPending.set((all) => all.filter((i) => i.requestId !== requestId));
-    },
-    interactionSession(requestId) {
-      for (const p of pendings.values()) {
-        const hit = p.get().find((i) => i.requestId === requestId);
-        if (hit) return hit.sessionId;
-      }
-      return undefined;
-    },
-  };
-}
-
-/**
- * A session's transcript state as a writable store over the session stream
- * store: reads are the store's snapshots, a write sets the events, the run
- * flag and the page state (`hydrated`, `hasEarlier`, `loadingEarlier`) in
- * one notification.
- */
-function transcriptState(store: SessionStreamStore, sessionId: string): Writable<TranscriptState> {
-  let last: TranscriptState | undefined;
-  const get = () => (last = transcriptSnapshot(store, sessionId, last));
-  return {
-    get,
-    set(next) {
-      const prev = get();
-      const resolved = typeof next === 'function' ? next(prev) : next;
-      if (Object.is(resolved, prev)) return;
-      store.write(sessionId, {
-        ...(resolved.events !== prev.events ? { events: resolved.events } : {}),
-        running: resolved.running,
-        page: resolved.hydrated
-          ? {
-              firstSeq: store.getPageSnapshot(sessionId).firstSeq,
-              hasMore: resolved.hasEarlier ?? false,
-              loadingEarlier: resolved.loadingEarlier ?? false,
-            }
-          : null,
-      });
-    },
-    subscribe: (onChange) => store.subscribeSession(sessionId, onChange),
-  };
-}

package/src/adapters/run-host.ts

@@ -1,238 +0,0 @@
-/**
- * A `ChatHost` around a run function you supply: the kit keeps the sessions,
- * transcripts and pending interactions in memory, you run the agent.
- *
- * `run` is called once per sent prompt. It streams the reply with `emit`,
- * using zidane's live event rule (see `live.ts`): `{ kind: 'markdown', text:
- * delta, streaming: true }` and `{ kind: 'thinking', text: delta }` grow the
- * open block, any other `StreamEvent` (`tool`, `tool-result`, `error`, …) is
- * a row of its own. It raises a question or a plan with `ask` and gets the
- * answer back (`null`: dismissed or interrupted). It watches `signal` for an
- * interrupt. Wiring a real zidane agent into `run` is the app's job, which
- * keeps this module free of the zidane runtime (it runs in a page or a Web
- * Worker). The user's prompt is echoed by the host; `run` does not emit it.
- */
-import type { InteractionRequest, InteractionResponse } from 'zidane/chat';
-
-import type {
-  ChatAttachment,
-  ChatEvent,
-  ChatHost,
-  ChatModelProvider,
-  ChatSession,
-  SendInput,
-} from '../chat/headless/host';
-import { constant, type Readable } from '../chat/headless/store';
-import { createLiveState } from './live';
-
-/** What {@link createRunHost} hands to the `run` function for one sent prompt. */
-export interface RunContext {
-  /** Id of the session the prompt was sent to. */
-  sessionId: string;
-  /** The prompt text. */
-  prompt: string;
-  /** Files sent with the prompt. Empty when there are none. */
-  attachments: readonly ChatAttachment[];
-  /** The model the user picked, as `provider/model` or a bare id. Absent when none was picked. */
-  model?: string;
-  /** The reasoning effort the user picked. Absent when none was picked. */
-  thinking?: SendInput['thinking'];
-  /** Aborted on interrupt. */
-  signal: AbortSignal;
-  /** Streams an event into the session's transcript. Markdown and thinking events with `streaming` grow the open block; any other event is a new row. */
-  emit(event: ChatEvent): void;
-  /** Ask the user; resolves with the answer, or `null` when dismissed or interrupted. */
-  ask(request: InteractionRequest): Promise<InteractionResponse | null>;
-  /** Receive messages the user steers into this run. Without a listener, `steer` reports false. */
-  onSteer(listener: (message: string) => void): void;
-}
-
-/** Runs the agent for one prompt. Called once per sent prompt with a {@link RunContext}. The run ends when the returned promise settles; a rejection shows as an error row. */
-export type RunFn = (context: RunContext) => void | Promise<void>;
-
-/** Options for {@link createRunHost}. */
-export interface RunHostOptions {
-  /** The function that runs the agent for each sent prompt. */
-  run: RunFn;
-  /** Sessions to start with (default: none; the user creates them). */
-  sessions?: readonly ChatSession[];
-  /** Their existing events, per session id. */
-  transcripts?: Record<string, readonly ChatEvent[]>;
-  /** Providers and models the host offers, fixed or live (a model's details change). Default: none. */
-  models?: readonly ChatModelProvider[] | Readable<readonly ChatModelProvider[]>;
-  /** New session ids (default: `crypto.randomUUID()`). */
-  newId?: () => string;
-}
-
-/** The {@link ChatHost} {@link createRunHost} returns, plus what only an in-memory host can do. */
-export interface RunHost extends ChatHost {
-  /**
-   * Adds a session with a history, as a new session first in the list (a saved or shared one). Its events show as they are; the agent's own memory of them is the app's concern.
-   *
-   * @param session - The session's title.
-   * @param events - Its transcript events, oldest first.
-   */
-  restore(session: { title: string }, events: readonly ChatEvent[]): ChatSession;
-}
-
-interface ActiveRun {
-  controller: AbortController;
-  steer?: (message: string) => void;
-  queued: SendInput[];
-}
-
-/**
- * Creates a {@link ChatHost} around a run function. Sessions, transcripts, and pending interactions live in memory; the app supplies the agent through `run`.
- *
- * @param options - The `run` function and optional initial sessions, transcripts, and models.
- */
-export function createRunHost(options: RunHostOptions): RunHost {
-  const state = createLiveState({ sessions: options.sessions ?? [] });
-  for (const s of options.sessions ?? []) state.hydrate(s.id, options.transcripts?.[s.id] ?? []);
-  const runs = new Map<string, ActiveRun>();
-  const waiters = new Map<string, (response: InteractionResponse | null) => void>();
-  const newId = options.newId ?? (() => crypto.randomUUID());
-
-  const settle = (requestId: string, response: InteractionResponse | null) => {
-    state.resolveInteraction(requestId);
-    const waiter = waiters.get(requestId);
-    waiters.delete(requestId);
-    waiter?.(response);
-  };
-
-  const send = async (input: SendInput): Promise<void> => {
-    const { sessionId } = input;
-    if (runs.has(sessionId)) {
-      // A run is in flight: the prompt waits for it, as a follow-up.
-      runs.get(sessionId)!.queued.push(input);
-      return;
-    }
-    const t = state.transcript(sessionId);
-    if (!t.state.get().hydrated) state.hydrate(sessionId, []);
-    const active: ActiveRun = { controller: new AbortController(), queued: [] };
-    runs.set(sessionId, active);
-    state.echoPrompt(sessionId, input.prompt, input.attachments);
-    state.setRunning(sessionId, true);
-    const live = () => runs.get(sessionId) === active;
-    const asked = new Set<string>();
-    let failed = false;
-    try {
-      await options.run({
-        sessionId,
-        prompt: input.prompt,
-        attachments: input.attachments ?? [],
-        ...(input.model ? { model: input.model } : {}),
-        ...(input.thinking ? { thinking: input.thinking } : {}),
-        signal: active.controller.signal,
-        emit(event) {
-          if (live()) state.apply(sessionId, event);
-        },
-        ask(request) {
-          if (!live()) return Promise.resolve(null);
-          asked.add(request.id);
-          return new Promise((resolve) => {
-            waiters.set(request.id, resolve);
-            state.addInteraction(sessionId, request);
-          });
-        },
-        onSteer(listener) {
-          active.steer = listener;
-        },
-      });
-    } catch (error) {
-      if (live() && !active.controller.signal.aborted) {
-        failed = true;
-        state.apply(sessionId, { kind: 'error', text: error instanceof Error ? error.message : String(error) });
-      }
-    }
-    for (const id of asked) if (waiters.has(id)) settle(id, null);
-    if (!live()) return;
-    runs.delete(sessionId);
-    state.setRunning(sessionId, false, failed ? 'error' : 'completed');
-    const next = active.queued.shift();
-    if (next !== undefined) {
-      // The rest of the queue moves to the run `next` starts (registered synchronously).
-      const started = send(next);
-      runs.get(sessionId)?.queued.push(...active.queued);
-      await started;
-    }
-  };
-
-  const host: RunHost = {
-    restore({ title }, events) {
-      const now = Date.now();
-      const session: ChatSession = { id: newId(), title, status: 'idle', createdAt: now, updatedAt: now };
-      state.sessions.set((all) => [session, ...all]);
-      state.hydrate(session.id, events);
-      return session;
-    },
-    sessions: {
-      list: state.sessions,
-      async create(input) {
-        const now = Date.now();
-        const session: ChatSession = {
-          id: newId(),
-          title: input?.title ?? 'New session',
-          status: 'idle',
-          createdAt: now,
-          updatedAt: now,
-        };
-        state.sessions.set((all) => [session, ...all]);
-        state.hydrate(session.id, []);
-        return session;
-      },
-      async rename(sessionId, title) {
-        state.patchSession(sessionId, { title, updatedAt: Date.now() });
-      },
-      async setArchived(sessionId, archived) {
-        state.patchSession(sessionId, { archived });
-      },
-      async remove(sessionId) {
-        host.interrupt!(sessionId);
-        state.sessions.set((all) => all.filter((s) => s.id !== sessionId));
-      },
-    },
-    transcript: (sessionId) => {
-      const t = state.transcript(sessionId);
-      if (!t.state.get().hydrated) state.hydrate(sessionId, []);
-      return state.readable(sessionId);
-    },
-    send,
-    interrupt(sessionId) {
-      const active = runs.get(sessionId);
-      if (!active) return;
-      runs.delete(sessionId);
-      active.controller.abort();
-      for (const i of state.pending(sessionId).get()) settle(i.requestId, null);
-      state.setRunning(sessionId, false, 'idle');
-    },
-    async steer(sessionId, message) {
-      const active = runs.get(sessionId);
-      if (!active?.steer) return false;
-      state.apply(sessionId, { kind: 'user-prompt', text: message });
-      active.steer(message);
-      return true;
-    },
-    async followUp(sessionId, message) {
-      const active = runs.get(sessionId);
-      if (!active) return false;
-      active.queued.push({ sessionId, prompt: message });
-      return true;
-    },
-    interactions: {
-      pending: state.pending,
-      async answer(requestId, response) {
-        settle(requestId, response);
-      },
-      async cancel(requestId) {
-        settle(requestId, null);
-      },
-    },
-    models: isReadable(options.models) ? options.models : constant(options.models ?? []),
-  };
-  return host;
-}
-
-function isReadable<T>(value: T | Readable<T> | undefined): value is Readable<T> {
-  return typeof value === 'object' && value !== null && typeof (value as Readable<T>).subscribe === 'function';
-}

package/src/adapters/server-approvals-host.ts

@@ -1,102 +0,0 @@
-/**
- * An `ApprovalsHost` on a running zidane-server, over a shared browser client
- * (`createServerClient`): the pending approvals (`approvals.listPending`,
- * re-read after every handshake, then kept current by the `approval:request` /
- * `approval:resolved` signals), decisions (`approvals.resolve`) and bulk deny
- * (`approvals.denyAll`).
- *
- * Listing needs a `chat` token; answering needs `approve`. Built after the
- * handshake (`await client.ready`), the host follows the token: one without
- * `approve` shows approvals without buttons.
- *
- * `safelist` is the server's "Always allow" list (`safelist.list`, a
- * `chat` token) and revoking an entry (`safelist.remove`, `approve`); a
- * server without those methods (older) leaves it out.
- */
-import type { ServerClient } from 'zidane/ipc/browser';
-import type { HostSignal } from 'zidane/ipc';
-
-import type { ApprovalDecision, ApprovalsHost } from '../approvals/headless/host';
-import { createPendingApprovals } from '../approvals/headless/pending';
-import { createSafelist } from '../approvals/headless/safelist';
-
-/** Options for {@link createServerApprovalsHost}. */
-export interface ServerApprovalsHostOptions {
-  /** The client to speak through, shared with the chat host (`createServerHost({ client })`) and other areas' hosts. */
-  client: ServerClient;
-  /**
-   * `false` leaves out `resolve` and `denyAll`, for a token without the `approve` scope.
-   * Default: `client.can('approvals.resolve')` once the handshake has landed, `true` before it.
-   */
-  canApprove?: boolean;
-  /** Called with errors no caller receives (a failed listing). Default: a console warning. */
-  onError?: (error: unknown) => void;
-}
-
-/**
- * Creates an {@link ApprovalsHost} on a running zidane-server.
- *
- * @param options - The shared client, whether the token may answer approvals, and where background errors go.
- */
-export function createServerApprovalsHost(options: ServerApprovalsHostOptions): ApprovalsHost {
-  const { client } = options;
-  const canApprove = options.canApprove ?? (client.hello() === null || client.can('approvals.resolve'));
-  const onError = options.onError ?? ((error: unknown) => console.warn('createServerApprovalsHost:', error));
-  const offers = (method: 'safelist.list' | 'safelist.remove') => client.hello() === null || client.can(method);
-
-  const pending = createPendingApprovals((sink) => {
-    let live = true;
-    const list = () => {
-      client
-        .call('approvals.listPending', {})
-        .then((requests) => {
-          if (live && Array.isArray(requests)) sink.merge(requests);
-        })
-        .catch((error: unknown) => {
-          if (live) onError(error);
-        });
-    };
-    const offSignal = client.onSignal((signal: HostSignal) => {
-      if (signal.kind === 'approval:request') sink.add(signal.request);
-      else if (signal.kind === 'approval:resolved') sink.drop(signal.requestId);
-    });
-    // After every handshake: approvals raised while this page was away.
-    const offOpen = client.onOpen(() => list());
-    if (client.hello()) list();
-    return () => {
-      live = false;
-      offSignal();
-      offOpen();
-    };
-  });
-
-  return {
-    pending,
-    ...(offers('safelist.list')
-      ? {
-          safelist: createSafelist({
-            list: async () => (await client.call('safelist.list', {})).projects,
-            ...(offers('safelist.remove')
-              ? {
-                  remove: async (project: string, entry: string) => {
-                    await client.call('safelist.remove', { project, entry });
-                  },
-                }
-              : {}),
-          }),
-        }
-      : {}),
-    ...(canApprove
-      ? {
-          async resolve(requestId: string, decision: ApprovalDecision) {
-            if (!pending.take(requestId)) return;
-            await client.call('approvals.resolve', { requestId, decision });
-          },
-          async denyAll(sessionId?: string) {
-            pending.takeAll(sessionId);
-            await client.call('approvals.denyAll', sessionId === undefined ? {} : { sessionId });
-          },
-        }
-      : {}),
-  };
-}

package/src/adapters/server-client.ts

@@ -1,15 +0,0 @@
-/**
- * The zidane-server client the server adapter speaks through: zidane's own browser client
- * (`zidane/ipc/browser`), re-exported so an app reaches it from the kit. Share one client
- * between the chat host and the other areas' hosts on the same server.
- */
-export {
-  createServerClient,
-  SERVER_AUTH_CHECK_PATH,
-  ServerCallError,
-  type ServerClient,
-  type ServerClientOptions,
-  type ServerClientState,
-  ServerConnectionError,
-  type ServerRefusal,
-} from 'zidane/ipc/browser';