feat: import serializers stuff from livekit-client instead

Author: 1egoman

packages/react/etc/components-react.api.md

@@ -675,20 +675,6 @@ export const ScreenShareIcon: (props: SVGProps<SVGSVGElement>) => React_2.JSX.El
 // @internal (undocumented)
 export const ScreenShareStopIcon: (props: SVGProps<SVGSVGElement>) => React_2.JSX.Element;
 
-// @beta
-export type Serializer<Input = any, Output = any> = {
-    symbol: typeof SerializerSymbol;
-    parse: (raw: string) => Input;
-    serialize: (val: Output) => string;
-};
-
-// @beta
-export const serializers: {
-    json: typeof json;
-    raw: typeof raw;
-    custom: typeof custom;
-};
-
 // @beta (undocumented)
 export type SessionCallbacks = {
     [SessionEvent.ConnectionStateChanged]: (newAgentConnectionState: ConnectionState_2) => void;
@@ -1525,9 +1511,6 @@ export { WidgetState }
 //
 // src/context/layout-context.ts:10:3 - (ae-forgotten-export) The symbol "PinContextType" needs to be exported by the entry point index.docs.d.ts
 // src/context/layout-context.ts:11:3 - (ae-forgotten-export) The symbol "WidgetContextType" needs to be exported by the entry point index.docs.d.ts
-// src/hooks/useRpc.ts:95:25 - (ae-forgotten-export) The symbol "json" needs to be exported by the entry point index.docs.d.ts
-// src/hooks/useRpc.ts:95:25 - (ae-forgotten-export) The symbol "raw" needs to be exported by the entry point index.docs.d.ts
-// src/hooks/useRpc.ts:95:25 - (ae-forgotten-export) The symbol "custom" needs to be exported by the entry point index.docs.d.ts
 
 // (No @packageDocumentation comment for this package)
 

packages/react/src/hooks/index.ts

@@ -71,12 +71,10 @@ export {
 export * from './useEvents';
 export * from './useSessionMessages';
 export {
-  type Serializer,
   type RpcHandler,
   type RpcCallParams,
   type UseRpcOptions,
   type RpcCallFn,
   type UseRpcReturn,
-  serializers,
   useRpc,
 } from './useRpc';

packages/react/src/hooks/useRpc.ts

@@ -1,99 +1,18 @@
 import * as React from 'react';
-import { RpcError, type RpcInvocationData, type PerformRpcParams } from 'livekit-client';
+import {
+  RpcError,
+  type RpcInvocationData,
+  type PerformRpcParams,
+  type Serializer,
+  isSerializer,
+  type SerializerInput,
+  type SerializerOutput,
+  serializers,
+} from 'livekit-client';
 
 import { useEnsureSession } from '../context';
 import { isUseSessionReturn, type UseSessionReturn } from './useSession';
 
-// ---------------------------------------------------------------------------
-// Serializer types + infrastructure
-// ---------------------------------------------------------------------------
-
-const SerializerSymbol = Symbol.for('lk.serializer');
-
-/**
- * A bidirectional data format descriptor for RPC payloads.
- *
- * - `parse(raw)` decodes an incoming wire string into `Input` (used by handlers)
- * - `serialize(val)` encodes an `Output` value to a wire string (used by handlers)
- *
- * For symmetric serializers (`serializers.raw`), `Input === Output === string`.
- * For `serializers.json`, both default to `any` so each handler can annotate its own types.
- * Use `serializers.custom` to supply your own `parse`/`serialize` pair.
- *
- * @beta
- */
-export type Serializer<Input = any, Output = any> = {
-  symbol: typeof SerializerSymbol;
-  parse: (raw: string) => Input;
-  serialize: (val: Output) => string;
-};
-
-function isSerializer(v: unknown): v is Serializer<any, any> {
-  return (
-    typeof v === 'object' &&
-    v !== null &&
-    'symbol' in v &&
-    (v as Record<string, unknown>)['symbol'] === SerializerSymbol
-  );
-}
-
-// Extract Input/Output from a Serializer type for use in handler/performRpc constraints.
-type SerializerInput<S> = S extends Serializer<infer Input, any> ? Input : any;
-type SerializerOutput<S> = S extends Serializer<any, infer Output> ? Output : any;
-
-/** @internal */
-function base<Input = any, Output = any>(
-  params: Omit<Serializer<Input, Output>, 'symbol'>,
-): Serializer<Input, Output> {
-  return { ...params, symbol: SerializerSymbol };
-}
-
-/**
- * JSON serializer — `JSON.parse` on the way in, `JSON.stringify` on the way out.
- * Defaults to `any` so individual handlers can annotate their own payload types.
- */
-function json<Input = any, Output = any>(): Serializer<Input, Output> {
-  return base({
-    parse: (raw: string) => JSON.parse(raw) as Input,
-    serialize: (val: unknown) => JSON.stringify(val),
-  });
-}
-
-/** Raw string serializer — passes payloads through as plain strings with no encoding. */
-function raw() {
-  return base({
-    parse: (raw: string) => raw,
-    serialize: (val: string) => val,
-  });
-}
-
-/** Custom serializer - allows custom defined parse and serialize functions */
-function custom<Input = any, Output = any>(
-  params: Omit<Serializer<Input, Output>, 'symbol'>,
-): Serializer<Input, Output> {
-  return base(params);
-}
-
-/**
- * Serializer helpers for RPC payload encoding.
- *
- * @example
- * ```ts
- * // Inline handler — types inferred
- * useRpc(session, "myMethod", async (payload: MyInput) => myOutput);
- *
- * // Override default serializer for a handler
- * useRpc(session, "myMethod", async (payload) => payload, { serializer: serializers.raw() });
- *
- * // Manual serializer instances
- * const a = serializers.raw(); // Serializer<string, string>
- * const b = serializer.json<{ foo: string }, { bar: string }>(); // Serializer<{ foo: string }, { bar: string }>
- * ```
- *
- * @beta
- */
-export const serializers = { json, raw, custom };
-
 // ---------------------------------------------------------------------------
 // RPC types
 // ---------------------------------------------------------------------------