export { makePublishInfo }; export type { ChannelBase, ChannelShield, ClientChannel, ChannelCloseCallback, ChannelCloseOptions, ChannelCloseResult, ChannelData, ChannelAck, ChannelPublishAck, ChannelPublishInfo, ChannelPublishMeta, ChannelListenReturn, ChannelListener, ChannelBinaryListener, BroadcastListener, BroadcastBinaryListener, }; import type { TELEFUNC_SHIELDS } from '../node/shared/transformer/generateShield/shield-key.js'; type ChannelData = [T] extends [never] ? never : T extends (data: infer D) => any ? D : T; type ChannelAck = [T] extends [never] ? never : T extends (data: any) => infer R ? Awaited : unknown; type ChannelPublishMeta = Record; /** Metadata delivered to broadcast subscribers alongside each message. */ type ChannelPublishInfo = { key: string; /** Strict per-key counter (1, 2, 3…). Resets if the authority restarts. Use for gap detection. */ seq: number; /** Server timestamp, Unix epoch milliseconds. */ timestamp: number; }; type ChannelPublishAck = ChannelPublishInfo & { meta?: ChannelPublishMeta; }; declare function makePublishInfo(key: string, seq: number, timestamp: number): ChannelPublishInfo; type ChannelListenReturn = [T] extends [never] ? void : T extends (data: any) => infer R ? Awaited | Promise> : unknown | Promise | void; type ChannelListener = (data: ChannelData) => ChannelListenReturn; type ChannelBinaryListener = (data: Uint8Array) => unknown | Promise; /** Callback for `Broadcast.subscribe()` — receives message data and publish info. */ type BroadcastListener = (data: ChannelData, info: ChannelPublishInfo) => ChannelListenReturn; /** Callback for `Broadcast.subscribeBinary()` — receives raw binary data and publish info. */ type BroadcastBinaryListener = (data: Uint8Array, info: ChannelPublishInfo) => unknown | Promise; type ChannelCloseOptions = { timeout?: number; }; type ChannelCloseResult = 0 | 1; type ChannelCloseCallback = (err?: Error) => void | Promise; /** * Internal base — `TOut` is what this side sends, `TIn` is what this side receives. * Each can be a raw message type or a handler signature `(msg) => ack`. * Shared base for `Channel` and `ClientChannel`. */ type ChannelBase = { readonly id: string; readonly isClosed: boolean; /** Default send. Returns `Promise` when `TDefault = true`, otherwise `Promise`. */ send(data: ChannelData): TDefault extends true ? Promise> : Promise; /** Per-send ack opt-in — always returns `Promise`. */ send(data: ChannelData, opts: { ack: true; }): Promise>; /** Per-send ack opt-out — always returns `Promise`. */ send(data: ChannelData, opts: { ack: false; }): Promise; sendBinary(data: Uint8Array): Promise; sendBinary(data: Uint8Array, opts: { ack: true; }): Promise; sendBinary(data: Uint8Array, opts: { ack: false; }): Promise; /** Receive messages. Return a value to ack the sender. Returns an unlisten function. */ listen(callback: ChannelListener): () => void; listenBinary(callback: ChannelBinaryListener): () => void; onClose(callback: ChannelCloseCallback): void; onOpen(callback: () => void): void; close(opts?: ChannelCloseOptions): Promise; abort(): void; abort(abortValue: unknown, message?: string): void; }; /** Shield contract — read by the server to validate messages. `data` is incoming * client→server data; `ack` is the ack the client returns from its `listen` * handler in response to a server `send`. The same slot is used on both `Channel` * (server-side instance) and `ClientChannel` (returned from a telefunction). */ type ChannelShield = { readonly [TELEFUNC_SHIELDS]: { data: ChannelData; ack: ChannelAck; }; }; /** Client-side channel. `ClientToServer` = messages the client sends; `ServerToClient` = messages the client receives. */ type ClientChannel = ChannelBase & ChannelShield;