@kavchat/react-native 0.0.0-stage → 0.0.1

package/src/controller.ts

@@ -0,0 +1,512 @@
+import {
+  aiQuestion,
+  answerWithAi,
+  configureEngine,
+  eventsPayload,
+  isRtl,
+  pendingQuestion,
+  pressChip,
+  sendText,
+  startConversation,
+  transcriptOf,
+  uiTexts,
+} from '@kavchat/core';
+import type { BotChip, BotEffect, BotResult, BotState, UiTexts } from '@kavchat/core';
+import { AnyRelease, ApiConfig, EnabledRelease, FetchLike, TicketInput, fetchRelease, postAiAnswer, postEvents, postScreens, postTicket } from './api';
+import { KavchatScreen, NormalizedScreen, SCREENS_MAX_AGE_MS, StoredScreens, normalizeScreens, screensFingerprint, screensKey } from './screens';
+import {
+  CachedRelease,
+  StorageAdapter,
+  StoredSession,
+  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 type ContactEffect = Extract<BotEffect, { type: 'contact' }>;
+export type KavchatStatus = 'loading' | 'ready' | 'unavailable';
+export type KavchatView = 'chat' | 'form' | 'sent';
+
+export type KavchatEvent =
+  | { type: 'ready'; version: number; offline: boolean }
+  | { type: 'unavailable'; reason?: string }
+  | { type: 'effect'; effect: BotEffect }
+  | { type: 'ticket'; id: string; number: number };
+
+export interface KavchatSnapshot {
+  status: KavchatStatus;
+  release: EnabledRelease | null;
+  /** הוצגה גרסה שמורה כי אין רשת */
+  offline: boolean;
+  /** שפת הממשק (הטקסטים הקבועים), לא שפת התסריט */
+  locale: string;
+  rtl: boolean;
+  texts: UiTexts;
+  conversation: BotState | null;
+  /** מחכים לתשובת AI: מציגים סימן הקלדה ולא מקבלים קלט */
+  typing: boolean;
+  view: KavchatView;
+  contact: ContactEffect | null;
+  ticketNumber: number | null;
+  /** למה הבוט לא זמין, למשל quota */
+  reason?: string;
+  identified: boolean;
+  userName?: string;
+}
+
+export interface ControllerOptions {
+  publicKey: string;
+  apiBase?: string;
+  locale?: string;
+  userToken?: string;
+  userName?: string;
+  storage?: StorageAdapter;
+  fetch?: FetchLike;
+  /** שפת המכשיר, כשלא נקבעה locale */
+  deviceLocale?: string;
+  /** כפתור מסוג screen בתסריט. בלי callback הכפתור לא עושה דבר */
+  onScreen?: (screen: string, targetId?: string) => void;
+  /** פתיחת קישור https או tel. ב-React Native זה Linking.openURL */
+  onLink?: (url: string) => void;
+  onEvent?: (event: KavchatEvent) => void;
+  /** מסכי האפליקציה שכפתור screen יכול לפתוח. נרשמים בשרת כדי שהעורך יציע אותם ברשימה */
+  screens?: readonly KavchatScreen[];
+  reportDelayMs?: number;
+  sessionMaxAgeMs?: number;
+  now?: () => number;
+}
+
+export interface ContactFields {
+  name?: string;
+  email?: string;
+  phone?: string;
+  topicId?: string;
+  message: string;
+}
+
+export class KavchatController {
+  private opts: ControllerOptions;
+  private api: ApiConfig;
+  private store: StorageAdapter;
+  private snap: KavchatSnapshot;
+  private listeners = new Set<() => void>();
+  private session: StoredSession | null = null;
+  private loadSeq = 0;
+  private reportTimer: ReturnType<typeof setTimeout> | null = null;
+  private dirty = false;
+  private disposed = false;
+  private screens: NormalizedScreen[] = [];
+  /** הגרסה כבר נטענה פעם אחת מהשרת, ולכן אפשר לרשום מסכים */
+  private releaseFetched = false;
+  /** הטביעה שכבר נוסתה בהפעלה הזו, בהצלחה או בכישלון. אחרי כישלון מנסים רק בהפעלה הבאה */
+  private screensTried: string | null = null;
+  /** מתממש כשהטעינה האחרונה הסתיימה */
+  ready: Promise<void> = Promise.resolve();
+  /** מתממש כשניסיון רישום המסכים האחרון הסתיים. בשביל בדיקות */
+  screensSync: Promise<void> = Promise.resolve();
+
+  constructor(options: ControllerOptions) {
+    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,
+    };
+  }
+
+  // ---------- מנוי, בשביל useSyncExternalStore ----------
+
+  subscribe = (listener: () => void) => {
+    this.listeners.add(listener);
+    return () => {
+      this.listeners.delete(listener);
+    };
+  };
+
+  getSnapshot = (): KavchatSnapshot => this.snap;
+
+  private update(patch: Partial<KavchatSnapshot>) {
+    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: Pick<ControllerOptions, 'onScreen' | 'onLink' | 'onEvent'>) {
+    this.opts.onScreen = cb.onScreen;
+    this.opts.onLink = cb.onLink;
+    this.opts.onEvent = cb.onEvent;
+  }
+
+  // ---------- טעינה ----------
+
+  load(): Promise<void> {
+    const seq = ++this.loadSeq;
+    this.ready = this.doLoad(seq);
+    return this.ready;
+  }
+
+  private async doLoad(seq: number) {
+    const pk = this.opts.publicKey;
+    const cached = await readJson<CachedRelease>(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: AnyRelease | null = 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);
+  }
+
+  private async apply(release: AnyRelease | null, offline: boolean) {
+    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 });
+  }
+
+  private async restoreSession(release: EnabledRelease, user: string): Promise<BotState | null> {
+    const saved = await readJson<StoredSession>(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: BotState['scripts'] = {};
+      for (const sc of release.scripts) scripts[sc.id] = sc;
+      this.session = saved;
+      return { ...saved.state, scripts } as BotState;
+    }
+    this.session = null;
+    return null;
+  }
+
+  /** החלפת משתמש (התחברות או התנתקות). הגרסה נטענת מחדש, כי הקהל testers תלוי בזהות */
+  setUser(user: { token?: string | null; name?: string | null } | null): Promise<void> {
+    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: readonly KavchatScreen[] | null | undefined) {
+    this.screens = normalizeScreens(screens);
+    if (this.releaseFetched) this.syncScreens();
+  }
+
+  /** לא מחכים לזה בטעינה: רישום המסכים לא אמור לעכב או להפיל את הבוט */
+  private 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<StoredScreens>(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: StoredScreens = { fingerprint, savedAt: this.now() };
+        // שומרים רק אחרי 200, כדי שכישלון ינוסה שוב בהפעלה הבאה
+        if (ok) await writeJson(this.store, key, next);
+      } catch {
+        // לעולם לא מפילים את האפליקציה בגלל הרישום
+      }
+    })();
+  }
+
+  setLocale(locale: string | undefined) {
+    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: BotChip) {
+    const state = this.snap.conversation;
+    if (!state || this.snap.typing) return;
+    this.afterAction(this.run(() => pressChip(state, chip)));
+  }
+
+  /** מתממש כשהתשובה הוצגה. עם תשובות AI זה אחרי הקריאה לשרת */
+  sendText(text: string): Promise<void> {
+    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);
+  }
+
+  private async askAi(before: BotState, text: string, question: string) {
+    const session = this.session!;
+    const pending = this.run(() => ({ state: pendingQuestion(before, text) })).state;
+    this.update({ conversation: pending, typing: true });
+    let ai: Awaited<ReturnType<typeof postAiAnswer>> = 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)));
+  }
+
+  /**
+   * התסריט נבדק בשפת הבוט, והטקסטים הקבועים של הצ'אט מוצגים בשפת הממשק.
+   * ההגדרה של המנוע גלובלית, ולכן קובעים אותה לפני כל קריאה
+   */
+  private run(fn: () => BotResult): BotResult {
+    configureEngine({ texts: this.snap.texts });
+    return fn();
+  }
+
+  private setConversation(state: BotState, extra: Partial<KavchatSnapshot> = {}) {
+    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 });
+  }
+
+  private afterAction(r: BotResult) {
+    this.setConversation(r.state);
+    this.scheduleReport();
+    if (r.effect) this.handleEffect(r.effect);
+  }
+
+  private handleEffect(effect: BotEffect) {
+    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: ContactFields): Promise<string | null> {
+    const t = this.snap.texts;
+    const effect = this.snap.contact;
+    const trim = (v?: string) => (v ?? '').trim() || undefined;
+    const input: TicketInput = {
+      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;
+  }
+
+  // ---------- דיווח ----------
+
+  private scheduleReport() {
+    this.dirty = true;
+    if (this.reportTimer) clearTimeout(this.reportTimer);
+    this.reportTimer = setTimeout(() => this.flush(), this.opts.reportDelayMs ?? 2000);
+  }
+
+  /** שולח את המסלול עכשיו. קוראים לזה גם כשהאפליקציה עוברת לרקע */
+  flush(): Promise<boolean> {
+    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();
+  }
+
+  private now() {
+    return this.opts.now ? this.opts.now() : Date.now();
+  }
+
+  private emit(event: KavchatEvent) {
+    this.safeCall(() => this.opts.onEvent?.(event), 'onEvent');
+  }
+
+  private safeCall(fn: () => unknown, name: string) {
+    try {
+      const r = fn() as unknown;
+      if (r && typeof (r as Promise<unknown>).catch === 'function') (r as Promise<unknown>).catch((e) => console.error(`Kavchat: ${name} failed`, e));
+    } catch (e) {
+      console.error(`Kavchat: ${name} failed`, e);
+    }
+  }
+}

