@ably/ai-transport 0.0.1

package/dist/react/ably-ai-transport-react.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"ably-ai-transport-react.js","names":[],"sources":["../../src/react/use-ably-messages.ts","../../src/constants.ts","../../src/react/use-active-turns.ts","../../src/errors.ts","../../src/event-emitter.ts","../../src/logger.ts","../../src/utils.ts","../../src/core/transport/conversation-tree.ts","../../src/core/transport/decode-history.ts","../../src/core/transport/headers.ts","../../src/core/transport/stream-router.ts","../../src/core/transport/client-transport.ts","../../src/react/use-client-transport.ts","../../src/react/use-conversation-tree.ts","../../src/react/use-edit.ts","../../src/react/use-history.ts","../../src/react/use-messages.ts","../../src/react/use-regenerate.ts","../../src/react/use-send.ts"],"sourcesContent":["/**\n * useAblyMessages — reactive raw Ably message log from a ClientTransport.\n *\n * Returns the accumulated raw Ably InboundMessages in chronological order,\n * including both live messages (from the channel subscription) and\n * history-loaded messages (from transport.history() calls).\n *\n * Subscribes to the transport's \"ably-message\" event and re-reads the\n * list on each update.\n */\n\nimport type * as Ably from 'ably';\nimport { useEffect, useState } from 'react';\n\nimport type { ClientTransport } from '../core/transport/types.js';\n\n/**\n * Subscribe to raw Ably message updates from a client transport.\n * @param transport - The client transport to observe.\n * @returns The accumulated raw Ably messages in chronological order.\n */\nexport const useAblyMessages = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage>,\n): Ably.InboundMessage[] => {\n  const [messages, setMessages] = useState<Ably.InboundMessage[]>(() => transport.getAblyMessages());\n\n  useEffect(() => {\n    setMessages(transport.getAblyMessages());\n\n    const unsub = transport.on('ably-message', () => {\n      setMessages(transport.getAblyMessages());\n    });\n    return unsub;\n  }, [transport]);\n\n  return messages;\n};\n","/**\n * Shared constants used by both codec and transport layers.\n *\n * Header constants define the `x-ably-*` wire protocol. Message and event\n * name constants define the transport lifecycle signals on the channel.\n *\n * These live at the top level (not in codec/ or transport/) because both\n * layers need them — the codec core reads/writes stream and status headers,\n * while the transport layer reads/writes turn, cancel, and role headers.\n */\n\n// ---------------------------------------------------------------------------\n// Stream headers (used by codec encoder/decoder core)\n// ---------------------------------------------------------------------------\n\n/** Header: whether this Ably message uses streaming (message appends) or is discrete. Always \"true\" or \"false\". */\nexport const HEADER_STREAM = 'x-ably-stream';\n\n/** Header: lifecycle status of a streamed message. Only set when x-ably-stream is \"true\". */\nexport const HEADER_STATUS = 'x-ably-status';\n\n/** Header: stream identity. Set by the encoder on every streamed message; read by the decoder to correlate streams. */\nexport const HEADER_STREAM_ID = 'x-ably-stream-id';\n\n// ---------------------------------------------------------------------------\n// Identity headers (used by transport for turn correlation)\n// ---------------------------------------------------------------------------\n\n/** Header: turn correlation ID. Set on every message in a turn. */\nexport const HEADER_TURN_ID = 'x-ably-turn-id';\n\n/** Header: message identity. Assigned per message (user or assistant). Used for optimistic reconciliation on the client. */\nexport const HEADER_MSG_ID = 'x-ably-msg-id';\n\n/** Header: clientId of the user who initiated the turn. Set by the server on stream messages. */\nexport const HEADER_TURN_CLIENT_ID = 'x-ably-turn-client-id';\n\n/** Header: message role (e.g. \"user\", \"assistant\"). */\nexport const HEADER_ROLE = 'x-ably-role';\n\n// ---------------------------------------------------------------------------\n// Cancel headers\n// ---------------------------------------------------------------------------\n\n/** Header: cancel a specific turn by ID. */\nexport const HEADER_CANCEL_TURN_ID = 'x-ably-cancel-turn-id';\n\n/** Header: cancel all turns belonging to the sender's clientId. */\nexport const HEADER_CANCEL_OWN = 'x-ably-cancel-own';\n\n/** Header: cancel all turns on the channel. */\nexport const HEADER_CANCEL_ALL = 'x-ably-cancel-all';\n\n/** Header: cancel all turns belonging to a specific clientId. */\nexport const HEADER_CANCEL_CLIENT_ID = 'x-ably-cancel-client-id';\n\n// ---------------------------------------------------------------------------\n// Fork / branching headers\n// ---------------------------------------------------------------------------\n\n/** Header: the msg-id of the immediately preceding message in this branch. */\nexport const HEADER_PARENT = 'x-ably-parent';\n\n/** Header: the msg-id of the message this one replaces (creates a fork). */\nexport const HEADER_FORK_OF = 'x-ably-fork-of';\n\n// ---------------------------------------------------------------------------\n// Turn lifecycle headers\n// ---------------------------------------------------------------------------\n\n/** Header: reason a turn ended (on x-ably-turn-end messages). */\nexport const HEADER_TURN_REASON = 'x-ably-turn-reason';\n\n// ---------------------------------------------------------------------------\n// Message / event names\n// ---------------------------------------------------------------------------\n\n/** Message name: client->server cancel signal. */\nexport const EVENT_CANCEL = 'x-ably-cancel';\n\n/** Message name: server publishes this to signal a turn has started. */\nexport const EVENT_TURN_START = 'x-ably-turn-start';\n\n/** Message name: server publishes this to signal a turn has ended. */\nexport const EVENT_TURN_END = 'x-ably-turn-end';\n\n/** Message name: transport-level abort signal (stream cancelled). */\nexport const EVENT_ABORT = 'x-ably-abort';\n\n/** Message name: transport-level error signal. */\nexport const EVENT_ERROR = 'x-ably-error';\n\n// ---------------------------------------------------------------------------\n// Domain header prefix (used by codec implementations)\n// ---------------------------------------------------------------------------\n\n/** Prefix for domain-specific headers. Distinguishes codec-layer headers from transport `x-ably-*` headers. */\nexport const DOMAIN_HEADER_PREFIX = 'x-domain-';\n","/**\n * useActiveTurns: reactive view of active turns on the channel,\n * keyed by clientId.\n *\n * Subscribes to transport turn lifecycle events and maintains a\n * Map<clientId, Set<turnId>> that updates on every turn start/end.\n *\n * Generic — works with any codec, not tied to Vercel types.\n */\n\nimport { useEffect, useState } from 'react';\n\nimport { EVENT_TURN_START } from '../constants.js';\nimport type { ClientTransport, TurnLifecycleEvent } from '../core/transport/types.js';\n\n/**\n * Returns a reactive Map of all active turns on the channel, keyed by clientId.\n * Updates when turns start or end.\n * @param transport - The client transport to observe, or null/undefined if not yet available.\n * @returns A Map where keys are clientIds and values are Sets of active turnIds.\n */\nexport const useActiveTurns = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage> | null | undefined,\n): Map<string, Set<string>> => {\n  const [turns, setTurns] = useState<Map<string, Set<string>>>(() => new Map());\n\n  useEffect(() => {\n    if (!transport) return;\n\n    // Initialize from current state\n    setTurns(transport.getActiveTurnIds());\n\n    const unsubscribe = transport.on('turn', (event: TurnLifecycleEvent) => {\n      setTurns((prev) => {\n        const next = new Map(prev);\n\n        if (event.type === EVENT_TURN_START) {\n          const set = new Set(next.get(event.clientId) ?? []);\n          set.add(event.turnId);\n          next.set(event.clientId, set);\n        } else {\n          const set = next.get(event.clientId);\n          if (set) {\n            set.delete(event.turnId);\n            if (set.size === 0) {\n              next.delete(event.clientId);\n            } else {\n              next.set(event.clientId, new Set(set));\n            }\n          }\n        }\n\n        return next;\n      });\n    });\n\n    return unsubscribe;\n  }, [transport]);\n\n  return turns;\n};\n","import * as Ably from 'ably';\n\n/**\n * Error codes for the AI Transport SDK.\n */\nexport enum ErrorCode {\n  /**\n   * The request was invalid.\n   */\n  BadRequest = 40000,\n\n  /**\n   * Invalid argument provided.\n   */\n  InvalidArgument = 40003,\n\n  // 104000 - 104999 are reserved for AI Transport SDK errors\n\n  /**\n   * Encoder recovery failed after flush — one or more updateMessage calls\n   * could not recover a failed append pipeline.\n   */\n  EncoderRecoveryFailed = 104000,\n\n  /**\n   * A transport-level channel subscription callback threw unexpectedly.\n   */\n  TransportSubscriptionError = 104001,\n\n  /**\n   * Cancel listener or onCancel hook threw while processing a cancel message.\n   */\n  CancelListenerError = 104002,\n\n  /**\n   * A turn lifecycle event (turn-start or turn-end) failed to publish.\n   */\n  TurnLifecycleError = 104003,\n\n  /**\n   * An operation was attempted on a transport that has already been closed.\n   */\n  TransportClosed = 104004,\n\n  /**\n   * The HTTP POST to the server endpoint failed (network error or non-2xx response).\n   */\n  TransportSendFailed = 104005,\n}\n\n/**\n * Returns true if the {@link Ably.ErrorInfo} code matches the provided ErrorCode value.\n * @param errorInfo The error info to check.\n * @param error The error code to compare against.\n * @returns true if the error code matches, false otherwise.\n */\n// eslint-disable-next-line @typescript-eslint/no-unsafe-enum-comparison\nexport const errorInfoIs = (errorInfo: Ably.ErrorInfo, error: ErrorCode): boolean => errorInfo.code === error;\n","/**\n * Type-safe EventEmitter wrapping Ably's internal EventEmitter.\n *\n * Takes a single `EventsMap` type parameter — an interface mapping event names\n * to payload types — rather than Ably's three type parameters. Adapted from\n * the ably-chat-js SDK.\n *\n * ```ts\n * interface MyEvents {\n *   reaction: { emoji: string };\n *   status: { online: boolean };\n * }\n *\n * const emitter = new EventEmitter<MyEvents>(logger);\n * emitter.on('reaction', (event) => console.log(event.emoji));\n * emitter.emit('reaction', { emoji: '👍' });\n * ```\n */\n\nimport * as Ably from 'ably';\n\nimport type { Logger } from './logger.js';\n\n/** Callback receiving a union of all possible event payloads. */\ntype Callback<EventsMap> = (arg: EventsMap[keyof EventsMap]) => void;\n\n/** Callback receiving the payload for a single event type. */\ntype CallbackSingle<K> = (arg: K) => void;\n\n/**\n * Type-safe interface for the Ably EventEmitter, parameterized by an EventsMap\n * that maps event names to their payload types.\n */\ninterface InterfaceEventEmitter<EventsMap> extends Ably.EventEmitter<Callback<EventsMap>, void, keyof EventsMap> {\n  /** Emit an event with a type-safe payload. Payload is optional for `undefined`-typed events. */\n  emit<K extends keyof EventsMap>(\n    event: K,\n    ...args: EventsMap[K] extends undefined ? [EventsMap[K]?] : [EventsMap[K]]\n  ): void;\n\n  /** Subscribe to a single event with a typed callback. */\n  on<K extends keyof EventsMap>(event: K, callback: CallbackSingle<EventsMap[K]>): void;\n  /** Subscribe to two events with a union-typed callback. */\n  on<K1 extends keyof EventsMap, K2 extends keyof EventsMap>(\n    events: [K1, K2],\n    callback: CallbackSingle<EventsMap[K1] | EventsMap[K2]>,\n  ): void;\n  /** Subscribe to three events with a union-typed callback. */\n  on<K1 extends keyof EventsMap, K2 extends keyof EventsMap, K3 extends keyof EventsMap>(\n    events: [K1, K2, K3],\n    callback: CallbackSingle<EventsMap[K1] | EventsMap[K2] | EventsMap[K3]>,\n  ): void;\n  /** Subscribe to an array of events. */\n  on(events: (keyof EventsMap)[], callback: Callback<EventsMap>): void;\n  /** Subscribe to all events. */\n  on(callback: Callback<EventsMap>): void;\n\n  /** Unsubscribe a callback from a specific event. */\n  off<K extends keyof EventsMap>(event: K, listener: CallbackSingle<EventsMap[K]>): void;\n  /** Unsubscribe a callback from all events, or remove all listeners if no callback provided. */\n  off(listener?: Callback<EventsMap>): void;\n}\n\n/**\n * Bridge from our {@link Logger} to the Ably EventEmitter's internal logger\n * contract. Ably's EventEmitter calls `logger.logAction(level, action, message)`\n * when a listener throws — we route that to our Logger's `error` method.\n * @param logger - The application logger to delegate to.\n * @returns An object satisfying the Ably EventEmitter's logger interface.\n */\nconst toAblyLogger = (logger: Logger): unknown => ({\n  logAction: (_level: number, action: string, message?: string) => {\n    logger.error(action, { detail: message });\n  },\n  shouldLog: () => true,\n});\n\n// CAST: Access Ably's internal EventEmitter constructor. Not publicly exported\n// but available to other Ably SDKs. The logger parameter ensures listener\n// exceptions are caught and logged rather than crashing.\nconst InternalEventEmitter: new <EventsMap>(logger: unknown) => InterfaceEventEmitter<EventsMap> = (\n  Ably.Realtime as unknown as { EventEmitter: new <EventsMap>(logger: unknown) => InterfaceEventEmitter<EventsMap> }\n).EventEmitter;\n\n/**\n * Type-safe EventEmitter based on Ably's internal EventEmitter.\n *\n * Provides the same semantics as {@link Ably.EventEmitter} (error isolation\n * between listeners, synchronous dispatch) but with a single `EventsMap` type\n * parameter for ergonomic type safety.\n *\n * Requires a {@link Logger} so that listener exceptions are routed through\n * the application's logging infrastructure rather than silently swallowed.\n */\nexport class EventEmitter<EventsMap> extends InternalEventEmitter<EventsMap> {\n  /**\n   * Create a new EventEmitter.\n   * @param logger - Application logger. Listener exceptions are logged at error level.\n   */\n  constructor(logger: Logger) {\n    super(toAblyLogger(logger));\n  }\n}\n","import * as Ably from 'ably';\n\nimport { ErrorCode } from './errors.js';\n\n/**\n * Structured logger with leveled output and hierarchical context.\n * Implementations filter messages by level and delegate to a {@link LogHandler}.\n */\nexport interface Logger {\n  /**\n   * Log a message at the trace level.\n   * @param message The message to log.\n   * @param context The context of the log message as key-value pairs.\n   */\n  trace(message: string, context?: LogContext): void;\n\n  /**\n   * Log a message at the debug level.\n   * @param message The message to log.\n   * @param context The context of the log message as key-value pairs.\n   */\n  debug(message: string, context?: LogContext): void;\n\n  /**\n   * Log a message at the info level.\n   * @param message The message to log.\n   * @param context The context of the log message as key-value pairs.\n   */\n  info(message: string, context?: LogContext): void;\n\n  /**\n   * Log a message at the warn level.\n   * @param message The message to log.\n   * @param context The context of the log message as key-value pairs.\n   */\n  warn(message: string, context?: LogContext): void;\n\n  /**\n   * Log a message at the error level.\n   * @param message The message to log.\n   * @param context The context of the log message as key-value pairs.\n   */\n  error(message: string, context?: LogContext): void;\n\n  /**\n   * Creates a new logger with a context that will be merged with any context provided to individual log calls.\n   * The context will be overridden by any matching keys in the individual log call's context.\n   * @param context The context to use for all log calls.\n   * @returns A new logger instance with the context.\n   */\n  withContext(context: LogContext): Logger;\n}\n\n/**\n * Represents the different levels of logging that can be used.\n */\nexport enum LogLevel {\n  /**\n   * Something routine and expected has occurred. This level will provide logs for the vast majority of operations\n   * and function calls.\n   */\n  Trace = 'trace',\n\n  /**\n   * Development information, messages that are useful when trying to debug library behavior,\n   * but superfluous to normal operation.\n   */\n  Debug = 'debug',\n\n  /**\n   * Informational messages. Operationally significant to the library but not out of the ordinary.\n   */\n  Info = 'info',\n\n  /**\n   * Anything that is not immediately an error, but could cause unexpected behavior in the future. For example,\n   * passing an invalid value to an option. Indicates that some action should be taken to prevent future errors.\n   */\n  Warn = 'warn',\n\n  /**\n   * A given operation has failed and cannot be automatically recovered. The error may threaten the continuity\n   * of operation.\n   */\n  Error = 'error',\n\n  /**\n   * No logging will be performed.\n   */\n  Silent = 'silent',\n}\n\n/**\n * Represents the context of a log message.\n * It is an object of key-value pairs that can be used to provide additional context to a log message.\n */\n// eslint-disable-next-line @typescript-eslint/no-explicit-any\nexport type LogContext = Record<string, any>;\n\n/**\n * A function that can be used to handle log messages.\n * @param message The message to log.\n * @param level The log level of the message.\n * @param context The context of the log message as key-value pairs.\n */\nexport type LogHandler = (message: string, level: LogLevel, context?: LogContext) => void;\n\n/**\n * A simple console logger that logs messages to the console.\n * @param message The message to log.\n * @param level The log level of the message.\n * @param context - The context of the log message as key-value pairs.\n */\nexport const consoleLogger = (message: string, level: LogLevel, context?: LogContext) => {\n  const contextString = context ? `, context: ${JSON.stringify(context)}` : '';\n  const formattedMessage = `[${new Date().toISOString()}] ${level.valueOf().toUpperCase()} ably-ai-transport: ${message}${contextString}`;\n\n  switch (level) {\n    case LogLevel.Trace:\n    case LogLevel.Debug: {\n      console.log(formattedMessage);\n      break;\n    }\n    case LogLevel.Info: {\n      console.info(formattedMessage);\n      break;\n    }\n    case LogLevel.Warn: {\n      console.warn(formattedMessage);\n      break;\n    }\n    case LogLevel.Error: {\n      console.error(formattedMessage);\n      break;\n    }\n    case LogLevel.Silent: {\n      break;\n    }\n  }\n};\n\n/**\n * Options for creating a logger.\n */\nexport interface LoggerOptions {\n  logHandler?: LogHandler;\n  logLevel: LogLevel;\n}\n\nexport const makeLogger = (options: LoggerOptions): Logger => {\n  const logHandler = options.logHandler ?? consoleLogger;\n\n  return new DefaultLogger(logHandler, options.logLevel);\n};\n\n/**\n * A convenient list of log levels as numbers that can be used for easier comparison.\n */\nenum LogLevelNumber {\n  Trace = 0,\n  Debug = 1,\n  Info = 2,\n  Warn = 3,\n  Error = 4,\n  Silent = 5,\n}\n\n/**\n * A mapping of log levels to their numeric equivalents.\n */\nconst logLevelNumberMap = new Map<LogLevel, LogLevelNumber>([\n  [LogLevel.Trace, LogLevelNumber.Trace],\n  [LogLevel.Debug, LogLevelNumber.Debug],\n  [LogLevel.Info, LogLevelNumber.Info],\n  [LogLevel.Warn, LogLevelNumber.Warn],\n  [LogLevel.Error, LogLevelNumber.Error],\n  [LogLevel.Silent, LogLevelNumber.Silent],\n]);\n\n/**\n * A default logger implementation.\n */\nclass DefaultLogger implements Logger {\n  private readonly _handler: LogHandler;\n  private readonly _levelNumber: LogLevelNumber;\n  private readonly _context?: LogContext;\n\n  constructor(handler: LogHandler, level: LogLevel, context?: LogContext) {\n    this._handler = handler;\n    this._context = context;\n\n    const levelNumber = logLevelNumberMap.get(level);\n    if (levelNumber === undefined) {\n      throw new Ably.ErrorInfo(`unable to create logger; invalid log level: ${level}`, ErrorCode.InvalidArgument, 400);\n    }\n\n    this._levelNumber = levelNumber;\n  }\n\n  trace(message: string, context?: LogContext): void {\n    this._write(message, LogLevel.Trace, LogLevelNumber.Trace, context);\n  }\n\n  debug(message: string, context?: LogContext): void {\n    this._write(message, LogLevel.Debug, LogLevelNumber.Debug, context);\n  }\n\n  info(message: string, context?: LogContext): void {\n    this._write(message, LogLevel.Info, LogLevelNumber.Info, context);\n  }\n\n  warn(message: string, context?: LogContext): void {\n    this._write(message, LogLevel.Warn, LogLevelNumber.Warn, context);\n  }\n\n  error(message: string, context?: LogContext): void {\n    this._write(message, LogLevel.Error, LogLevelNumber.Error, context);\n  }\n\n  withContext(context: LogContext): Logger {\n    // Get the original log level by finding the key in logLevelNumberMap that matches this._levelNumber\n    const originalLevel =\n      [...logLevelNumberMap.entries()].find(([, value]) => value === this._levelNumber)?.[0] ?? LogLevel.Error;\n\n    return new DefaultLogger(this._handler, originalLevel, this._mergeContext(context));\n  }\n\n  private _write(message: string, level: LogLevel, levelNumber: LogLevelNumber, context?: LogContext): void {\n    if (levelNumber >= this._levelNumber) {\n      this._handler(message, level, this._mergeContext(context));\n    }\n  }\n\n  private _mergeContext(context?: LogContext): LogContext | undefined {\n    if (!this._context) {\n      return context ?? undefined;\n    }\n\n    return context ? { ...this._context, ...context } : this._context;\n  }\n}\n","/**\n * Shared utilities for working with Ably messages.\n *\n * These are general-purpose helpers used by both the codec and transport\n * layers. They live at the top level to avoid either layer depending on\n * the other.\n */\n\nimport type * as Ably from 'ably';\n\nimport { DOMAIN_HEADER_PREFIX } from './constants.js';\n\n/**\n * Extract extras.headers from an Ably InboundMessage.\n * @param message - The Ably message to extract headers from.\n * @returns The headers record, or an empty object if absent.\n */\nexport const getHeaders = (message: Ably.InboundMessage): Record<string, string> => {\n  // CAST: Ably SDK types `extras` as `any`; runtime checks below guard access.\n  const extras = message.extras as unknown;\n  if (!extras || typeof extras !== 'object') return {};\n  const headers = (extras as { headers?: unknown }).headers;\n  if (!headers || typeof headers !== 'object') return {};\n  // CAST: Ably wire protocol guarantees headers is Record<string, string>\n  // when present, verified by the runtime guards above.\n  return headers as Record<string, string>;\n};\n\n/**\n * Parse a JSON string, returning undefined on failure.\n * @param value - The JSON string to parse.\n * @returns The parsed value, or undefined if parsing fails.\n */\nexport const parseJson = (value: string | undefined): unknown => {\n  if (value === undefined) return undefined;\n  try {\n    return JSON.parse(value) as unknown;\n  } catch {\n    return undefined;\n  }\n};\n\n/**\n * Set a header value if defined, skipping undefined and null. Strings are set directly,\n * booleans and numbers are stringified, objects are JSON-serialized.\n * @param headers - The headers object to mutate.\n * @param key - The header key.\n * @param value - The value to set.\n */\nexport const setIfPresent = (headers: Record<string, string>, key: string, value: unknown): void => {\n  if (value === undefined || value === null) return;\n  if (typeof value === 'string') {\n    headers[key] = value;\n  } else if (typeof value === 'boolean' || typeof value === 'number') {\n    headers[key] = String(value);\n  } else if (typeof value === 'object') {\n    headers[key] = JSON.stringify(value);\n  }\n};\n\n/**\n * Set multiple headers at once, skipping entries whose values are undefined or null.\n * Each value is converted using the same rules as {@link setIfPresent}.\n * @param headers - The headers object to mutate.\n * @param entries - Key-value pairs to set.\n */\nexport const setHeadersIfPresent = (headers: Record<string, string>, entries: Record<string, unknown>): void => {\n  for (const [key, value] of Object.entries(entries)) {\n    setIfPresent(headers, key, value);\n  }\n};\n\n/**\n * Merge two header records into a new object. Later values override earlier ones.\n * Undefined inputs are treated as empty.\n * @param base - Base headers (lower priority).\n * @param overrides - Override headers (higher priority).\n * @returns A new merged headers object.\n */\nexport const mergeHeaders = (\n  base: Record<string, string> | undefined,\n  overrides: Record<string, string> | undefined,\n): Record<string, string> => ({\n  ...base,\n  ...overrides,\n});\n\n/**\n * Parse a boolean header (\"true\"/\"false\"), returning undefined if absent.\n * @param value - The header string to parse.\n * @returns True if \"true\", false for any other string, or undefined if absent.\n */\nexport const parseBool = (value: string | undefined): boolean | undefined => {\n  if (value === undefined) return undefined;\n  return value === 'true';\n};\n\n/**\n * Build a domain headers record from key-value pairs. Each key is automatically\n * prefixed with {@link DOMAIN_HEADER_PREFIX}. Values that are undefined or null\n * are skipped; strings are set directly; booleans, numbers, and objects are\n * converted using the same rules as {@link setIfPresent}.\n * @param entries - Unprefixed key-value pairs (e.g. `{ toolCallId: 'tc-1' }` becomes `{ 'x-domain-toolCallId': 'tc-1' }`).\n * @returns A new headers record with prefixed keys.\n */\nexport const domainHeaders = (entries: Record<string, unknown>): Record<string, string> => {\n  const h: Record<string, string> = {};\n  for (const [key, value] of Object.entries(entries)) {\n    setIfPresent(h, DOMAIN_HEADER_PREFIX + key, value);\n  }\n  return h;\n};\n\n/**\n * Read a domain header value from a headers record.\n * @param headers - The headers record to read from.\n * @param key - The unprefixed domain key (e.g. `'toolCallId'` reads `'x-domain-toolCallId'`).\n * @returns The header value, or undefined if absent.\n */\nexport const getDomainHeader = (headers: Record<string, string>, key: string): string | undefined =>\n  headers[DOMAIN_HEADER_PREFIX + key];\n\n/**\n * Mapped type that converts properties whose type includes `undefined`\n * into optional properties with `undefined` excluded from the value.\n * Properties typed as `unknown` are kept required (since `undefined extends unknown`\n * is always true, but `unknown` fields are intentionally broad, not optional).\n */\nexport type Stripped<T> = {\n  [K in keyof T as undefined extends T[K] ? (unknown extends T[K] ? K : never) : K]: T[K];\n} & {\n  [K in keyof T as undefined extends T[K] ? (unknown extends T[K] ? never : K) : never]?: Exclude<T[K], undefined>;\n};\n\n/**\n * Remove all keys whose value is `undefined` from a shallow object.\n * Returns a new object — the input is not mutated. Useful for building\n * chunk literals with optional fields without conditional spread noise.\n *\n * The return type converts `{ foo: T | undefined }` to `{ foo?: T }`,\n * matching the optional-field pattern used by the AI SDK chunk types.\n * @param obj - The object to strip undefined values from.\n * @returns A shallow copy with undefined-valued keys removed.\n */\nexport const stripUndefined = <T extends Record<string, unknown>>(obj: T): Stripped<T> => {\n  const result = {} as Record<string, unknown>;\n  for (const key in obj) {\n    if (Object.prototype.hasOwnProperty.call(obj, key) && obj[key] !== undefined) {\n      result[key] = obj[key];\n    }\n  }\n  // CAST: The runtime strip guarantees the Stripped<T> contract —\n  // required keys are always present, optional keys are absent when undefined.\n  return result as Stripped<T>;\n};\n\n// ---------------------------------------------------------------------------\n// DomainHeaderReader — typed accessors for domain headers\n// ---------------------------------------------------------------------------\n\n/**\n * Typed accessor wrapper around a headers record for reading domain headers.\n * Reduces repetitive `getDomainHeader` + `parseBool` / `parseJson` chains.\n */\nexport interface DomainHeaderReader {\n  /** Read a domain header as a string, or undefined if absent. */\n  str(key: string): string | undefined;\n  /** Read a domain header as a string, falling back to a default if absent. */\n  strOr(key: string, fallback: string): string;\n  /** Read a domain header as a boolean (\"true\"/\"false\"), or undefined if absent. */\n  bool(key: string): boolean | undefined;\n  /** Read a domain header as parsed JSON, or undefined if absent or invalid. */\n  json(key: string): unknown;\n}\n\n/**\n * Create a {@link DomainHeaderReader} over a headers record.\n * @param headers - The raw headers record to read domain headers from.\n * @returns A typed accessor for domain header values.\n */\nexport const headerReader = (headers: Record<string, string>): DomainHeaderReader => ({\n  str: (key: string) => getDomainHeader(headers, key),\n  strOr: (key: string, fallback: string) => getDomainHeader(headers, key) ?? fallback,\n  bool: (key: string) => parseBool(getDomainHeader(headers, key)),\n  json: (key: string) => parseJson(getDomainHeader(headers, key)),\n});\n\n// ---------------------------------------------------------------------------\n// DomainHeaderWriter — typed builder for domain headers\n// ---------------------------------------------------------------------------\n\n/**\n * Fluent builder for constructing domain header records with typed setters.\n * Mirrors {@link DomainHeaderReader} with the same method names for symmetry.\n * Undefined values are silently skipped on all setters.\n */\nexport interface DomainHeaderWriter {\n  /** Set a string domain header. Skips if value is undefined. */\n  str(key: string, value: string | undefined): DomainHeaderWriter;\n  /** Set a boolean domain header (serialized as \"true\"/\"false\"). Skips if value is undefined. */\n  bool(key: string, value: boolean | undefined): DomainHeaderWriter;\n  /** Set a JSON-serialized domain header. Skips if value is undefined or null. */\n  json(key: string, value: unknown): DomainHeaderWriter;\n  /** Return the accumulated headers record. */\n  build(): Record<string, string>;\n}\n\n/**\n * Create a {@link DomainHeaderWriter} for building a domain headers record.\n * @returns A fluent builder that prefixes each key with the domain header prefix.\n */\nexport const headerWriter = (): DomainHeaderWriter => {\n  const h: Record<string, string> = {};\n  const writer: DomainHeaderWriter = {\n    str: (key: string, value: string | undefined) => {\n      if (value !== undefined) h[DOMAIN_HEADER_PREFIX + key] = value;\n      return writer;\n    },\n    bool: (key: string, value: boolean | undefined) => {\n      if (value !== undefined) h[DOMAIN_HEADER_PREFIX + key] = String(value);\n      return writer;\n    },\n    json: (key: string, value: unknown) => {\n      if (value !== undefined && value !== null) h[DOMAIN_HEADER_PREFIX + key] = JSON.stringify(value);\n      return writer;\n    },\n    build: () => h,\n  };\n  return writer;\n};\n","/**\n * ConversationTree — materializes a branching conversation from a flat\n * oplog of Ably messages using serial-first ordering.\n *\n * Serial order (the total order assigned by Ably) is the primary mechanism\n * for linear message sequences. `x-ably-parent` and `x-ably-fork-of` headers\n * are only structurally meaningful at branch points — where the user is\n * interacting with a visible message and the client always has it loaded.\n *\n * `upsert()` is the sole mutation method. Messages can arrive in any order\n * (live subscription, history pages, seed data) and the tree produces the\n * correct `flatten()` output once all messages are present.\n *\n * The tree owns conversation state. `flatten()` returns the linear message\n * list for the currently selected branches — this is what the transport's\n * `getMessages()` delegates to.\n */\n\nimport { HEADER_FORK_OF, HEADER_PARENT } from '../../constants.js';\nimport type { Logger } from '../../logger.js';\nimport type { ConversationNode, ConversationTree } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Internal node type\n// ---------------------------------------------------------------------------\n\ninterface InternalNode<TMessage> {\n  node: ConversationNode<TMessage>;\n  /** Insertion sequence — tiebreaker for null-serial messages. */\n  insertSeq: number;\n}\n\n// ---------------------------------------------------------------------------\n// Implementation\n// ---------------------------------------------------------------------------\n\n// Spec: AIT-CT13\nclass DefaultConversationTree<TMessage> implements ConversationTree<TMessage> {\n  /** All nodes indexed by msgId (x-ably-msg-id). */\n  private readonly _nodeIndex = new Map<string, InternalNode<TMessage>>();\n\n  /** Secondary index: codec message key to msgId. Bridges UIMessage.id to x-ably-msg-id. */\n  private readonly _codecKeyIndex = new Map<string, string>();\n\n  /**\n   * All nodes sorted by serial (lexicographic). Null-serial messages\n   * (optimistic inserts, seed data) sort after all serial-bearing messages,\n   * ordered among themselves by insertion sequence.\n   */\n  private readonly _sortedList: InternalNode<TMessage>[] = [];\n\n  /**\n   * Parent index: parentId to set of child msgIds.\n   * Nodes with no parent are indexed under the key `null`.\n   */\n  private readonly _parentIndex = new Map<string | undefined, Set<string>>();\n\n  /**\n   * Selected sibling index at each fork point, keyed by the msgId of\n   * the first sibling in the group (the fork target). Default: last.\n   */\n  private readonly _selections = new Map<string, number>();\n\n  private readonly _getKey: (message: TMessage) => string;\n  private readonly _logger: Logger;\n\n  /** Monotonically increasing counter for insertion sequence. */\n  private _seqCounter = 0;\n\n  constructor(getKey: (message: TMessage) => string, logger: Logger) {\n    this._getKey = getKey;\n    this._logger = logger;\n  }\n\n  // -------------------------------------------------------------------------\n  // Sorted list maintenance\n  // -------------------------------------------------------------------------\n\n  /**\n   * Compare two nodes for sorted list ordering.\n   * Serial-bearing nodes sort by serial (lexicographic).\n   * Null-serial nodes sort after all serial-bearing nodes.\n   * Among null-serial nodes, sort by insertion sequence.\n   * @param a - First node to compare.\n   * @param b - Second node to compare.\n   * @returns Negative if a sorts before b, positive if after, zero if equal.\n   */\n  // Spec: AIT-CT13a\n  private _compareNodes(a: InternalNode<TMessage>, b: InternalNode<TMessage>): number {\n    const sa = a.node.serial;\n    const sb = b.node.serial;\n    if (sa === undefined && sb === undefined) return a.insertSeq - b.insertSeq;\n    if (sa === undefined) return 1; // a sorts after serial-bearing b\n    if (sb === undefined) return -1; // b sorts after serial-bearing a\n    if (sa < sb) return -1;\n    if (sa > sb) return 1;\n    return a.insertSeq - b.insertSeq; // same serial: preserve insertion order\n  }\n\n  /**\n   * Insert a node into sortedList at the correct position via binary search.\n   * @param internal - The node to insert.\n   */\n  private _insertSorted(internal: InternalNode<TMessage>): void {\n    const serial = internal.node.serial;\n\n    // Fast path: null-serial always appends to end (among other null-serials)\n    if (serial === undefined) {\n      this._sortedList.push(internal);\n      return;\n    }\n\n    // Binary search for insertion point among serial-bearing nodes.\n    let lo = 0;\n    let hi = this._sortedList.length;\n    while (lo < hi) {\n      const mid = (lo + hi) >>> 1;\n      const midNode = this._sortedList[mid];\n      if (!midNode) break; // unreachable: mid is always in bounds\n      if (this._compareNodes(midNode, internal) <= 0) {\n        lo = mid + 1;\n      } else {\n        hi = mid;\n      }\n    }\n    this._sortedList.splice(lo, 0, internal);\n  }\n\n  /**\n   * Remove a node from sortedList.\n   * @param internal - The node to remove.\n   */\n  private _removeSorted(internal: InternalNode<TMessage>): void {\n    const idx = this._sortedList.indexOf(internal);\n    if (idx !== -1) this._sortedList.splice(idx, 1);\n  }\n\n  // -------------------------------------------------------------------------\n  // Parent index maintenance\n  // -------------------------------------------------------------------------\n\n  private _addToParentIndex(parentId: string | undefined, msgId: string): void {\n    let set = this._parentIndex.get(parentId);\n    if (!set) {\n      set = new Set();\n      this._parentIndex.set(parentId, set);\n    }\n    set.add(msgId);\n  }\n\n  private _removeFromParentIndex(parentId: string | undefined, msgId: string): void {\n    const set = this._parentIndex.get(parentId);\n    if (set) {\n      set.delete(msgId);\n      if (set.size === 0) this._parentIndex.delete(parentId);\n    }\n  }\n\n  // -------------------------------------------------------------------------\n  // Sibling grouping\n  // -------------------------------------------------------------------------\n\n  /**\n   * Get the sibling group that `msgId` belongs to.\n   *\n   * A sibling group is: the original message + all messages whose `forkOf`\n   * points to the original (or transitively to a sibling). We find the\n   * group root by following `forkOf` chains to the earliest ancestor that\n   * has no `forkOf` (or whose `forkOf` target doesn't share the same parent).\n   * @param msgId - The msg-id to look up the sibling group for.\n   * @returns The ordered list of sibling nodes.\n   */\n  // Spec: AIT-CT13b\n  private _getSiblingGroup(msgId: string): ConversationNode<TMessage>[] {\n    const entry = this._nodeIndex.get(msgId);\n    if (!entry) return [];\n\n    // Find the \"original\" — the message at the root of the fork chain\n    // that shares the same parentId. Guard against cycles in forkOf chains.\n    let original = entry.node;\n    const visitedGroup = new Set<string>([original.msgId]);\n    while (original.forkOf) {\n      if (visitedGroup.has(original.forkOf)) break; // cycle guard\n      const forkTarget = this._nodeIndex.get(original.forkOf);\n      if (!forkTarget || forkTarget.node.parentId !== original.parentId) break;\n      original = forkTarget.node;\n      visitedGroup.add(original.msgId);\n    }\n\n    // Collect all siblings: nodes with the same parentId that either\n    // ARE the original, or have a forkOf chain leading to the original.\n    const parentId = original.parentId;\n    const originalId = original.msgId;\n    const siblings: InternalNode<TMessage>[] = [];\n\n    const candidateIds = this._parentIndex.get(parentId);\n    if (candidateIds) {\n      for (const childId of candidateIds) {\n        const childEntry = this._nodeIndex.get(childId);\n        if (childEntry && this._isSiblingOf(childEntry.node, originalId)) {\n          siblings.push(childEntry);\n        }\n      }\n    }\n\n    // Sort by Ably serial (lexicographic). Messages without a serial\n    // (optimistic inserts before server relay) sort after all serial-bearing\n    // siblings — they represent the user's most recent action.\n    siblings.sort((a, b) => this._compareNodes(a, b));\n    return siblings.map((s) => s.node);\n  }\n\n  /**\n   * Check if `node` belongs to the sibling group rooted at `originalId`.\n   * A node is a sibling if it IS the original or its forkOf chain leads\n   * to the original (with the same parentId).\n   * @param node - The node to check.\n   * @param originalId - The group root to match against.\n   * @returns True if the node belongs to the sibling group.\n   */\n  private _isSiblingOf(node: ConversationNode<TMessage>, originalId: string): boolean {\n    if (node.msgId === originalId) return true;\n    let current = node;\n    const visited = new Set<string>([current.msgId]);\n    while (current.forkOf) {\n      if (current.forkOf === originalId) return true;\n      if (visited.has(current.forkOf)) break; // cycle guard\n      const target = this._nodeIndex.get(current.forkOf);\n      if (!target) break;\n      current = target.node;\n      visited.add(current.msgId);\n    }\n    return false;\n  }\n\n  /**\n   * Get the \"group root\" msgId for a sibling group — the original message\n   * that all forks trace back to.\n   * @param msgId - Any msg-id in the sibling group.\n   * @returns The msg-id of the group root.\n   */\n  private _getGroupRoot(msgId: string): string {\n    const entry = this._nodeIndex.get(msgId);\n    if (!entry) return msgId;\n\n    let current = entry.node;\n    const visited = new Set<string>([current.msgId]);\n    while (current.forkOf) {\n      if (visited.has(current.forkOf)) break; // cycle guard\n      const forkTarget = this._nodeIndex.get(current.forkOf);\n      if (!forkTarget || forkTarget.node.parentId !== current.parentId) break;\n      current = forkTarget.node;\n      visited.add(current.msgId);\n    }\n    return current.msgId;\n  }\n\n  // -------------------------------------------------------------------------\n  // Public query methods\n  // -------------------------------------------------------------------------\n\n  flatten(): TMessage[] {\n    const result: TMessage[] = [];\n    const currentPath = new Set<string>();\n    // Track which sibling groups we've already resolved to avoid\n    // re-resolving for every member of the group.\n    const resolvedGroups = new Map<string, string>(); // groupRootId → selected msgId\n\n    for (const internal of this._sortedList) {\n      const node = internal.node;\n      const { msgId, parentId } = node;\n\n      // Step 1: Check parent reachability.\n      if (parentId !== undefined && !currentPath.has(parentId)) {\n        continue;\n      }\n\n      // Step 2: Check sibling selection.\n      const group = this._getSiblingGroup(msgId);\n      if (group.length > 1) {\n        const groupRootId = this._getGroupRoot(msgId);\n        let selectedId = resolvedGroups.get(groupRootId);\n        if (selectedId === undefined) {\n          const selectedIdx = this._selections.get(groupRootId) ?? group.length - 1;\n          const clamped = Math.max(0, Math.min(selectedIdx, group.length - 1));\n          const selected = group[clamped];\n          if (!selected) break; // unreachable: clamped is always in bounds\n          selectedId = selected.msgId;\n          resolvedGroups.set(groupRootId, selectedId);\n        }\n        if (msgId !== selectedId) {\n          continue;\n        }\n      }\n\n      currentPath.add(msgId);\n      result.push(node.message);\n    }\n\n    return result;\n  }\n\n  getSiblings(msgId: string): TMessage[] {\n    return this._getSiblingGroup(msgId).map((n) => n.message);\n  }\n\n  hasSiblings(msgId: string): boolean {\n    return this._getSiblingGroup(msgId).length > 1;\n  }\n\n  getSelectedIndex(msgId: string): number {\n    const group = this._getSiblingGroup(msgId);\n    if (group.length <= 1) return 0;\n    const groupRootId = this._getGroupRoot(msgId);\n    const stored = this._selections.get(groupRootId);\n    if (stored !== undefined) return Math.max(0, Math.min(stored, group.length - 1));\n    return group.length - 1; // default: latest\n  }\n\n  // Spec: AIT-CT13c\n  select(msgId: string, index: number): void {\n    this._logger.debug('ConversationTree.select();', { msgId, index });\n    const group = this._getSiblingGroup(msgId);\n    if (group.length <= 1) return;\n    const groupRootId = this._getGroupRoot(msgId);\n    this._selections.set(groupRootId, Math.max(0, Math.min(index, group.length - 1)));\n  }\n\n  getNode(msgId: string): ConversationNode<TMessage> | undefined {\n    return this._nodeIndex.get(msgId)?.node;\n  }\n\n  getNodeByKey(key: string): ConversationNode<TMessage> | undefined {\n    const msgId = this._codecKeyIndex.get(key);\n    if (!msgId) return undefined;\n    return this._nodeIndex.get(msgId)?.node;\n  }\n\n  getHeaders(msgId: string): Record<string, string> | undefined {\n    return this._nodeIndex.get(msgId)?.node.headers;\n  }\n\n  // -------------------------------------------------------------------------\n  // Mutation\n  // -------------------------------------------------------------------------\n\n  upsert(msgId: string, message: TMessage, headers: Record<string, string>, serial?: string): void {\n    const parentId = headers[HEADER_PARENT] ?? undefined;\n    const forkOf = headers[HEADER_FORK_OF] ?? undefined;\n\n    // Maintain codec key → msgId secondary index\n    this._codecKeyIndex.set(this._getKey(message), msgId);\n\n    const existing = this._nodeIndex.get(msgId);\n    if (existing) {\n      // Update in place — message content may have changed (e.g. streaming).\n      // Only update headers if the new headers are non-empty (prevents\n      // streaming updates from erasing canonical headers).\n      existing.node.message = message;\n      if (Object.keys(headers).length > 0) {\n        existing.node.headers = { ...headers };\n      }\n      // Spec: AIT-CT13d\n      // Promote serial: optimistic (null) → server-assigned on relay.\n      if (serial && !existing.node.serial) {\n        this._logger.debug('ConversationTree.upsert(); promoting serial', { msgId, serial });\n        existing.node.serial = serial;\n        // Re-sort: remove from current position, re-insert at correct position.\n        this._removeSorted(existing);\n        this._insertSorted(existing);\n      }\n      return;\n    }\n\n    this._logger.trace('ConversationTree.upsert(); inserting new node', { msgId, parentId, forkOf });\n\n    const node: ConversationNode<TMessage> = {\n      message,\n      msgId,\n      parentId,\n      forkOf,\n      headers: { ...headers },\n      serial,\n    };\n\n    const internal: InternalNode<TMessage> = { node, insertSeq: this._seqCounter++ };\n    this._nodeIndex.set(msgId, internal);\n    this._addToParentIndex(parentId, msgId);\n    this._insertSorted(internal);\n  }\n\n  delete(msgId: string): void {\n    const entry = this._nodeIndex.get(msgId);\n    if (!entry) return;\n\n    this._logger.debug('ConversationTree.delete();', { msgId });\n\n    const { node } = entry;\n\n    // Clean up secondary index\n    const codecKey = this._getKey(node.message);\n    if (this._codecKeyIndex.get(codecKey) === msgId) {\n      this._codecKeyIndex.delete(codecKey);\n    }\n\n    // Remove from parent index\n    this._removeFromParentIndex(node.parentId, msgId);\n\n    // Remove from sorted list\n    this._removeSorted(entry);\n\n    // Remove from primary index\n    this._nodeIndex.delete(msgId);\n    this._selections.delete(msgId);\n\n    // Children are NOT deleted — they become unreachable in flatten()\n    // because their parent is no longer on the active path.\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a ConversationTree that materializes branching history from a flat oplog.\n * @param getKey - Codec function that returns a stable key for a domain message.\n * @param logger - Logger for diagnostic output.\n * @returns A new {@link ConversationTree} instance.\n */\nexport const createConversationTree = <TMessage>(\n  getKey: (message: TMessage) => string,\n  logger: Logger,\n): ConversationTree<TMessage> => new DefaultConversationTree(getKey, logger);\n","/**\n * decodeHistory — load conversation history from an Ably channel and\n * return decoded messages as a PaginatedMessages result.\n *\n * Uses a fresh decoder (not shared with the live subscription) to avoid\n * state conflicts. Per-turn accumulators handle interleaved turns correctly.\n *\n * The `limit` option controls the number of **messages** returned,\n * not the number of Ably wire messages fetched. The implementation pages\n * back through Ably history until `limit` complete messages have\n * been assembled. Partial turns (incomplete at the page boundary) are\n * buffered internally and completed when `next()` fetches more pages.\n *\n * Only completed messages appear in `items`. A message is complete when\n * its terminal event (finish/abort/error) has been received.\n *\n * Because Ably history returns newest-first while the decoder requires\n * chronological order, all collected Ably messages are re-decoded from\n * oldest to newest after each page fetch. This handles turns that span\n * page boundaries correctly.\n */\n\nimport type * as Ably from 'ably';\n\nimport { HEADER_MSG_ID, HEADER_TURN_ID } from '../../constants.js';\nimport type { Logger } from '../../logger.js';\nimport { getHeaders } from '../../utils.js';\nimport type { Codec, DecoderOutput, MessageAccumulator } from '../codec/types.js';\nimport type { LoadHistoryOptions, PaginatedMessages } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Shared state across pages within one history traversal\n// ---------------------------------------------------------------------------\n\ninterface HistoryState<TEvent, TMessage> {\n  codec: Codec<TEvent, TMessage>;\n  /** All raw Ably messages collected so far, in newest-first order (as received from Ably). */\n  rawMessages: Ably.InboundMessage[];\n  /** How many completed messages have been returned to the consumer so far. */\n  returnedCount: number;\n  /** How many raw Ably messages have been returned to the consumer so far. */\n  returnedRawCount: number;\n  /** The last Ably page cursor for continued pagination. */\n  lastAblyPage: Ably.PaginatedResult<Ably.InboundMessage> | undefined;\n  /** Key function for domain messages (codec.getMessageKey). */\n  getMessageKey: (message: TMessage) => string;\n  logger: Logger;\n}\n\n/** A completed message paired with its canonical wire headers and serial. */\ninterface DecodedItem<TMessage> {\n  message: TMessage;\n  headers: Record<string, string>;\n  /** Ably serial from the first Ably message for this domain message. */\n  serial: string;\n}\n\n// ---------------------------------------------------------------------------\n// Decode all collected messages from scratch (chronological order)\n// ---------------------------------------------------------------------------\n\n/**\n * Re-decode all collected raw messages into completed domain messages.\n * @param state - The shared history traversal state.\n * @returns Completed messages in newest-first order.\n */\nconst decodeAll = <TEvent, TMessage>(state: HistoryState<TEvent, TMessage>): DecodedItem<TMessage>[] => {\n  // Reverse to chronological (oldest first)\n  const chronological = [...state.rawMessages].toReversed();\n\n  // Fresh decoder and per-turn accumulators for each full re-decode.\n  const decoder = state.codec.createDecoder();\n  const turns = new Map<\n    string,\n    {\n      accumulator: MessageAccumulator<TEvent, TMessage>;\n      firstSeen: number;\n      /** Headers from the first Ably message per x-ably-msg-id within this turn. */\n      msgHeaders: Map<string, Record<string, string>>;\n      /** Ably serial from the first Ably message per x-ably-msg-id within this turn. */\n      msgSerials: Map<string, string>;\n    }\n  >();\n  const defaultAccumulator = state.codec.createAccumulator();\n  let orderCounter = 0;\n\n  // Headers for discrete messages (writeMessages output), keyed by codec message key.\n  const discreteHeaders = new Map<string, Record<string, string>>();\n  // Serials for discrete messages, keyed by codec message key.\n  const discreteSerials = new Map<string, string>();\n\n  for (const msg of chronological) {\n    const outputs: DecoderOutput<TEvent, TMessage>[] = decoder.decode(msg);\n    const headers = getHeaders(msg);\n    const turnId = headers[HEADER_TURN_ID];\n    const msgId = headers[HEADER_MSG_ID];\n    const serial = msg.serial;\n\n    if (turnId) {\n      let turn = turns.get(turnId);\n      if (!turn) {\n        turn = {\n          accumulator: state.codec.createAccumulator(),\n          firstSeen: orderCounter++,\n          msgHeaders: new Map(),\n          msgSerials: new Map(),\n        };\n        turns.set(turnId, turn);\n      }\n      // Capture headers per msg-id within this turn. Update on later\n      // messages too (e.g. closing append overrides status from\n      // \"streaming\" to \"finished\"/\"aborted\"). Only merge when the\n      // incoming message has non-empty headers.\n      if (msgId) {\n        const existing = turn.msgHeaders.get(msgId);\n        if (!existing) {\n          turn.msgHeaders.set(msgId, { ...headers });\n          if (serial) turn.msgSerials.set(msgId, serial);\n        } else if (Object.keys(headers).length > 0) {\n          Object.assign(existing, headers);\n        }\n      }\n      turn.accumulator.processOutputs(outputs);\n    } else {\n      defaultAccumulator.processOutputs(outputs);\n    }\n\n    // Capture headers and serial for discrete messages by codec key.\n    for (const output of outputs) {\n      if (output.kind === 'message') {\n        const key = state.getMessageKey(output.message);\n        const existingDiscrete = discreteHeaders.get(key);\n        if (!existingDiscrete) {\n          discreteHeaders.set(key, { ...headers });\n          if (serial) discreteSerials.set(key, serial);\n        } else if (Object.keys(headers).length > 0) {\n          Object.assign(existingDiscrete, headers);\n        }\n      }\n    }\n  }\n\n  // Collect completed messages in chronological order (oldest first) by turn.\n  const completed: DecodedItem<TMessage>[] = [];\n\n  for (const msg of defaultAccumulator.completedMessages) {\n    const key = state.getMessageKey(msg);\n    completed.push({\n      message: msg,\n      headers: discreteHeaders.get(key) ?? {},\n      serial: discreteSerials.get(key) ?? '',\n    });\n  }\n\n  const sorted = [...turns.values()].toSorted((a, b) => a.firstSeen - b.firstSeen);\n  for (const turn of sorted) {\n    // Assign headers and serials to each completed message in this turn.\n    // Discrete messages were already captured by codec key. Accumulated\n    // messages need to be matched to the turn's per-msg-id headers.\n    const claimedMsgIds = new Set<string>();\n\n    // First pass: resolve discrete messages and mark their msg-ids as claimed\n    const turnKeyHeaders = new Map<string, Record<string, string>>();\n    const turnKeySerials = new Map<string, string>();\n    for (const msg of turn.accumulator.completedMessages) {\n      const key = state.getMessageKey(msg);\n      const discrete = discreteHeaders.get(key);\n      if (discrete) {\n        turnKeyHeaders.set(key, discrete);\n        const dSerial = discreteSerials.get(key);\n        if (dSerial) turnKeySerials.set(key, dSerial);\n        const mid = discrete[HEADER_MSG_ID];\n        if (mid) claimedMsgIds.add(mid);\n      }\n    }\n\n    // Second pass: assign unclaimed msg-id entries to remaining messages\n    const unclaimedEntries = [...turn.msgHeaders.entries()].filter(([mid]) => !claimedMsgIds.has(mid));\n    let unclaimedIdx = 0;\n\n    for (const msg of turn.accumulator.completedMessages) {\n      const key = state.getMessageKey(msg);\n      const unclaimed = unclaimedEntries[unclaimedIdx];\n      if (!turnKeyHeaders.has(key) && unclaimed) {\n        const [mid, hdrs] = unclaimed;\n        turnKeyHeaders.set(key, hdrs);\n        const mSerial = turn.msgSerials.get(mid);\n        if (mSerial) turnKeySerials.set(key, mSerial);\n        unclaimedIdx++;\n      }\n    }\n\n    for (const msg of turn.accumulator.completedMessages) {\n      const key = state.getMessageKey(msg);\n      completed.push({\n        message: msg,\n        headers: turnKeyHeaders.get(key) ?? {},\n        serial: turnKeySerials.get(key) ?? '',\n      });\n    }\n  }\n\n  // Reverse to newest-first. The consumer slices from the front for the\n  // most recent page, and progressively deeper for older pages.\n  return completed.toReversed();\n};\n\n// ---------------------------------------------------------------------------\n// Fetch Ably pages until we have enough completed messages\n// ---------------------------------------------------------------------------\n\n/**\n * Fetch Ably history pages until we have enough completed messages.\n * @param state - The shared history traversal state.\n * @param ablyPage - The current Ably paginated result to start from.\n * @param limit - Target number of completed messages beyond what has already been returned.\n */\nconst fetchUntilLimit = async <TEvent, TMessage>(\n  state: HistoryState<TEvent, TMessage>,\n  ablyPage: Ably.PaginatedResult<Ably.InboundMessage>,\n  limit: number,\n): Promise<void> => {\n  state.rawMessages.push(...ablyPage.items);\n  state.lastAblyPage = ablyPage;\n\n  let decodedCount = decodeAll(state).length;\n  while (decodedCount < state.returnedCount + limit && ablyPage.hasNext()) {\n    state.logger.debug('decodeHistory.fetchUntilLimit(); fetching next page', {\n      collected: state.rawMessages.length,\n      decoded: decodedCount,\n    });\n    const nextPage = await ablyPage.next();\n    if (!nextPage) break;\n    ablyPage = nextPage;\n    state.rawMessages.push(...nextPage.items);\n    state.lastAblyPage = nextPage;\n    decodedCount = decodeAll(state).length;\n  }\n};\n\n// ---------------------------------------------------------------------------\n// Build PaginatedMessages result from current state\n// ---------------------------------------------------------------------------\n\n/**\n * Build a PaginatedMessages page from the current decode state.\n * @param state - The shared history traversal state.\n * @param limit - Max messages per page.\n * @returns A page of decoded messages with a `next()` cursor.\n */\nconst buildResult = <TEvent, TMessage>(\n  state: HistoryState<TEvent, TMessage>,\n  limit: number,\n): PaginatedMessages<TMessage> => {\n  // allCompleted is newest-first. Slice from returnedCount for this page,\n  // then reverse to chronological for display.\n  const allCompleted = decodeAll(state);\n\n  const pageSlice = allCompleted.slice(state.returnedCount, state.returnedCount + limit);\n  const chronSlice = [...pageSlice].toReversed();\n  state.returnedCount += pageSlice.length;\n\n  const moreCompleted = allCompleted.length > state.returnedCount;\n  const moreAblyPages = state.lastAblyPage?.hasNext() ?? false;\n\n  // Raw Ably messages for this page in chronological order.\n  const newRawCount = state.rawMessages.length - state.returnedRawCount;\n  const rawSlice = newRawCount > 0 ? state.rawMessages.slice(state.returnedRawCount).toReversed() : [];\n  state.returnedRawCount = state.rawMessages.length;\n\n  return {\n    items: chronSlice.map((d) => d.message),\n    itemHeaders: chronSlice.map((d) => d.headers),\n    itemSerials: chronSlice.map((d) => d.serial),\n    rawMessages: rawSlice,\n    hasNext: () => moreCompleted || moreAblyPages,\n    next: async () => {\n      if (moreCompleted) {\n        return buildResult(state, limit);\n      }\n      if (!moreAblyPages || !state.lastAblyPage) return;\n      const nextAbly = await state.lastAblyPage.next();\n      if (!nextAbly) return;\n      await fetchUntilLimit(state, nextAbly, limit);\n      return buildResult(state, limit);\n    },\n  };\n};\n\n// ---------------------------------------------------------------------------\n// Public API\n// ---------------------------------------------------------------------------\n\n/**\n * Load conversation history from a channel and return decoded messages.\n *\n * Attaches the channel if not already attached, then calls\n * `channel.history({ untilAttach: true })` to guarantee no gap between\n * historical and live messages. The attach is idempotent.\n *\n * The `limit` option controls the number of complete messages\n * returned per page, not the number of Ably wire messages fetched.\n * @param channel - The Ably channel to load history from.\n * @param codec - The codec for decoding wire messages into domain messages.\n * @param options - Pagination options.\n * @param logger - Logger for diagnostic output.\n * @returns The first page of decoded history messages.\n */\n// Spec: AIT-CT11, AIT-CT11b\nexport const decodeHistory = async <TEvent, TMessage>(\n  channel: Ably.RealtimeChannel,\n  codec: Codec<TEvent, TMessage>,\n  options: LoadHistoryOptions | undefined,\n  logger: Logger,\n): Promise<PaginatedMessages<TMessage>> => {\n  const limit = options?.limit ?? 100;\n  const state: HistoryState<TEvent, TMessage> = {\n    codec,\n    rawMessages: [],\n    returnedCount: 0,\n    returnedRawCount: 0,\n    lastAblyPage: undefined,\n    getMessageKey: codec.getMessageKey.bind(codec),\n    logger,\n  };\n\n  logger.trace('decodeHistory();', { limit });\n\n  // Request more Ably messages than the domain limit to account for\n  // the many-to-one ratio (multiple wire messages per message).\n  const wireLimit = limit * 10;\n\n  await channel.attach();\n  const ablyPage = await channel.history({ untilAttach: true, limit: wireLimit });\n  await fetchUntilLimit(state, ablyPage, limit);\n  return buildResult(state, limit);\n};\n","/**\n * Transport header builder.\n *\n * Single source of truth for which `x-ably-*` headers every transport\n * message carries. Used by the server transport (addMessages, streamResponse)\n * and will be used by the client transport (optimistic message stamping).\n */\n\nimport {\n  HEADER_FORK_OF,\n  HEADER_MSG_ID,\n  HEADER_PARENT,\n  HEADER_ROLE,\n  HEADER_TURN_CLIENT_ID,\n  HEADER_TURN_ID,\n} from '../../constants.js';\n\n/**\n * Build the standard transport header set for a message.\n * @param opts - The header values to include.\n * @param opts.role - Message role (e.g. \"user\", \"assistant\").\n * @param opts.turnId - Turn correlation ID.\n * @param opts.msgId - Message identity.\n * @param opts.turnClientId - ClientId of the turn initiator.\n * @param opts.parent - Preceding message's msg-id (for branching). Null means root.\n * @param opts.forkOf - Forked message's msg-id (for edit/regen).\n * @returns A headers record with the `x-ably-*` transport headers set.\n */\nexport const buildTransportHeaders = (opts: {\n  role: string;\n  turnId: string;\n  msgId: string;\n  turnClientId?: string;\n  parent?: string | null;\n  forkOf?: string;\n}): Record<string, string> => {\n  const h: Record<string, string> = {\n    [HEADER_ROLE]: opts.role,\n    [HEADER_TURN_ID]: opts.turnId,\n    [HEADER_MSG_ID]: opts.msgId,\n  };\n  if (opts.turnClientId !== undefined) h[HEADER_TURN_CLIENT_ID] = opts.turnClientId;\n  if (opts.parent) h[HEADER_PARENT] = opts.parent;\n  if (opts.forkOf) h[HEADER_FORK_OF] = opts.forkOf;\n  return h;\n};\n","/**\n * Client-side stream routing.\n *\n * Maintains a map of turnId to ReadableStreamController. Routes decoded events\n * to the correct stream. Closes streams on terminal events or explicit close.\n */\n\nimport * as Ably from 'ably';\n\nimport { ErrorCode } from '../../errors.js';\nimport type { Logger } from '../../logger.js';\nimport type { TurnEntry } from './types.js';\n\n// ---------------------------------------------------------------------------\n// Interface\n// ---------------------------------------------------------------------------\n\n/** Routes decoded events to the correct turn's ReadableStream. */\nexport interface StreamRouter<TEvent> {\n  /** Register a new stream for a turnId. Returns the ReadableStream the consumer reads from. */\n  createStream(turnId: string): ReadableStream<TEvent>;\n  /** Close the stream for a turnId. Returns true if a stream was closed. */\n  closeStream(turnId: string): boolean;\n  /** Enqueue an event to the correct stream. Returns true if routed successfully. */\n  route(turnId: string, event: TEvent): boolean;\n  /** Whether a specific turnId has an active stream. */\n  has(turnId: string): boolean;\n}\n\n// ---------------------------------------------------------------------------\n// Implementation\n// ---------------------------------------------------------------------------\n\n// Spec: AIT-CT14\nclass DefaultStreamRouter<TEvent> implements StreamRouter<TEvent> {\n  private readonly _turns = new Map<string, TurnEntry<TEvent>>();\n  private readonly _isTerminal: (event: TEvent) => boolean;\n  private readonly _logger: Logger;\n\n  constructor(isTerminal: (event: TEvent) => boolean, logger: Logger) {\n    this._isTerminal = isTerminal;\n    this._logger = logger;\n  }\n\n  createStream(turnId: string): ReadableStream<TEvent> {\n    this._logger.trace('StreamRouter.createStream();', { turnId });\n\n    // Build stream+controller together. ReadableStream's start() runs synchronously\n    // per spec, so the controller is captured before the constructor returns.\n    const entry: { controller?: ReadableStreamDefaultController<TEvent> } = {};\n    const stream = new ReadableStream<TEvent>({\n      start(controller) {\n        entry.controller = controller;\n      },\n    });\n    if (!entry.controller) {\n      throw new Ably.ErrorInfo(\n        'unable to create stream; ReadableStream start() was not called synchronously',\n        ErrorCode.TransportSubscriptionError,\n        500,\n      );\n    }\n    this._turns.set(turnId, { controller: entry.controller, turnId });\n    return stream;\n  }\n\n  // Spec: AIT-CT14b\n  closeStream(turnId: string): boolean {\n    const turn = this._turns.get(turnId);\n    if (!turn) return false;\n\n    this._logger.debug('StreamRouter.closeStream(); closing stream', { turnId });\n    try {\n      turn.controller.close();\n    } catch {\n      /* already closed */\n    }\n    this._turns.delete(turnId);\n    return true;\n  }\n\n  // Spec: AIT-CT14a\n  route(turnId: string, event: TEvent): boolean {\n    const turn = this._turns.get(turnId);\n    if (!turn) return false;\n\n    try {\n      turn.controller.enqueue(event);\n    } catch {\n      this._turns.delete(turnId);\n      return false;\n    }\n\n    if (this._isTerminal(event)) {\n      this.closeStream(turnId);\n    }\n    return true;\n  }\n\n  has(turnId: string): boolean {\n    return this._turns.has(turnId);\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a StreamRouter that routes decoded events to per-turn ReadableStreams.\n * @param isTerminal - Predicate that returns true for events that close the stream.\n * @param logger - Logger for diagnostic output.\n * @returns A new {@link StreamRouter} instance.\n */\nexport const createStreamRouter = <TEvent>(\n  isTerminal: (event: TEvent) => boolean,\n  logger: Logger,\n): StreamRouter<TEvent> => new DefaultStreamRouter(isTerminal, logger);\n","/**\n * Core client-side transport, parameterized by codec.\n *\n * Composes StreamRouter and ConversationTree to handle the full client-side\n * lifecycle. Subscribes to the Ably channel on construction. The same\n * subscription, decoder, and channel are reused across turns.\n *\n * The client never publishes user messages directly. Instead, it sends them\n * to the server via HTTP POST. The server publishes user messages and turn\n * lifecycle events (turn-start, turn-end) on behalf of the client.\n */\n\nimport * as Ably from 'ably';\n\nimport {\n  EVENT_CANCEL,\n  EVENT_TURN_END,\n  EVENT_TURN_START,\n  HEADER_CANCEL_ALL,\n  HEADER_CANCEL_CLIENT_ID,\n  HEADER_CANCEL_OWN,\n  HEADER_CANCEL_TURN_ID,\n  HEADER_MSG_ID,\n  HEADER_PARENT,\n  HEADER_ROLE,\n  HEADER_TURN_CLIENT_ID,\n  HEADER_TURN_ID,\n  HEADER_TURN_REASON,\n} from '../../constants.js';\nimport { ErrorCode } from '../../errors.js';\nimport { EventEmitter } from '../../event-emitter.js';\nimport type { Logger } from '../../logger.js';\nimport { LogLevel, makeLogger } from '../../logger.js';\nimport { getHeaders } from '../../utils.js';\nimport type { DecoderOutput, MessageAccumulator, StreamDecoder } from '../codec/types.js';\nimport { createConversationTree } from './conversation-tree.js';\nimport { decodeHistory } from './decode-history.js';\nimport { buildTransportHeaders } from './headers.js';\nimport type { StreamRouter } from './stream-router.js';\nimport { createStreamRouter } from './stream-router.js';\nimport type {\n  ActiveTurn,\n  CancelFilter,\n  ClientTransport,\n  ClientTransportOptions,\n  CloseOptions,\n  ConversationTree,\n  LoadHistoryOptions,\n  MessageWithHeaders,\n  PaginatedMessages,\n  SendOptions,\n  TurnEndReason,\n  TurnLifecycleEvent,\n} from './types.js';\n\n/**\n * Returned from `on()` when the transport is already closed — the subscription\n * is silently ignored since no further events will fire.\n */\n// eslint-disable-next-line @typescript-eslint/no-empty-function -- intentional no-op\nconst noopUnsubscribe = (): void => {};\n\n// ---------------------------------------------------------------------------\n// Event map for the transport's typed EventEmitter\n// ---------------------------------------------------------------------------\n\ninterface ClientTransportEventsMap {\n  message: undefined;\n  turn: TurnLifecycleEvent;\n  error: Ably.ErrorInfo;\n  'ably-message': undefined;\n}\n\n// ---------------------------------------------------------------------------\n// Per-turn observer state — consolidated to avoid parallel-map bookkeeping\n// ---------------------------------------------------------------------------\n\ninterface TurnObserverState<TEvent, TMessage> {\n  headers: Record<string, string>;\n  serial: string | undefined;\n  accumulator: MessageAccumulator<TEvent, TMessage>;\n}\n\n// ---------------------------------------------------------------------------\n// Implementation\n// ---------------------------------------------------------------------------\n\n// Spec: AIT-CT1\nclass DefaultClientTransport<TEvent, TMessage> implements ClientTransport<TEvent, TMessage> {\n  private readonly _channel: Ably.RealtimeChannel;\n  private readonly _codec: ClientTransportOptions<TEvent, TMessage>['codec'];\n  private readonly _clientId: string | undefined;\n  private readonly _api: string;\n  private readonly _credentials: RequestCredentials | undefined;\n  private readonly _headersFn: (() => Record<string, string>) | undefined;\n  private readonly _bodyFn: (() => Record<string, unknown>) | undefined;\n  private readonly _fetchFn: typeof globalThis.fetch;\n  private readonly _logger: Logger;\n\n  // Typed event emitter for all transport events\n  private readonly _emitter: EventEmitter<ClientTransportEventsMap>;\n\n  // Relay detection — tracks msg-ids of optimistic inserts for reconciliation\n  private readonly _ownMsgIds = new Set<string>();\n  private readonly _ownTurnIds = new Set<string>();\n\n  // Track clientId per turn for getActiveTurnIds()\n  private readonly _turnClientIds = new Map<string, string>();\n  // Track msgIds per turn for cleanup on turn-end\n  private readonly _turnMsgIds = new Map<string, Set<string>>();\n\n  // Per-turn observer state: headers, serial, and accumulator in one map.\n  // A single .delete(turnId) cleans up all three.\n  private readonly _turnObservers = new Map<string, TurnObserverState<TEvent, TMessage>>();\n\n  // Raw Ably message log\n  private readonly _ablyMessages: Ably.InboundMessage[] = [];\n\n  // History pagination: withheld messages hidden from getMessages()\n  private readonly _withheldKeys = new Set<string>();\n\n  // Sub-components\n  private readonly _tree: ConversationTree<TMessage>;\n  private readonly _router: StreamRouter<TEvent>;\n  private readonly _decoder: StreamDecoder<TEvent, TMessage>;\n\n  // Channel subscription — subscribe() returns a Promise that resolves when the channel attaches\n  private readonly _attachPromise: Promise<unknown>;\n  private readonly _onMessage: (msg: Ably.InboundMessage) => void;\n\n  private _closed = false;\n\n  constructor(options: ClientTransportOptions<TEvent, TMessage>) {\n    this._channel = options.channel;\n    this._codec = options.codec;\n    this._clientId = options.clientId;\n    this._api = options.api ?? '/api/chat';\n    this._credentials = options.credentials;\n    this._headersFn =\n      typeof options.headers === 'function'\n        ? options.headers\n        : options.headers\n          ? () => options.headers as Record<string, string>\n          : undefined;\n    this._bodyFn =\n      typeof options.body === 'function'\n        ? options.body\n        : options.body\n          ? () => options.body as Record<string, unknown>\n          : undefined;\n    this._fetchFn = options.fetch ?? globalThis.fetch.bind(globalThis);\n    this._logger = (options.logger ?? makeLogger({ logLevel: LogLevel.Silent })).withContext({\n      component: 'ClientTransport',\n    });\n\n    this._emitter = new EventEmitter<ClientTransportEventsMap>(this._logger);\n\n    // Compose sub-components\n    this._tree = createConversationTree<TMessage>(this._codec.getMessageKey.bind(this._codec), this._logger);\n    this._router = createStreamRouter<TEvent>(this._codec.isTerminal.bind(this._codec), this._logger);\n    this._decoder = this._codec.createDecoder();\n\n    // Seed tree with initial messages\n    if (options.messages) {\n      let prevMsgId: string | undefined;\n      for (const msg of options.messages) {\n        const msgId = this._codec.getMessageKey(msg);\n        const seedHeaders: Record<string, string> = {};\n        if (prevMsgId) seedHeaders[HEADER_PARENT] = prevMsgId;\n        this._tree.upsert(msgId, msg, seedHeaders);\n        prevMsgId = msgId;\n      }\n      this._emitter.emit('message');\n    }\n\n    // Spec: AIT-CT2\n    // Subscribe before attach (RTL7g)\n    this._onMessage = (ablyMessage: Ably.InboundMessage) => {\n      this._handleMessage(ablyMessage);\n    };\n    this._attachPromise = this._channel.subscribe(this._onMessage);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Message subscription handler\n  // ---------------------------------------------------------------------------\n\n  private _handleMessage(ablyMessage: Ably.InboundMessage): void {\n    if (this._closed) return;\n\n    this._ablyMessages.push(ablyMessage);\n    this._emitter.emit('ably-message');\n\n    try {\n      // Spec: AIT-CT16a\n      // --- Turn lifecycle events from the server ---\n      if (ablyMessage.name === EVENT_TURN_START) {\n        const headers = getHeaders(ablyMessage);\n        const turnId = headers[HEADER_TURN_ID];\n        const turnCid = headers[HEADER_TURN_CLIENT_ID] ?? '';\n        if (turnId) {\n          this._turnClientIds.set(turnId, turnCid);\n          this._emitter.emit('turn', { type: EVENT_TURN_START, turnId, clientId: turnCid });\n        }\n        return;\n      }\n\n      if (ablyMessage.name === EVENT_TURN_END) {\n        const headers = getHeaders(ablyMessage);\n        const turnId = headers[HEADER_TURN_ID];\n        const turnCid = headers[HEADER_TURN_CLIENT_ID] ?? '';\n        // CAST: server always writes a valid TurnEndReason; default to 'complete' for robustness\n        const reason = (headers[HEADER_TURN_REASON] ?? 'complete') as TurnEndReason;\n        if (turnId) {\n          this._router.closeStream(turnId);\n          this._turnObservers.delete(turnId);\n          this._turnClientIds.delete(turnId);\n          // Clean up per-turn relay-detection state\n          const msgIds = this._turnMsgIds.get(turnId);\n          if (msgIds) {\n            for (const mid of msgIds) this._ownMsgIds.delete(mid);\n            this._turnMsgIds.delete(turnId);\n          }\n          this._ownTurnIds.delete(turnId);\n          this._emitter.emit('turn', { type: EVENT_TURN_END, turnId, clientId: turnCid, reason });\n        }\n        return;\n      }\n\n      // --- Codec-decoded messages ---\n      const outputs = this._decoder.decode(ablyMessage);\n      const headers = getHeaders(ablyMessage);\n      const serial = ablyMessage.serial;\n\n      // Always update observer headers, even when the decoder produces no outputs.\n      // This ensures header transitions (e.g. x-ably-status: streaming → aborted)\n      // are captured for events that the decoder suppresses (AIT-CD8: aborted\n      // stream appends emit no events but still carry the updated status header).\n      const turnId = headers[HEADER_TURN_ID];\n      if (turnId) {\n        this._updateTurnObserverHeaders(turnId, headers, serial);\n      }\n\n      for (const output of outputs) {\n        if (output.kind === 'message') {\n          this._handleMessageOutput(output.message, headers, serial, ablyMessage.action);\n        } else {\n          this._handleEventOutput(output, headers);\n        }\n      }\n    } catch (error) {\n      const cause = error instanceof Ably.ErrorInfo ? error : undefined;\n      this._emitter.emit(\n        'error',\n        new Ably.ErrorInfo(\n          `unable to process channel message; ${error instanceof Error ? error.message : String(error)}`,\n          ErrorCode.TransportSubscriptionError,\n          500,\n          cause,\n        ),\n      );\n    }\n  }\n\n  /**\n   * Handle a decoded domain message (user message create or relayed own message).\n   * @param message - The decoded domain message.\n   * @param headers - Ably headers from the wire message.\n   * @param serial - Ably serial for tree ordering.\n   * @param action - Ably message action (e.g. 'message.create').\n   */\n  private _handleMessageOutput(\n    message: TMessage,\n    headers: Record<string, string>,\n    serial: string | undefined,\n    action: string | undefined,\n  ): void {\n    // Spec: AIT-CT15\n    const msgId = headers[HEADER_MSG_ID];\n    if (msgId && this._ownMsgIds.has(msgId)) {\n      // Relayed own message — reconcile optimistic entry with server-assigned fields\n      this._upsertAndNotify(message, headers, serial);\n      return;\n    }\n\n    if (action === 'message.create') {\n      this._upsertAndNotify(message, headers, serial);\n    }\n  }\n\n  /**\n   * Handle a decoded streaming event: route to own-turn stream or accumulate for observer.\n   * @param output - The decoded event output from the codec.\n   * @param headers - Ably headers from the wire message.\n   */\n  private _handleEventOutput(output: DecoderOutput<TEvent, TMessage>, headers: Record<string, string>): void {\n    if (output.kind !== 'event') return;\n    const event = output.event;\n    const turnId = headers[HEADER_TURN_ID];\n    if (!turnId) return;\n\n    // Observer headers are already updated in _handleMessage (before outputs\n    // are iterated) so that header transitions are captured even when the\n    // decoder produces no outputs (e.g. aborted stream appends per AIT-CD8).\n\n    // Active own turn — route to the ReadableStream\n    if (this._router.route(turnId, event)) {\n      this._accumulateAndEmit(turnId, output);\n      if (this._codec.isTerminal(event)) this._turnObservers.delete(turnId);\n      return;\n    }\n\n    // Completed own turn — late arrival, skip\n    if (this._ownTurnIds.has(turnId) && !this._turnObservers.has(turnId)) return;\n\n    // Spec: AIT-CT16\n    // Observer turn — accumulate and emit\n    this._accumulateAndEmit(turnId, output);\n    if (this._codec.isTerminal(event)) this._turnObservers.delete(turnId);\n  }\n\n  // ---------------------------------------------------------------------------\n  // Tree mutation + notification helpers\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Upsert a message into the tree and notify subscribers.\n   * @param message - The domain message to insert or update.\n   * @param headers - Ably headers for the message.\n   * @param serial - Ably serial for tree ordering.\n   */\n  private _upsertAndNotify(message: TMessage, headers: Record<string, string>, serial?: string): void {\n    const key = this._codec.getMessageKey(message);\n    const msgId = headers[HEADER_MSG_ID] ?? key;\n    this._tree.upsert(msgId, message, headers, serial);\n    this._emitter.emit('message');\n  }\n\n  // ---------------------------------------------------------------------------\n  // Observer accumulation\n  // ---------------------------------------------------------------------------\n\n  /**\n   * Ensure a TurnObserverState exists for turnId, updating headers and serial as new events arrive.\n   * @param turnId - The turn to track.\n   * @param headers - Headers from the current event.\n   * @param serial - Ably serial from the current event.\n   */\n  private _updateTurnObserverHeaders(\n    turnId: string,\n    headers: Record<string, string>,\n    serial: string | undefined,\n  ): void {\n    const existing = this._turnObservers.get(turnId);\n    if (existing) {\n      if (Object.keys(headers).length > 0) {\n        Object.assign(existing.headers, headers);\n      }\n      // Always advance the serial so the tree node sorts after all\n      // earlier messages in the turn (e.g. user-message relays that\n      // arrive before the assistant response).\n      if (serial !== undefined) {\n        existing.serial = serial;\n      }\n    } else {\n      this._turnObservers.set(turnId, {\n        headers: { ...headers },\n        serial,\n        accumulator: this._codec.createAccumulator(),\n      });\n    }\n  }\n\n  /**\n   * Process a streaming event through the turn's accumulator and emit the latest message.\n   * @param turnId - The turn this event belongs to.\n   * @param output - The decoded event output to accumulate.\n   */\n  private _accumulateAndEmit(turnId: string, output: DecoderOutput<TEvent, TMessage>): void {\n    const observer = this._turnObservers.get(turnId);\n    if (!observer) return;\n\n    observer.accumulator.processOutputs([output]);\n\n    const messages = observer.accumulator.messages;\n    if (messages.length === 0) return;\n\n    let message: TMessage | undefined;\n    try {\n      message = structuredClone(messages.at(-1));\n    } catch {\n      // CAST: structuredClone can fail if the message contains non-cloneable\n      // values (e.g. functions). Fall back to the reference — the tree upsert\n      // below copies headers independently, so shared message state is the\n      // only risk. Accumulator messages are replaced on each event, so\n      // mutation between events is not a practical concern.\n      message = messages.at(-1);\n    }\n\n    if (message) {\n      this._tree.upsert(\n        observer.headers[HEADER_MSG_ID] ?? this._codec.getMessageKey(message),\n        message,\n        { ...observer.headers },\n        observer.serial,\n      );\n      this._emitter.emit('message');\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Cancel helpers\n  // ---------------------------------------------------------------------------\n\n  private async _publishCancel(filter: CancelFilter): Promise<void> {\n    this._logger.trace('ClientTransport._publishCancel();', { filter });\n\n    const headers: Record<string, string> = {};\n    if (filter.turnId) {\n      headers[HEADER_CANCEL_TURN_ID] = filter.turnId;\n    } else if (filter.own) {\n      headers[HEADER_CANCEL_OWN] = 'true';\n    } else if (filter.clientId) {\n      headers[HEADER_CANCEL_CLIENT_ID] = filter.clientId;\n    } else if (filter.all) {\n      headers[HEADER_CANCEL_ALL] = 'true';\n    }\n\n    await this._channel.publish({\n      name: EVENT_CANCEL,\n      extras: { headers },\n    });\n  }\n\n  private _closeMatchingTurnStreams(filter: CancelFilter): void {\n    // Only close the router streams here — do NOT clear _turnObservers.\n    // The observer must remain alive so that late server events (e.g. abort,\n    // x-ably-status: aborted) arriving before turn-end are still accumulated\n    // into the message store. The turn-end handler cleans up observers.\n    if (filter.all) {\n      for (const turnId of this._ownTurnIds) {\n        this._router.closeStream(turnId);\n      }\n    } else if (filter.own) {\n      for (const tid of this._ownTurnIds) {\n        this._router.closeStream(tid);\n      }\n    } else if (filter.clientId) {\n      for (const [tid, cid] of this._turnClientIds) {\n        if (cid === filter.clientId) {\n          this._router.closeStream(tid);\n        }\n      }\n    } else if (filter.turnId) {\n      this._router.closeStream(filter.turnId);\n    }\n  }\n\n  private _getMatchingTurnIds(filter: CancelFilter): Set<string> {\n    const matched = new Set<string>();\n    if (filter.all) {\n      for (const turnId of this._turnClientIds.keys()) matched.add(turnId);\n    } else if (filter.own) {\n      for (const [turnId, cid] of this._turnClientIds) {\n        if (cid === this._clientId) matched.add(turnId);\n      }\n    } else if (filter.clientId) {\n      for (const [turnId, cid] of this._turnClientIds) {\n        if (cid === filter.clientId) matched.add(turnId);\n      }\n    } else if (filter.turnId && this._turnClientIds.has(filter.turnId)) {\n      matched.add(filter.turnId);\n    }\n    return matched;\n  }\n\n  // ---------------------------------------------------------------------------\n  // Input message helpers\n  // ---------------------------------------------------------------------------\n\n  private _getMessagesWithHeaders(): MessageWithHeaders<TMessage>[] {\n    return this._tree.flatten().map((m) => ({\n      message: m,\n      headers: this.getMessageHeaders(m),\n    }));\n  }\n\n  /**\n   * Compute truncated history: everything before the target message.\n   * Used by regenerate so the LLM doesn't see the response being replaced.\n   * @param messageId - The msg-id to truncate history before.\n   * @returns Input messages preceding the target.\n   */\n  private _getHistoryBefore(messageId: string): MessageWithHeaders<TMessage>[] {\n    const all = this._getMessagesWithHeaders();\n    const idx = all.findIndex((inp) => inp.headers?.[HEADER_MSG_ID] === messageId);\n    return idx === -1 ? all : all.slice(0, idx);\n  }\n\n  // ---------------------------------------------------------------------------\n  // History pagination helpers\n  // ---------------------------------------------------------------------------\n\n  private _processHistoryPage(page: PaginatedMessages<TMessage>): void {\n    for (const [i, message] of page.items.entries()) {\n      const headers = page.itemHeaders?.[i] ?? {};\n      const serial = page.itemSerials?.[i];\n      const key = this._codec.getMessageKey(message);\n      const msgId = headers[HEADER_MSG_ID] ?? key;\n      this._tree.upsert(msgId, message, headers, serial);\n    }\n    this._emitter.emit('message');\n\n    // Prepend raw Ably messages (older messages go at the beginning)\n    if (page.rawMessages && page.rawMessages.length > 0) {\n      this._ablyMessages.unshift(...page.rawMessages);\n      this._emitter.emit('ably-message');\n    }\n  }\n\n  private async _loadUntilVisible(\n    firstPage: PaginatedMessages<TMessage>,\n    target: number,\n    beforeKeys: Set<string>,\n  ): Promise<{ newVisible: TMessage[]; lastPage: PaginatedMessages<TMessage> }> {\n    this._processHistoryPage(firstPage);\n    let page = firstPage;\n\n    const newVisibleCount = (): number => {\n      let count = 0;\n      for (const m of this._tree.flatten()) {\n        if (!beforeKeys.has(this._codec.getMessageKey(m))) count++;\n      }\n      return count;\n    };\n\n    while (newVisibleCount() < target && page.hasNext()) {\n      const nextPage = await page.next();\n      if (!nextPage) break;\n      this._processHistoryPage(nextPage);\n      page = nextPage;\n    }\n\n    const newVisible = this._tree.flatten().filter((m) => !beforeKeys.has(this._codec.getMessageKey(m)));\n    return { newVisible, lastPage: page };\n  }\n\n  private _releaseWithheld(messages: TMessage[]): void {\n    for (const m of messages) {\n      this._withheldKeys.delete(this._codec.getMessageKey(m));\n    }\n    if (messages.length > 0) {\n      this._emitter.emit('message');\n    }\n  }\n\n  // ---------------------------------------------------------------------------\n  // Public API\n  // ---------------------------------------------------------------------------\n\n  // Spec: AIT-CT3, AIT-CT4\n  async send(input: TMessage | TMessage[], sendOptions?: SendOptions): Promise<ActiveTurn<TEvent>> {\n    if (this._closed) {\n      throw new Ably.ErrorInfo('unable to send; transport is closed', ErrorCode.TransportClosed, 400);\n    }\n    await this._attachPromise;\n    // CAST: re-check after await — close() may have been called while waiting for attach.\n    // TypeScript's control flow narrows _closed to false after the first check, but the\n    // await yields and close() can mutate _closed concurrently.\n    if (this._closed as boolean) {\n      throw new Ably.ErrorInfo('unable to send; transport is closed', ErrorCode.TransportClosed, 400);\n    }\n\n    this._logger.trace('ClientTransport.send();');\n\n    const msgs = Array.isArray(input) ? input : [input];\n    const turnId = crypto.randomUUID();\n    this._ownTurnIds.add(turnId);\n\n    const msgIds = new Set<string>();\n    const postMessages: { message: TMessage; headers: Record<string, string> }[] = [];\n\n    // Capture history BEFORE optimistic inserts. The optimistic messages are\n    // sent in the `messages` field — including them in `history` too would\n    // cause the server to see them twice.\n    const preInsertHistory = this._getMessagesWithHeaders();\n\n    // Spec: AIT-CT3d\n    // Auto-compute parent from the current thread if not explicitly provided\n    let autoParent: string | undefined;\n    if (sendOptions?.parent === undefined && !sendOptions?.forkOf) {\n      const flat = this._tree.flatten();\n      if (flat.length > 0) {\n        const lastMsg = flat.at(-1);\n        if (lastMsg) {\n          const lastKey = this._codec.getMessageKey(lastMsg);\n          const lastNode = this._tree.getNodeByKey(lastKey);\n          autoParent = lastNode?.msgId ?? lastKey;\n        }\n      }\n    }\n\n    // Capture the first parent for the POST body before the loop advances it.\n    const postParent = sendOptions?.parent === undefined ? autoParent : sendOptions.parent;\n\n    for (const message of msgs) {\n      const msgId = crypto.randomUUID();\n      this._ownMsgIds.add(msgId);\n      msgIds.add(msgId);\n\n      const resolvedParent = sendOptions?.parent === undefined ? autoParent : (sendOptions.parent ?? undefined);\n\n      const optimisticHeaders = buildTransportHeaders({\n        role: 'user',\n        turnId,\n        msgId,\n        turnClientId: this._clientId,\n        parent: resolvedParent,\n        forkOf: sendOptions?.forkOf,\n      });\n      // Spec: AIT-CT3c\n      // Optimistically insert each user message into the tree\n      this._upsertAndNotify(message, optimisticHeaders);\n\n      // Include per-message parent so the server chains messages correctly.\n      const postHeaders: Record<string, string> = { [HEADER_MSG_ID]: msgId, [HEADER_ROLE]: 'user' };\n      if (resolvedParent) postHeaders[HEADER_PARENT] = resolvedParent;\n      postMessages.push({ message, headers: postHeaders });\n\n      // Spec: AIT-CT3e\n      // Chain: each subsequent message in the batch parents off the previous\n      // one, forming a linear conversation thread rather than siblings.\n      if (sendOptions?.parent === undefined && !sendOptions?.forkOf) {\n        autoParent = msgId;\n      }\n    }\n\n    this._turnMsgIds.set(turnId, msgIds);\n\n    // Create ReadableStream via router\n    const stream = this._router.createStream(turnId);\n\n    // Resolve headers and body\n    const resolvedHeaders = this._headersFn?.() ?? {};\n    const resolvedBody = this._bodyFn?.() ?? {};\n\n    const postBody: Record<string, unknown> = {\n      ...resolvedBody,\n      history: preInsertHistory,\n      ...sendOptions?.body,\n      turnId,\n      clientId: this._clientId,\n      messages: postMessages,\n      ...(sendOptions?.forkOf !== undefined && { forkOf: sendOptions.forkOf }),\n      ...(postParent !== undefined && { parent: postParent }),\n    };\n\n    const postHeaders: Record<string, string> = {\n      ...resolvedHeaders,\n      ...sendOptions?.headers,\n    };\n\n    // Spec: AIT-CT3a, AIT-CT3b\n    // Fire-and-forget: POST must not block the stream return to the caller.\n    // .catch() is intentional — async/await would delay stream availability.\n    this._fetchFn(this._api, {\n      method: 'POST',\n      headers: {\n        'Content-Type': 'application/json',\n        ...postHeaders,\n      },\n      body: JSON.stringify(postBody),\n      ...(this._credentials ? { credentials: this._credentials } : {}),\n    })\n      .then((response) => {\n        if (!response.ok) {\n          this._emitter.emit(\n            'error',\n            new Ably.ErrorInfo(\n              `unable to send; HTTP POST to ${this._api} returned ${String(response.status)} ${response.statusText}`,\n              ErrorCode.TransportSendFailed,\n              response.status,\n            ),\n          );\n          this._router.closeStream(turnId);\n        }\n      })\n      .catch((error: unknown) => {\n        const cause = error instanceof Ably.ErrorInfo ? error : undefined;\n        this._emitter.emit(\n          'error',\n          new Ably.ErrorInfo(\n            `unable to send; HTTP POST to ${this._api} failed: ${error instanceof Error ? error.message : String(error)}`,\n            ErrorCode.TransportSendFailed,\n            500,\n            cause,\n          ),\n        );\n        this._router.closeStream(turnId);\n      });\n\n    return {\n      stream,\n      turnId,\n      cancel: async () => this.cancel({ turnId }),\n    };\n  }\n\n  // Spec: AIT-CT5\n  async regenerate(messageId: string, sendOptions?: SendOptions): Promise<ActiveTurn<TEvent>> {\n    this._logger.trace('ClientTransport.regenerate();', { messageId });\n\n    const node = this._tree.getNode(messageId);\n    const parentId = node?.parentId;\n\n    return this.send([], {\n      ...sendOptions,\n      body: {\n        history: this._getHistoryBefore(messageId),\n        ...sendOptions?.body,\n      },\n      forkOf: messageId,\n      parent: parentId,\n    });\n  }\n\n  // Spec: AIT-CT6\n  async edit(\n    messageId: string,\n    newMessages: TMessage | TMessage[],\n    sendOptions?: SendOptions,\n  ): Promise<ActiveTurn<TEvent>> {\n    this._logger.trace('ClientTransport.edit();', { messageId });\n\n    const node = this._tree.getNode(messageId);\n    const parentId = node?.parentId;\n\n    return this.send(newMessages, {\n      ...sendOptions,\n      body: {\n        history: this._getHistoryBefore(messageId),\n        ...sendOptions?.body,\n      },\n      forkOf: messageId,\n      parent: parentId,\n    });\n  }\n\n  // Spec: AIT-CT7, AIT-CT7a\n  async cancel(filter?: CancelFilter): Promise<void> {\n    if (this._closed) return;\n    const resolved = filter ?? { own: true };\n    this._logger.debug('ClientTransport.cancel();', { filter: resolved });\n    await this._publishCancel(resolved);\n    this._closeMatchingTurnStreams(resolved);\n  }\n\n  // Spec: AIT-CT18\n  async waitForTurn(filter?: CancelFilter): Promise<void> {\n    if (this._closed) return;\n    const resolved = filter ?? { own: true };\n    const remaining = this._getMatchingTurnIds(resolved);\n    if (remaining.size === 0) return;\n\n    this._logger.debug('ClientTransport.waitForTurn();', { turnIds: [...remaining] });\n\n    return new Promise<void>((resolve) => {\n      const handler = (event: TurnLifecycleEvent): void => {\n        if (event.type !== EVENT_TURN_END) return;\n        remaining.delete(event.turnId);\n        if (remaining.size === 0) {\n          this._emitter.off('turn', handler);\n          resolve();\n        }\n      };\n      this._emitter.on('turn', handler);\n    });\n  }\n\n  // Spec: AIT-CT8, AIT-CT8a, AIT-CT8b, AIT-CT8c, AIT-CT8d\n  on(event: 'message' | 'ably-message', handler: () => void): () => void;\n  on(event: 'turn', handler: (event: TurnLifecycleEvent) => void): () => void;\n  on(event: 'error', handler: (error: Ably.ErrorInfo) => void): () => void;\n  on(\n    eventName: 'message' | 'turn' | 'error' | 'ably-message',\n    handler: (() => void) | ((event: TurnLifecycleEvent) => void) | ((error: Ably.ErrorInfo) => void),\n  ): () => void {\n    if (this._closed) return noopUnsubscribe;\n    // CAST: the overload signatures enforce correct handler types per event name.\n    // The implementation must cast to satisfy the EventEmitter's generic callback type.\n    const cb = handler as (arg: ClientTransportEventsMap[keyof ClientTransportEventsMap]) => void;\n    this._emitter.on(eventName, cb);\n    return () => {\n      this._emitter.off(eventName, cb);\n    };\n  }\n\n  // Spec: AIT-CT10\n  getTree(): ConversationTree<TMessage> {\n    return this._tree;\n  }\n\n  // Spec: AIT-CT17\n  getActiveTurnIds(): Map<string, Set<string>> {\n    const result = new Map<string, Set<string>>();\n    for (const [turnId, cid] of this._turnClientIds) {\n      let set = result.get(cid);\n      if (!set) {\n        set = new Set();\n        result.set(cid, set);\n      }\n      set.add(turnId);\n    }\n    return result;\n  }\n\n  getMessageHeaders(message: TMessage): Record<string, string> | undefined {\n    const key = this._codec.getMessageKey(message);\n    return this._tree.getNodeByKey(key)?.headers;\n  }\n\n  // Spec: AIT-CT9\n  getMessages(): TMessage[] {\n    if (this._withheldKeys.size === 0) return this._tree.flatten();\n    return this._tree.flatten().filter((m) => !this._withheldKeys.has(this._codec.getMessageKey(m)));\n  }\n\n  getMessagesWithHeaders(): MessageWithHeaders<TMessage>[] {\n    return this._getMessagesWithHeaders();\n  }\n\n  getAblyMessages(): Ably.InboundMessage[] {\n    return [...this._ablyMessages];\n  }\n\n  // Spec: AIT-CT11, AIT-CT11a, AIT-CT11b, AIT-CT11c\n  async history(opts?: LoadHistoryOptions): Promise<PaginatedMessages<TMessage>> {\n    if (this._closed) {\n      throw new Ably.ErrorInfo('unable to load history; transport is closed', ErrorCode.TransportClosed, 400);\n    }\n    this._logger.trace('ClientTransport.history();', { limit: opts?.limit });\n    const limit = opts?.limit ?? 100;\n\n    // Snapshot before loading — everything already in the tree stays visible\n    const beforeKeys = new Set(this._tree.flatten().map((m) => this._codec.getMessageKey(m)));\n\n    let lastPage = await decodeHistory(this._channel, this._codec, opts, this._logger);\n\n    const initial = await this._loadUntilVisible(lastPage, limit, beforeKeys);\n    lastPage = initial.lastPage;\n\n    // newVisible is chronological (oldest-first from flatten).\n    // For \"load older\" pagination: release the NEWEST `limit` now,\n    // withhold the older ones for subsequent next() calls.\n    const newVisible = initial.newVisible;\n\n    // Withhold ALL new visible messages first, then release the newest batch\n    for (const m of newVisible) {\n      this._withheldKeys.add(this._codec.getMessageKey(m));\n    }\n\n    const released = newVisible.slice(-limit);\n    // Mutable buffer of older messages, drained newest-first by successive next() calls\n    const withheldBuffer = newVisible.slice(0, -limit);\n    this._releaseWithheld(released);\n\n    const buildPage = (items: TMessage[]): PaginatedMessages<TMessage> => ({\n      items,\n      hasNext: () => withheldBuffer.length > 0 || lastPage.hasNext(),\n      next: async () => {\n        // Drain withheld buffer first (older messages, released newest-first)\n        if (withheldBuffer.length > 0) {\n          // Remove and return the newest `limit` items from the buffer\n          const batch = withheldBuffer.splice(-limit, limit);\n          this._releaseWithheld(batch);\n          return buildPage(batch);\n        }\n\n        // Buffer exhausted — load more pages from decodeHistory\n        if (!lastPage.hasNext()) return;\n\n        const nextInternal = await lastPage.next();\n        if (!nextInternal) return;\n\n        // Everything currently in the tree is \"already known\"\n        const alreadyKnown = new Set(beforeKeys);\n        for (const m of this._tree.flatten()) {\n          alreadyKnown.add(this._codec.getMessageKey(m));\n        }\n\n        const loaded = await this._loadUntilVisible(nextInternal, limit, alreadyKnown);\n        lastPage = loaded.lastPage;\n\n        const moreVisible = loaded.newVisible;\n        for (const m of moreVisible) {\n          this._withheldKeys.add(this._codec.getMessageKey(m));\n        }\n        // Remove and return the newest `limit` items; rest stays in buffer\n        const moreBatch = moreVisible.splice(-limit, limit);\n        withheldBuffer.push(...moreVisible);\n        this._releaseWithheld(moreBatch);\n\n        if (moreBatch.length === 0) return;\n        return buildPage(moreBatch);\n      },\n    });\n\n    return buildPage(released);\n  }\n\n  // Spec: AIT-CT12, AIT-CT12a, AIT-CT12b\n  async close(options?: CloseOptions): Promise<void> {\n    if (this._closed) return;\n    this._closed = true;\n    this._logger.info('ClientTransport.close();');\n\n    // Best-effort cancel publish before tearing down local state\n    if (options?.cancel) {\n      try {\n        await this._publishCancel(options.cancel);\n      } catch {\n        // Swallow: cancel is best-effort during teardown\n      }\n      this._closeMatchingTurnStreams(options.cancel);\n    }\n\n    this._channel.unsubscribe(this._onMessage);\n\n    // Close any remaining active streams\n    for (const turnId of this._ownTurnIds) {\n      this._router.closeStream(turnId);\n    }\n\n    this._turnObservers.clear();\n    this._emitter.off();\n    this._ownTurnIds.clear();\n    this._ownMsgIds.clear();\n    this._turnMsgIds.clear();\n    this._turnClientIds.clear();\n    this._withheldKeys.clear();\n    this._ablyMessages.length = 0;\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Factory\n// ---------------------------------------------------------------------------\n\n/**\n * Create a client-side transport that manages conversation state over an Ably channel.\n *\n * Subscribes to the channel immediately (before attach per RTL7g). The caller should\n * ensure the channel is attached or will be attached shortly after creation.\n * @param options - Configuration for the client transport.\n * @returns A new {@link ClientTransport} instance.\n */\nexport const createClientTransport = <TEvent, TMessage>(\n  options: ClientTransportOptions<TEvent, TMessage>,\n): ClientTransport<TEvent, TMessage> => new DefaultClientTransport(options);\n","/**\n * useClientTransport: creates and memoizes a core ClientTransport instance\n * across renders.\n *\n * Stores the instance in a ref so the same transport is returned on every render.\n * The transport manages its own Ably channel subscription in the constructor —\n * this hook adds no subscription logic.\n *\n * The hook does NOT auto-close the transport on unmount. Channel lifecycle is\n * managed by the Ably provider (useChannel), which detaches the channel and\n * clears all subscriptions. Auto-closing would break React Strict Mode\n * (double-mount calls close() on the first cleanup, leaving a dead transport\n * on the second mount). Call transport.close() explicitly if you need to tear\n * down the transport independently of the channel lifecycle.\n */\n\nimport { useRef } from 'react';\n\nimport { createClientTransport } from '../core/transport/client-transport.js';\nimport type { ClientTransport, ClientTransportOptions } from '../core/transport/types.js';\n\n/**\n * Create and memoize a {@link ClientTransport} across renders.\n * @param options - Configuration for the client transport.\n * @returns The memoized transport instance.\n */\nexport const useClientTransport = <TEvent, TMessage>(\n  options: ClientTransportOptions<TEvent, TMessage>,\n): ClientTransport<TEvent, TMessage> => {\n  const transportRef = useRef<ClientTransport<TEvent, TMessage> | null>(null);\n\n  if (transportRef.current === null) {\n    transportRef.current = createClientTransport(options);\n  }\n\n  return transportRef.current;\n};\n","/**\n * useConversationTree — reactive branch navigation for a ClientTransport.\n *\n * Subscribes to the transport's \"message\" notification and provides\n * branch navigation primitives (getSiblings, selectSibling, hasSiblings)\n * backed by the transport's ConversationTree.\n *\n * Branch selection state is local to the hook instance — each component\n * (or tab) can navigate branches independently.\n */\n\nimport { useCallback, useEffect, useState } from 'react';\n\nimport type { ClientTransport } from '../core/transport/types.js';\n\n/** Handle for navigating the branching conversation tree. */\nexport interface ConversationTreeHandle<TMessage> {\n  /** Linear message list for the currently selected branch. */\n  messages: TMessage[];\n  /** Get all sibling messages at a fork point. */\n  getSiblings: (msgId: string) => TMessage[];\n  /** Whether a message has siblings (should show navigation arrows). */\n  hasSiblings: (msgId: string) => boolean;\n  /** Index of the currently selected sibling. */\n  getSelectedIndex: (msgId: string) => number;\n  /** Navigate to a sibling. Triggers re-render with updated messages. */\n  selectSibling: (msgId: string, index: number) => void;\n}\n\n/**\n * Subscribe to transport message updates and provide branch navigation primitives.\n * @param transport - The client transport whose conversation tree to navigate.\n * @returns A {@link ConversationTreeHandle} with the current messages and navigation methods.\n */\nexport const useConversationTree = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage>,\n): ConversationTreeHandle<TMessage> => {\n  const [messages, setMessages] = useState<TMessage[]>(() => transport.getMessages());\n\n  useEffect(() => {\n    setMessages(transport.getMessages());\n\n    const unsub = transport.on('message', () => {\n      setMessages(transport.getMessages());\n    });\n    return unsub;\n  }, [transport]);\n\n  const getSiblings = useCallback((msgId: string) => transport.getTree().getSiblings(msgId), [transport]);\n\n  const hasSiblings = useCallback((msgId: string) => transport.getTree().hasSiblings(msgId), [transport]);\n\n  const getSelectedIndex = useCallback((msgId: string) => transport.getTree().getSelectedIndex(msgId), [transport]);\n\n  const selectSibling = useCallback(\n    (msgId: string, index: number) => {\n      transport.getTree().select(msgId, index);\n      // flatten() returns a new array after select(), triggering re-render.\n      setMessages(transport.getMessages());\n    },\n    [transport],\n  );\n\n  return {\n    messages,\n    getSiblings,\n    hasSiblings,\n    getSelectedIndex,\n    selectSibling,\n  };\n};\n","/**\n * useEdit — stable callback for editing a user message.\n *\n * Delegates to `transport.edit()`, which automatically computes\n * `forkOf`, `parent`, and history from the conversation tree.\n */\n\nimport { useCallback } from 'react';\n\nimport type { ActiveTurn, ClientTransport, SendOptions } from '../core/transport/types.js';\n\n/**\n * Return a stable `edit` callback bound to the given transport.\n * @param transport - The client transport to edit through.\n * @returns A function that edits a user message and returns an {@link ActiveTurn} handle.\n */\nexport const useEdit = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage>,\n): ((messageId: string, newMessages: TMessage | TMessage[], options?: SendOptions) => Promise<ActiveTurn<TEvent>>) =>\n  useCallback(\n    async (messageId: string, newMessages: TMessage | TMessage[], options?: SendOptions): Promise<ActiveTurn<TEvent>> =>\n      transport.edit(messageId, newMessages, options),\n    [transport],\n  );\n","/**\n * useHistory — history pagination handle for a ClientTransport.\n *\n * Returns a `HistoryHandle` with `load()`, `next()`, `hasNext`, and\n * `loading` — mirroring the transport's `history()` and\n * `PaginatedMessages` API.\n *\n * The transport's `history()` is branch-aware: `limit` means \"keep loading\n * until N new messages appear on the selected branch.\" Messages on\n * unselected branches are loaded into the tree but not counted toward the\n * limit. The returned `items` contain only the newly visible messages.\n *\n * When `options` are provided, auto-loads the first page on mount\n * (SWR-style: options present = enabled). When omitted or null,\n * no auto-load — call `load()` manually.\n *\n * Usage:\n * ```tsx\n * // Auto-load on mount\n * const history = useHistory(transport, { limit: 30 });\n *\n * // Manual load (e.g. on button press)\n * const history = useHistory(transport);\n * // ...later: await history.load({ limit: 30 });\n *\n * // Scroll-back\n * if (history.hasNext) await history.next();\n * ```\n */\n\nimport { useCallback, useEffect, useRef, useState } from 'react';\n\nimport type { ClientTransport, LoadHistoryOptions, PaginatedMessages } from '../core/transport/types.js';\n\n/** Handle for paginated history loading. */\nexport interface HistoryHandle {\n  /** Are there older pages available? False until `load()` has been called. */\n  hasNext: boolean;\n  /** Is a page being fetched? */\n  loading: boolean;\n  /** Load the first page (or re-load with different options). Inserts into the conversation tree. */\n  load: (options?: LoadHistoryOptions) => Promise<void>;\n  /** Fetch the next (older) page. No-op if loading or no more pages. Inserts into the conversation tree. */\n  next: () => Promise<void>;\n}\n\n/**\n * Paginated history handle for a client transport.\n * @param transport - The client transport to load history from, or null/undefined if not yet available.\n * @param options - When provided, auto-loads the first page on mount. Omit or pass null for manual loading.\n * @returns A {@link HistoryHandle} for loading and paginating through history.\n */\nexport const useHistory = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage> | null | undefined,\n  options?: LoadHistoryOptions | null,\n): HistoryHandle => {\n  const [hasNext, setHasNext] = useState(false);\n  const [loading, setLoading] = useState(false);\n  const loadingRef = useRef(false);\n  const pageRef = useRef<PaginatedMessages<TMessage> | null>(null);\n  const transportRef = useRef(transport);\n  transportRef.current = transport;\n\n  const load = useCallback(async (loadOptions?: LoadHistoryOptions) => {\n    if (!transportRef.current || loadingRef.current) return;\n    loadingRef.current = true;\n    setLoading(true);\n    try {\n      const page = await transportRef.current.history(loadOptions);\n      pageRef.current = page;\n      setHasNext(page.hasNext());\n    } finally {\n      loadingRef.current = false;\n      setLoading(false);\n    }\n  }, []);\n\n  const next = useCallback(async () => {\n    const page = pageRef.current;\n    if (!page || !page.hasNext() || loadingRef.current || !transportRef.current) return;\n\n    loadingRef.current = true;\n    setLoading(true);\n    try {\n      const older = await page.next();\n      if (older) {\n        pageRef.current = older;\n        setHasNext(older.hasNext());\n      } else {\n        setHasNext(false);\n      }\n    } finally {\n      loadingRef.current = false;\n      setLoading(false);\n    }\n  }, []);\n\n  // Auto-load first page on mount when options are provided (SWR-style).\n  const autoLoad = options !== undefined && options !== null;\n  const autoLoadedRef = useRef(false);\n  const optionsRef = useRef(options);\n  optionsRef.current = options;\n\n  useEffect(() => {\n    if (!autoLoad || autoLoadedRef.current || !transportRef.current) return;\n    autoLoadedRef.current = true;\n    void load(optionsRef.current ?? undefined);\n  }, [autoLoad, load]);\n\n  return { hasNext, loading, load, next };\n};\n","/**\n * useMessages — reactive message list from a ClientTransport.\n *\n * Subscribes to the transport's \"message\" notification and returns\n * the current message list as React state. Replaces the manual\n * useState + useEffect + on(\"message\") + getMessages() pattern.\n */\n\nimport { useEffect, useState } from 'react';\n\nimport type { ClientTransport } from '../core/transport/types.js';\n\n/**\n * Subscribe to transport message updates and return the current message list.\n * @param transport - The client transport to observe.\n * @returns The current list of decoded messages.\n */\nexport const useMessages = <TEvent, TMessage>(transport: ClientTransport<TEvent, TMessage>): TMessage[] => {\n  const [messages, setMessages] = useState<TMessage[]>(() => transport.getMessages());\n\n  useEffect(() => {\n    // Sync initial state in case the transport already has messages\n    setMessages(transport.getMessages());\n\n    const unsub = transport.on('message', () => {\n      setMessages(transport.getMessages());\n    });\n    return unsub;\n  }, [transport]);\n\n  return messages;\n};\n","/**\n * useRegenerate — stable callback for regenerating an assistant message.\n *\n * Delegates to `transport.regenerate()`, which automatically computes\n * `forkOf`, `parent`, and truncated history from the conversation tree.\n */\n\nimport { useCallback } from 'react';\n\nimport type { ActiveTurn, ClientTransport, SendOptions } from '../core/transport/types.js';\n\n/**\n * Return a stable `regenerate` callback bound to the given transport.\n * @param transport - The client transport to regenerate through.\n * @returns A function that regenerates an assistant message and returns an {@link ActiveTurn} handle.\n */\nexport const useRegenerate = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage>,\n): ((messageId: string, options?: SendOptions) => Promise<ActiveTurn<TEvent>>) =>\n  useCallback(\n    async (messageId: string, options?: SendOptions): Promise<ActiveTurn<TEvent>> =>\n      transport.regenerate(messageId, options),\n    [transport],\n  );\n","/**\n * useSend — stable callback for sending messages through a ClientTransport.\n *\n * Returns a `send` function that sends one or more messages in a single\n * turn via `transport.send()`. Callers construct the domain messages\n * themselves; the hook provides a stable reference suitable for React deps.\n */\n\nimport { useCallback } from 'react';\n\nimport type { ActiveTurn, ClientTransport, SendOptions } from '../core/transport/types.js';\n\n/**\n * Return a stable `send` callback bound to the given transport.\n * @param transport - The client transport to send through.\n * @returns A function that sends messages and returns an {@link ActiveTurn} handle.\n */\nexport const useSend = <TEvent, TMessage>(\n  transport: ClientTransport<TEvent, TMessage>,\n): ((messages: TMessage[], options?: SendOptions) => Promise<ActiveTurn<TEvent>>) =>\n  useCallback(\n    async (messages: TMessage[], options?: SendOptions): Promise<ActiveTurn<TEvent>> =>\n      transport.send(messages, options),\n    [transport],\n  );\n"],"mappings":"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"}

