@ably/ai-transport 0.1.0 → 0.3.0

package/src/core/transport/stream-router.ts

@@ -1,136 +0,0 @@
-/**
- * Client-side stream routing.
- *
- * Maintains a map of turnId to ReadableStreamController. Routes decoded events
- * to the correct stream. Closes streams on terminal events, explicit close, or
- * error.
- */
-
-import * as Ably from 'ably';
-
-import { ErrorCode } from '../../errors.js';
-import type { Logger } from '../../logger.js';
-import type { TurnEntry } from './types.js';
-
-// ---------------------------------------------------------------------------
-// Interface
-// ---------------------------------------------------------------------------
-
-/** Routes decoded events to the correct turn's ReadableStream. */
-export interface StreamRouter<TEvent> {
-  /** Register a new stream for a turnId. Returns the ReadableStream the consumer reads from. */
-  createStream(turnId: string): ReadableStream<TEvent>;
-  /** Close the stream for a turnId. Returns true if a stream existed. */
-  closeStream(turnId: string): boolean;
-  /** Error the stream for a turnId. The consumer's reader will reject with the given error. Returns true if a stream existed. */
-  errorStream(turnId: string, error: Ably.ErrorInfo): boolean;
-  /** Enqueue an event to the correct stream. Returns true if routed successfully. */
-  route(turnId: string, event: TEvent): boolean;
-  /** Whether a specific turnId has an active stream. */
-  has(turnId: string): boolean;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-// Spec: AIT-CT14
-class DefaultStreamRouter<TEvent> implements StreamRouter<TEvent> {
-  private readonly _turns = new Map<string, TurnEntry<TEvent>>();
-  private readonly _isTerminal: (event: TEvent) => boolean;
-  private readonly _logger: Logger;
-
-  constructor(isTerminal: (event: TEvent) => boolean, logger: Logger) {
-    this._isTerminal = isTerminal;
-    this._logger = logger;
-  }
-
-  createStream(turnId: string): ReadableStream<TEvent> {
-    this._logger.trace('StreamRouter.createStream();', { turnId });
-
-    // Build stream+controller together. ReadableStream's start() runs synchronously
-    // per spec, so the controller is captured before the constructor returns.
-    const entry: { controller?: ReadableStreamDefaultController<TEvent> } = {};
-    const stream = new ReadableStream<TEvent>({
-      start(controller) {
-        entry.controller = controller;
-      },
-    });
-    if (!entry.controller) {
-      throw new Ably.ErrorInfo(
-        'unable to create stream; ReadableStream start() was not called synchronously',
-        ErrorCode.TransportSubscriptionError,
-        500,
-      );
-    }
-    this._turns.set(turnId, { controller: entry.controller, turnId });
-    return stream;
-  }
-
-  // Spec: AIT-CT14b
-  closeStream(turnId: string): boolean {
-    const turn = this._turns.get(turnId);
-    if (!turn) return false;
-
-    this._logger.debug('StreamRouter.closeStream(); closing stream', { turnId });
-    try {
-      turn.controller.close();
-    } catch {
-      /* consumer cancelled the stream */
-    }
-    this._turns.delete(turnId);
-    return true;
-  }
-
-  // Spec: AIT-CT14c
-  errorStream(turnId: string, error: Ably.ErrorInfo): boolean {
-    const turn = this._turns.get(turnId);
-    if (!turn) return false;
-
-    this._logger.debug('StreamRouter.errorStream(); erroring stream', { turnId });
-    try {
-      turn.controller.error(error);
-    } catch {
-      /* consumer cancelled the stream */
-    }
-    this._turns.delete(turnId);
-    return true;
-  }
-
-  // Spec: AIT-CT14a
-  route(turnId: string, event: TEvent): boolean {
-    const turn = this._turns.get(turnId);
-    if (!turn) return false;
-
-    try {
-      turn.controller.enqueue(event);
-    } catch {
-      this._turns.delete(turnId);
-      return false;
-    }
-
-    if (this._isTerminal(event)) {
-      this.closeStream(turnId);
-    }
-    return true;
-  }
-
-  has(turnId: string): boolean {
-    return this._turns.has(turnId);
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a StreamRouter that routes decoded events to per-turn ReadableStreams.
- * @param isTerminal - Predicate that returns true for events that close the stream.
- * @param logger - Logger for diagnostic output.
- * @returns A new {@link StreamRouter} instance.
- */
-export const createStreamRouter = <TEvent>(
-  isTerminal: (event: TEvent) => boolean,
-  logger: Logger,
-): StreamRouter<TEvent> => new DefaultStreamRouter(isTerminal, logger);

package/src/core/transport/turn-manager.ts

@@ -1,165 +0,0 @@
-/**
- * Server-side turn state management and lifecycle event publishing.
- *
- * Owns the authoritative turn lifecycle. Tracks active turns with their
- * AbortControllers and clientIds. Publishes turn-start and turn-end events
- * on the Ably channel so all clients can react to turn state changes.
- */
-
-import type * as Ably from 'ably';
-
-import {
-  EVENT_TURN_END,
-  EVENT_TURN_START,
-  HEADER_FORK_OF,
-  HEADER_PARENT,
-  HEADER_TURN_CLIENT_ID,
-  HEADER_TURN_ID,
-  HEADER_TURN_REASON,
-} from '../../constants.js';
-import type { Logger } from '../../logger.js';
-import type { TurnEndReason } from './types.js';
-
-// ---------------------------------------------------------------------------
-// Interface
-// ---------------------------------------------------------------------------
-
-/** Manages active turns and publishes turn lifecycle events on the channel. */
-export interface TurnManager {
-  /** Register a new turn. Publishes turn-start on the channel. Returns AbortSignal. */
-  startTurn(
-    turnId: string,
-    clientId?: string,
-    controller?: AbortController,
-    metadata?: { parent?: string; forkOf?: string },
-  ): Promise<AbortSignal>;
-  /** End a turn. Publishes turn-end on the channel. Cleans up internal state. */
-  endTurn(turnId: string, reason: TurnEndReason): Promise<void>;
-  /** Get the AbortSignal for a turn. */
-  getSignal(turnId: string): AbortSignal | undefined;
-  /** Get the clientId that owns a turn. */
-  getClientId(turnId: string): string | undefined;
-  /** Abort the signal for a turn. */
-  abort(turnId: string): void;
-  /** Get all active turn IDs. */
-  getActiveTurnIds(): string[];
-  /** Abort all active turns and clear state. */
-  close(): void;
-}
-
-// ---------------------------------------------------------------------------
-// Internal state
-// ---------------------------------------------------------------------------
-
-interface ActiveTurnsEntry {
-  controller: AbortController;
-  clientId: string;
-}
-
-// ---------------------------------------------------------------------------
-// Implementation
-// ---------------------------------------------------------------------------
-
-class DefaultTurnManager implements TurnManager {
-  private readonly _channel: Ably.RealtimeChannel;
-  private readonly _logger: Logger | undefined;
-  private readonly _activeTurns = new Map<string, ActiveTurnsEntry>();
-
-  constructor(channel: Ably.RealtimeChannel, logger?: Logger) {
-    this._channel = channel;
-    this._logger = logger?.withContext({ component: 'TurnManager' });
-  }
-
-  async startTurn(
-    turnId: string,
-    clientId?: string,
-    externalController?: AbortController,
-    metadata?: { parent?: string; forkOf?: string },
-  ): Promise<AbortSignal> {
-    this._logger?.trace('DefaultTurnManager.startTurn();', { turnId, clientId });
-
-    const controller = externalController ?? new AbortController();
-    const resolvedClientId = clientId ?? '';
-    this._activeTurns.set(turnId, { controller, clientId: resolvedClientId });
-
-    const headers: Record<string, string> = {
-      [HEADER_TURN_ID]: turnId,
-      [HEADER_TURN_CLIENT_ID]: resolvedClientId,
-    };
-    if (metadata?.parent !== undefined) {
-      headers[HEADER_PARENT] = metadata.parent;
-    }
-    if (metadata?.forkOf !== undefined) {
-      headers[HEADER_FORK_OF] = metadata.forkOf;
-    }
-
-    await this._channel.publish({
-      name: EVENT_TURN_START,
-      extras: { headers },
-    });
-
-    this._logger?.debug('DefaultTurnManager.startTurn(); turn started', { turnId });
-    return controller.signal;
-  }
-
-  async endTurn(turnId: string, reason: TurnEndReason): Promise<void> {
-    this._logger?.trace('DefaultTurnManager.endTurn();', { turnId, reason });
-
-    const state = this._activeTurns.get(turnId);
-    const resolvedClientId = state?.clientId ?? '';
-
-    // Publish before deleting local state so that if publish fails,
-    // the turn remains in the active set and can be retried or cleaned up.
-    await this._channel.publish({
-      name: EVENT_TURN_END,
-      extras: {
-        headers: {
-          [HEADER_TURN_ID]: turnId,
-          [HEADER_TURN_CLIENT_ID]: resolvedClientId,
-          [HEADER_TURN_REASON]: reason,
-        },
-      },
-    });
-
-    this._activeTurns.delete(turnId);
-    this._logger?.debug('DefaultTurnManager.endTurn(); turn ended', { turnId, reason });
-  }
-
-  getSignal(turnId: string): AbortSignal | undefined {
-    return this._activeTurns.get(turnId)?.controller.signal;
-  }
-
-  getClientId(turnId: string): string | undefined {
-    return this._activeTurns.get(turnId)?.clientId;
-  }
-
-  abort(turnId: string): void {
-    this._logger?.debug('DefaultTurnManager.abort();', { turnId });
-    this._activeTurns.get(turnId)?.controller.abort();
-  }
-
-  getActiveTurnIds(): string[] {
-    return [...this._activeTurns.keys()];
-  }
-
-  close(): void {
-    this._logger?.trace('DefaultTurnManager.close();', { activeTurns: this._activeTurns.size });
-    for (const state of this._activeTurns.values()) {
-      state.controller.abort();
-    }
-    this._activeTurns.clear();
-  }
-}
-
-// ---------------------------------------------------------------------------
-// Factory
-// ---------------------------------------------------------------------------
-
-/**
- * Create a turn manager bound to the given channel.
- * @param channel - The Ably channel to publish lifecycle events on.
- * @param logger - Optional logger for diagnostic output.
- * @returns A new {@link TurnManager} instance.
- */
-export const createTurnManager = (channel: Ably.RealtimeChannel, logger?: Logger): TurnManager =>
-  new DefaultTurnManager(channel, logger);

package/src/react/contexts/transport-context.ts

@@ -1,37 +0,0 @@
-import type * as Ably from 'ably';
-import { createContext } from 'react';
-
-import type { ClientTransport } from '../../core/transport/types.js';
-
-/**
- * A single entry in the transport registry, holding the transport and any
- * error that occurred during its construction.
- *
- * `transport` is `undefined` when construction failed.
- * `error` is set when `createClientTransport` threw during provider render.
- */
-export interface TransportSlot {
-  /** The constructed transport, or `undefined` if construction failed. */
-  transport: ClientTransport<unknown, unknown> | undefined;
-  /** Construction error from `createClientTransport`, or `undefined` on success. */
-  error: Ably.ErrorInfo | undefined;
-}
-
-/** The shape of the TransportContext value — a record of channelName → slot. */
-export type TransportContextValue = Readonly<Record<string, TransportSlot>>;
-
-/**
- * Context that holds the registered {@link ClientTransport} slots, keyed by channelName.
- * Each slot contains the transport (or `undefined` on construction failure) and any error.
- * Populated by {@link TransportProvider}; read by {@link useClientTransport}.
- */
-export const TransportContext = createContext<TransportContextValue>({});
-
-/**
- * Context that holds the nearest (innermost) transport slot.
- * Each {@link TransportProvider} sets this to its own slot, so descendants
- * can access the nearest transport without knowing its channel name.
- * `undefined` when no provider is present.
- * Read by hooks whose `transport` argument is omitted.
- */
-export const NearestTransportContext = createContext<TransportSlot | undefined>(undefined);

package/src/react/contexts/transport-provider.tsx

@@ -1,164 +0,0 @@
-/**
- * TransportProvider: creates a ClientTransport and makes it available to
- * descendants via TransportContext.
- *
- * Wraps children with Ably's ChannelProvider so the underlying channel
- * lifecycle is managed in one place. An inner component calls useChannel
- * to get the stable channel reference and creates the transport once on
- * first render (via useRef).
- *
- * If createClientTransport throws, the error is stored in the TransportSlot
- * (alongside an undefined transport) so that useClientTransport can surface it
- * as transportError without crashing the component tree.
- *
- * The transport is closed when the provider truly unmounts. The close is
- * scheduled as a microtask so that React Strict Mode's synchronous
- * remount cycle (mount → fake-unmount → remount) can cancel it before it
- * fires, avoiding unnecessary transport teardown in development.
- *
- * Multiple TransportProviders can be nested using distinct channelNames.
- * Each provider merges its slot into the parent record so descendants
- * can access all registered transports via useClientTransport(channelName).
- */
-
-import * as Ably from 'ably';
-import { ChannelProvider, useChannel } from 'ably/react';
-import { type PropsWithChildren, type ReactNode, useContext, useEffect, useMemo, useRef } from 'react';
-
-import { createClientTransport } from '../../core/transport/client-transport.js';
-import type { ClientTransport, ClientTransportOptions } from '../../core/transport/types.js';
-import { ErrorCode } from '../../errors.js';
-import type { TransportSlot } from '../contexts/transport-context.js';
-import { NearestTransportContext, TransportContext } from '../contexts/transport-context.js';
-
-/**
- * Props for {@link TransportProvider}.
- *
- * All {@link ClientTransportOptions} except `channel` (managed internally) plus `channelName`.
- */
-export interface TransportProviderProps<TEvent, TMessage>
-  extends Omit<ClientTransportOptions<TEvent, TMessage>, 'channel'>, PropsWithChildren {
-  /** The Ably channel name to subscribe to. Also used as the context registry key. */
-  channelName: string;
-}
-
-// Inner component: rendered inside ChannelProvider so useChannel resolves to
-// the channel created by the outer wrapper.
-const TransportProviderInner = <TEvent, TMessage>({
-  channelName,
-  children,
-  ...transportOptions
-}: TransportProviderProps<TEvent, TMessage>) => {
-  const { channel } = useChannel({ channelName });
-  const transportRef = useRef<ClientTransport<TEvent, TMessage> | undefined>(undefined);
-  const transportChannelRef = useRef<string>(channelName);
-  const transportsToDisposeRef = useRef<ClientTransport<unknown, unknown>[]>([]);
-  const pendingCloseRef = useRef(false);
-  const constructionErrorRef = useRef<Ably.ErrorInfo | undefined>(undefined);
-
-  const alreadyCreatedOrFailed = !!transportRef.current || !!constructionErrorRef.current;
-
-  if (!alreadyCreatedOrFailed || transportChannelRef.current !== channelName) {
-    transportChannelRef.current = channelName;
-    if (transportRef.current) transportsToDisposeRef.current.push(transportRef.current);
-    try {
-      transportRef.current = createClientTransport({ ...transportOptions, channel });
-      constructionErrorRef.current = undefined;
-    } catch (error) {
-      transportRef.current = undefined;
-      constructionErrorRef.current =
-        error instanceof Ably.ErrorInfo
-          ? error
-          : new Ably.ErrorInfo('Unknown error while creating transport', ErrorCode.BadRequest, 400);
-    }
-  }
-
-  const parentMap = useContext(TransportContext);
-
-  // Capture ref values as locals so useMemo deps track changes correctly.
-  // CAST: TransportContext stores transports with erased generics.
-  // The generic types are fixed at the TransportProvider<TEvent, TMessage> boundary.
-  const currentTransport = transportRef.current as ClientTransport<unknown, unknown> | undefined;
-  const currentError = constructionErrorRef.current;
-
-  const slot = useMemo<TransportSlot>(
-    () => ({ transport: currentTransport, error: currentError }),
-    [currentTransport, currentError],
-  );
-
-  const contextValue = useMemo(() => ({ ...parentMap, [channelName]: slot }), [channelName, parentMap, slot]);
-
-  useEffect(
-    () => () => {
-      for (const transport of transportsToDisposeRef.current) void transport.close();
-    },
-    [channelName],
-  );
-
-  // Close the transport when the component truly unmounts. The close is
-  // scheduled as a microtask: in React Strict Mode (dev) the component
-  // remounts synchronously before any microtask can drain, so the remount's
-  // effect setup resets pendingCloseRef.current = false and cancels the
-  // close. On a real unmount no remount follows, the microtask fires, and
-  // the transport is closed.
-  useEffect(() => {
-    pendingCloseRef.current = false;
-    return () => {
-      pendingCloseRef.current = true;
-      void Promise.resolve().then(() => {
-        if (pendingCloseRef.current) {
-          void transportRef.current?.close();
-        }
-      });
-    };
-  }, []);
-
-  return (
-    <TransportContext.Provider value={contextValue}>
-      <NearestTransportContext.Provider value={slot}>{children}</NearestTransportContext.Provider>
-    </TransportContext.Provider>
-  );
-};
-
-/**
- * Provide a {@link ClientTransport} to descendant components.
- *
- * Wraps children with Ably's `ChannelProvider` using `channelName`, creates a
- * transport from the resolved channel and the remaining options, and registers it
- * in `TransportContext` under `channelName`. Descendants call
- * {@link useClientTransport} with the same `channelName` to access the transport.
- *
- * If `createClientTransport` throws during construction, the error is surfaced
- * through `useClientTransport` as `transportError` — the component tree does not
- * crash and children are still rendered.
- *
- * ```tsx
- * <TransportProvider channelName="ai:demo" codec={UIMessageCodec}>
- *   <Chat />
- * </TransportProvider>
- *
- * // Inside Chat:
- * const { transport, transportError } = useClientTransport({ channelName: 'ai:demo' });
- * ```
- *
- * For multiple transports, nest providers with distinct channelNames:
- *
- * ```tsx
- * <TransportProvider channelName="ai:main" codec={UIMessageCodec}>
- *   <TransportProvider channelName="ai:aux" codec={UIMessageCodec}>
- *     <App />
- *   </TransportProvider>
- * </TransportProvider>
- *
- * // Inside App:
- * const { transport: main } = useClientTransport({ channelName: 'ai:main' });
- * const { transport: aux }  = useClientTransport({ channelName: 'ai:aux' });
- * ```
- * @param props - Provider configuration including `channelName`, `codec`, and all other {@link ClientTransportOptions}.
- * @returns A React element wrapping children with ChannelProvider and TransportContext.
- */
-export const TransportProvider = <TEvent, TMessage>(props: TransportProviderProps<TEvent, TMessage>): ReactNode => (
-  <ChannelProvider channelName={props.channelName}>
-    <TransportProviderInner {...props} />
-  </ChannelProvider>
-);

package/src/react/create-transport-hooks.ts

@@ -1,144 +0,0 @@
-/**
- * createTransportHooks: factory that captures TEvent and TMessage once and returns
- * a bundle of type-safe hooks + TransportProvider. Hook call sites need no type
- * parameters at every use — just call the hooks directly.
- * @example
- * // Once per app (e.g. in a shared transport.ts):
- * export const {
- *   TransportProvider,
- *   useClientTransport,
- *   useView,
- *   useActiveTurns,
- * } = createTransportHooks<UIMessageChunk, UIMessage>();
- *
- * // In page:
- * <TransportProvider channelName="ai:demo" codec={UIMessageCodec}>
- *   <Chat />
- * </TransportProvider>
- *
- * // In Chat — no type params needed, transport is implicit from nearest provider:
- * const { nodes } = useView({ limit: 30 });
- * const turns = useActiveTurns();
- */
-
-import type * as Ably from 'ably';
-import type { ComponentType } from 'react';
-
-import type { ClientTransport, View } from '../core/transport/types.js';
-import type { TransportProviderProps } from './contexts/transport-provider.js';
-import { TransportProvider as _TransportProvider } from './contexts/transport-provider.js';
-import { useAblyMessages as _useAblyMessages } from './use-ably-messages.js';
-import { useActiveTurns as _useActiveTurns } from './use-active-turns.js';
-import type { ClientTransportHandle } from './use-client-transport.js';
-import { useClientTransport as _useClientTransport } from './use-client-transport.js';
-import { useCreateView as _useCreateView } from './use-create-view.js';
-import type { TreeHandle } from './use-tree.js';
-import { useTree as _useTree } from './use-tree.js';
-import type { ViewHandle } from './use-view.js';
-import { useView as _useView } from './use-view.js';
-
-/**
- * Bundle of type-safe hooks and provider returned by {@link createTransportHooks}.
- *
- * `TEvent` and `TMessage` are baked in at factory creation time so no type params
- * are needed at hook call sites.
- */
-export interface TransportHooks<TEvent, TMessage> {
-  /**
-   * `TransportProvider` narrowed to `TEvent`/`TMessage`. No JSX type params needed.
-   */
-  TransportProvider: ComponentType<TransportProviderProps<TEvent, TMessage>>;
-  /**
-   * Read the transport from context. No type params needed.
-   *
-   * Returns `{ transport, transportError }`. When no provider is found,
-   * `transportError` is set and `transport` is a stub that throws on access —
-   * the hook never throws during render.
-   *
-   * Pass `onError` to subscribe to post-construction transport errors
-   * (e.g. send failures, channel continuity loss) without wiring
-   * `transport.on('error', …)` manually.
-   */
-  useClientTransport: (props?: {
-    /** Channel name to look up; omit to use the nearest {@link TransportProvider}. */
-    channelName?: string;
-    /** When `true`, return a stub transport that throws on any access. */
-    skip?: boolean;
-    /** Called whenever the resolved transport emits an error event. */
-    onError?: (error: Ably.ErrorInfo) => void;
-  }) => ClientTransportHandle<TEvent, TMessage>;
-  /**
-   * Subscribe to the nearest transport's view and return the visible node list with pagination.
-   * Pass `transport` to use a transport's default view, `view` to subscribe to a specific view
-   * directly. Pass `limit` to auto-load on mount. Pass `skip: true` for an empty handle.
-   */
-  useView: (props?: {
-    /** Client transport whose default view to subscribe to; defaults to the nearest {@link TransportProvider}. */
-    transport?: ClientTransport<TEvent, TMessage> | null;
-    /** A specific {@link View} to subscribe to directly. Takes priority over `transport`. */
-    view?: View<TEvent, TMessage> | null;
-    /** When provided, auto-loads the first page on mount. */
-    limit?: number;
-    /** When `true`, skip all subscriptions and return an empty handle. */
-    skip?: boolean;
-  }) => ViewHandle<TEvent, TMessage>;
-  /**
-   * Track active turns across all clients on the channel.
-   * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-   */
-  useActiveTurns: (props?: {
-    /** Override transport; defaults to the nearest {@link TransportProvider}. */
-    transport?: ClientTransport<TEvent, TMessage> | null;
-  }) => Map<string, Set<string>>;
-  /**
-   * Navigate conversation branches in the transport tree.
-   * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-   */
-  useTree: (props?: {
-    /** Override transport; defaults to the nearest {@link TransportProvider}. */
-    transport?: ClientTransport<TEvent, TMessage>;
-  }) => TreeHandle<TMessage>;
-  /**
-   * Subscribe to raw Ably messages on the transport channel.
-   * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-   * Pass `skip: true` to return an empty array without subscribing.
-   */
-  useAblyMessages: (props?: {
-    /** Override transport; defaults to the nearest {@link TransportProvider}. */
-    transport?: ClientTransport<TEvent, TMessage>;
-    /** When `true`, skip all subscriptions and return an empty array. */
-    skip?: boolean;
-  }) => Ably.InboundMessage[];
-  /**
-   * Create an independent view over the same tree.
-   * Pass `transport` to override; defaults to the nearest {@link TransportProvider}.
-   * Pass `skip: true` to return an empty handle without creating a view.
-   */
-  useCreateView: (props?: {
-    /** Override transport; defaults to the nearest {@link TransportProvider}. */
-    transport?: ClientTransport<TEvent, TMessage> | null;
-    /** When provided, auto-loads the first page on mount. */
-    limit?: number;
-    /** When `true`, skip view creation and return an empty handle. */
-    skip?: boolean;
-  }) => ViewHandle<TEvent, TMessage>;
-}
-
-/**
- * Create a bundle of type-safe hooks and provider for a given `TEvent`/`TMessage` pair.
- *
- * `TEvent` and `TMessage` are captured at factory creation time; hook call sites need
- * no type parameters. The returned hooks are thin wrappers around the standalone hooks
- * with the types resolved.
- * @returns A {@link TransportHooks} bundle.
- */
-export const createTransportHooks = <TEvent, TMessage>(): TransportHooks<TEvent, TMessage> => ({
-  // CAST: TransportProvider is generic; factory narrows it to TEvent/TMessage.
-  TransportProvider: _TransportProvider as ComponentType<TransportProviderProps<TEvent, TMessage>>,
-  useClientTransport: (props) => _useClientTransport<TEvent, TMessage>(props ?? {}),
-  useView: (props) => _useView<TEvent, TMessage>(props ?? {}),
-  useActiveTurns: (props) => _useActiveTurns<TEvent, TMessage>(props ?? {}),
-  useTree: (props) => _useTree<TEvent, TMessage>(props ?? {}),
-  useAblyMessages: (props) => _useAblyMessages<TEvent, TMessage>(props ?? {}),
-  useCreateView: (props) => _useCreateView<TEvent, TMessage>(props ?? {}),
-});