@luckystack/sync 0.10.2 → 0.11.0

package/dist/index.d.ts

@@ -1,91 +1,7 @@
-export { S as SYNC_ERROR_CODES, a as SyncErrorCode } from './errorCodes-B8GoTenr.js';
-import { syncMessage } from '@luckystack/core';
-import { Socket } from 'socket.io';
-
-declare function handleSyncRequest(args: {
-    msg: syncMessage;
-    socket: Socket;
-    token: string | null;
-}): Promise<void>;
-
-type SyncStreamPayload = Record<string, unknown>;
-
-interface HttpSyncRequestParams {
-    name: string;
-    cb?: string;
-    data: Record<string, unknown>;
-    receiver: string;
-    ignoreSelf?: boolean;
-    token: string | null;
-    requesterIp?: string;
-    xLanguageHeader?: string | string[];
-    acceptLanguageHeader?: string | string[];
-    stream?: (payload: HttpSyncStreamEvent) => void;
-    /**
-     * Optional AbortSignal. The HTTP server (`@luckystack/server`) wires this
-     * to `req.on('close', ...)` so a closed SSE connection aborts in-flight
-     * stream emits. Sync handlers receive it as `abortSignal` in params.
-     */
-    abortSignal?: AbortSignal;
-}
-interface HttpSyncResponse {
-    status: 'success' | 'error';
-    message: string;
-    result?: unknown;
-    errorCode?: string;
-    errorParams?: {
-        key: string;
-        value: string | number | boolean;
-    }[];
-    httpStatus?: number;
-}
-type HttpSyncStreamEvent = SyncStreamPayload;
-declare function handleHttpSyncRequest(args: HttpSyncRequestParams): Promise<HttpSyncResponse>;
-
-interface CreateStreamThrottleOptions {
-    /**
-     * Flush buffered text once it crosses this many characters. Default: 32.
-     * Lower = more updates, more network traffic.
-     * Higher = fewer updates, choppier UI.
-     */
-    flushAtChars?: number;
-    /**
-     * Flush buffered text after this many milliseconds even if the char
-     * threshold hasn't been hit. Default: 50ms — fast enough that the user
-     * perceives "live typing", slow enough that 50–100 tokens batch into a
-     * single message on a fast LLM stream.
-     *
-     * Set to `false` to disable the timer (only flush at char threshold or
-     * on explicit `flush()`).
-     */
-    flushEveryMs?: number | false;
-    /**
-     * Field name on the emitted payload that carries the buffered text.
-     * Default: `'chunk'`. Override if your stream payload uses a different
-     * key (e.g. `'text'`, `'delta'`).
-     */
-    field?: string;
-}
-interface StreamThrottle {
-    /** Append text to the buffer. May trigger a flush. */
-    push: (text: string, emit: (payload: Record<string, unknown>) => void) => void;
-    /** Force-flush whatever is in the buffer right now. Call after the source loop ends. */
-    flush: (emit: (payload: Record<string, unknown>) => void) => void;
-    /** Drop the buffered text without emitting. Useful on abort. */
-    reset: () => void;
-}
-/**
- * Build a chunk throttle for streaming use cases. Designed for LLM token
- * streams where the provider yields very small pieces (3–10 chars) and you
- * don't want to send a separate socket message for each one.
- *
- * @example
- *   const throttle = createStreamThrottle({ flushEveryMs: 50, flushAtChars: 32 });
- *   for await (const chunk of openaiStream) {
- *     throttle.push(chunk.text, broadcastStream);
- *   }
- *   throttle.flush(broadcastStream);
- */
-declare const createStreamThrottle: (options?: CreateStreamThrottleOptions) => StreamThrottle;
-
-export { type CreateStreamThrottleOptions, type HttpSyncStreamEvent, type StreamThrottle, createStreamThrottle, handleHttpSyncRequest, handleSyncRequest };
+export { SYNC_ERROR_CODES } from './_shared/errorCodes.js';
+export type { SyncErrorCode } from './_shared/errorCodes.js';
+export { default as handleSyncRequest } from './handleSyncRequest.js';
+export { default as handleHttpSyncRequest } from './handleHttpSyncRequest.js';
+export type { HttpSyncStreamEvent } from './handleHttpSyncRequest.js';
+export { createStreamThrottle } from './streamThrottle.js';
+export type { StreamThrottle, CreateStreamThrottleOptions, } from './streamThrottle.js';