@kavchat/react-native 0.0.0-stage → 0.0.2

package/lib/controller.js

@@ -0,0 +1,419 @@
+import { aiQuestion, answerWithAi, configureEngine, eventsPayload, isRtl, pendingQuestion, pressChip, sendText, startConversation, transcriptOf, uiTexts, } from '@kavchat/core';
+import { fetchRelease, postAiAnswer, postEvents, postScreens, postTicket } from './api';
+import { SCREENS_MAX_AGE_MS, normalizeScreens, screensFingerprint, screensKey } from './screens';
+import { memoryStorage, randomId, readJson, releaseKey, sessionKey, userFingerprint, writeJson, } from './storage';
+import { pickLocale, safeUrl, ticketError, validateTicket } from './text';
+/**
+ * הבקר: טעינת הגרסה עם ETag ומטמון, שמירת השיחה, דיווח לשרת ופניות
+ * קוד TypeScript רגיל בלי React Native, כדי שאפשר יהיה לבדוק אותו ב-Node.
+ * לוגיקת ההתאמה ומכונת המצבים נמצאות ב-@kavchat/core ולא כאן
+ */
+export const DEFAULT_API = 'https://api.kavchat.com';
+export const BRANDING_URL = 'https://kavchat.com';
+export class KavchatController {
+    constructor(options) {
+        this.listeners = new Set();
+        this.session = null;
+        this.loadSeq = 0;
+        this.reportTimer = null;
+        this.dirty = false;
+        this.disposed = false;
+        this.screens = [];
+        /** הגרסה כבר נטענה פעם אחת מהשרת, ולכן אפשר לרשום מסכים */
+        this.releaseFetched = false;
+        /** הטביעה שכבר נוסתה בהפעלה הזו, בהצלחה או בכישלון. אחרי כישלון מנסים רק בהפעלה הבאה */
+        this.screensTried = null;
+        /** מתממש כשהטעינה האחרונה הסתיימה */
+        this.ready = Promise.resolve();
+        /** מתממש כשניסיון רישום המסכים האחרון הסתיים. בשביל בדיקות */
+        this.screensSync = Promise.resolve();
+        // ---------- מנוי, בשביל useSyncExternalStore ----------
+        this.subscribe = (listener) => {
+            this.listeners.add(listener);
+            return () => {
+                this.listeners.delete(listener);
+            };
+        };
+        this.getSnapshot = () => this.snap;
+        if (!options || !options.publicKey)
+            throw new Error('Kavchat: publicKey is required');
+        this.opts = { ...options };
+        this.store = options.storage ?? memoryStorage();
+        this.api = {
+            apiBase: options.apiBase || DEFAULT_API,
+            publicKey: options.publicKey,
+            getToken: () => this.opts.userToken || undefined,
+            fetch: options.fetch,
+        };
+        this.screens = normalizeScreens(options.screens);
+        const locale = pickLocale(options.locale, options.deviceLocale, 'en');
+        this.snap = {
+            status: 'loading',
+            release: null,
+            offline: false,
+            locale,
+            rtl: isRtl(locale),
+            texts: uiTexts(locale),
+            conversation: null,
+            typing: false,
+            view: 'chat',
+            contact: null,
+            ticketNumber: null,
+            identified: !!options.userToken,
+            userName: options.userName,
+        };
+    }
+    update(patch) {
+        if (this.disposed)
+            return;
+        this.snap = { ...this.snap, ...patch };
+        this.listeners.forEach((l) => {
+            try {
+                l();
+            }
+            catch (e) {
+                console.error('Kavchat: listener failed', e);
+            }
+        });
+    }
+    /** callbacks שמשתנים בכל רינדור (onScreen וכו') מתעדכנים בלי לבנות בקר חדש */
+    setCallbacks(cb) {
+        this.opts.onScreen = cb.onScreen;
+        this.opts.onLink = cb.onLink;
+        this.opts.onEvent = cb.onEvent;
+    }
+    // ---------- טעינה ----------
+    load() {
+        const seq = ++this.loadSeq;
+        this.ready = this.doLoad(seq);
+        return this.ready;
+    }
+    async doLoad(seq) {
+        const pk = this.opts.publicKey;
+        const cached = await readJson(this.store, releaseKey(pk));
+        const result = await fetchRelease(this.api, cached?.etag || undefined);
+        // טעינה חדשה יותר (למשל אחרי setUser) כבר בדרך: מתעלמים מהתוצאה הישנה
+        if (seq !== this.loadSeq || this.disposed)
+            return;
+        if (result.kind === 'ok' || result.kind === 'not-modified') {
+            this.releaseFetched = true;
+            this.syncScreens();
+        }
+        let release = null;
+        let offline = false;
+        if (result.kind === 'ok') {
+            await writeJson(this.store, releaseKey(pk), { etag: result.etag, release: result.release });
+            release = result.release;
+        }
+        else if (result.kind === 'not-modified') {
+            release = cached?.release ?? null;
+        }
+        else if (result.kind === 'offline') {
+            release = cached?.release ?? null;
+            offline = !!release;
+        }
+        await this.apply(release, offline);
+    }
+    async apply(release, offline) {
+        if (!release || !release.enabled) {
+            // הבוט כבוי, מוגבל למשתמשי בדיקה או שנגמרה המכסה: לא מציגים כלום
+            this.session = null;
+            const reason = release && 'reason' in release ? release.reason : undefined;
+            this.update({ status: 'unavailable', release: null, conversation: null, offline: false, view: 'chat', contact: null, reason });
+            this.emit({ type: 'unavailable', reason });
+            return;
+        }
+        const prev = this.snap.release;
+        const user = userFingerprint(this.opts.userToken);
+        const changed = !prev || prev.version !== release.version || (this.session && this.session.user !== user);
+        const locale = pickLocale(this.opts.locale, this.opts.deviceLocale, release.locale);
+        let conversation = this.snap.conversation;
+        let view = this.snap.view;
+        if (changed || !conversation) {
+            conversation = await this.restoreSession(release, user);
+            view = 'chat';
+        }
+        this.update({
+            status: 'ready',
+            release,
+            offline,
+            locale,
+            rtl: isRtl(locale),
+            texts: uiTexts(locale),
+            conversation,
+            view,
+            contact: view === 'chat' ? null : this.snap.contact,
+            reason: undefined,
+            identified: !!this.opts.userToken,
+            userName: this.opts.userName,
+        });
+        this.emit({ type: 'ready', version: release.version, offline });
+    }
+    async restoreSession(release, user) {
+        const saved = await readJson(this.store, sessionKey(this.opts.publicKey));
+        const maxAge = this.opts.sessionMaxAgeMs ?? 24 * 60 * 60 * 1000;
+        const fresh = !saved?.savedAt || this.now() - saved.savedAt <= maxAge;
+        if (saved && saved.state && saved.version === release.version && (saved.user ?? '') === user && fresh) {
+            const scripts = {};
+            for (const sc of release.scripts)
+                scripts[sc.id] = sc;
+            this.session = saved;
+            return { ...saved.state, scripts };
+        }
+        this.session = null;
+        return null;
+    }
+    /** החלפת משתמש (התחברות או התנתקות). הגרסה נטענת מחדש, כי הקהל testers תלוי בזהות */
+    setUser(user) {
+        const token = user?.token || undefined;
+        const name = user?.name || undefined;
+        if (token === this.opts.userToken && name === this.opts.userName)
+            return this.ready;
+        this.flush();
+        this.opts.userToken = token;
+        this.opts.userName = name;
+        return this.load();
+    }
+    /** הצהרה או עדכון של המסכים אחרי היצירה. נשלח רק אם הרשימה השתנתה */
+    registerScreens(screens) {
+        this.screens = normalizeScreens(screens);
+        if (this.releaseFetched)
+            this.syncScreens();
+    }
+    /** לא מחכים לזה בטעינה: רישום המסכים לא אמור לעכב או להפיל את הבוט */
+    syncScreens() {
+        const screens = this.screens;
+        if (!screens.length || this.disposed)
+            return;
+        const fingerprint = screensFingerprint(screens);
+        if (this.screensTried === fingerprint)
+            return;
+        this.screensTried = fingerprint;
+        const key = screensKey(this.opts.publicKey);
+        this.screensSync = (async () => {
+            try {
+                const stored = await readJson(this.store, key);
+                if (stored && stored.fingerprint === fingerprint && this.now() - stored.savedAt < SCREENS_MAX_AGE_MS)
+                    return;
+                const ok = await postScreens(this.api, { platform: 'react-native', screens });
+                const next = { fingerprint, savedAt: this.now() };
+                // שומרים רק אחרי 200, כדי שכישלון ינוסה שוב בהפעלה הבאה
+                if (ok)
+                    await writeJson(this.store, key, next);
+            }
+            catch {
+                // לעולם לא מפילים את האפליקציה בגלל הרישום
+            }
+        })();
+    }
+    setLocale(locale) {
+        this.opts.locale = locale;
+        const releaseLocale = this.snap.release?.locale ?? 'en';
+        const next = pickLocale(locale, this.opts.deviceLocale, releaseLocale);
+        if (next !== this.snap.locale)
+            this.update({ locale: next, rtl: isRtl(next), texts: uiTexts(next) });
+    }
+    // ---------- שיחה ----------
+    /** מתחיל שיחה אם עוד אין. קוראים לזה כשהצ'אט נפתח */
+    ensureConversation() {
+        if (this.snap.status === 'ready' && !this.snap.conversation)
+            this.startFresh();
+    }
+    startFresh() {
+        const release = this.snap.release;
+        if (!release)
+            return;
+        this.flush();
+        this.session = {
+            id: randomId(),
+            startedAt: new Date(this.now()).toISOString(),
+            version: release.version,
+            user: userFingerprint(this.opts.userToken),
+            state: null,
+        };
+        const state = this.run(() => ({
+            state: startConversation({
+                scripts: release.scripts,
+                openingScriptId: release.openingScriptId,
+                locale: release.locale,
+                userName: this.opts.userName,
+            }),
+        })).state;
+        this.setConversation(state, { view: 'chat', contact: null, ticketNumber: null });
+    }
+    pressChip(chip) {
+        const state = this.snap.conversation;
+        if (!state || this.snap.typing)
+            return;
+        this.afterAction(this.run(() => pressChip(state, chip)));
+    }
+    /** מתממש כשהתשובה הוצגה. עם תשובות AI זה אחרי הקריאה לשרת */
+    sendText(text) {
+        const state = this.snap.conversation;
+        if (!state || !String(text ?? '').trim() || this.snap.typing)
+            return Promise.resolve();
+        // תשובות AI רק כשהן דלוקות בגרסה ואין תסריט שעונה על השאלה
+        const question = this.snap.release?.settings.aiAnswers === true && this.session ? aiQuestion(state, text) : null;
+        if (!question) {
+            this.afterAction(this.run(() => sendText(state, text)));
+            return Promise.resolve();
+        }
+        return this.askAi(state, text, question);
+    }
+    async askAi(before, text, question) {
+        const session = this.session;
+        const pending = this.run(() => ({ state: pendingQuestion(before, text) })).state;
+        this.update({ conversation: pending, typing: true });
+        let ai = null;
+        try {
+            ai = await postAiAnswer(this.api, session.id, question);
+        }
+        catch {
+            ai = null;
+        }
+        if (this.disposed)
+            return;
+        // השיחה התחלפה בזמן ההמתנה (שיחה חדשה, משתמש אחר, גרסה חדשה): לא נוגעים בה
+        if (this.session !== session || this.snap.conversation !== pending) {
+            this.update({ typing: false });
+            return;
+        }
+        // תשובה ריקה או כישלון: answerWithAi מחזיר בדיוק את "לא נמצא" הרגיל
+        this.update({ typing: false });
+        this.afterAction(this.run(() => answerWithAi(before, text, ai?.answer ?? null, ai?.scriptId ?? null)));
+    }
+    /**
+     * התסריט נבדק בשפת הבוט, והטקסטים הקבועים של הצ'אט מוצגים בשפת הממשק.
+     * ההגדרה של המנוע גלובלית, ולכן קובעים אותה לפני כל קריאה
+     */
+    run(fn) {
+        configureEngine({ texts: this.snap.texts });
+        return fn();
+    }
+    setConversation(state, extra = {}) {
+        if (this.session) {
+            const { scripts: _omit, ...rest } = state;
+            this.session.state = rest;
+            this.session.savedAt = this.now();
+            void writeJson(this.store, sessionKey(this.opts.publicKey), this.session);
+        }
+        this.update({ conversation: state, ...extra });
+    }
+    afterAction(r) {
+        this.setConversation(r.state);
+        this.scheduleReport();
+        if (r.effect)
+            this.handleEffect(r.effect);
+    }
+    handleEffect(effect) {
+        this.emit({ type: 'effect', effect });
+        if (effect.type === 'contact') {
+            this.update({ view: 'form', contact: effect, ticketNumber: null });
+        }
+        else if (effect.type === 'link') {
+            // רק https ו-tel. כל פרוטוקול אחר מהתסריט נחסם
+            const href = safeUrl(effect.url, ['https', 'tel']);
+            if (href)
+                this.safeCall(() => this.opts.onLink?.(href), 'onLink');
+        }
+        else if (effect.type === 'screen') {
+            this.safeCall(() => this.opts.onScreen?.(effect.screen, effect.targetId), 'onScreen');
+        }
+    }
+    /** פתיחת הטופס מכפתור מחוץ לתסריט */
+    openContactForm(prefill = '') {
+        const state = this.snap.conversation;
+        this.update({
+            view: 'form',
+            ticketNumber: null,
+            contact: {
+                type: 'contact',
+                contactTopicId: null,
+                scriptId: state?.lastScriptId ?? null,
+                prefill,
+                transcript: state ? transcriptOf(state) : [],
+            },
+        });
+    }
+    backToChat() {
+        this.update({ view: 'chat', contact: null, ticketNumber: null });
+    }
+    /** שולח פנייה. מחזיר הודעת שגיאה בשפת הממשק, או null אם נשלחה */
+    async submitTicket(fields) {
+        const t = this.snap.texts;
+        const effect = this.snap.contact;
+        const trim = (v) => (v ?? '').trim() || undefined;
+        const input = {
+            message: (fields.message ?? '').trim(),
+            name: trim(fields.name),
+            email: trim(fields.email),
+            phone: trim(fields.phone),
+            topicId: trim(fields.topicId),
+            scriptId: effect?.scriptId || undefined,
+            sessionId: this.session?.id,
+            transcript: (effect?.transcript ?? []).slice(-200).map((x) => ({ ...x, text: x.text.slice(0, 1000) })),
+        };
+        const problem = validateTicket(input, !!this.opts.userToken, t);
+        if (problem)
+            return problem;
+        const res = await postTicket(this.api, input);
+        if (this.disposed)
+            return null;
+        if (!res.ok)
+            return ticketError(res.code, res.message, t);
+        this.flush();
+        this.emit({ type: 'ticket', id: res.id, number: res.number });
+        this.update({ view: 'sent', ticketNumber: res.number });
+        return null;
+    }
+    // ---------- דיווח ----------
+    scheduleReport() {
+        this.dirty = true;
+        if (this.reportTimer)
+            clearTimeout(this.reportTimer);
+        this.reportTimer = setTimeout(() => this.flush(), this.opts.reportDelayMs ?? 2000);
+    }
+    /** שולח את המסלול עכשיו. קוראים לזה גם כשהאפליקציה עוברת לרקע */
+    flush() {
+        if (this.reportTimer) {
+            clearTimeout(this.reportTimer);
+            this.reportTimer = null;
+        }
+        const state = this.snap.conversation;
+        const release = this.snap.release;
+        const session = this.session;
+        if (!this.dirty || !state || !release || !session || this.disposed)
+            return Promise.resolve(false);
+        this.dirty = false;
+        const payload = eventsPayload(state, session.id, release.version, session.startedAt);
+        return postEvents(this.api, payload).then((ok) => {
+            // כישלון: ינסה שוב בפעולה הבאה
+            if (!ok)
+                this.dirty = true;
+            return ok;
+        });
+    }
+    dispose() {
+        if (this.disposed)
+            return;
+        void this.flush();
+        this.disposed = true;
+        this.listeners.clear();
+    }
+    now() {
+        return this.opts.now ? this.opts.now() : Date.now();
+    }
+    emit(event) {
+        this.safeCall(() => this.opts.onEvent?.(event), 'onEvent');
+    }
+    safeCall(fn, name) {
+        try {
+            const r = fn();
+            if (r && typeof r.catch === 'function')
+                r.catch((e) => console.error(`Kavchat: ${name} failed`, e));
+        }
+        catch (e) {
+            console.error(`Kavchat: ${name} failed`, e);
+        }
+    }
+}

