export { configUser as config }; export { getServerConfig }; export { getServerExtensionTypes }; export { enableChannelTransports }; export { setRootFromVite }; export type { ConfigUser, ConfigResolved, StreamConfigUser, ChannelConfigUser, ChannelConfigResolved, BroadcastConfigUser, }; import type { TelefuncServerExtension } from './extensions.js'; import { type BroadcastTransport } from '../../wire-protocol/server/broadcast.js'; import { type ChannelTransports, type StreamTransport } from '../../wire-protocol/constants.js'; type StreamConfigUser = { /** * Default transport for streamed telefunction results. * * - `'binary-inline'` (default): raw binary HTTP response body * - `'sse-inline'`: inline SSE response body * - `'channel'`: stream over the configured channel transport */ transport?: StreamTransport; }; type BroadcastConfigUser = { /** Transport for cross-node `Broadcast` delivery. */ transport?: BroadcastTransport; }; type ChannelConfigUser = { /** * Transports enabled on this server for Telefunc channels. * Determines which transport(s) clients may connect with or upgrade to. * * - `['sse']` (default): SSE only * - `['sse', 'ws']`: SSE and WebSocket — clients may upgrade to WS * - `['ws']`: WebSocket only * * Connections arriving on a transport not listed here are immediately rejected. */ transports?: ChannelTransports; /** * How long, in milliseconds, the server keeps channel state after a client * disconnects while waiting for a reconnect. */ reconnectTimeout?: number; /** * How long, in milliseconds, to keep the shared channel connection alive * after the last channel closes. */ idleTimeout?: number; /** * How often, in milliseconds, the client sends a ping for channel health * checks. The server considers the client dead after 2x this interval. */ pingInterval?: number; /** * Per-channel replay buffer size, in bytes, kept on the server for * reconnect recovery. */ serverReplayBuffer?: number; /** Per-channel replay buffer size for binary frames, in bytes, kept on the server. */ serverReplayBufferBinary?: number; /** * Per-channel replay buffer size, in bytes, advertised to the client so it * can replay recent client-to-server frames after reconnect. */ clientReplayBuffer?: number; /** Per-channel replay buffer size for binary frames, in bytes, advertised to the client. */ clientReplayBufferBinary?: number; /** * How long, in milliseconds, a newly created channel waits for the client to * connect before it is closed automatically. */ connectTtl?: number; /** * Maximum number of bytes buffered per channel for text messages * while no client peer is currently attached. */ bufferLimit?: number; /** Maximum number of bytes buffered per channel for binary messages while no client peer is attached. */ bufferLimitBinary?: number; /** * When using SSE channels, upstream client-to-server frames are batched for at * most this many milliseconds before Telefunc sends a POST. * * This value also defines the idle window used to detect the first POST after * an idle period. */ sseFlushThrottle?: number; /** * When using SSE channels, the first upstream batch POST after an idle period * waits at most this many milliseconds before Telefunc flushes it. * * Idle means no upstream SSE batch POST has started within the current * `sseFlushThrottle` window. */ ssePostIdleFlushDelay?: number; }; type ChannelConfigResolved = { transports: ChannelTransports; reconnectTimeout: number; idleTimeout: number; pingInterval: number; serverReplayBuffer: number; serverReplayBufferBinary: number; clientReplayBuffer: number; clientReplayBufferBinary: number; connectTtl: number; bufferLimit: number; bufferLimitBinary: number; sseFlushThrottle: number; ssePostIdleFlushDelay: number; }; /** Telefunc Server Configuration */ type ConfigUser = { /** * The Telefunc HTTP endpoint URL, e.g. `/api/_telefunc`. * * @default /_telefunc * * https://telefunc.com/telefuncUrl */ telefuncUrl?: string; /** See https://telefunc.com/event-based#naming-convention */ disableNamingConvention?: boolean; /** Your `.telefunc.js` files */ telefuncFiles?: string[]; /** Your project root directory, e.g. `/home/alice/code/my-app/` */ root?: string; /** Whether to disable ETag cache headers */ disableEtag?: boolean; /** * Whether to generate shield. * * https://telefunc.com/shield-config * https://telefunc.com/shield * * @default { dev: false, prod: true } */ shield?: { dev?: boolean; prod?: boolean; } | boolean; log?: { /** Whether to log shield errors */ shieldErrors?: boolean | { /** Whether to log shield errors in production */ prod?: boolean; /** Whether to log shield errors in development */ dev?: boolean; }; }; /** Default transport for streamed telefunction results when the client doesn't specify one. */ stream: StreamConfigUser; /** Enabled transports and runtime settings for Telefunc channels. */ channel: ChannelConfigUser; /** `Broadcast` configuration. */ broadcast: BroadcastConfigUser; /** Registered server extensions. Use `config.extensions.push(ext)` to add. */ extensions: TelefuncServerExtension[]; }; type ConfigResolved = { telefuncUrl: string; root: string | null; disableEtag: boolean; telefuncFiles: string[] | null; disableNamingConvention: boolean; shield: { dev: boolean; prod: boolean; }; log: { shieldErrors: { dev: boolean; prod: boolean; }; }; stream: { transport: StreamTransport; }; channel: ChannelConfigResolved; extensions: TelefuncServerExtension[]; }; declare const configUser: ConfigUser; declare function getServerConfig(): ConfigResolved; /** Extension wire types are consumed after user modules may have registered more extensions. * Keep them out of the request-start config snapshot and resolve only at the operation that uses them. */ declare function getServerExtensionTypes(): { responseTypes: import("./index.js").ReplacerType[]; requestTypes: import("./index.js").ReviverType[]; }; /** @internal Push additional transports into the default only if the user hasn't set one. */ declare function enableChannelTransports(transports: ChannelTransports): void; declare function setRootFromVite(root: string): void;