package/src/index.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/src/screens.ts

@@ -0,0 +1,141 @@
+/**
+ * רישום מסכי האפליקציה בשרת, כדי שהעורך בלוח הניהול יציע רשימה במקום שם חופשי עם שגיאות כתיב.
+ * הכללים זהים לשרת, ולכן מסך לא תקין נזרק כבר כאן ולא מכשיל את כל הבקשה
+ */
+
+export interface KavchatScreen {
+  /** השם שמגיע ל-onScreen. אותיות לטיניות, ספרות, _ . - עד 40 תווים */
+  id: string;
+  /** השם שמנהל הבוט רואה בעורך, עד 60 תווים */
+  label: string;
+  /** true כשהמסך צריך targetId, למשל מזהה מוצר */
+  needsTarget?: boolean;
+}
+
+export type NormalizedScreen = { id: string; label: string; needsTarget: boolean };
+
+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: string) => `kavchat:screens:${pk}`;
+
+export interface StoredScreens {
+  fingerprint: string;
+  savedAt: number;
+}
+
+declare const __DEV__: boolean | undefined;
+const isDev = () => typeof __DEV__ !== 'undefined' && !!__DEV__;
+
+/** מסנן לפי כללי השרת: מזהה ותווית תקינים, בלי כפולים, 100 הראשונים */
+export function normalizeScreens(list: readonly KavchatScreen[] | null | undefined, log: (msg: string) => void = defaultLog): NormalizedScreen[] {
+  const out: NormalizedScreen[] = [];
+  const seen = new Set<string>();
+  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: string) {
+  // רק בפיתוח: באפליקציה שפורסמה אין טעם להציף את הלוג
+  if (isDev()) console.warn(msg);
+}
+
+/** טביעה יציבה: שורות id|label|needsTarget ממוינות לפי id, ואז SHA-256. סדר ההצהרה לא משנה */
+export function screensFingerprint(list: readonly NormalizedScreen[]): string {
+  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: string): number[] {
+  const out: number[] = [];
+  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: string): string {
+  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: number, n: number) => (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('');
+}