package/lib/index.d.ts

@@ -0,0 +1,13 @@
+export { KavchatProvider, useKavchat } from './ui/KavchatProvider';
+export type { KavchatProviderProps } from './ui/KavchatProvider';
+export { KavchatChat } from './ui/KavchatChat';
+export type { KavchatChatProps } from './ui/KavchatChat';
+export { KavchatLauncher } from './ui/KavchatLauncher';
+export type { KavchatLauncherProps } from './ui/KavchatLauncher';
+export { KavchatController, DEFAULT_API, BRANDING_URL } from './controller';
+export type { ControllerOptions, ContactFields, KavchatEvent, KavchatSnapshot, KavchatStatus, KavchatView } from './controller';
+export { memoryStorage, defaultStorage } from './storage';
+export type { StorageAdapter } from './storage';
+export { themeFor } from './theme';
+export type { KavchatTheme } from './theme';
+export type { KavchatScreen } from './screens';

package/lib/index.js

@@ -0,0 +1,6 @@
+export { KavchatProvider, useKavchat } from './ui/KavchatProvider';
+export { KavchatChat } from './ui/KavchatChat';
+export { KavchatLauncher } from './ui/KavchatLauncher';
+export { KavchatController, DEFAULT_API, BRANDING_URL } from './controller';
+export { memoryStorage, defaultStorage } from './storage';
+export { themeFor } from './theme';

