@piedata/pieui 2.0.4 → 2.0.6

package/dist/util/mittAgentTools.d.ts

@@ -0,0 +1,89 @@
+import { tool } from '@openai/agents';
+import type { Emitter } from 'mitt';
+import { type MittEvents } from './mitt';
+/**
+ * Descriptor passed to the customization callbacks on
+ * {@link MittAgentToolsOptions}.
+ */
+export type MittAgentToolDescriptor = {
+    /** Method key originally registered on the `PieCard.methods` map. */
+    methodName: string;
+    /** Value of `data.name` on the target `PieCard`. */
+    cardName: string;
+    /** Raw mitt event name (`pie{methodName}_{cardName}`). */
+    eventName: string;
+};
+/**
+ * Options accepted by {@link getMittAgentTools} and
+ * {@link usePieMittAgentTools}.
+ */
+export type MittAgentToolsOptions = {
+    /**
+     * Optional predicate invoked for each discovered PieCard method. Return
+     * `false` to omit the event from the generated tool list. Defaults to
+     * accepting everything.
+     */
+    filter?: (descriptor: MittAgentToolDescriptor) => boolean;
+    /**
+     * Optional override for the tool description surfaced to the model.
+     * Defaults to a generic string mentioning the card and method.
+     */
+    describe?: (descriptor: MittAgentToolDescriptor) => string;
+    /**
+     * Optional override for the public tool name. Defaults to
+     * `{cardName}_{methodName}`. The returned value must be unique within the
+     * final tool set.
+     */
+    nameFor?: (descriptor: MittAgentToolDescriptor) => string;
+};
+/**
+ * Return type of {@link getMittAgentTools}. We intentionally keep this loose
+ * rather than importing the deeply-parameterized `FunctionTool` generic from
+ * `@openai/agents-core` — callers typically feed the result directly into
+ * `new Agent({ tools: [...] })` which accepts any tool-shaped value.
+ */
+export type MittAgentTool = ReturnType<typeof tool>;
+/**
+ * Scans a mitt emitter for all currently-registered PieCard methods (events
+ * matching `pie{methodName}_{cardName}`) and wraps each one as an
+ * `@openai/agents` function tool.
+ *
+ * Calling a returned tool re-emits the matching mitt event with the
+ * `payload` argument supplied by the model. Because mitt listeners run
+ * synchronously in-process, the tool executes entirely locally with no
+ * network hop.
+ *
+ * This takes a *snapshot* of the emitter at the moment it is called — cards
+ * that mount afterwards will not be represented until the function is called
+ * again. Prefer {@link usePieMittAgentTools} from inside React components so
+ * the snapshot refreshes whenever the surrounding tree re-renders.
+ *
+ * @param emitter The mitt emitter to scan. Defaults to the global PieUI
+ *                singleton returned by {@link getEmitter}.
+ * @param options See {@link MittAgentToolsOptions}.
+ * @returns An array of `@openai/agents` function tools, one per discovered
+ *          PieCard method.
+ */
+export declare function getMittAgentTools(emitter?: Emitter<MittEvents>, options?: MittAgentToolsOptions): MittAgentTool[];
+/**
+ * React hook wrapper around {@link getMittAgentTools}. Reads the emitter from
+ * {@link MittContext} — falling back to the global singleton returned by
+ * {@link getEmitter} when used outside of a PieRoot — and memoizes the
+ * resulting tool array by a sorted snapshot of registered event names so the
+ * returned reference is stable across renders that don't add or remove
+ * PieCard methods.
+ *
+ * Because mitt does not emit a "handler-added" notification, the hook only
+ * refreshes its snapshot when the calling component re-renders. If you need
+ * to react to cards mounting at arbitrary times, trigger a re-render from the
+ * consumer or call {@link getMittAgentTools} imperatively right before you
+ * build the `Agent`.
+ *
+ * @example
+ * ```tsx
+ * const tools = usePieMittAgentTools()
+ * const agent = useMemo(() => new Agent({ name: 'UI', tools }), [tools])
+ * ```
+ */
+export declare function usePieMittAgentTools(options?: MittAgentToolsOptions): MittAgentTool[];
+//# sourceMappingURL=mittAgentTools.d.ts.map

package/dist/util/mittAgentTools.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"mittAgentTools.d.ts","sourceRoot":"","sources":["../../src/util/mittAgentTools.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,IAAI,EAAE,MAAM,gBAAgB,CAAA;AAErC,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,MAAM,CAAA;AACnC,OAAoB,EAAc,KAAK,UAAU,EAAE,MAAM,QAAQ,CAAA;AAWjE;;;GAGG;AACH,MAAM,MAAM,uBAAuB,GAAG;IAClC,qEAAqE;IACrE,UAAU,EAAE,MAAM,CAAA;IAClB,oDAAoD;IACpD,QAAQ,EAAE,MAAM,CAAA;IAChB,0DAA0D;IAC1D,SAAS,EAAE,MAAM,CAAA;CACpB,CAAA;AAED;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAChC;;;;OAIG;IACH,MAAM,CAAC,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,OAAO,CAAA;IACzD;;;OAGG;IACH,QAAQ,CAAC,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,MAAM,CAAA;IAC1D;;;;OAIG;IACH,OAAO,CAAC,EAAE,CAAC,UAAU,EAAE,uBAAuB,KAAK,MAAM,CAAA;CAC5D,CAAA;AAED;;;;;GAKG;AACH,MAAM,MAAM,aAAa,GAAG,UAAU,CAAC,OAAO,IAAI,CAAC,CAAA;AAEnD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,wBAAgB,iBAAiB,CAC7B,OAAO,GAAE,OAAO,CAAC,UAAU,CAAgB,EAC3C,OAAO,GAAE,qBAA0B,GACpC,aAAa,EAAE,CAqDjB;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,oBAAoB,CAChC,OAAO,GAAE,qBAA0B,GACpC,aAAa,EAAE,CAsBjB"}