package/dist/react/ably-ai-transport-react.umd.cjs

@@ -0,0 +1,2 @@
+(function(e,t){typeof exports==`object`&&typeof module<`u`?t(exports,require(`react`),require(`ably`)):typeof define==`function`&&define.amd?define([`exports`,`react`,`ably`],t):(e=typeof globalThis<`u`?globalThis:e||self,t(e.AblyAiTransportReact={},e.React,e.Ably))})(this,function(e,t,n){Object.defineProperty(e,Symbol.toStringTag,{value:`Module`});var r=Object.create,i=Object.defineProperty,a=Object.getOwnPropertyDescriptor,o=Object.getOwnPropertyNames,s=Object.getPrototypeOf,c=Object.prototype.hasOwnProperty,l=(e,t,n,r)=>{if(t&&typeof t==`object`||typeof t==`function`)for(var s=o(t),l=0,u=s.length,d;l<u;l++)d=s[l],!c.call(e,d)&&d!==n&&i(e,d,{get:(e=>t[e]).bind(null,d),enumerable:!(r=a(t,d))||r.enumerable});return e};n=((e,t,n)=>(n=e==null?{}:r(s(e)),l(t||!e||!e.__esModule?i(n,`default`,{value:e,enumerable:!0}):n,e)))(n);var u=e=>{let[n,r]=(0,t.useState)(()=>e.getAblyMessages());return(0,t.useEffect)(()=>(r(e.getAblyMessages()),e.on(`ably-message`,()=>{r(e.getAblyMessages())})),[e]),n},d=`x-ably-turn-id`,f=`x-ably-msg-id`,p=`x-ably-turn-client-id`,m=`x-ably-role`,h=`x-ably-cancel-turn-id`,g=`x-ably-cancel-own`,_=`x-ably-cancel-all`,v=`x-ably-cancel-client-id`,y=`x-ably-parent`,b=`x-ably-fork-of`,x=`x-ably-cancel`,S=`x-ably-turn-start`,C=`x-ably-turn-end`,w=e=>{let[n,r]=(0,t.useState)(()=>new Map);return(0,t.useEffect)(()=>{if(e)return r(e.getActiveTurnIds()),e.on(`turn`,e=>{r(t=>{let n=new Map(t);if(e.type===`x-ably-turn-start`){let t=new Set(n.get(e.clientId)??[]);t.add(e.turnId),n.set(e.clientId,t)}else{let t=n.get(e.clientId);t&&(t.delete(e.turnId),t.size===0?n.delete(e.clientId):n.set(e.clientId,new Set(t)))}return n})})},[e]),n},T=function(e){return e[e.BadRequest=4e4]=`BadRequest`,e[e.InvalidArgument=40003]=`InvalidArgument`,e[e.EncoderRecoveryFailed=104e3]=`EncoderRecoveryFailed`,e[e.TransportSubscriptionError=104001]=`TransportSubscriptionError`,e[e.CancelListenerError=104002]=`CancelListenerError`,e[e.TurnLifecycleError=104003]=`TurnLifecycleError`,e[e.TransportClosed=104004]=`TransportClosed`,e[e.TransportSendFailed=104005]=`TransportSendFailed`,e}({}),E=e=>({logAction:(t,n,r)=>{e.error(n,{detail:r})},shouldLog:()=>!0}),D=n.Realtime.EventEmitter,O=class extends D{constructor(e){super(E(e))}},k=function(e){return e.Trace=`trace`,e.Debug=`debug`,e.Info=`info`,e.Warn=`warn`,e.Error=`error`,e.Silent=`silent`,e}({}),A=(e,t,n)=>{let r=n?`, context: ${JSON.stringify(n)}`:``,i=`[${new Date().toISOString()}] ${t.valueOf().toUpperCase()} ably-ai-transport: ${e}${r}`;switch(t){case k.Trace:case k.Debug:console.log(i);break;case k.Info:console.info(i);break;case k.Warn:console.warn(i);break;case k.Error:console.error(i);break;case k.Silent:break}},j=e=>new P(e.logHandler??A,e.logLevel),M=function(e){return e[e.Trace=0]=`Trace`,e[e.Debug=1]=`Debug`,e[e.Info=2]=`Info`,e[e.Warn=3]=`Warn`,e[e.Error=4]=`Error`,e[e.Silent=5]=`Silent`,e}(M||{}),N=new Map([[k.Trace,M.Trace],[k.Debug,M.Debug],[k.Info,M.Info],[k.Warn,M.Warn],[k.Error,M.Error],[k.Silent,M.Silent]]),P=class e{constructor(e,t,r){this._handler=e,this._context=r;let i=N.get(t);if(i===void 0)throw new n.ErrorInfo(`unable to create logger; invalid log level: ${t}`,T.InvalidArgument,400);this._levelNumber=i}trace(e,t){this._write(e,k.Trace,M.Trace,t)}debug(e,t){this._write(e,k.Debug,M.Debug,t)}info(e,t){this._write(e,k.Info,M.Info,t)}warn(e,t){this._write(e,k.Warn,M.Warn,t)}error(e,t){this._write(e,k.Error,M.Error,t)}withContext(t){let n=[...N.entries()].find(([,e])=>e===this._levelNumber)?.[0]??k.Error;return new e(this._handler,n,this._mergeContext(t))}_write(e,t,n,r){n>=this._levelNumber&&this._handler(e,t,this._mergeContext(r))}_mergeContext(e){return this._context?e?{...this._context,...e}:this._context:e??void 0}},F=e=>{let t=e.extras;if(!t||typeof t!=`object`)return{};let n=t.headers;return!n||typeof n!=`object`?{}:n},I=class{constructor(e,t){this._nodeIndex=new Map,this._codecKeyIndex=new Map,this._sortedList=[],this._parentIndex=new Map,this._selections=new Map,this._seqCounter=0,this._getKey=e,this._logger=t}_compareNodes(e,t){let n=e.node.serial,r=t.node.serial;return n===void 0&&r===void 0?e.insertSeq-t.insertSeq:n===void 0?1:r===void 0||n<r?-1:n>r?1:e.insertSeq-t.insertSeq}_insertSorted(e){if(e.node.serial===void 0){this._sortedList.push(e);return}let t=0,n=this._sortedList.length;for(;t<n;){let r=t+n>>>1,i=this._sortedList[r];if(!i)break;this._compareNodes(i,e)<=0?t=r+1:n=r}this._sortedList.splice(t,0,e)}_removeSorted(e){let t=this._sortedList.indexOf(e);t!==-1&&this._sortedList.splice(t,1)}_addToParentIndex(e,t){let n=this._parentIndex.get(e);n||(n=new Set,this._parentIndex.set(e,n)),n.add(t)}_removeFromParentIndex(e,t){let n=this._parentIndex.get(e);n&&(n.delete(t),n.size===0&&this._parentIndex.delete(e))}_getSiblingGroup(e){let t=this._nodeIndex.get(e);if(!t)return[];let n=t.node,r=new Set([n.msgId]);for(;n.forkOf&&!r.has(n.forkOf);){let e=this._nodeIndex.get(n.forkOf);if(!e||e.node.parentId!==n.parentId)break;n=e.node,r.add(n.msgId)}let i=n.parentId,a=n.msgId,o=[],s=this._parentIndex.get(i);if(s)for(let e of s){let t=this._nodeIndex.get(e);t&&this._isSiblingOf(t.node,a)&&o.push(t)}return o.sort((e,t)=>this._compareNodes(e,t)),o.map(e=>e.node)}_isSiblingOf(e,t){if(e.msgId===t)return!0;let n=e,r=new Set([n.msgId]);for(;n.forkOf;){if(n.forkOf===t)return!0;if(r.has(n.forkOf))break;let e=this._nodeIndex.get(n.forkOf);if(!e)break;n=e.node,r.add(n.msgId)}return!1}_getGroupRoot(e){let t=this._nodeIndex.get(e);if(!t)return e;let n=t.node,r=new Set([n.msgId]);for(;n.forkOf&&!r.has(n.forkOf);){let e=this._nodeIndex.get(n.forkOf);if(!e||e.node.parentId!==n.parentId)break;n=e.node,r.add(n.msgId)}return n.msgId}flatten(){let e=[],t=new Set,n=new Map;for(let r of this._sortedList){let i=r.node,{msgId:a,parentId:o}=i;if(o!==void 0&&!t.has(o))continue;let s=this._getSiblingGroup(a);if(s.length>1){let e=this._getGroupRoot(a),t=n.get(e);if(t===void 0){let r=this._selections.get(e)??s.length-1,i=s[Math.max(0,Math.min(r,s.length-1))];if(!i)break;t=i.msgId,n.set(e,t)}if(a!==t)continue}t.add(a),e.push(i.message)}return e}getSiblings(e){return this._getSiblingGroup(e).map(e=>e.message)}hasSiblings(e){return this._getSiblingGroup(e).length>1}getSelectedIndex(e){let t=this._getSiblingGroup(e);if(t.length<=1)return 0;let n=this._getGroupRoot(e),r=this._selections.get(n);return r===void 0?t.length-1:Math.max(0,Math.min(r,t.length-1))}select(e,t){this._logger.debug(`ConversationTree.select();`,{msgId:e,index:t});let n=this._getSiblingGroup(e);if(n.length<=1)return;let r=this._getGroupRoot(e);this._selections.set(r,Math.max(0,Math.min(t,n.length-1)))}getNode(e){return this._nodeIndex.get(e)?.node}getNodeByKey(e){let t=this._codecKeyIndex.get(e);if(t)return this._nodeIndex.get(t)?.node}getHeaders(e){return this._nodeIndex.get(e)?.node.headers}upsert(e,t,n,r){let i=n[`x-ably-parent`]??void 0,a=n[`x-ably-fork-of`]??void 0;this._codecKeyIndex.set(this._getKey(t),e);let o=this._nodeIndex.get(e);if(o){o.node.message=t,Object.keys(n).length>0&&(o.node.headers={...n}),r&&!o.node.serial&&(this._logger.debug(`ConversationTree.upsert(); promoting serial`,{msgId:e,serial:r}),o.node.serial=r,this._removeSorted(o),this._insertSorted(o));return}this._logger.trace(`ConversationTree.upsert(); inserting new node`,{msgId:e,parentId:i,forkOf:a});let s={node:{message:t,msgId:e,parentId:i,forkOf:a,headers:{...n},serial:r},insertSeq:this._seqCounter++};this._nodeIndex.set(e,s),this._addToParentIndex(i,e),this._insertSorted(s)}delete(e){let t=this._nodeIndex.get(e);if(!t)return;this._logger.debug(`ConversationTree.delete();`,{msgId:e});let{node:n}=t,r=this._getKey(n.message);this._codecKeyIndex.get(r)===e&&this._codecKeyIndex.delete(r),this._removeFromParentIndex(n.parentId,e),this._removeSorted(t),this._nodeIndex.delete(e),this._selections.delete(e)}},L=(e,t)=>new I(e,t),R=e=>{let t=[...e.rawMessages].toReversed(),n=e.codec.createDecoder(),r=new Map,i=e.codec.createAccumulator(),a=0,o=new Map,s=new Map;for(let c of t){let t=n.decode(c),l=F(c),u=l[d],p=l[f],m=c.serial;if(u){let n=r.get(u);if(n||(n={accumulator:e.codec.createAccumulator(),firstSeen:a++,msgHeaders:new Map,msgSerials:new Map},r.set(u,n)),p){let e=n.msgHeaders.get(p);e?Object.keys(l).length>0&&Object.assign(e,l):(n.msgHeaders.set(p,{...l}),m&&n.msgSerials.set(p,m))}n.accumulator.processOutputs(t)}else i.processOutputs(t);for(let n of t)if(n.kind===`message`){let t=e.getMessageKey(n.message),r=o.get(t);r?Object.keys(l).length>0&&Object.assign(r,l):(o.set(t,{...l}),m&&s.set(t,m))}}let c=[];for(let t of i.completedMessages){let n=e.getMessageKey(t);c.push({message:t,headers:o.get(n)??{},serial:s.get(n)??``})}let l=[...r.values()].toSorted((e,t)=>e.firstSeen-t.firstSeen);for(let t of l){let n=new Set,r=new Map,i=new Map;for(let a of t.accumulator.completedMessages){let t=e.getMessageKey(a),c=o.get(t);if(c){r.set(t,c);let e=s.get(t);e&&i.set(t,e);let a=c[f];a&&n.add(a)}}let a=[...t.msgHeaders.entries()].filter(([e])=>!n.has(e)),l=0;for(let n of t.accumulator.completedMessages){let o=e.getMessageKey(n),s=a[l];if(!r.has(o)&&s){let[e,n]=s;r.set(o,n);let a=t.msgSerials.get(e);a&&i.set(o,a),l++}}for(let n of t.accumulator.completedMessages){let t=e.getMessageKey(n);c.push({message:n,headers:r.get(t)??{},serial:i.get(t)??``})}}return c.toReversed()},z=async(e,t,n)=>{e.rawMessages.push(...t.items),e.lastAblyPage=t;let r=R(e).length;for(;r<e.returnedCount+n&&t.hasNext();){e.logger.debug(`decodeHistory.fetchUntilLimit(); fetching next page`,{collected:e.rawMessages.length,decoded:r});let n=await t.next();if(!n)break;t=n,e.rawMessages.push(...n.items),e.lastAblyPage=n,r=R(e).length}},B=(e,t)=>{let n=R(e),r=n.slice(e.returnedCount,e.returnedCount+t),i=[...r].toReversed();e.returnedCount+=r.length;let a=n.length>e.returnedCount,o=e.lastAblyPage?.hasNext()??!1,s=e.rawMessages.length-e.returnedRawCount>0?e.rawMessages.slice(e.returnedRawCount).toReversed():[];return e.returnedRawCount=e.rawMessages.length,{items:i.map(e=>e.message),itemHeaders:i.map(e=>e.headers),itemSerials:i.map(e=>e.serial),rawMessages:s,hasNext:()=>a||o,next:async()=>{if(a)return B(e,t);if(!o||!e.lastAblyPage)return;let n=await e.lastAblyPage.next();if(n)return await z(e,n,t),B(e,t)}}},V=async(e,t,n,r)=>{let i=n?.limit??100,a={codec:t,rawMessages:[],returnedCount:0,returnedRawCount:0,lastAblyPage:void 0,getMessageKey:t.getMessageKey.bind(t),logger:r};r.trace(`decodeHistory();`,{limit:i});let o=i*10;return await e.attach(),await z(a,await e.history({untilAttach:!0,limit:o}),i),B(a,i)},H=e=>{let t={[m]:e.role,[d]:e.turnId,[f]:e.msgId};return e.turnClientId!==void 0&&(t[p]=e.turnClientId),e.parent&&(t[y]=e.parent),e.forkOf&&(t[b]=e.forkOf),t},U=class{constructor(e,t){this._turns=new Map,this._isTerminal=e,this._logger=t}createStream(e){this._logger.trace(`StreamRouter.createStream();`,{turnId:e});let t={},r=new ReadableStream({start(e){t.controller=e}});if(!t.controller)throw new n.ErrorInfo(`unable to create stream; ReadableStream start() was not called synchronously`,T.TransportSubscriptionError,500);return this._turns.set(e,{controller:t.controller,turnId:e}),r}closeStream(e){let t=this._turns.get(e);if(!t)return!1;this._logger.debug(`StreamRouter.closeStream(); closing stream`,{turnId:e});try{t.controller.close()}catch{}return this._turns.delete(e),!0}route(e,t){let n=this._turns.get(e);if(!n)return!1;try{n.controller.enqueue(t)}catch{return this._turns.delete(e),!1}return this._isTerminal(t)&&this.closeStream(e),!0}has(e){return this._turns.has(e)}},W=(e,t)=>new U(e,t),G=()=>{},K=class{constructor(e){if(this._ownMsgIds=new Set,this._ownTurnIds=new Set,this._turnClientIds=new Map,this._turnMsgIds=new Map,this._turnObservers=new Map,this._ablyMessages=[],this._withheldKeys=new Set,this._closed=!1,this._channel=e.channel,this._codec=e.codec,this._clientId=e.clientId,this._api=e.api??`/api/chat`,this._credentials=e.credentials,this._headersFn=typeof e.headers==`function`?e.headers:e.headers?()=>e.headers:void 0,this._bodyFn=typeof e.body==`function`?e.body:e.body?()=>e.body:void 0,this._fetchFn=e.fetch??globalThis.fetch.bind(globalThis),this._logger=(e.logger??j({logLevel:k.Silent})).withContext({component:`ClientTransport`}),this._emitter=new O(this._logger),this._tree=L(this._codec.getMessageKey.bind(this._codec),this._logger),this._router=W(this._codec.isTerminal.bind(this._codec),this._logger),this._decoder=this._codec.createDecoder(),e.messages){let t;for(let n of e.messages){let e=this._codec.getMessageKey(n),r={};t&&(r[y]=t),this._tree.upsert(e,n,r),t=e}this._emitter.emit(`message`)}this._onMessage=e=>{this._handleMessage(e)},this._attachPromise=this._channel.subscribe(this._onMessage)}_handleMessage(e){if(!this._closed){this._ablyMessages.push(e),this._emitter.emit(`ably-message`);try{if(e.name===`x-ably-turn-start`){let t=F(e),n=t[d],r=t[`x-ably-turn-client-id`]??``;n&&(this._turnClientIds.set(n,r),this._emitter.emit(`turn`,{type:S,turnId:n,clientId:r}));return}if(e.name===`x-ably-turn-end`){let t=F(e),n=t[d],r=t[`x-ably-turn-client-id`]??``,i=t[`x-ably-turn-reason`]??`complete`;if(n){this._router.closeStream(n),this._turnObservers.delete(n),this._turnClientIds.delete(n);let e=this._turnMsgIds.get(n);if(e){for(let t of e)this._ownMsgIds.delete(t);this._turnMsgIds.delete(n)}this._ownTurnIds.delete(n),this._emitter.emit(`turn`,{type:C,turnId:n,clientId:r,reason:i})}return}let t=this._decoder.decode(e),n=F(e),r=e.serial,i=n[d];i&&this._updateTurnObserverHeaders(i,n,r);for(let i of t)i.kind===`message`?this._handleMessageOutput(i.message,n,r,e.action):this._handleEventOutput(i,n)}catch(e){let t=e instanceof n.ErrorInfo?e:void 0;this._emitter.emit(`error`,new n.ErrorInfo(`unable to process channel message; ${e instanceof Error?e.message:String(e)}`,T.TransportSubscriptionError,500,t))}}}_handleMessageOutput(e,t,n,r){let i=t[f];if(i&&this._ownMsgIds.has(i)){this._upsertAndNotify(e,t,n);return}r===`message.create`&&this._upsertAndNotify(e,t,n)}_handleEventOutput(e,t){if(e.kind!==`event`)return;let n=e.event,r=t[d];if(r){if(this._router.route(r,n)){this._accumulateAndEmit(r,e),this._codec.isTerminal(n)&&this._turnObservers.delete(r);return}this._ownTurnIds.has(r)&&!this._turnObservers.has(r)||(this._accumulateAndEmit(r,e),this._codec.isTerminal(n)&&this._turnObservers.delete(r))}}_upsertAndNotify(e,t,n){let r=this._codec.getMessageKey(e),i=t[`x-ably-msg-id`]??r;this._tree.upsert(i,e,t,n),this._emitter.emit(`message`)}_updateTurnObserverHeaders(e,t,n){let r=this._turnObservers.get(e);r?(Object.keys(t).length>0&&Object.assign(r.headers,t),n!==void 0&&(r.serial=n)):this._turnObservers.set(e,{headers:{...t},serial:n,accumulator:this._codec.createAccumulator()})}_accumulateAndEmit(e,t){let n=this._turnObservers.get(e);if(!n)return;n.accumulator.processOutputs([t]);let r=n.accumulator.messages;if(r.length===0)return;let i;try{i=structuredClone(r.at(-1))}catch{i=r.at(-1)}i&&(this._tree.upsert(n.headers[`x-ably-msg-id`]??this._codec.getMessageKey(i),i,{...n.headers},n.serial),this._emitter.emit(`message`))}async _publishCancel(e){this._logger.trace(`ClientTransport._publishCancel();`,{filter:e});let t={};e.turnId?t[h]=e.turnId:e.own?t[g]=`true`:e.clientId?t[v]=e.clientId:e.all&&(t[_]=`true`),await this._channel.publish({name:x,extras:{headers:t}})}_closeMatchingTurnStreams(e){if(e.all)for(let e of this._ownTurnIds)this._router.closeStream(e);else if(e.own)for(let e of this._ownTurnIds)this._router.closeStream(e);else if(e.clientId)for(let[t,n]of this._turnClientIds)n===e.clientId&&this._router.closeStream(t);else e.turnId&&this._router.closeStream(e.turnId)}_getMatchingTurnIds(e){let t=new Set;if(e.all)for(let e of this._turnClientIds.keys())t.add(e);else if(e.own)for(let[e,n]of this._turnClientIds)n===this._clientId&&t.add(e);else if(e.clientId)for(let[n,r]of this._turnClientIds)r===e.clientId&&t.add(n);else e.turnId&&this._turnClientIds.has(e.turnId)&&t.add(e.turnId);return t}_getMessagesWithHeaders(){return this._tree.flatten().map(e=>({message:e,headers:this.getMessageHeaders(e)}))}_getHistoryBefore(e){let t=this._getMessagesWithHeaders(),n=t.findIndex(t=>t.headers?.[f]===e);return n===-1?t:t.slice(0,n)}_processHistoryPage(e){for(let[t,n]of e.items.entries()){let r=e.itemHeaders?.[t]??{},i=e.itemSerials?.[t],a=this._codec.getMessageKey(n),o=r[`x-ably-msg-id`]??a;this._tree.upsert(o,n,r,i)}this._emitter.emit(`message`),e.rawMessages&&e.rawMessages.length>0&&(this._ablyMessages.unshift(...e.rawMessages),this._emitter.emit(`ably-message`))}async _loadUntilVisible(e,t,n){this._processHistoryPage(e);let r=e,i=()=>{let e=0;for(let t of this._tree.flatten())n.has(this._codec.getMessageKey(t))||e++;return e};for(;i()<t&&r.hasNext();){let e=await r.next();if(!e)break;this._processHistoryPage(e),r=e}return{newVisible:this._tree.flatten().filter(e=>!n.has(this._codec.getMessageKey(e))),lastPage:r}}_releaseWithheld(e){for(let t of e)this._withheldKeys.delete(this._codec.getMessageKey(t));e.length>0&&this._emitter.emit(`message`)}async send(e,t){if(this._closed||(await this._attachPromise,this._closed))throw new n.ErrorInfo(`unable to send; transport is closed`,T.TransportClosed,400);this._logger.trace(`ClientTransport.send();`);let r=Array.isArray(e)?e:[e],i=crypto.randomUUID();this._ownTurnIds.add(i);let a=new Set,o=[],s=this._getMessagesWithHeaders(),c;if(t?.parent===void 0&&!t?.forkOf){let e=this._tree.flatten();if(e.length>0){let t=e.at(-1);if(t){let e=this._codec.getMessageKey(t);c=this._tree.getNodeByKey(e)?.msgId??e}}}let l=t?.parent===void 0?c:t.parent;for(let e of r){let n=crypto.randomUUID();this._ownMsgIds.add(n),a.add(n);let r=t?.parent===void 0?c:t.parent??void 0,s=H({role:`user`,turnId:i,msgId:n,turnClientId:this._clientId,parent:r,forkOf:t?.forkOf});this._upsertAndNotify(e,s);let l={[f]:n,[m]:`user`};r&&(l[y]=r),o.push({message:e,headers:l}),t?.parent===void 0&&!t?.forkOf&&(c=n)}this._turnMsgIds.set(i,a);let u=this._router.createStream(i),d=this._headersFn?.()??{},p={...this._bodyFn?.()??{},history:s,...t?.body,turnId:i,clientId:this._clientId,messages:o,...t?.forkOf!==void 0&&{forkOf:t.forkOf},...l!==void 0&&{parent:l}},h={...d,...t?.headers};return this._fetchFn(this._api,{method:`POST`,headers:{"Content-Type":`application/json`,...h},body:JSON.stringify(p),...this._credentials?{credentials:this._credentials}:{}}).then(e=>{e.ok||(this._emitter.emit(`error`,new n.ErrorInfo(`unable to send; HTTP POST to ${this._api} returned ${String(e.status)} ${e.statusText}`,T.TransportSendFailed,e.status)),this._router.closeStream(i))}).catch(e=>{let t=e instanceof n.ErrorInfo?e:void 0;this._emitter.emit(`error`,new n.ErrorInfo(`unable to send; HTTP POST to ${this._api} failed: ${e instanceof Error?e.message:String(e)}`,T.TransportSendFailed,500,t)),this._router.closeStream(i)}),{stream:u,turnId:i,cancel:async()=>this.cancel({turnId:i})}}async regenerate(e,t){this._logger.trace(`ClientTransport.regenerate();`,{messageId:e});let n=this._tree.getNode(e)?.parentId;return this.send([],{...t,body:{history:this._getHistoryBefore(e),...t?.body},forkOf:e,parent:n})}async edit(e,t,n){this._logger.trace(`ClientTransport.edit();`,{messageId:e});let r=this._tree.getNode(e)?.parentId;return this.send(t,{...n,body:{history:this._getHistoryBefore(e),...n?.body},forkOf:e,parent:r})}async cancel(e){if(this._closed)return;let t=e??{own:!0};this._logger.debug(`ClientTransport.cancel();`,{filter:t}),await this._publishCancel(t),this._closeMatchingTurnStreams(t)}async waitForTurn(e){if(this._closed)return;let t=e??{own:!0},n=this._getMatchingTurnIds(t);if(n.size!==0)return this._logger.debug(`ClientTransport.waitForTurn();`,{turnIds:[...n]}),new Promise(e=>{let t=r=>{r.type===`x-ably-turn-end`&&(n.delete(r.turnId),n.size===0&&(this._emitter.off(`turn`,t),e()))};this._emitter.on(`turn`,t)})}on(e,t){if(this._closed)return G;let n=t;return this._emitter.on(e,n),()=>{this._emitter.off(e,n)}}getTree(){return this._tree}getActiveTurnIds(){let e=new Map;for(let[t,n]of this._turnClientIds){let r=e.get(n);r||(r=new Set,e.set(n,r)),r.add(t)}return e}getMessageHeaders(e){let t=this._codec.getMessageKey(e);return this._tree.getNodeByKey(t)?.headers}getMessages(){return this._withheldKeys.size===0?this._tree.flatten():this._tree.flatten().filter(e=>!this._withheldKeys.has(this._codec.getMessageKey(e)))}getMessagesWithHeaders(){return this._getMessagesWithHeaders()}getAblyMessages(){return[...this._ablyMessages]}async history(e){if(this._closed)throw new n.ErrorInfo(`unable to load history; transport is closed`,T.TransportClosed,400);this._logger.trace(`ClientTransport.history();`,{limit:e?.limit});let t=e?.limit??100,r=new Set(this._tree.flatten().map(e=>this._codec.getMessageKey(e))),i=await V(this._channel,this._codec,e,this._logger),a=await this._loadUntilVisible(i,t,r);i=a.lastPage;let o=a.newVisible;for(let e of o)this._withheldKeys.add(this._codec.getMessageKey(e));let s=o.slice(-t),c=o.slice(0,-t);this._releaseWithheld(s);let l=e=>({items:e,hasNext:()=>c.length>0||i.hasNext(),next:async()=>{if(c.length>0){let e=c.splice(-t,t);return this._releaseWithheld(e),l(e)}if(!i.hasNext())return;let e=await i.next();if(!e)return;let n=new Set(r);for(let e of this._tree.flatten())n.add(this._codec.getMessageKey(e));let a=await this._loadUntilVisible(e,t,n);i=a.lastPage;let o=a.newVisible;for(let e of o)this._withheldKeys.add(this._codec.getMessageKey(e));let s=o.splice(-t,t);if(c.push(...o),this._releaseWithheld(s),s.length!==0)return l(s)}});return l(s)}async close(e){if(!this._closed){if(this._closed=!0,this._logger.info(`ClientTransport.close();`),e?.cancel){try{await this._publishCancel(e.cancel)}catch{}this._closeMatchingTurnStreams(e.cancel)}this._channel.unsubscribe(this._onMessage);for(let e of this._ownTurnIds)this._router.closeStream(e);this._turnObservers.clear(),this._emitter.off(),this._ownTurnIds.clear(),this._ownMsgIds.clear(),this._turnMsgIds.clear(),this._turnClientIds.clear(),this._withheldKeys.clear(),this._ablyMessages.length=0}}},q=e=>new K(e);e.useAblyMessages=u,e.useActiveTurns=w,e.useClientTransport=e=>{let n=(0,t.useRef)(null);return n.current===null&&(n.current=q(e)),n.current},e.useConversationTree=e=>{let[n,r]=(0,t.useState)(()=>e.getMessages());return(0,t.useEffect)(()=>(r(e.getMessages()),e.on(`message`,()=>{r(e.getMessages())})),[e]),{messages:n,getSiblings:(0,t.useCallback)(t=>e.getTree().getSiblings(t),[e]),hasSiblings:(0,t.useCallback)(t=>e.getTree().hasSiblings(t),[e]),getSelectedIndex:(0,t.useCallback)(t=>e.getTree().getSelectedIndex(t),[e]),selectSibling:(0,t.useCallback)((t,n)=>{e.getTree().select(t,n),r(e.getMessages())},[e])}},e.useEdit=e=>(0,t.useCallback)(async(t,n,r)=>e.edit(t,n,r),[e]),e.useHistory=(e,n)=>{let[r,i]=(0,t.useState)(!1),[a,o]=(0,t.useState)(!1),s=(0,t.useRef)(!1),c=(0,t.useRef)(null),l=(0,t.useRef)(e);l.current=e;let u=(0,t.useCallback)(async e=>{if(!(!l.current||s.current)){s.current=!0,o(!0);try{let t=await l.current.history(e);c.current=t,i(t.hasNext())}finally{s.current=!1,o(!1)}}},[]),d=(0,t.useCallback)(async()=>{let e=c.current;if(!(!e||!e.hasNext()||s.current||!l.current)){s.current=!0,o(!0);try{let t=await e.next();t?(c.current=t,i(t.hasNext())):i(!1)}finally{s.current=!1,o(!1)}}},[]),f=n!=null,p=(0,t.useRef)(!1),m=(0,t.useRef)(n);return m.current=n,(0,t.useEffect)(()=>{!f||p.current||!l.current||(p.current=!0,u(m.current??void 0))},[f,u]),{hasNext:r,loading:a,load:u,next:d}},e.useMessages=e=>{let[n,r]=(0,t.useState)(()=>e.getMessages());return(0,t.useEffect)(()=>(r(e.getMessages()),e.on(`message`,()=>{r(e.getMessages())})),[e]),n},e.useRegenerate=e=>(0,t.useCallback)(async(t,n)=>e.regenerate(t,n),[e]),e.useSend=e=>(0,t.useCallback)(async(t,n)=>e.send(t,n),[e])});
+//# sourceMappingURL=ably-ai-transport-react.umd.cjs.map