package/lib/screens.d.ts

@@ -0,0 +1,30 @@
+/**
+ * רישום מסכי האפליקציה בשרת, כדי שהעורך בלוח הניהול יציע רשימה במקום שם חופשי עם שגיאות כתיב.
+ * הכללים זהים לשרת, ולכן מסך לא תקין נזרק כבר כאן ולא מכשיל את כל הבקשה
+ */
+export interface KavchatScreen {
+    /** השם שמגיע ל-onScreen. אותיות לטיניות, ספרות, _ . - עד 40 תווים */
+    id: string;
+    /** השם שמנהל הבוט רואה בעורך, עד 60 תווים */
+    label: string;
+    /** true כשהמסך צריך targetId, למשל מזהה מוצר */
+    needsTarget?: boolean;
+}
+export type NormalizedScreen = {
+    id: string;
+    label: string;
+    needsTarget: boolean;
+};
+export declare const MAX_SCREENS = 100;
+/** גם בלי שינוי שולחים פעם בשבוע, כדי שהשרת ידע שהאפליקציה עדיין משתמשת במסכים */
+export declare const SCREENS_MAX_AGE_MS: number;
+export declare const screensKey: (pk: string) => string;
+export interface StoredScreens {
+    fingerprint: string;
+    savedAt: number;
+}
+/** מסנן לפי כללי השרת: מזהה ותווית תקינים, בלי כפולים, 100 הראשונים */
+export declare function normalizeScreens(list: readonly KavchatScreen[] | null | undefined, log?: (msg: string) => void): NormalizedScreen[];
+/** טביעה יציבה: שורות id|label|needsTarget ממוינות לפי id, ואז SHA-256. סדר ההצהרה לא משנה */
+export declare function screensFingerprint(list: readonly NormalizedScreen[]): string;
+export declare function sha256Hex(text: string): string;