package/dist/util/navigate.d.ts

@@ -1,4 +1,15 @@
+/**
+ * Signature of the navigation callback supplied to a PieRoot via its
+ * `onNavigate` prop. Implementations typically forward the url to the host
+ * router (Next.js, React Router, Telegram Mini App navigation, …).
+ */
 export type NavigateFunction = (_: string) => void;
+/**
+ * React context that exposes the host application's navigation function to
+ * any PieUI component that needs to change routes (e.g. `AutoRedirectCard`,
+ * anchor components). `undefined` means no handler was provided — consumers
+ * should fall back to a native `window.location` assignment in that case.
+ */
 declare const NavigateContext: import("react").Context<NavigateFunction | undefined>;
 export default NavigateContext;
 //# sourceMappingURL=navigate.d.ts.map

package/dist/util/navigate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/util/navigate.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;AAElD,QAAA,MAAM,eAAe,uDAAyD,CAAA;AAE9E,eAAe,eAAe,CAAA"}
+{"version":3,"file":"navigate.d.ts","sourceRoot":"","sources":["../../src/util/navigate.ts"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,MAAM,MAAM,gBAAgB,GAAG,CAAC,CAAC,EAAE,MAAM,KAAK,IAAI,CAAA;AAElD;;;;;GAKG;AACH,QAAA,MAAM,eAAe,uDAAyD,CAAA;AAE9E,eAAe,eAAe,CAAA"}

package/dist/util/pieConfig.d.ts

@@ -1,17 +1,52 @@
 import { PieConfig } from '../types';
+/**
+ * React context that carries the {@link PieConfig} object supplied to a
+ * PieRoot. All runtime configuration (API server URL, Centrifuge URL,
+ * logging flag, page processor mode) flows through this context so that
+ * utilities can be plain hooks instead of reading from `process.env`.
+ */
 export declare const PieConfigContext: import("react").Context<PieConfig | null>;
+/**
+ * Returns the current {@link PieConfig} from {@link PieConfigContext}.
+ *
+ * @throws Error When called outside of a PieRoot — the context will be
+ *               `null` and no sensible default exists.
+ * @returns The config object provided to the enclosing PieRoot.
+ */
 export declare const usePieConfig: () => PieConfig;
+/**
+ * Convenience hook returning the `apiServer` field from the current
+ * {@link PieConfig}. Must be called inside a PieRoot.
+ */
 export declare const useApiServer: () => string;
 /** @deprecated Use useApiServer() instead */
 export declare const getApiServer: () => string;
+/**
+ * Convenience hook returning the `centrifugeServer` field from the current
+ * {@link PieConfig}. Returns `undefined` when Centrifuge is not configured.
+ */
 export declare const useCentrifugeServer: () => string | undefined;
 /** @deprecated Use useCentrifugeServer() instead */
 export declare const getCentrifugeServer: () => string | undefined;
+/**
+ * Convenience hook returning the `enableRenderingLog` flag from the current
+ * {@link PieConfig}. Used by internal components to gate verbose logging.
+ */
 export declare const useIsRenderingLogEnabled: () => boolean | undefined;
 /** @deprecated Use useIsRenderingLogEnabled() instead */
 export declare const isRenderingLogEnabled: () => boolean | undefined;
+/**
+ * Convenience hook returning the `pageProcessor` field from the current
+ * {@link PieConfig}. Used by root components to decide how the page should
+ * be initialized (for example, whether to auto-expand Telegram WebApp).
+ */
 export declare const usePageProcessor: () => string | undefined;
 /** @deprecated Use usePageProcessor() instead */
 export declare const getPageProcessor: () => string | undefined;
+/**
+ * Separator token used by {@link pieName} to build nested component names
+ * of the form `parent{PIEBREAK}child`. Keeping it in one place ensures the
+ * UI configuration generator and the runtime agree on the delimiter.
+ */
 export declare const PIEBREAK = "__piedemo__";
 //# sourceMappingURL=pieConfig.d.ts.map

package/dist/util/pieConfig.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pieConfig.d.ts","sourceRoot":"","sources":["../../src/util/pieConfig.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC,eAAO,MAAM,gBAAgB,2CAAwC,CAAA;AAErE,eAAO,MAAM,YAAY,iBAMxB,CAAA;AAED,eAAO,MAAM,YAAY,cAGxB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,YAAY,cAAe,CAAA;AAExC,eAAO,MAAM,mBAAmB,0BAG/B,CAAA;AAED,oDAAoD;AACpD,eAAO,MAAM,mBAAmB,0BAAsB,CAAA;AAEtD,eAAO,MAAM,wBAAwB,2BAGpC,CAAA;AAED,yDAAyD;AACzD,eAAO,MAAM,qBAAqB,2BAA2B,CAAA;AAE7D,eAAO,MAAM,gBAAgB,0BAG5B,CAAA;AAED,iDAAiD;AACjD,eAAO,MAAM,gBAAgB,0BAAmB,CAAA;AAEhD,eAAO,MAAM,QAAQ,gBAAgB,CAAA"}
+{"version":3,"file":"pieConfig.d.ts","sourceRoot":"","sources":["../../src/util/pieConfig.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;;GAKG;AACH,eAAO,MAAM,gBAAgB,2CAAwC,CAAA;AAErE;;;;;;GAMG;AACH,eAAO,MAAM,YAAY,iBAMxB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,YAAY,cAGxB,CAAA;AAED,6CAA6C;AAC7C,eAAO,MAAM,YAAY,cAAe,CAAA;AAExC;;;GAGG;AACH,eAAO,MAAM,mBAAmB,0BAG/B,CAAA;AAED,oDAAoD;AACpD,eAAO,MAAM,mBAAmB,0BAAsB,CAAA;AAEtD;;;GAGG;AACH,eAAO,MAAM,wBAAwB,2BAGpC,CAAA;AAED,yDAAyD;AACzD,eAAO,MAAM,qBAAqB,2BAA2B,CAAA;AAE7D;;;;GAIG;AACH,eAAO,MAAM,gBAAgB,0BAG5B,CAAA;AAED,iDAAiD;AACjD,eAAO,MAAM,gBAAgB,0BAAmB,CAAA;AAEhD;;;;GAIG;AACH,eAAO,MAAM,QAAQ,gBAAgB,CAAA"}

package/dist/util/pieName.d.ts

@@ -1,2 +1,14 @@
+/**
+ * Composes a nested PieUI component name of the form `parent{PIEBREAK}child`.
+ *
+ * PieUI uses this convention to identify inputs/cards that belong to a
+ * structured parent (for example, a single field inside a composite form).
+ * The separator is defined by {@link PIEBREAK} so that runtime and UI config
+ * generators cannot drift apart.
+ *
+ * @param name  Name of the enclosing component.
+ * @param child Name of the nested child/field.
+ * @returns The joined name string.
+ */
 export declare const pieName: (name: string, child: string) => string;
 //# sourceMappingURL=pieName.d.ts.map

package/dist/util/pieName.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pieName.d.ts","sourceRoot":"","sources":["../../src/util/pieName.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,WACnB,CAAA"}
+{"version":3,"file":"pieName.d.ts","sourceRoot":"","sources":["../../src/util/pieName.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,OAAO,GAAI,MAAM,MAAM,EAAE,OAAO,MAAM,WACnB,CAAA"}

package/dist/util/piecache.d.ts

@@ -1,4 +1,19 @@
 import { ReactNode } from 'react';
 import { UIConfigType } from '../types';
+/**
+ * Picks the appropriate "loading" view for a PieRoot based on the provided
+ * `piecache`.
+ *
+ * If a cached `UIConfigType` exists for the current pathname (the leading
+ * slash is stripped before lookup), the helper returns a `<UILoading>`
+ * component rendering that cached configuration — this lets users see the
+ * last known shell of a page instantly on navigation. When no cache entry
+ * matches, the caller's own `fallback` node is returned instead.
+ *
+ * @param pathname Current route pathname (with or without a leading `/`).
+ * @param piecache Optional map of `pathname → cached UIConfig`.
+ * @param fallback Caller-provided fallback node used when the cache misses.
+ * @returns The cached loading UI, the original fallback, or `undefined`.
+ */
 export declare function resolvePieCacheFallback(pathname: string, piecache: Record<string, UIConfigType> | undefined, fallback: ReactNode | undefined): ReactNode | undefined;
 //# sourceMappingURL=piecache.d.ts.map

package/dist/util/piecache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"piecache.d.ts","sourceRoot":"","sources":["../../src/util/piecache.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGvC,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,EAClD,QAAQ,EAAE,SAAS,GAAG,SAAS,GAChC,SAAS,GAAG,SAAS,CAQvB"}
+{"version":3,"file":"piecache.d.ts","sourceRoot":"","sources":["../../src/util/piecache.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,OAAO,CAAA;AACjC,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAGvC;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,uBAAuB,CACnC,QAAQ,EAAE,MAAM,EAChB,QAAQ,EAAE,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,GAAG,SAAS,EAClD,QAAQ,EAAE,SAAS,GAAG,SAAS,GAChC,SAAS,GAAG,SAAS,CAQvB"}

package/dist/util/registry.d.ts

@@ -1,12 +1,61 @@
 import { ComponentMetadata, ComponentRegistration } from '../types';
 import { ComponentType } from 'react';
+/**
+ * Central in-memory registry of PieUI components keyed by their name. Every
+ * call to {@link registerPieComponent} writes into this `Map`, and the
+ * dynamic UI renderer reads from it at render time to resolve a `card` name
+ * to a concrete React component.
+ */
 export declare const registry: Map<string, ComponentRegistration<any>>;
+/**
+ * Registers a PieUI component so it can be rendered by name from a dynamic
+ * UI configuration.
+ *
+ * The registration must provide at least a `name` and either a `component`
+ * or a `loader` (for code-split modules). When only `loader` is given, the
+ * helper wraps it in {@link trackLazy} automatically and the resulting
+ * `React.lazy` component is what gets stored.
+ *
+ * @param registration Shape describing the component, its metadata, and how
+ *                     to load it.
+ * @returns The concrete (possibly lazy) component that was stored.
+ * @throws  Error When `name` is missing or neither `component` nor `loader`
+ *                was supplied.
+ */
 export declare function registerPieComponent<TProps>(registration: ComponentRegistration<TProps>): ComponentType<TProps> | undefined;
+/**
+ * Convenience wrapper that calls {@link registerPieComponent} for each item
+ * in the provided array. Useful when a package exports a catalogue of cards
+ * that should all be registered at once.
+ */
 export declare const registerMultipleComponents: (components: ComponentRegistration<any>[]) => void;
+/**
+ * Removes a previously registered component from the registry. Subsequent
+ * renders of that name will fall back to the default "unknown component"
+ * behaviour of the dynamic renderer.
+ */
 export declare const unregisterComponent: (name: string) => void;
+/**
+ * Returns `true` when a component with the given name has been registered.
+ */
 export declare const hasComponent: (name: string) => boolean;
+/**
+ * Returns the `metadata` object supplied at registration time, or
+ * `undefined` when the component was not registered or had no metadata.
+ */
 export declare const getComponentMeta: (name: string) => ComponentMetadata | undefined;
+/**
+ * Returns the full {@link ComponentRegistration} entry for the given name,
+ * including any `fallback` node and the normalized component reference.
+ */
 export declare const getRegistryEntry: (name: string) => ComponentRegistration<any> | undefined;
+/**
+ * Returns the list of names of every currently-registered PieUI component.
+ * Handy for debugging and for the `pieui postbuild` CLI manifest generator.
+ */
 export declare const getAllRegisteredComponents: () => string[];
+/**
+ * Returns the number of components currently in the registry.
+ */
 export declare const getRegistrySize: () => number;
 //# sourceMappingURL=registry.d.ts.map

package/dist/util/registry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAEnE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAErC,eAAO,MAAM,QAAQ,yCAAgD,CAAA;AAoCrE,wBAAgB,oBAAoB,CAAC,MAAM,EACvC,YAAY,EAAE,qBAAqB,CAAC,MAAM,CAAC,GAC5C,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAInC;AAED,eAAO,MAAM,0BAA0B,GACnC,YAAY,qBAAqB,CAAC,GAAG,CAAC,EAAE,SAG3C,CAAA;AAED,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,SAE/C,CAAA;AAED,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,YAExC,CAAA;AAED,eAAO,MAAM,gBAAgB,GACzB,MAAM,MAAM,KACb,iBAAiB,GAAG,SAEtB,CAAA;AAED,eAAO,MAAM,gBAAgB,GACzB,MAAM,MAAM,KACb,qBAAqB,CAAC,GAAG,CAAC,GAAG,SAE/B,CAAA;AAED,eAAO,MAAM,0BAA0B,QAAO,MAAM,EAEnD,CAAA;AAED,eAAO,MAAM,eAAe,QAAO,MAElC,CAAA"}
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../src/util/registry.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,qBAAqB,EAAE,MAAM,UAAU,CAAA;AAEnE,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAA;AAErC;;;;;GAKG;AACH,eAAO,MAAM,QAAQ,yCAAgD,CAAA;AAoCrE;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAAC,MAAM,EACvC,YAAY,EAAE,qBAAqB,CAAC,MAAM,CAAC,GAC5C,aAAa,CAAC,MAAM,CAAC,GAAG,SAAS,CAInC;AAED;;;;GAIG;AACH,eAAO,MAAM,0BAA0B,GACnC,YAAY,qBAAqB,CAAC,GAAG,CAAC,EAAE,SAG3C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,SAE/C,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,YAAY,GAAI,MAAM,MAAM,YAExC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GACzB,MAAM,MAAM,KACb,iBAAiB,GAAG,SAEtB,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,gBAAgB,GACzB,MAAM,MAAM,KACb,qBAAqB,CAAC,GAAG,CAAC,GAAG,SAE/B,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,0BAA0B,QAAO,MAAM,EAEnD,CAAA;AAED;;GAEG;AACH,eAAO,MAAM,eAAe,QAAO,MAElC,CAAA"}

package/dist/util/socket.d.ts

@@ -1,5 +1,27 @@
 import { Socket } from 'socket.io-client';
+/**
+ * Returns a cached Socket.IO client for the given PieUI API server, creating
+ * one on first access.
+ *
+ * The client is configured with `autoConnect: false` so that the enclosing
+ * `SocketIOInitProvider` is in charge of connecting after any necessary
+ * handshake (e.g. token fetch, `window.sid` assignment). Only the
+ * `websocket` transport is enabled — long-polling is explicitly disabled to
+ * keep connection semantics predictable across hosts.
+ *
+ * Calling the function repeatedly with the same `apiServer` always returns
+ * the same instance, which is important because PieCard subscriptions rely
+ * on a shared socket.
+ *
+ * @param apiServer Base URL of the PieUI API server.
+ * @returns A shared `Socket` instance for that server.
+ */
 export declare const getSocket: (apiServer: string) => Socket;
+/**
+ * React context that exposes the active Socket.IO client to components
+ * rendered inside a PieRoot. `PieCard` reads it to register `pie*` event
+ * listeners corresponding to its `methods` map.
+ */
 declare const SocketIOContext: import("react").Context<Socket<import("@socket.io/component-emitter").DefaultEventsMap, import("@socket.io/component-emitter").DefaultEventsMap> | null>;
 export default SocketIOContext;
 //# sourceMappingURL=socket.d.ts.map

package/dist/util/socket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/util/socket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAM,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAK7C,eAAO,MAAM,SAAS,GAAI,WAAW,MAAM,KAAG,MAU7C,CAAA;AAED,QAAA,MAAM,eAAe,0JAAqC,CAAA;AAE1D,eAAe,eAAe,CAAA"}
+{"version":3,"file":"socket.d.ts","sourceRoot":"","sources":["../../src/util/socket.ts"],"names":[],"mappings":"AAEA,OAAO,EAAM,MAAM,EAAE,MAAM,kBAAkB,CAAA;AAK7C;;;;;;;;;;;;;;;;GAgBG;AACH,eAAO,MAAM,SAAS,GAAI,WAAW,MAAM,KAAG,MAU7C,CAAA;AAED;;;;GAIG;AACH,QAAA,MAAM,eAAe,0JAAqC,CAAA;AAE1D,eAAe,eAAe,CAAA"}

package/dist/util/tailwindCommonUtils.d.ts

@@ -1,3 +1,17 @@
 import { type ClassValue } from 'clsx';
+/**
+ * Merges a list of Tailwind CSS class name inputs into a single deduplicated
+ * class string.
+ *
+ * First runs `clsx` to flatten arrays, booleans and object shorthand into a
+ * flat list, then pipes the result through `tailwind-merge` so that later
+ * utilities override earlier ones on the same property (e.g. `px-2 px-4`
+ * collapses to `px-4`). This is the canonical PieUI helper for composing
+ * className props.
+ *
+ * @param inputs Any combination of strings, arrays, objects or falsy values
+ *               accepted by `clsx`.
+ * @returns A merged, whitespace-separated class name string.
+ */
 export declare function cn(...inputs: ClassValue[]): string;
 //# sourceMappingURL=tailwindCommonUtils.d.ts.map

package/dist/util/tailwindCommonUtils.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tailwindCommonUtils.d.ts","sourceRoot":"","sources":["../../src/util/tailwindCommonUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}
+{"version":3,"file":"tailwindCommonUtils.d.ts","sourceRoot":"","sources":["../../src/util/tailwindCommonUtils.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,KAAK,UAAU,EAAE,MAAM,MAAM,CAAA;AAG5C;;;;;;;;;;;;;GAaG;AACH,wBAAgB,EAAE,CAAC,GAAG,MAAM,EAAE,UAAU,EAAE,UAEzC"}

package/dist/util/uiRenderer.d.ts

@@ -1,9 +1,23 @@
 import { ComponentType } from 'react';
 import { SetUiAjaxConfigurationType, UIConfigType } from '../types';
+/**
+ * Props accepted by any component installed as the active UI renderer.
+ *
+ * @property uiConfig               The declarative UI configuration to render.
+ * @property setUiAjaxConfiguration Optional setter forwarded by Ajax
+ *                                  containers so nested cards can update the
+ *                                  tree in response to AJAX calls.
+ */
 export type UIRendererProps = {
     uiConfig: UIConfigType;
     setUiAjaxConfiguration?: SetUiAjaxConfigurationType;
 };
+/**
+ * React context that exposes the active UI renderer component to nested
+ * cards. PieRoot variants populate this so that containers can render new
+ * `UIConfigType` subtrees (e.g. after an Ajax update) without importing the
+ * renderer module themselves, which would create a circular dependency.
+ */
 declare const UIRendererContext: import("react").Context<ComponentType<UIRendererProps> | null>;
 export default UIRendererContext;
 //# sourceMappingURL=uiRenderer.d.ts.map

package/dist/util/uiRenderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"uiRenderer.d.ts","sourceRoot":"","sources":["../../src/util/uiRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAiB,MAAM,OAAO,CAAA;AACpD,OAAO,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEnE,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,YAAY,CAAA;IACtB,sBAAsB,CAAC,EAAE,0BAA0B,CAAA;CACtD,CAAA;AAED,QAAA,MAAM,iBAAiB,gEAEtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"uiRenderer.d.ts","sourceRoot":"","sources":["../../src/util/uiRenderer.tsx"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAiB,MAAM,OAAO,CAAA;AACpD,OAAO,EAAE,0BAA0B,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEnE;;;;;;;GAOG;AACH,MAAM,MAAM,eAAe,GAAG;IAC1B,QAAQ,EAAE,YAAY,CAAA;IACtB,sBAAsB,CAAC,EAAE,0BAA0B,CAAA;CACtD,CAAA;AAED;;;;;GAKG;AACH,QAAA,MAAM,iBAAiB,gEAEtB,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/util/useIsSupported.d.ts

@@ -1,2 +1,20 @@
+/**
+ * React hook that asks the PieUI backend whether a named feature/component is
+ * supported for the current user, and returns the boolean answer.
+ *
+ * The hook maintains two module-level caches:
+ * - `resultCache` stores resolved answers for the rest of the session, so
+ *   only the first caller actually hits the network;
+ * - `inflightCache` deduplicates concurrent requests for the same
+ *   `(apiServer, name)` pair, so multiple components mounting in the same
+ *   tick share one fetch.
+ *
+ * While the answer is being fetched the hook returns `null`, which callers
+ * can use to show a neutral/loading state.
+ *
+ * @param apiServer Base URL of the PieUI API server.
+ * @param name      Feature/component identifier passed as `api/support/{name}`.
+ * @returns `true`/`false` once known, or `null` while loading.
+ */
 export declare function useIsSupported(apiServer: string, name: string): boolean | null;
 //# sourceMappingURL=useIsSupported.d.ts.map

package/dist/util/useIsSupported.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useIsSupported.d.ts","sourceRoot":"","sources":["../../src/util/useIsSupported.ts"],"names":[],"mappings":"AAQA,wBAAgB,cAAc,CAC1B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACb,OAAO,GAAG,IAAI,CAiDhB"}
+{"version":3,"file":"useIsSupported.d.ts","sourceRoot":"","sources":["../../src/util/useIsSupported.ts"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC1B,SAAS,EAAE,MAAM,EACjB,IAAI,EAAE,MAAM,GACb,OAAO,GAAG,IAAI,CAiDhB"}

package/dist/util/useMaxWebApp.d.ts

@@ -1,6 +1,33 @@
 import { MaxWebApp, MaxWebAppData } from '../types';
+/**
+ * React hook that resolves the MAX (VK Messenger mini-app) WebApp object
+ * from `window.WebApp` and calls `ready()` on first access. Returns `null`
+ * on the server and when running outside of the MAX host, so callers can
+ * gracefully degrade.
+ */
 export declare const useMaxWebApp: () => MaxWebApp | null;
+/**
+ * Convenience hook that returns `[initDataUnsafe, initData]` from the MAX
+ * WebApp. Both values are `undefined` until the mini-app is ready or when
+ * running outside of the MAX host.
+ */
 export declare const useMaxInitData: () => readonly [MaxWebAppData | undefined, string | undefined];
+/**
+ * Wires up the MAX native BackButton.
+ *
+ * When `onBack` is provided, the back button is shown and will invoke the
+ * callback on press; the effect cleanly un-registers the listener and hides
+ * the button on unmount or when `onBack` changes. When the WebApp is not
+ * available (SSR or non-MAX host) the hook is a no-op and returns `null`.
+ *
+ * @param onBack Optional callback fired when the user taps the back button.
+ * @returns The native `BackButton` controller, or `null` when unavailable.
+ */
 export declare const useMaxBackButton: (onBack?: () => void) => MaxWebApp["BackButton"] | null;
+/**
+ * Returns the MAX `HapticFeedback` controller, or `null` when the WebApp is
+ * not available. Use it to trigger vibration/impact feedback in response to
+ * user interactions inside a MAX mini-app.
+ */
 export declare const useMaxHapticFeedback: () => MaxWebApp["HapticFeedback"] | null;
 //# sourceMappingURL=useMaxWebApp.d.ts.map

package/dist/util/useMaxWebApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useMaxWebApp.d.ts","sourceRoot":"","sources":["../../src/util/useMaxWebApp.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAEnD,eAAO,MAAM,YAAY,QAAO,SAAS,GAAG,IAc3C,CAAA;AAED,eAAO,MAAM,cAAc,QAAO,SAAS,CACvC,aAAa,GAAG,SAAS,EACzB,MAAM,GAAG,SAAS,CAKrB,CAAA;AAED,eAAO,MAAM,gBAAgB,GACzB,SAAS,MAAM,IAAI,KACpB,SAAS,CAAC,YAAY,CAAC,GAAG,IAgB5B,CAAA;AAED,eAAO,MAAM,oBAAoB,QAAO,SAAS,CAAC,gBAAgB,CAAC,GAAG,IAGrE,CAAA"}
+{"version":3,"file":"useMaxWebApp.d.ts","sourceRoot":"","sources":["../../src/util/useMaxWebApp.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,UAAU,CAAA;AAEnD;;;;;GAKG;AACH,eAAO,MAAM,YAAY,QAAO,SAAS,GAAG,IAc3C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,cAAc,QAAO,SAAS,CACvC,aAAa,GAAG,SAAS,EACzB,MAAM,GAAG,SAAS,CAKrB,CAAA;AAED;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,GACzB,SAAS,MAAM,IAAI,KACpB,SAAS,CAAC,YAAY,CAAC,GAAG,IAgB5B,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,oBAAoB,QAAO,SAAS,CAAC,gBAAgB,CAAC,GAAG,IAGrE,CAAA"}

package/dist/util/useOpenAIWebRTC.d.ts

@@ -1,14 +1,58 @@
+/**
+ * A single OpenAI Realtime event exchanged over the WebRTC data channel.
+ * `type` is always present; `event_id` and `timestamp` are auto-populated
+ * by the hook when missing. Any additional fields defined by the OpenAI
+ * Realtime API are passed through unchanged.
+ */
 export type OpenAIEvent = {
     type: string;
     event_id?: string;
     timestamp?: string;
     [key: string]: any;
 };
+/**
+ * Return type of {@link useOpenAIWebRTC}. Exposes the live session state
+ * and imperative controls for opening/closing a realtime voice session.
+ *
+ * @property isSessionActive Whether the peer connection is currently
+ *                           `connected` — updates in real time.
+ * @property startSession    Opens a new peer connection to the OpenAI
+ *                           Realtime API and attaches the configured audio
+ *                           element. Resolves once the data channel is
+ *                           open and safe to send on.
+ * @property stopSession     Stops microphone tracks, closes the peer
+ *                           connection, and releases all resources.
+ * @property sendTextMessage Queues a `conversation.item.create` + `response.create`
+ *                           pair on the data channel, waiting for the
+ *                           channel to open if necessary.
+ */
 export type UseOpenAIWebRTCReturn = {
     isSessionActive: boolean;
     startSession: (ephemeralKey: string, useMicrophone?: boolean) => Promise<void>;
     stopSession: () => void;
     sendTextMessage: (text: string) => void;
 };
+/**
+ * React hook that manages a realtime voice session with the OpenAI Realtime
+ * API over WebRTC.
+ *
+ * Usage flow:
+ * 1. Render an `<audio autoPlay />` element and pass its ref in as
+ *    `audioElement` — remote audio will be routed there.
+ * 2. Fetch an ephemeral key from your backend.
+ * 3. Call `startSession(ephemeralKey, useMicrophone?)`. When `useMicrophone`
+ *    is `false` the hook creates a silent local track so the peer connection
+ *    is still valid (useful for text-only demos).
+ * 4. Use `sendTextMessage(text)` to inject user turns and receive replies
+ *    via the `onEvent` callback.
+ * 5. Call `stopSession()` when done.
+ *
+ * All handlers are stable and safe to pass to dependent effects/memos.
+ *
+ * @param audioElement Target `<audio>` element used to play back the model's
+ *                     response audio. `null` disables playback routing.
+ * @param onEvent      Optional listener invoked for every incoming and
+ *                     outgoing realtime event (with `timestamp` populated).
+ */
 export default function useOpenAIWebRTC(audioElement?: HTMLAudioElement | null, onEvent?: (event: OpenAIEvent) => void): UseOpenAIWebRTCReturn;
 //# sourceMappingURL=useOpenAIWebRTC.d.ts.map

package/dist/util/useOpenAIWebRTC.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useOpenAIWebRTC.d.ts","sourceRoot":"","sources":["../../src/util/useOpenAIWebRTC.ts"],"names":[],"mappings":"AAIA,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACrB,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAChC,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,CACV,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,OAAO,KACtB,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC1C,CAAA;AAcD,MAAM,CAAC,OAAO,UAAU,eAAe,CACnC,YAAY,GAAE,gBAAgB,GAAG,IAAW,EAC5C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GACvC,qBAAqB,CAkKvB"}
+{"version":3,"file":"useOpenAIWebRTC.d.ts","sourceRoot":"","sources":["../../src/util/useOpenAIWebRTC.ts"],"names":[],"mappings":"AAIA;;;;;GAKG;AACH,MAAM,MAAM,WAAW,GAAG;IACtB,IAAI,EAAE,MAAM,CAAA;IACZ,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,SAAS,CAAC,EAAE,MAAM,CAAA;IAClB,CAAC,GAAG,EAAE,MAAM,GAAG,GAAG,CAAA;CACrB,CAAA;AAED;;;;;;;;;;;;;;;GAeG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAChC,eAAe,EAAE,OAAO,CAAA;IACxB,YAAY,EAAE,CACV,YAAY,EAAE,MAAM,EACpB,aAAa,CAAC,EAAE,OAAO,KACtB,OAAO,CAAC,IAAI,CAAC,CAAA;IAClB,WAAW,EAAE,MAAM,IAAI,CAAA;IACvB,eAAe,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,CAAA;CAC1C,CAAA;AAcD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,MAAM,CAAC,OAAO,UAAU,eAAe,CACnC,YAAY,GAAE,gBAAgB,GAAG,IAAW,EAC5C,OAAO,CAAC,EAAE,CAAC,KAAK,EAAE,WAAW,KAAK,IAAI,GACvC,qBAAqB,CAkKvB"}

package/dist/util/useWebApp.d.ts

@@ -1,6 +1,27 @@
 import { InitData, InitDataUnsafe, WebApp } from '../types';
+/**
+ * React hook that resolves the Telegram `WebApp` object from
+ * `window.Telegram.WebApp`, calls `ready()`, and optionally expands the
+ * viewport on iOS/Android when the current `pageProcessor` is
+ * `'telegram_expanded'`.
+ *
+ * When Telegram is not present (SSR, regular browsers, embedded previews)
+ * the hook silently returns `null`. Any error thrown by `ready()` is
+ * swallowed and forwarded to the caller-provided `onError` callback so
+ * that a failed init does not crash the tree.
+ *
+ * Accepts a single options object with an optional `onError` handler that
+ * fires when `wApp.ready()` throws.
+ *
+ * @returns The Telegram WebApp instance, or `null` when unavailable.
+ */
 export declare const useWebApp: ({ onError, }?: {
     onError?: () => void;
 }) => WebApp | null;
+/**
+ * Convenience hook returning the Telegram WebApp init payload as a tuple of
+ * `[initDataUnsafe, initData]`. Both values are `undefined` on the server
+ * and while Telegram is still initializing.
+ */
 export declare const useInitData: () => readonly [InitDataUnsafe | undefined, InitData | undefined];
 //# sourceMappingURL=useWebApp.d.ts.map

package/dist/util/useWebApp.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"useWebApp.d.ts","sourceRoot":"","sources":["../../src/util/useWebApp.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAE3D,eAAO,MAAM,SAAS,GAAI,eAEvB;IAAE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CAAO,KAAG,MAAM,GAAG,IA2B3C,CAAA;AAED,eAAO,MAAM,WAAW,QAAO,SAAS,CACpC,cAAc,GAAG,SAAS,EAC1B,QAAQ,GAAG,SAAS,CAKvB,CAAA"}
+{"version":3,"file":"useWebApp.d.ts","sourceRoot":"","sources":["../../src/util/useWebApp.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,QAAQ,EAAE,cAAc,EAAE,MAAM,EAAE,MAAM,UAAU,CAAA;AAE3D;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,SAAS,GAAI,eAEvB;IAAE,OAAO,CAAC,EAAE,MAAM,IAAI,CAAA;CAAO,KAAG,MAAM,GAAG,IA2B3C,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,WAAW,QAAO,SAAS,CACpC,cAAc,GAAG,SAAS,EAC1B,QAAQ,GAAG,SAAS,CAKvB,CAAA"}

package/dist/util/webrtcClient.d.ts

@@ -1,3 +1,26 @@
+/**
+ * Options accepted by {@link WebRTCClient}.
+ *
+ * @property endpoint            HTTP endpoint that exchanges SDP with the
+ *                               backend; must accept a POST of
+ *                               `{ sdp, type, webrtc_id }` and return the
+ *                               answer description.
+ * @property onConnected         Fires after `setRemoteDescription` succeeds.
+ * @property onDisconnected      Fires when `disconnect()` is invoked,
+ *                               regardless of whether a connection existed.
+ * @property onMessage           Invoked for every JSON-parsed message
+ *                               received on the `text` data channel.
+ * @property onAudioStream       Receives the remote `MediaStream` once
+ *                               negotiated so the caller can attach it to
+ *                               an audio element.
+ * @property onAudioLevel        Throttled average microphone level in
+ *                               `[0, 1]`. Updates roughly every 100ms.
+ * @property audioInputDeviceId  Optional `deviceId` constraint for
+ *                               `getUserMedia`.
+ * @property audioOutputDeviceId Output device id forwarded to the audio
+ *                               stream consumer via
+ *                               `options.audioOutputDeviceId`.
+ */
 interface WebRTCClientOptions {
     endpoint: string;
     onConnected?: () => void;
@@ -8,6 +31,15 @@ interface WebRTCClientOptions {
     audioInputDeviceId?: string;
     audioOutputDeviceId?: string;
 }
+/**
+ * Browser-side WebRTC helper that opens an audio peer connection to a PieUI
+ * backend endpoint, exchanges SDP, and exposes lightweight hooks for
+ * messaging and microphone level analysis.
+ *
+ * The class is safe to instantiate in SSR environments — `connect()` and
+ * device setters guard on `typeof window !== 'undefined'` and no-op on the
+ * server. Calling any method twice cleanly re-establishes the connection.
+ */
 export declare class WebRTCClient {
     private peerConnection;
     private mediaStream;
@@ -20,12 +52,41 @@ export declare class WebRTCClient {
     private currentInputDeviceId;
     private currentOutputDeviceId;
     constructor(options: WebRTCClientOptions);
+    /**
+     * Changes the active microphone device.
+     *
+     * If a peer connection is already open the client tears it down and
+     * re-connects with the new device, because WebRTC tracks cannot be
+     * swapped mid-session without renegotiation.
+     */
     setAudioInputDevice(deviceId: string): void;
+    /**
+     * Changes the preferred audio output device. Because the actual sink is
+     * attached to the `<audio>` element in the consumer code, the new
+     * `deviceId` is forwarded through `options.audioOutputDeviceId` so the
+     * `onAudioStream` callback can apply `HTMLAudioElement.setSinkId()`.
+     */
     setAudioOutputDevice(deviceId: string): void;
+    /**
+     * Opens a new peer connection: acquires the microphone, wires up audio
+     * analysis, creates a `text` data channel, exchanges SDP with the
+     * configured endpoint, and invokes `onConnected` on success.
+     *
+     * Throws user-friendly `Error`s for the two most common microphone
+     * failures (`NotAllowedError` → permission denied, `NotFoundError` →
+     * no device detected). Any other failure triggers `disconnect()` and
+     * the underlying error is re-thrown so the caller can react.
+     */
     connect(): Promise<void>;
     private setupAudioAnalysis;
     private startAnalysis;
     private stopAnalysis;
+    /**
+     * Tears the session down: stops the microphone tracks, closes the peer
+     * connection and data channel, releases the `AudioContext` used for
+     * level analysis, and invokes `onDisconnected`. Safe to call multiple
+     * times and on the server (no-op).
+     */
     disconnect(): void;
 }
 export {};

package/dist/util/webrtcClient.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"webrtcClient.d.ts","sourceRoot":"","sources":["../../src/util/webrtcClient.ts"],"names":[],"mappings":"AAAA,UAAU,mBAAmB;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAClC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;IAC7C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAKD,qBAAa,YAAY;IACrB,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,SAAS,CAAuC;IACxD,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,oBAAoB,CAAgC;IAC5D,OAAO,CAAC,qBAAqB,CAAgC;gBAEjD,OAAO,EAAE,mBAAmB;IAOxC,mBAAmB,CAAC,QAAQ,EAAE,MAAM;IAWpC,oBAAoB,CAAC,QAAQ,EAAE,MAAM;IAY/B,OAAO;IA4Gb,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,aAAa;IA+BrB,OAAO,CAAC,YAAY;IAiBpB,UAAU;CAqBb"}
+{"version":3,"file":"webrtcClient.d.ts","sourceRoot":"","sources":["../../src/util/webrtcClient.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,UAAU,mBAAmB;IACzB,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,CAAC,EAAE,MAAM,IAAI,CAAA;IACxB,cAAc,CAAC,EAAE,MAAM,IAAI,CAAA;IAC3B,SAAS,CAAC,EAAE,CAAC,OAAO,EAAE,GAAG,KAAK,IAAI,CAAA;IAClC,aAAa,CAAC,EAAE,CAAC,MAAM,EAAE,WAAW,KAAK,IAAI,CAAA;IAC7C,YAAY,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,IAAI,CAAA;IACtC,kBAAkB,CAAC,EAAE,MAAM,CAAA;IAC3B,mBAAmB,CAAC,EAAE,MAAM,CAAA;CAC/B;AAKD;;;;;;;;GAQG;AACH,qBAAa,YAAY;IACrB,OAAO,CAAC,cAAc,CAAiC;IACvD,OAAO,CAAC,WAAW,CAA2B;IAC9C,OAAO,CAAC,WAAW,CAA8B;IACjD,OAAO,CAAC,OAAO,CAAqB;IACpC,OAAO,CAAC,YAAY,CAA4B;IAChD,OAAO,CAAC,QAAQ,CAA4B;IAC5C,OAAO,CAAC,SAAS,CAAuC;IACxD,OAAO,CAAC,gBAAgB,CAAsB;IAC9C,OAAO,CAAC,oBAAoB,CAAgC;IAC5D,OAAO,CAAC,qBAAqB,CAAgC;gBAEjD,OAAO,EAAE,mBAAmB;IAMxC;;;;;;OAMG;IACH,mBAAmB,CAAC,QAAQ,EAAE,MAAM;IAUpC;;;;;OAKG;IACH,oBAAoB,CAAC,QAAQ,EAAE,MAAM;IAYrC;;;;;;;;;OASG;IACG,OAAO;IA4Gb,OAAO,CAAC,kBAAkB;IAuB1B,OAAO,CAAC,aAAa;IA+BrB,OAAO,CAAC,YAAY;IAiBpB;;;;;OAKG;IACH,UAAU;CAqBb"}