@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/chunk-GBJ3YI4E.js

@@ -0,0 +1,966 @@
+// src/core/availability.ts
+var WEEKDAYS = ["mon", "tue", "wed", "thu", "fri", "sat", "sun"];
+var SHORT = { mon: "Mon", tue: "Tue", wed: "Wed", thu: "Thu", fri: "Fri", sat: "Sat", sun: "Sun" };
+function minutesOf(hhmm) {
+  if (typeof hhmm !== "string") return null;
+  const m = /^(\d{1,2}):(\d{2})$/.exec(hhmm.trim());
+  if (!m) return null;
+  const h = Number(m[1]);
+  const min = Number(m[2]);
+  if (h > 24 || min > 59 || h === 24 && min > 0) return null;
+  return h * 60 + min;
+}
+var MAX_RANGES_PER_DAY = 4;
+function normalizeHours(raw) {
+  if (!raw || typeof raw !== "object" || Array.isArray(raw)) return null;
+  const src = raw;
+  const out = {};
+  let any = false;
+  for (const day of WEEKDAYS) {
+    if (!Object.prototype.hasOwnProperty.call(src, day)) continue;
+    const ranges = src[day];
+    if (!Array.isArray(ranges)) continue;
+    const kept = [];
+    for (const r of ranges) {
+      if (!Array.isArray(r) || r.length !== 2) continue;
+      const [from, to] = r;
+      if (typeof from !== "string" || typeof to !== "string" || minutesOf(from) == null || minutesOf(to) == null) continue;
+      kept.push([from, to]);
+      if (kept.length >= MAX_RANGES_PER_DAY) break;
+    }
+    if (kept.length) {
+      out[day] = kept;
+      any = true;
+    }
+  }
+  return any ? out : null;
+}
+function localClock(now, timeZone) {
+  let parts;
+  try {
+    parts = new Intl.DateTimeFormat("en-US", {
+      timeZone: timeZone || void 0,
+      weekday: "short",
+      hour: "2-digit",
+      minute: "2-digit",
+      hourCycle: "h23"
+    }).formatToParts(now);
+  } catch {
+    parts = new Intl.DateTimeFormat("en-US", { weekday: "short", hour: "2-digit", minute: "2-digit", hourCycle: "h23" }).formatToParts(now);
+  }
+  const get = (t) => parts.find((p) => p.type === t)?.value ?? "";
+  const day = get("weekday").slice(0, 3).toLowerCase();
+  const hour = Number(get("hour")) % 24;
+  return { day: WEEKDAYS.includes(day) ? day : "mon", minutes: hour * 60 + Number(get("minute")) };
+}
+function isWithinWorkingHours(raw, timeZone, now = /* @__PURE__ */ new Date()) {
+  const hours = normalizeHours(raw);
+  if (!hours) return true;
+  const { day, minutes } = localClock(now, timeZone);
+  const yesterday = WEEKDAYS[(WEEKDAYS.indexOf(day) + 6) % 7];
+  for (const [from, to] of hours[day] ?? []) {
+    const a = minutesOf(from);
+    const b = minutesOf(to);
+    if (a == null || b == null) continue;
+    if (b > a ? minutes >= a && minutes < b : minutes >= a) return true;
+  }
+  for (const [from, to] of hours[yesterday] ?? []) {
+    const a = minutesOf(from);
+    const b = minutesOf(to);
+    if (a == null || b == null) continue;
+    if (b <= a && minutes < b) return true;
+  }
+  return false;
+}
+function isAway(a, now = /* @__PURE__ */ new Date()) {
+  if (!a) return false;
+  if (a.awayUntil) return Date.parse(a.awayUntil) > now.getTime();
+  return Boolean(a.awayMessage?.trim());
+}
+function clock(hhmm) {
+  const total = minutesOf(hhmm) ?? 0;
+  const h = Math.floor(total / 60) % 24;
+  const m = total % 60;
+  const h12 = h % 12 === 0 ? 12 : h % 12;
+  return m ? `${h12}:${String(m).padStart(2, "0")}` : String(h12);
+}
+function hoursSummary(raw) {
+  const hours = normalizeHours(raw);
+  if (!hours) return "";
+  const key = (d) => (hours[d] ?? []).map(([a, b]) => `${clock(a)}\u2013${clock(b)}`).join(", ");
+  const runs = [];
+  for (const d of WEEKDAYS) {
+    const text = key(d);
+    if (!text) continue;
+    const last = runs[runs.length - 1];
+    if (last && last.text === text && WEEKDAYS.indexOf(last.to) === WEEKDAYS.indexOf(d) - 1) last.to = d;
+    else runs.push({ from: d, to: d, text });
+  }
+  return runs.map((r) => {
+    const days = r.from === r.to ? SHORT[r.from] : WEEKDAYS.indexOf(r.to) - WEEKDAYS.indexOf(r.from) === 1 ? `${SHORT[r.from]}, ${SHORT[r.to]}` : `${SHORT[r.from]}\u2013${SHORT[r.to]}`;
+    return `${days}, ${r.text}`;
+  }).join("; ");
+}
+function timeZoneLabel(timeZone, locale = "en-US") {
+  if (!timeZone) return "";
+  try {
+    const name = new Intl.DateTimeFormat(locale, { timeZone, timeZoneName: "longGeneric" }).formatToParts(/* @__PURE__ */ new Date()).find((p) => p.type === "timeZoneName")?.value;
+    if (name && !/^GMT|^UTC/.test(name)) return name.replace(/ Time$/, "");
+  } catch {
+  }
+  return (timeZone.split("/").pop() ?? timeZone).replace(/_/g, " ");
+}
+function untilLabel(iso, now = /* @__PURE__ */ new Date(), locale, timeZone) {
+  const d = new Date(iso);
+  if (!Number.isFinite(d.getTime())) return "later";
+  try {
+    return untilIn(d, now, locale, timeZone || void 0);
+  } catch {
+    return untilIn(d, now, void 0, void 0);
+  }
+}
+function untilIn(d, now, locale, tz) {
+  const dayKey = (x) => new Intl.DateTimeFormat("en-CA", { timeZone: tz, year: "numeric", month: "2-digit", day: "2-digit" }).format(x);
+  if (dayKey(d) === dayKey(now)) return d.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit", timeZone: tz });
+  const days = (d.getTime() - now.getTime()) / 864e5;
+  if (days < 7) return d.toLocaleDateString(locale, { weekday: "long", timeZone: tz });
+  return d.toLocaleDateString(locale, { day: "numeric", month: "short", timeZone: tz });
+}
+function awayLine(a, name, opts = {}) {
+  if (!a) return null;
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const message = a.awayMessage?.trim();
+  if (isAway(a, now)) {
+    if (a.awayUntil) return `Away until ${untilLabel(a.awayUntil, now, opts.locale, a.timeZone)}${message ? `: ${message}` : ""}`;
+    return `${name} is away${message ? `: ${message}` : ""}`;
+  }
+  const summary = hoursSummary(a.hours);
+  if (!summary) return null;
+  if (!opts.always && isWithinWorkingHours(a.hours, a.timeZone, now)) return null;
+  const zone = timeZoneLabel(a.timeZone, opts.locale);
+  return `${name} replies ${summary}${zone ? ` (${zone})` : ""}`;
+}
+function namesLine(names) {
+  if (names.length <= 1) return names[0] ?? "";
+  if (names.length === 2) return `${names[0]} and ${names[1]}`;
+  const rest = names.length - 2;
+  return `${names[0]}, ${names[1]} and ${rest === 1 ? "1 other" : `${rest} others`}`;
+}
+function awaySummary(people, opts = {}) {
+  const now = opts.now ?? /* @__PURE__ */ new Date();
+  const out = people.filter((p) => awayLine(p.availability, p.name, { ...opts, now, always: false }) !== null);
+  if (out.length === 0) return null;
+  if (out.length === 1) return awayLine(out[0].availability, out[0].name, { ...opts, now, always: false });
+  const away = out.filter((p) => isAway(p.availability, now)).length;
+  const what = away === out.length ? "away" : away === 0 ? "outside their hours" : "away or outside their hours";
+  return `${namesLine(out.map((p) => p.name))} are ${what}`;
+}
+
+// src/core/media.ts
+function randomId() {
+  const c = globalThis.crypto;
+  if (c?.randomUUID) return c.randomUUID();
+  const b = new Uint8Array(16);
+  if (c?.getRandomValues) c.getRandomValues(b);
+  else for (let i = 0; i < 16; i++) b[i] = Math.floor(Math.random() * 256);
+  b[6] = b[6] & 15 | 64;
+  b[8] = b[8] & 63 | 128;
+  const h = [...b].map((x) => x.toString(16).padStart(2, "0")).join("");
+  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
+}
+var ALLOWED_EXTENSIONS = [
+  "png",
+  "jpg",
+  "jpeg",
+  "webp",
+  "gif",
+  "heic",
+  "heif",
+  "m4a",
+  "aac",
+  "mp3",
+  "ogg",
+  "oga",
+  "opus",
+  "weba",
+  "webm",
+  "mp4",
+  "mov",
+  "pdf",
+  "txt",
+  "csv",
+  "docx",
+  "xlsx",
+  "pptx"
+];
+var MIME_EXTENSIONS = {
+  "image/png": "png",
+  "image/jpeg": "jpg",
+  "image/webp": "webp",
+  "image/gif": "gif",
+  "image/heic": "heic",
+  "image/heif": "heif",
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/aac": "aac",
+  "audio/mpeg": "mp3",
+  "audio/ogg": "ogg",
+  "audio/webm": "webm",
+  "video/mp4": "mp4",
+  "video/quicktime": "mov",
+  "video/webm": "webm",
+  "application/pdf": "pdf",
+  "text/plain": "txt",
+  "text/csv": "csv",
+  "application/vnd.openxmlformats-officedocument.wordprocessingml.document": "docx",
+  "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": "xlsx",
+  "application/vnd.openxmlformats-officedocument.presentationml.presentation": "pptx"
+};
+function fileExtension(name, contentType) {
+  const base = (contentType ?? "").split(";")[0].trim().toLowerCase();
+  const fromType = MIME_EXTENSIONS[base];
+  if (fromType) return fromType;
+  const dot = name.lastIndexOf(".");
+  return dot >= 0 ? name.slice(dot + 1).toLowerCase() : "";
+}
+function isAllowedExtension(ext) {
+  return ALLOWED_EXTENSIONS.includes(ext.toLowerCase());
+}
+function attachmentKindFor(contentType, opts = {}) {
+  const t = contentType.toLowerCase();
+  if (opts.recordedVoice || t.startsWith("audio/")) return "voice";
+  if (t.startsWith("image/")) return "image";
+  if (t.startsWith("video/")) return "video";
+  return "file";
+}
+var CHAT_LIMITS = {
+  /** Voice notes and videos, for members. */
+  recordingMs: 5 * 6e4,
+  /** For owners, admins and observers (coaches, staff). */
+  staffRecordingMs: 10 * 6e4,
+  fileBytes: 50 * 1024 * 1024,
+  videoBytes: 100 * 1024 * 1024,
+  attachmentsPerMessage: 20,
+  bodyChars: 1e4
+};
+function recordingLimitMs(role) {
+  return role === "owner" || role === "admin" || role === "observer" ? CHAT_LIMITS.staffRecordingMs : CHAT_LIMITS.recordingMs;
+}
+function waveformPeaks(samples, count = 48) {
+  const n = Math.max(1, Math.min(128, Math.floor(count)));
+  if (samples.length === 0) return new Array(n).fill(0);
+  const size = samples.length / n;
+  const raw = [];
+  for (let i = 0; i < n; i++) {
+    let peak = 0;
+    const end = Math.min(samples.length, Math.floor((i + 1) * size));
+    for (let j = Math.floor(i * size); j < end; j++) {
+      const v = Math.abs(samples[j]);
+      if (v > peak) peak = v;
+    }
+    raw.push(peak);
+  }
+  const max = Math.max(...raw);
+  if (max < 0.01) return raw.map(() => 0);
+  return raw.map((v) => Math.round(v / max * 100));
+}
+function waveformFromMetering(levelsDb, count = 48) {
+  const linear = levelsDb.map((db) => Number.isFinite(db) ? Math.pow(10, Math.max(-60, Math.min(0, db)) / 20) : 0);
+  return waveformPeaks(linear, count);
+}
+function formatDuration(ms) {
+  const total = Math.max(0, Math.round((ms ?? 0) / 1e3));
+  const h = Math.floor(total / 3600);
+  const m = Math.floor(total % 3600 / 60);
+  const s = total % 60;
+  return h > 0 ? `${h}:${String(m).padStart(2, "0")}:${String(s).padStart(2, "0")}` : `${m}:${String(s).padStart(2, "0")}`;
+}
+var PLAYBACK_RATES = [1, 1.5, 2];
+function nextPlaybackRate(rate) {
+  const i = PLAYBACK_RATES.indexOf(rate);
+  return PLAYBACK_RATES[(i + 1) % PLAYBACK_RATES.length];
+}
+
+// src/core/client.ts
+var CHAT_SCHEMA = "genesis_chat";
+var CHAT_BUCKET = "genesis-chat";
+var conversationTopic = (conversationId) => `genesis-chat:conv:${conversationId}`;
+var userTopic = (userId) => `genesis-chat:user:${userId}`;
+var ChatError = class extends Error {
+  constructor(message, code, operation) {
+    super(message);
+    this.code = code;
+    this.operation = operation;
+    this.name = "ChatError";
+  }
+  code;
+  operation;
+  get forbidden() {
+    return this.code === "42501";
+  }
+  get rateLimited() {
+    return this.code === "GS429";
+  }
+  /** Worth trying again: the network, not the database, said no. */
+  get transient() {
+    return this.code === void 0 || this.code === "" || /^(08|57|53)/.test(this.code) || this.code === "PGRST000";
+  }
+  /**
+   * Sending it again won't help: the database refused what was sent (not allowed 42501, bad
+   * data 22xxx such as 22023, a conflict 23xxx such as 23505, another refusal 42xxx, or a
+   * function's own `raise` P0001). A person may still retry by hand; nothing retries it alone.
+   */
+  get permanent() {
+    return !this.transient && !this.rateLimited && /^(22|23|42|P0)/.test(this.code ?? "");
+  }
+};
+function must(operation, result) {
+  if (result.error) throw new ChatError(result.error.message, result.error.code, operation);
+  return result.data;
+}
+var str = (v) => v == null ? null : String(v);
+var num = (v) => v == null ? null : Number(v);
+function toAttachment(r) {
+  return {
+    id: String(r.id),
+    messageId: String(r.message_id),
+    position: Number(r.position ?? 0),
+    kind: String(r.kind),
+    ref: r.ref ?? {},
+    provider: r.provider ?? "storage",
+    path: str(r.path),
+    providerId: str(r.provider_id),
+    playbackId: str(r.playback_id),
+    url: str(r.url),
+    status: r.status ?? "ready",
+    name: str(r.name),
+    mime: str(r.mime),
+    bytes: num(r.bytes),
+    width: num(r.width),
+    height: num(r.height),
+    durationMs: num(r.duration_ms),
+    waveform: r.waveform ?? null,
+    posterPath: str(r.poster_path),
+    thumbhash: str(r.thumbhash),
+    transcript: str(r.transcript),
+    transcriptStatus: r.transcript_status ?? null
+  };
+}
+function toMessage(r) {
+  const attachments = (r.attachments ?? []).map(toAttachment).sort((a, b) => a.position - b.position);
+  const reactions = (r.reactions ?? []).map((x) => ({ emoji: String(x.emoji), userId: String(x.user_id) }));
+  return {
+    id: String(r.id),
+    conversationId: String(r.conversation_id),
+    seq: Number(r.seq),
+    clientId: String(r.client_id),
+    senderId: str(r.sender_id),
+    senderRole: r.sender_role,
+    kind: r.kind ?? "text",
+    body: String(r.body ?? ""),
+    mentions: r.mentions ?? [],
+    replyToId: str(r.reply_to_id),
+    threadRootId: str(r.thread_root_id),
+    threadCount: Number(r.thread_count ?? 0),
+    threadLastAt: str(r.thread_last_at),
+    topic: str(r.topic),
+    visibility: r.visibility ?? "everyone",
+    silent: Boolean(r.silent),
+    meta: r.meta ?? {},
+    createdAt: String(r.created_at),
+    editedAt: str(r.edited_at),
+    deletedAt: str(r.deleted_at),
+    moderation: r.moderation === "hidden" || r.moderation === "flagged" ? r.moderation : null,
+    attachments,
+    reactions
+  };
+}
+function toConversation(r) {
+  return {
+    id: String(r.id),
+    kind: String(r.kind),
+    title: str(r.title),
+    subjectType: str(r.subject_type),
+    subjectId: str(r.subject_id),
+    settings: r.settings ?? {},
+    status: r.status ?? null,
+    assigneeId: str(r.assignee_id),
+    lastSeq: Number(r.last_seq ?? 0),
+    lastMessageAt: str(r.last_message_at),
+    createdAt: String(r.created_at),
+    archivedAt: str(r.archived_at)
+  };
+}
+function toInboxItem(r) {
+  const last = r.last_message;
+  return {
+    conversationId: String(r.conversation_id),
+    kind: String(r.kind),
+    title: str(r.title),
+    subjectType: str(r.subject_type),
+    subjectId: str(r.subject_id),
+    status: r.status ?? null,
+    role: r.role,
+    otherUserId: str(r.other_user_id),
+    memberCount: Number(r.member_count ?? 0),
+    lastSeq: Number(r.last_seq ?? 0),
+    lastReadSeq: Number(r.last_read_seq ?? 0),
+    unread: Number(r.unread ?? 0),
+    mentioned: Boolean(r.mentioned),
+    muted: Boolean(r.muted),
+    pinned: Boolean(r.pinned),
+    archived: Boolean(r.archived),
+    lastMessageAt: str(r.last_message_at),
+    lastMessage: last ? {
+      id: String(last.id),
+      seq: Number(last.seq),
+      senderId: str(last.sender_id),
+      kind: last.kind ?? "text",
+      body: String(last.body ?? ""),
+      deleted: Boolean(last.deleted),
+      createdAt: String(last.created_at),
+      attachment: last.attachment ?? null
+    } : null
+  };
+}
+function toTopic(r) {
+  return {
+    conversationId: String(r.conversation_id),
+    topic: String(r.topic),
+    title: String(r.title ?? r.topic),
+    position: Number(r.position ?? 0),
+    closedAt: str(r.closed_at),
+    createdBy: str(r.created_by),
+    createdAt: String(r.created_at)
+  };
+}
+function fromAttachmentArg(a) {
+  const out = { kind: String(a.kind ?? "file") };
+  const map = [
+    ["path", "path"],
+    ["provider", "provider"],
+    ["providerId", "provider_id"],
+    ["url", "url"],
+    ["ref", "ref"],
+    ["status", "status"],
+    ["name", "name"],
+    ["mime", "mime"],
+    ["bytes", "bytes"],
+    ["width", "width"],
+    ["height", "height"],
+    ["durationMs", "duration_ms"],
+    ["waveform", "waveform"],
+    ["posterPath", "poster_path"],
+    ["thumbhash", "thumbhash"]
+  ];
+  for (const [k, col] of map) if (a[col] != null) out[k] = a[col];
+  return out;
+}
+function toScheduled(r) {
+  const sentMessageId = str(r.sent_message_id);
+  const cancelledAt = str(r.cancelled_at);
+  const error = str(r.error);
+  return {
+    id: String(r.id),
+    conversationId: String(r.conversation_id),
+    clientId: String(r.client_id),
+    body: String(r.body ?? ""),
+    attachments: (r.attachments ?? []).map(fromAttachmentArg),
+    replyToId: str(r.reply_to_id),
+    topic: str(r.topic),
+    mentions: r.mentions ?? [],
+    silent: Boolean(r.silent),
+    sendAt: String(r.send_at),
+    sentMessageId,
+    cancelledAt,
+    error,
+    createdAt: String(r.created_at),
+    status: sentMessageId ? "sent" : cancelledAt ? "cancelled" : error ? "failed" : "scheduled"
+  };
+}
+function toAvailability(r) {
+  return {
+    userId: String(r.user_id),
+    awayMessage: str(r.away_message),
+    awayUntil: str(r.away_until),
+    timeZone: str(r.time_zone),
+    // Someone else's hours: only well-formed days and ranges reach the renderers.
+    hours: normalizeHours(r.hours)
+  };
+}
+function toSearchHit(r) {
+  return {
+    messageId: String(r.message_id),
+    conversationId: String(r.conversation_id),
+    seq: Number(r.seq),
+    senderId: str(r.sender_id),
+    createdAt: String(r.created_at),
+    snippet: String(r.snippet ?? ""),
+    inTranscript: Boolean(r.in_transcript),
+    threadRootId: str(r.thread_root_id)
+  };
+}
+function toLinkPreview(r) {
+  const image = str(r.image_url);
+  return {
+    url: String(r.url),
+    status: r.status ?? "ok",
+    title: str(r.title),
+    description: str(r.description),
+    imageUrl: image && /^https:\/\//i.test(image) ? image : null,
+    siteName: str(r.site_name),
+    fetchedAt: String(r.fetched_at)
+  };
+}
+var MESSAGE_COLUMNS = "*, attachments(*), reactions(emoji, user_id)";
+function createChatClient(supabase, options = {}) {
+  const db = () => supabase.schema(CHAT_SCHEMA);
+  const signedUrlSeconds = options.signedUrlSeconds ?? 3600;
+  const signedCache = /* @__PURE__ */ new Map();
+  const unsubscribed = /* @__PURE__ */ new WeakSet();
+  function join(channel, onStatus) {
+    const realtime = supabase.realtime;
+    void Promise.resolve(realtime?.setAuth?.()).catch(() => void 0).then(() => {
+      if (!unsubscribed.has(channel)) channel.subscribe(onStatus);
+    });
+    return () => {
+      unsubscribed.add(channel);
+      void supabase.removeChannel(channel);
+    };
+  }
+  async function rpc(fn, args) {
+    return must(fn, await db().rpc(fn, args));
+  }
+  return {
+    supabase,
+    /** Your conversations: one `kind`, several `kinds`, or all but `excludeKinds` (e.g. Messages without `support`). */
+    async inbox(opts = {}) {
+      const rows = await rpc("inbox", {
+        p_kind: opts.kind ?? null,
+        p_archived: opts.archived ?? false,
+        p_limit: opts.limit ?? 50,
+        p_before: opts.before ?? null,
+        ...opts.kinds?.length ? { p_kinds: opts.kinds } : {},
+        ...opts.excludeKinds?.length ? { p_exclude_kinds: opts.excludeKinds } : {}
+      });
+      return rows.map(toInboxItem);
+    },
+    async observed(kind, opts = {}) {
+      return rpc("observed", { p_kind: kind, p_status: opts.status ?? null, p_limit: opts.limit ?? 50, p_before: opts.before ?? null });
+    },
+    /** Unread across your conversations (for a badge), leaving out `excludeKinds` to match an inbox that does. */
+    async unreadTotal(opts = {}) {
+      return rpc("unread_total", opts.excludeKinds?.length ? { p_exclude_kinds: opts.excludeKinds } : {});
+    },
+    async conversation(id) {
+      const row = must("conversation", await db().from("conversations").select("*").eq("id", id).maybeSingle());
+      return row ? toConversation(row) : null;
+    },
+    /** A kind's rules (how many members, who posts, threads), for what the UI offers. */
+    async kind(kind) {
+      const row = must("kind", await db().from("kinds").select("kind, label, max_members, who_posts, membership, threads, observers_post").eq("kind", kind).maybeSingle());
+      return row ? {
+        kind: String(row.kind),
+        label: String(row.label),
+        maxMembers: row.max_members == null ? null : Number(row.max_members),
+        whoPosts: row.who_posts,
+        membership: row.membership,
+        threads: Boolean(row.threads),
+        observersPost: Boolean(row.observers_post)
+      } : null;
+    },
+    async myRole(id) {
+      return rpc("my_role", { p_conversation_id: id });
+    },
+    async canPost(id) {
+      return rpc("can_post", { p_conversation_id: id });
+    },
+    async members(id) {
+      const rows = must(
+        "members",
+        await db().from("members").select("*").eq("conversation_id", id).is("left_at", null).neq("role", "observer")
+      );
+      return rows.map((r) => ({
+        conversationId: String(r.conversation_id),
+        userId: String(r.user_id),
+        role: r.role,
+        lastReadSeq: Number(r.last_read_seq ?? 0),
+        joinedAt: String(r.joined_at)
+      }));
+    },
+    /**
+     * A page of messages, oldest first: the latest `limit` (default 50), or those
+     * before `beforeSeq`, or (to catch up after a reconnect) those after `afterSeq`.
+     * A thread's replies with `threadRootId`; one topic's with `topic`.
+     */
+    async messages(conversationId, opts = {}) {
+      const limit = Math.min(Math.max(opts.limit ?? 50, 1), 200);
+      let q = db().from("messages").select(MESSAGE_COLUMNS).eq("conversation_id", conversationId);
+      q = opts.threadRootId ? q.eq("thread_root_id", opts.threadRootId) : q.is("thread_root_id", null);
+      if (opts.topic) q = q.eq("topic", opts.topic);
+      if (opts.afterSeq != null) {
+        const rows2 = must("messages", await q.gt("seq", opts.afterSeq).order("seq", { ascending: true }).limit(limit));
+        return { messages: rows2.map(toMessage), hasEarlier: false };
+      }
+      if (opts.beforeSeq != null) q = q.lt("seq", opts.beforeSeq);
+      const rows = must("messages", await q.order("seq", { ascending: false }).limit(limit + 1));
+      const hasEarlier = rows.length > limit;
+      return { messages: rows.slice(0, limit).map(toMessage).reverse(), hasEarlier };
+    },
+    async message(id) {
+      const row = must("message", await db().from("messages").select(MESSAGE_COLUMNS).eq("id", id).maybeSingle());
+      return row ? toMessage(row) : null;
+    },
+    async startConversation(kind, memberIds, opts = {}) {
+      return rpc("start_conversation", {
+        p_kind: kind,
+        p_member_ids: memberIds,
+        p_title: opts.title ?? null,
+        p_subject_type: opts.subjectType ?? null,
+        p_subject_id: opts.subjectId ?? null
+      });
+    },
+    /** Sends a message. Safe to retry with the same clientId. */
+    async send(input) {
+      const row = await rpc("send_message", {
+        p_conversation_id: input.conversationId,
+        p_client_id: input.clientId,
+        p_body: input.body ?? "",
+        p_attachments: (input.attachments ?? []).map(attachmentArg),
+        p_reply_to_id: input.replyToId ?? null,
+        p_thread_root_id: input.threadRootId ?? null,
+        p_topic: input.topic ?? null,
+        p_mentions: input.mentions ?? [],
+        p_visibility: input.visibility ?? "everyone",
+        p_silent: input.silent ?? false
+      });
+      return await this.message(String(row.id)) ?? toMessage(row);
+    },
+    async edit(messageId, body, mentions = []) {
+      return toMessage(await rpc("edit_message", { p_message_id: messageId, p_body: body, p_mentions: mentions }));
+    },
+    async remove(messageId) {
+      await rpc("delete_message", { p_message_id: messageId });
+    },
+    async react(messageId, emoji, on = true) {
+      await rpc("react", { p_message_id: messageId, p_emoji: emoji, p_on: on });
+    },
+    async markRead(conversationId, seq) {
+      return rpc("mark_read", { p_conversation_id: conversationId, p_seq: seq ?? null });
+    },
+    async setMySettings(conversationId, s) {
+      await rpc("set_my_settings", {
+        p_conversation_id: conversationId,
+        p_muted_until: s.mutedUntil ?? null,
+        p_notify: s.notify ?? null,
+        p_archived: s.archived ?? null,
+        p_pinned: s.pinned ?? null,
+        p_clear_mute: s.mutedUntil === null
+      });
+    },
+    async updateConversation(conversationId, s) {
+      await rpc("update_conversation", { p_conversation_id: conversationId, p_title: s.title ?? null, p_settings: s.settings ?? null });
+    },
+    async addMembers(conversationId, userIds) {
+      await rpc("add_members", { p_conversation_id: conversationId, p_user_ids: userIds });
+    },
+    async removeMember(conversationId, userId) {
+      await rpc("remove_member", { p_conversation_id: conversationId, p_user_id: userId ?? null });
+    },
+    async setStatus(conversationId, status, assigneeId) {
+      await rpc("set_status", { p_conversation_id: conversationId, p_status: status, p_assignee_id: assigneeId ?? null });
+    },
+    async pin(messageId, on = true) {
+      await rpc("pin_message", { p_message_id: messageId, p_on: on });
+    },
+    async pins(conversationId) {
+      const rows = must("pins", await db().from("pins").select("message_id").eq("conversation_id", conversationId));
+      return rows.map((r) => String(r.message_id));
+    },
+    async save(messageId, on = true, note) {
+      await rpc("save_message", { p_message_id: messageId, p_on: on, p_note: note ?? null });
+    },
+    async report(messageId, reason, note) {
+      return rpc("report_message", { p_message_id: messageId, p_reason: reason, p_note: note ?? null });
+    },
+    // ── Migration 0002 ──────────────────────────────────────────────────────
+    /** A conversation's topics, in order (position, then key). */
+    async topics(conversationId) {
+      const rows = must(
+        "topics",
+        await db().from("topics").select("*").eq("conversation_id", conversationId).order("position", { ascending: true }).order("topic", { ascending: true })
+      );
+      return rows.map(toTopic);
+    },
+    /** Adds a topic, or renames, reorders, closes (`closed: true`) or reopens it. Owners and admins. */
+    async setTopic(conversationId, topic, input = {}) {
+      await rpc("set_topic", {
+        p_conversation_id: conversationId,
+        p_topic: topic,
+        p_title: input.title ?? null,
+        p_position: input.position ?? null,
+        p_closed: input.closed ?? null
+      });
+    },
+    /** Schedules a message (a minute to a year ahead) and returns its id. Safe to retry with the same clientId. */
+    async schedule(input) {
+      const sendAt = typeof input.sendAt === "string" ? input.sendAt : input.sendAt.toISOString();
+      return rpc("schedule_message", {
+        p_conversation_id: input.conversationId,
+        p_client_id: input.clientId,
+        p_send_at: sendAt,
+        p_body: input.body ?? "",
+        p_attachments: (input.attachments ?? []).map(attachmentArg),
+        p_reply_to_id: input.replyToId ?? null,
+        p_topic: input.topic ?? null,
+        p_mentions: input.mentions ?? [],
+        p_silent: input.silent ?? false
+      });
+    },
+    /** Your messages still waiting to go (and ones that failed when due), soonest first; in one conversation or all. */
+    async scheduled(conversationId) {
+      let q = db().from("scheduled").select("*").is("sent_message_id", null).is("cancelled_at", null);
+      if (conversationId) q = q.eq("conversation_id", conversationId);
+      const rows = must("scheduled", await q.order("send_at", { ascending: true }).limit(200));
+      return rows.map(toScheduled);
+    },
+    async cancelScheduled(id) {
+      await rpc("cancel_scheduled", { p_id: id });
+    },
+    /** The away message and hours of a conversation's members who set them (not observers). */
+    async availabilityFor(conversationId) {
+      const rows = await rpc("availability_for", { p_conversation_id: conversationId });
+      return (rows ?? []).map(toAvailability);
+    },
+    /** Your own away message and hours, or null when never set. */
+    async myAvailability() {
+      const row = must("myAvailability", await db().from("availability").select("*").maybeSingle());
+      return row ? toAvailability(row) : null;
+    },
+    /** Replaces your away message and hours (a field left out is cleared). */
+    async setAvailability(input) {
+      const until = input.awayUntil ?? null;
+      await rpc("set_availability", {
+        p_away_message: input.awayMessage ?? null,
+        p_away_until: until,
+        p_time_zone: input.timeZone ?? null,
+        p_hours: input.hours ?? null
+      });
+    },
+    /**
+     * Sends one text message into each of these conversations where you may post (a coach to
+     * each client's direct conversation), so replies come back privately. Text only. Safe to
+     * retry with the same clientId. Returns the ids of the messages sent.
+     */
+    async broadcast(conversationIds, clientId, body, opts = {}) {
+      const ids = await rpc("broadcast_message", {
+        p_conversation_ids: conversationIds,
+        p_client_id: clientId,
+        p_body: body,
+        p_attachments: [],
+        p_silent: opts.silent ?? false
+      });
+      return (ids ?? []).map(String);
+    },
+    /** Messages (and transcripts) you can read that match, newest first: in one conversation or all of yours. Two characters at least. */
+    async search(query, conversationId, opts = {}) {
+      if (query.trim().length < 2) return [];
+      const rows = await rpc("search_messages", {
+        p_query: query,
+        p_conversation_id: conversationId ?? null,
+        p_limit: opts.limit ?? 30
+      });
+      return (rows ?? []).map(toSearchHit);
+    },
+    /**
+     * The previews the server has fetched for the links in these messages, by message id (only
+     * `ok` ones; links not fetched yet are left out). Read through link_previews_for, one call
+     * per message (up to 6 at once), which answers only for messages you can read: the preview
+     * table itself is closed, since a URL can carry a secret.
+     */
+    async linkPreviewsFor(messageIds) {
+      const ids = [...new Set(messageIds.filter(Boolean))].slice(0, 200);
+      const out = {};
+      let next = 0;
+      const worker = async () => {
+        while (next < ids.length) {
+          const id = ids[next++];
+          const rows = await rpc("link_previews_for", { p_message_id: id });
+          out[id] = (rows ?? []).map(toLinkPreview).filter((p) => p.status === "ok");
+        }
+      };
+      await Promise.all(Array.from({ length: Math.min(6, ids.length) }, worker));
+      return out;
+    },
+    /**
+     * Uploads a file into the conversation's folder for the signed-in person and
+     * returns its path, ready to attach. Resumable for big files is the native
+     * renderer's job (Supabase TUS); this is the plain upload.
+     *
+     * With `onProgress(sent, total)`, where XMLHttpRequest exists (browsers, React Native), the
+     * bytes go to a signed upload URL (`createSignedUploadUrl`, which checks the same storage
+     * policy as a plain upload) through XMLHttpRequest, which reports progress; elsewhere the
+     * plain upload runs and reports once, at the end. `signal` cancels it.
+     */
+    async upload(conversationId, userId, file, opts) {
+      const ext = fileExtension(opts.name, opts.contentType);
+      if (!isAllowedExtension(ext)) throw new ChatError(`Files of type .${ext} can't be sent`, "22023", "upload");
+      const id = opts.id ?? randomId();
+      const path = `${conversationId}/${userId}/${id}.${ext}`;
+      const bucket = supabase.storage.from(CHAT_BUCKET);
+      if (opts.onProgress && typeof XMLHttpRequest !== "undefined" && typeof bucket.createSignedUploadUrl === "function") {
+        const signed = must("upload", await bucket.createSignedUploadUrl(path));
+        if (!signed?.signedUrl) throw new ChatError("No upload URL came back", void 0, "upload");
+        await sendBytes(signed.signedUrl, file, {
+          method: "PUT",
+          headers: { "content-type": opts.contentType, "x-upsert": "false", "cache-control": "max-age=3600" },
+          signal: opts.signal,
+          onProgress: opts.onProgress
+        });
+        return path;
+      }
+      must("upload", await bucket.upload(path, file, { contentType: opts.contentType, upsert: false }));
+      const total = typeof Blob !== "undefined" && file instanceof Blob ? file.size : file.byteLength;
+      opts.onProgress?.(total, total);
+      return path;
+    },
+    /** Signed links for files, cached until shortly before they expire. */
+    async fileUrls(paths) {
+      const now = Date.now();
+      const out = {};
+      const missing = [];
+      for (const p of new Set(paths)) {
+        const hit = signedCache.get(p);
+        if (hit && hit.until > now) out[p] = hit.url;
+        else missing.push(p);
+      }
+      if (missing.length) {
+        const { data, error } = await supabase.storage.from(CHAT_BUCKET).createSignedUrls(missing, signedUrlSeconds);
+        if (error) throw new ChatError(error.message, void 0, "fileUrls");
+        for (const d of data ?? []) {
+          if (d.signedUrl && d.path) {
+            out[d.path] = d.signedUrl;
+            signedCache.set(d.path, { url: d.signedUrl, until: now + (signedUrlSeconds - 60) * 1e3 });
+          }
+        }
+      }
+      return out;
+    },
+    /** Your inbox's live hints (a new message anywhere you are, a membership change). */
+    subscribeInbox(userId, onSignal) {
+      const channel = supabase.channel(userTopic(userId), { config: { private: true } }).on(
+        "broadcast",
+        { event: "inbox" },
+        ({ payload }) => onSignal({ type: "inbox", conversationId: String(payload?.conversation_id), seq: payload?.seq })
+      );
+      return { unsubscribe: join(channel) };
+    },
+    /**
+     * A conversation's live hints, plus who is typing or recording. `onJoin` runs every
+     * time the channel joins, the first time included: the moment to fetch what arrived
+     * before the subscription was live. `onReconnect` (kept for older callers) runs on
+     * re-joins only.
+     */
+    subscribeConversation(conversationId, me, handlers) {
+      let joinedOnce = false;
+      const channel = supabase.channel(conversationTopic(conversationId), { config: { private: true, broadcast: { self: false } } }).on(
+        "broadcast",
+        { event: "message" },
+        ({ payload }) => handlers.onSignal({ type: "message", conversationId, id: String(payload?.id), seq: payload?.seq, op: payload?.op ?? "insert" })
+      ).on(
+        "broadcast",
+        { event: "reaction" },
+        ({ payload }) => handlers.onSignal({ type: "reaction", conversationId, messageId: String(payload?.message_id) })
+      ).on("broadcast", { event: "members" }, () => handlers.onSignal({ type: "members", conversationId })).on("broadcast", { event: "conversation" }, () => handlers.onSignal({ type: "conversation", conversationId })).on("broadcast", { event: "activity" }, ({ payload }) => {
+        if (payload?.userId && payload.userId !== me) handlers.onActivity?.({ userId: payload.userId, activity: payload.activity, at: Date.now() });
+      });
+      let joined = false;
+      const leave = join(channel, (status) => {
+        joined = status === "SUBSCRIBED";
+        if (status === "SUBSCRIBED") {
+          handlers.onJoin?.();
+          if (joinedOnce) handlers.onReconnect?.();
+          joinedOnce = true;
+        }
+      });
+      return {
+        signal(activity) {
+          if (!joined) return;
+          void channel.send({ type: "broadcast", event: "activity", payload: { userId: me, activity } });
+        },
+        unsubscribe: leave
+      };
+    }
+  };
+}
+function attachmentArg(a) {
+  return {
+    kind: a.kind,
+    path: a.path,
+    provider: a.provider,
+    provider_id: a.providerId,
+    url: a.url,
+    ref: a.ref,
+    status: a.status,
+    name: a.name,
+    mime: a.mime,
+    bytes: a.bytes,
+    width: a.width,
+    height: a.height,
+    duration_ms: a.durationMs,
+    waveform: a.waveform,
+    poster_path: a.posterPath,
+    thumbhash: a.thumbhash
+  };
+}
+
+// src/core/transfer.ts
+var sizeOf = (body) => typeof Blob !== "undefined" && body instanceof Blob ? body.size : body.byteLength;
+var refusal = (status) => status >= 500 || status === 0 || status === 408 ? void 0 : status === 429 ? "GS429" : "22023";
+var aborted = () => new ChatError("The upload was cancelled", "GSABORT", "upload");
+function sendBytes(url, body, opts = {}) {
+  const method = opts.method ?? "PUT";
+  const total = sizeOf(body);
+  if (opts.signal?.aborted) return Promise.reject(aborted());
+  if (typeof XMLHttpRequest === "undefined" || opts.fetch) {
+    const f = opts.fetch ?? fetch;
+    return f(url, { method, body, headers: opts.headers, signal: opts.signal }).then(async (res) => {
+      if (!res.ok) throw new ChatError(`The upload failed (${res.status})`, refusal(res.status), "upload");
+      opts.onProgress?.(total, total);
+      return res.text().catch(() => "");
+    });
+  }
+  return new Promise((resolve, reject) => {
+    const xhr = new XMLHttpRequest();
+    const onAbort = () => xhr.abort();
+    const done = () => opts.signal?.removeEventListener("abort", onAbort);
+    xhr.open(method, url);
+    for (const [k, v] of Object.entries(opts.headers ?? {})) xhr.setRequestHeader(k, v);
+    if (opts.onProgress && xhr.upload) {
+      xhr.upload.onprogress = (e) => opts.onProgress?.(e.loaded, e.lengthComputable ? e.total : total);
+    }
+    xhr.onload = () => {
+      done();
+      if (xhr.status >= 200 && xhr.status < 300) {
+        opts.onProgress?.(total, total);
+        resolve(typeof xhr.responseText === "string" ? xhr.responseText : "");
+      } else {
+        reject(new ChatError(`The upload failed (${xhr.status})`, refusal(xhr.status), "upload"));
+      }
+    };
+    xhr.onerror = () => {
+      done();
+      reject(new ChatError("The upload didn't reach the server", void 0, "upload"));
+    };
+    xhr.onabort = () => {
+      done();
+      reject(aborted());
+    };
+    opts.signal?.addEventListener("abort", onAbort, { once: true });
+    xhr.send(body);
+  });
+}
+
+export { ALLOWED_EXTENSIONS, CHAT_BUCKET, CHAT_LIMITS, CHAT_SCHEMA, ChatError, MAX_RANGES_PER_DAY, PLAYBACK_RATES, WEEKDAYS, attachmentKindFor, awayLine, awaySummary, conversationTopic, createChatClient, fileExtension, formatDuration, hoursSummary, isAllowedExtension, isAway, isWithinWorkingHours, localClock, minutesOf, namesLine, nextPlaybackRate, normalizeHours, randomId, recordingLimitMs, sendBytes, timeZoneLabel, toAttachment, toAvailability, toLinkPreview, toMessage, toScheduled, toSearchHit, toTopic, untilLabel, userTopic, waveformFromMetering, waveformPeaks };
+//# sourceMappingURL=chunk-GBJ3YI4E.js.map
+//# sourceMappingURL=chunk-GBJ3YI4E.js.map