package/lib/screens.js

@@ -0,0 +1,120 @@
+/**
+ * רישום מסכי האפליקציה בשרת, כדי שהעורך בלוח הניהול יציע רשימה במקום שם חופשי עם שגיאות כתיב.
+ * הכללים זהים לשרת, ולכן מסך לא תקין נזרק כבר כאן ולא מכשיל את כל הבקשה
+ */
+export const MAX_SCREENS = 100;
+/** גם בלי שינוי שולחים פעם בשבוע, כדי שהשרת ידע שהאפליקציה עדיין משתמשת במסכים */
+export const SCREENS_MAX_AGE_MS = 7 * 24 * 60 * 60 * 1000;
+const ID_RE = /^[A-Za-z0-9_.-]{1,40}$/;
+export const screensKey = (pk) => `kavchat:screens:${pk}`;
+const isDev = () => typeof __DEV__ !== 'undefined' && !!__DEV__;
+/** מסנן לפי כללי השרת: מזהה ותווית תקינים, בלי כפולים, 100 הראשונים */
+export function normalizeScreens(list, log = defaultLog) {
+    const out = [];
+    const seen = new Set();
+    for (const s of Array.isArray(list) ? list : []) {
+        const id = typeof s?.id === 'string' ? s.id : '';
+        const label = typeof s?.label === 'string' ? s.label.trim() : '';
+        if (!ID_RE.test(id)) {
+            log(`Kavchat: screen dropped, invalid id ${JSON.stringify(s?.id)}`);
+            continue;
+        }
+        if (label.length < 1 || label.length > 60) {
+            log(`Kavchat: screen "${id}" dropped, label must be 1-60 characters`);
+            continue;
+        }
+        if (seen.has(id)) {
+            log(`Kavchat: screen "${id}" dropped, duplicate id`);
+            continue;
+        }
+        if (out.length >= MAX_SCREENS) {
+            log(`Kavchat: screen "${id}" dropped, more than ${MAX_SCREENS} screens`);
+            continue;
+        }
+        seen.add(id);
+        out.push({ id, label, needsTarget: s.needsTarget === true });
+    }
+    return out;
+}
+function defaultLog(msg) {
+    // רק בפיתוח: באפליקציה שפורסמה אין טעם להציף את הלוג
+    if (isDev())
+        console.warn(msg);
+}
+/** טביעה יציבה: שורות id|label|needsTarget ממוינות לפי id, ואז SHA-256. סדר ההצהרה לא משנה */
+export function screensFingerprint(list) {
+    const lines = [...list]
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))
+        .map((s) => `${s.id}|${s.label}|${s.needsTarget}`)
+        .join('\n');
+    return sha256Hex(lines);
+}
+// ---------- SHA-256 ב-JS טהור: ב-Hermes אין crypto.subtle, ולא רוצים להוסיף תלות נייטיב ----------
+const K = new Uint32Array([
+    0x428a2f98, 0x71374491, 0xb5c0fbcf, 0xe9b5dba5, 0x3956c25b, 0x59f111f1, 0x923f82a4, 0xab1c5ed5, 0xd807aa98, 0x12835b01, 0x243185be,
+    0x550c7dc3, 0x72be5d74, 0x80deb1fe, 0x9bdc06a7, 0xc19bf174, 0xe49b69c1, 0xefbe4786, 0x0fc19dc6, 0x240ca1cc, 0x2de92c6f, 0x4a7484aa,
+    0x5cb0a9dc, 0x76f988da, 0x983e5152, 0xa831c66d, 0xb00327c8, 0xbf597fc7, 0xc6e00bf3, 0xd5a79147, 0x06ca6351, 0x14292967, 0x27b70a85,
+    0x2e1b2138, 0x4d2c6dfc, 0x53380d13, 0x650a7354, 0x766a0abb, 0x81c2c92e, 0x92722c85, 0xa2bfe8a1, 0xa81a664b, 0xc24b8b70, 0xc76c51a3,
+    0xd192e819, 0xd6990624, 0xf40e3585, 0x106aa070, 0x19a4c116, 0x1e376c08, 0x2748774c, 0x34b0bcb5, 0x391c0cb3, 0x4ed8aa4a, 0x5b9cca4f,
+    0x682e6ff3, 0x748f82ee, 0x78a5636f, 0x84c87814, 0x8cc70208, 0x90befffa, 0xa4506ceb, 0xbef9a3f7, 0xc67178f2,
+]);
+function utf8(text) {
+    const out = [];
+    for (const ch of text) {
+        let c = ch.codePointAt(0);
+        if (c < 0x80)
+            out.push(c);
+        else if (c < 0x800)
+            out.push(0xc0 | (c >> 6), 0x80 | (c & 63));
+        else if (c < 0x10000)
+            out.push(0xe0 | (c >> 12), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+        else
+            out.push(0xf0 | (c >> 18), 0x80 | ((c >> 12) & 63), 0x80 | ((c >> 6) & 63), 0x80 | (c & 63));
+    }
+    return out;
+}
+export function sha256Hex(text) {
+    const bytes = utf8(text);
+    const bitLen = bytes.length * 8;
+    bytes.push(0x80);
+    while (bytes.length % 64 !== 56)
+        bytes.push(0);
+    // אורך ב-64 ביט. מחרוזות כאן קטנות מ-2^32 ביט, ולכן החצי העליון אפס
+    bytes.push(0, 0, 0, 0, (bitLen >>> 24) & 255, (bitLen >>> 16) & 255, (bitLen >>> 8) & 255, bitLen & 255);
+    const h = new Uint32Array([0x6a09e667, 0xbb67ae85, 0x3c6ef372, 0xa54ff53a, 0x510e527f, 0x9b05688c, 0x1f83d9ab, 0x5be0cd19]);
+    const w = new Uint32Array(64);
+    const rotr = (x, n) => (x >>> n) | (x << (32 - n));
+    for (let off = 0; off < bytes.length; off += 64) {
+        for (let i = 0; i < 16; i++) {
+            const j = off + i * 4;
+            w[i] = (bytes[j] << 24) | (bytes[j + 1] << 16) | (bytes[j + 2] << 8) | bytes[j + 3];
+        }
+        for (let i = 16; i < 64; i++) {
+            const s0 = rotr(w[i - 15], 7) ^ rotr(w[i - 15], 18) ^ (w[i - 15] >>> 3);
+            const s1 = rotr(w[i - 2], 17) ^ rotr(w[i - 2], 19) ^ (w[i - 2] >>> 10);
+            w[i] = w[i - 16] + s0 + w[i - 7] + s1;
+        }
+        let [a, b, c, d, e, f, g, hh] = h;
+        for (let i = 0; i < 64; i++) {
+            const t1 = (hh + (rotr(e, 6) ^ rotr(e, 11) ^ rotr(e, 25)) + ((e & f) ^ (~e & g)) + K[i] + w[i]) >>> 0;
+            const t2 = ((rotr(a, 2) ^ rotr(a, 13) ^ rotr(a, 22)) + ((a & b) ^ (a & c) ^ (b & c))) >>> 0;
+            hh = g;
+            g = f;
+            f = e;
+            e = (d + t1) >>> 0;
+            d = c;
+            c = b;
+            b = a;
+            a = (t1 + t2) >>> 0;
+        }
+        h[0] += a;
+        h[1] += b;
+        h[2] += c;
+        h[3] += d;
+        h[4] += e;
+        h[5] += f;
+        h[6] += g;
+        h[7] += hh;
+    }
+    return Array.from(h, (x) => x.toString(16).padStart(8, '0')).join('');
+}

package/lib/storage.d.ts

@@ -0,0 +1,35 @@
+import type { BotState } from '@kavchat/core';
+import type { AnyRelease } from './api';
+/**
+ * אחסון במכשיר דרך מתאם, כדי שאפליקציה בלי AsyncStorage עדיין תעבוד (רק בלי מטמון בין הפעלות)
+ * המפתחות זהים ל-Flutter, כדי שההתנהגות תהיה אחידה בכל ה-SDK
+ */
+export interface StorageAdapter {
+    getItem(key: string): Promise<string | null> | string | null;
+    setItem(key: string, value: string): Promise<void> | void;
+    removeItem?(key: string): Promise<void> | void;
+}
+export declare function memoryStorage(): StorageAdapter;
+export declare function defaultStorage(): StorageAdapter;
+export declare const releaseKey: (pk: string) => string;
+export declare const sessionKey: (pk: string) => string;
+export declare function readJson<T>(store: StorageAdapter, key: string): Promise<T | null>;
+export declare function writeJson(store: StorageAdapter, key: string, value: unknown): Promise<void>;
+export interface CachedRelease {
+    etag: string;
+    release: AnyRelease;
+}
+/** השיחה השמורה. בלי התסריטים עצמם, הם מגיעים מהגרסה השמורה */
+export interface StoredSession {
+    id: string;
+    startedAt: string;
+    version: number;
+    /** טביעה של המשתמש, לא הטוקן עצמו, כדי לא להציג שיחה של משתמש אחר אחרי החלפת חשבון */
+    user: string;
+    savedAt?: number;
+    state: Omit<BotState, 'scripts'> | null;
+}
+/** מזהה שיחה אקראי של 22 תווים מתוך [A-Za-z0-9_-], כפי שהשרת מצפה */
+export declare function randomId(length?: number, random?: () => number): string;
+/** טביעה קצרה של הטוקן (FNV-1a, כמו ב-Flutter), כדי לא לשמור את הטוקן בדיסק */
+export declare function userFingerprint(token: string | null | undefined): string;