@smartmemory/sdk-js 1.4.119 → 1.4.120

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@smartmemory/sdk-js",
-  "version": "1.4.119",
+  "version": "1.4.120",
   "description": "Unified JavaScript SDK for SmartMemory API — auth + API client for all frontends",
   "type": "module",
   "main": "dist/index.js",
@@ -23,16 +23,24 @@
       "default": "./dist/react/analytics.js"
     },
     "./fetch": {
+      "types": "./types/fetch.d.ts",
       "development": "./src/fetch/index.js",
       "default": "./dist/fetch.js"
     },
     "./progress": {
+      "types": "./types/progress.d.ts",
       "development": "./src/progress.ts",
       "default": "./dist/progress.js"
+    },
+    "./connection": {
+      "types": "./types/connection.d.ts",
+      "development": "./src/connection/index.js",
+      "default": "./dist/connection.js"
     }
   },
   "files": [
-    "dist"
+    "dist",
+    "types"
   ],
   "scripts": {
     "build": "vite build",

package/types/connection.d.ts

@@ -0,0 +1,30 @@
+export type ConnectionState = 'connected' | 'reconnecting' | 'signed_out';
+export interface ConnectionSnapshot {
+  readonly status: ConnectionState;
+  readonly reason: string | null;
+}
+export declare class ConnectionStatus {
+  readonly snapshot: ConnectionSnapshot;
+  subscribe(listener: (snapshot: ConnectionSnapshot) => void): () => void;
+  report(source: string | symbol, reason: string | null): void;
+  signedOut(): void;
+  authenticated(): void;
+}
+/** Structural type for client.connection / client.auth.connection. */
+export interface RecoveryClient {
+  connection: ConnectionStatus;
+  auth: RecoveryAuth;
+}
+export interface RecoveryAuth {
+  apiBaseUrl: string;
+  connection: ConnectionStatus;
+  getAuthHeaders(extra?: HeadersInit): Record<string, string>;
+  getRequestOptions(extra?: RequestInit): RequestInit;
+  refreshToken(): Promise<string | null>;
+  clearLocalAuth(): void;
+}
+export declare class SessionRefreshError extends Error {
+  constructor(message: string, status?: number, recoverable?: boolean);
+  status: number;
+  recoverable: boolean;
+}

package/types/fetch.d.ts

@@ -0,0 +1,12 @@
+import type { RecoveryAuth } from './connection.js';
+export type { RecoveryAuth, RecoveryClient, ConnectionSnapshot, ConnectionState } from './connection.js';
+export interface AuthFetchOptions {
+  fetchFn?: typeof fetch;
+  apiBases?: string[];
+}
+export interface InterceptorOptions extends AuthFetchOptions {
+  urlPatterns?: string[];
+}
+export declare function createAuthFetch(authCore: RecoveryAuth, options?: AuthFetchOptions): typeof fetch;
+/** Returns an injectable fetch; does not mutate global fetch or return an uninstaller. */
+export declare function installInterceptor(authCore: RecoveryAuth, options?: InterceptorOptions): typeof fetch;

package/types/progress.d.ts

@@ -0,0 +1,48 @@
+export interface ProgressEvent {
+  run_id: string;
+  scope: string;
+  seq: number;
+  ts: number;
+  kind: string;
+  status: 'started' | 'progress' | 'ok' | 'warn' | 'error' | 'skipped';
+  payload: Record<string, unknown>;
+  /** Optional — pipeline stage name when applicable */
+  stage?: string | null;
+}
+
+export interface ProgressAuth {
+  getAuthHeaders(): Record<string, string>;
+  getRequestOptions(options?: RequestInit): RequestInit;
+  refreshToken(): Promise<unknown>;
+  clearLocalAuth(): void;
+  connection?: ProgressConnection;
+}
+export interface ProgressConnection {
+  report(source: string | symbol, reason: string | null): void;
+}
+export interface SubscribeProgressOptions {
+  baseUrl?: string;
+  /** Static credentials remain supported. Prefer auth for session recovery. */
+  token?: string;
+  apiKey?: string;
+  workspaceId?: string;
+  auth?: ProgressAuth;
+  /** Synchronous live headers, read on every connection; overrides static headers. */
+  getHeaders?: () => Record<string, string>;
+  connection?: ProgressConnection;
+  fetchFn?: typeof fetch;
+  runId?: string;
+  fromSeq?: number;
+  since?: string;
+  useCookieAuth?: boolean;
+  /** Default true. Set false for deliberate finite replay; EOF invokes onComplete. */
+  reconnect?: boolean;
+  onComplete?: () => void;
+  onEvent: (event: ProgressEvent) => void;
+  /** Terminal errors only; transient interruption invokes onReconnect. */
+  onError: (err: unknown) => void;
+  onReconnect?: () => void;
+}
+export interface ProgressSubscription { close(): void; }
+
+export declare function subscribeProgress(options: SubscribeProgressOptions): ProgressSubscription;