@marktiderman/genesis-chat 0.1.1 → 0.2.1

package/dist/{client-BtdALFCx.d.ts → client-DUIG1hum.d.ts}

@@ -2,7 +2,7 @@ import { SupabaseClient } from '@supabase/supabase-js';
 
 /**
  * @feat:chat
- * The chat contract: what the genesis_chat schema (migration 0001) stores, in
+ * The chat contract: what the genesis_chat schema (migrations 0001 and 0002) stores, in
  * the app's words. Everything here is plain data, shared by web, native and
  * the server.
  */
@@ -64,6 +64,11 @@ interface ChatMessage {
     createdAt: string;
     editedAt: string | null;
     deletedAt: string | null;
+    /**
+     * What moderation said (migration 0002): `hidden` messages reach only their sender and the
+     * conversation's observers; `flagged` ones are visible to everyone and reported to observers.
+     */
+    moderation?: "flagged" | "hidden" | null;
     attachments: ChatAttachment[];
     reactions: ChatReaction[];
 }
@@ -174,6 +179,8 @@ interface PendingMessage {
     createdAt: string;
     status: "sending" | "failed";
     error?: string;
+    /** The server refused it (not allowed, bad data): only a manual retry sends it again. */
+    permanent?: boolean;
     /** Local previews for files still uploading (object URLs or file URIs). */
     previews?: Record<number, string>;
     /** What each file is, in order, so a pending bubble can draw it (a voice note's duration and waveform, a file's name). */
@@ -186,6 +193,20 @@ interface PendingFile {
     meta?: Partial<AttachmentInput>;
     /** Not kept between launches (bytes with nowhere to save them): attach it again. */
     lost?: boolean;
+    /** How much of it has uploaded, 0 to 1, once the upload reports progress. */
+    progress?: number;
+    /** Going to the hosted video provider (Mux, Cloudflare) rather than storage. */
+    hosted?: boolean;
+}
+/**
+ * A hosted video upload that has started: the provider's upload id, sent with the message as
+ * `{ provider, providerId, status: "pending" }` while the bytes still go up. The provider's
+ * webhook marks the attachment ready.
+ */
+interface HostedAttachment {
+    provider: "mux" | "cloudflare";
+    providerId: string;
+    status: "pending";
 }
 /** A live hint from Realtime: something changed; fetch to see what. */
 type ChatSignal = {
@@ -215,10 +236,101 @@ interface ChatActivity {
     activity: "typing" | "recording-voice" | "recording-video";
     at: number;
 }
+/** A named sub-thread of a conversation (a cohort's lesson threads). Messages join one through `topic`. */
+interface ChatTopic {
+    conversationId: string;
+    /** The key messages carry in `topic`. */
+    topic: string;
+    title: string;
+    position: number;
+    /** Set when closed: only owners, admins and observers post in it then. */
+    closedAt: string | null;
+    createdBy: string | null;
+    createdAt: string;
+}
+/** What `setTopic` changes; anything left out keeps its value (a new topic's title is its key). */
+interface TopicInput {
+    title?: string;
+    position?: number;
+    closed?: boolean;
+}
+/** A message to send later, as its sender. Only its sender reads it. */
+interface ScheduledMessage {
+    id: string;
+    conversationId: string;
+    clientId: string;
+    body: string;
+    attachments: AttachmentInput[];
+    replyToId: string | null;
+    topic: string | null;
+    mentions: string[];
+    silent: boolean;
+    sendAt: string;
+    sentMessageId: string | null;
+    cancelledAt: string | null;
+    /** Why it couldn't be sent when due (the sender left the conversation, say). */
+    error: string | null;
+    createdAt: string;
+    status: "scheduled" | "sent" | "cancelled" | "failed";
+}
+/** Between a minute and a year ahead. Files in `attachments` are uploaded first, as for `send`. */
+interface ScheduleInput extends Omit<SendInput, "threadRootId" | "visibility"> {
+    sendAt: string | Date;
+}
+type Weekday = "mon" | "tue" | "wed" | "thu" | "fri" | "sat" | "sun";
+/** Working hours per weekday as `[["09:00","17:00"]]`, 24-hour local times; a missing day is not working. An end at or before its start runs past midnight. */
+type WorkingHours = Partial<Record<Weekday, [string, string][]>>;
+/** A person's away message and working hours. */
+interface ChatAvailability {
+    userId: string;
+    awayMessage: string | null;
+    /** Away until then; with an away message and no date, away until they clear it. */
+    awayUntil: string | null;
+    /** An IANA zone (`America/New_York`); hours are read in it. */
+    timeZone: string | null;
+    hours: WorkingHours | null;
+}
+type AvailabilityInput = Partial<Omit<ChatAvailability, "userId">>;
+/** One search result. `snippet` marks the matched words with « and » (the text's own « and » arrive as ‹ and ›, so marks are always real). */
+interface ChatSearchHit {
+    messageId: string;
+    conversationId: string;
+    seq: number;
+    senderId: string | null;
+    createdAt: string;
+    snippet: string;
+    /** Found in a voice note's or video's transcript, not the text. */
+    inTranscript: boolean;
+    /** The thread the message is a reply in (open that thread to show it); null on the main timeline. */
+    threadRootId: string | null;
+}
+/** Open Graph data for a link (fetched by the server's runner). Plain text: never render it as HTML. */
+interface ChatLinkPreview {
+    url: string;
+    status: "ok" | "failed" | "blocked";
+    title: string | null;
+    description: string | null;
+    /** Always https when present. */
+    imageUrl: string | null;
+    siteName: string | null;
+    fetchedAt: string;
+}
+
+type UploadProgress = (sent: number, total: number) => void;
+interface SendBytesOptions {
+    method?: "PUT" | "POST";
+    headers?: Record<string, string>;
+    signal?: AbortSignal;
+    onProgress?: UploadProgress;
+    /** For tests and runtimes without XMLHttpRequest. */
+    fetch?: typeof fetch;
+}
+/** Sends `body` to `url`; resolves with the response text, throws a ChatError on a non-2xx answer. */
+declare function sendBytes(url: string, body: Blob | ArrayBuffer, opts?: SendBytesOptions): Promise<string>;
 
 /**
  * @feat:chat
- * The chat client: the app's own Supabase (migration 0001, the genesis_chat
+ * The chat client: the app's own Supabase (migrations 0001 and 0002, the genesis_chat
  * schema) under row level security. Reads are table selects; every write is a
  * genesis_chat function. Live updates are hints on private Realtime topics,
  * after which the client fetches again, so nothing is trusted from the wire.
@@ -239,10 +351,21 @@ declare class ChatError extends Error {
     get rateLimited(): boolean;
     /** Worth trying again: the network, not the database, said no. */
     get transient(): boolean;
+    /**
+     * 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(): boolean;
 }
 type Row = Record<string, unknown>;
 declare function toAttachment(r: Row): ChatAttachment;
 declare function toMessage(r: Row): ChatMessage;
+declare function toTopic(r: Row): ChatTopic;
+declare function toScheduled(r: Row): ScheduledMessage;
+declare function toAvailability(r: Row): ChatAvailability;
+declare function toSearchHit(r: Row): ChatSearchHit;
+declare function toLinkPreview(r: Row): ChatLinkPreview;
 interface MessagePage {
     messages: ChatMessage[];
     /** More, older messages exist before the first one. */
@@ -255,14 +378,25 @@ interface ChatClientOptions {
 interface Subscription {
     unsubscribe(): void;
 }
+interface ConversationHandlers {
+    onSignal: (s: ChatSignal) => void;
+    onActivity?: (a: ChatActivity) => void;
+    /** Every join, the first included: catch up on what arrived before the channel was live. */
+    onJoin?: () => void;
+    /** Re-joins only. Prefer `onJoin`. */
+    onReconnect?: () => void;
+}
 interface ConversationChannel extends Subscription {
     /** Tell the others you are typing or recording (throttle to once every 3 seconds). */
     signal(activity: ChatActivity["activity"]): void;
 }
 declare function createChatClient(supabase: ChatSupabase, options?: ChatClientOptions): {
     supabase: ChatSupabase;
+    /** Your conversations: one `kind`, several `kinds`, or all but `excludeKinds` (e.g. Messages without `support`). */
     inbox(opts?: {
         kind?: string;
+        kinds?: string[];
+        excludeKinds?: string[];
         archived?: boolean;
         limit?: number;
         before?: string;
@@ -272,7 +406,10 @@ declare function createChatClient(supabase: ChatSupabase, options?: ChatClientOp
         limit?: number;
         before?: string;
     }): Promise<Row[]>;
-    unreadTotal(): Promise<number>;
+    /** Unread across your conversations (for a badge), leaving out `excludeKinds` to match an inbox that does. */
+    unreadTotal(opts?: {
+        excludeKinds?: string[];
+    }): Promise<number>;
     conversation(id: string): Promise<ChatConversation | null>;
     /** A kind's rules (how many members, who posts, threads), for what the UI offers. */
     kind(kind: string): Promise<ChatKindRules | null>;
@@ -320,30 +457,69 @@ declare function createChatClient(supabase: ChatSupabase, options?: ChatClientOp
     pins(conversationId: string): Promise<string[]>;
     save(messageId: string, on?: boolean, note?: string): Promise<void>;
     report(messageId: string, reason: "spam" | "harassment" | "safety" | "other", note?: string): Promise<string>;
+    /** A conversation's topics, in order (position, then key). */
+    topics(conversationId: string): Promise<ChatTopic[]>;
+    /** Adds a topic, or renames, reorders, closes (`closed: true`) or reopens it. Owners and admins. */
+    setTopic(conversationId: string, topic: string, input?: TopicInput): Promise<void>;
+    /** Schedules a message (a minute to a year ahead) and returns its id. Safe to retry with the same clientId. */
+    schedule(input: ScheduleInput): Promise<string>;
+    /** Your messages still waiting to go (and ones that failed when due), soonest first; in one conversation or all. */
+    scheduled(conversationId?: string): Promise<ScheduledMessage[]>;
+    cancelScheduled(id: string): Promise<void>;
+    /** The away message and hours of a conversation's members who set them (not observers). */
+    availabilityFor(conversationId: string): Promise<ChatAvailability[]>;
+    /** Your own away message and hours, or null when never set. */
+    myAvailability(): Promise<ChatAvailability | null>;
+    /** Replaces your away message and hours (a field left out is cleared). */
+    setAvailability(input: AvailabilityInput): Promise<void>;
+    /**
+     * 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.
+     */
+    broadcast(conversationIds: string[], clientId: string, body: string, opts?: {
+        silent?: boolean;
+    }): Promise<string[]>;
+    /** Messages (and transcripts) you can read that match, newest first: in one conversation or all of yours. Two characters at least. */
+    search(query: string, conversationId?: string | null, opts?: {
+        limit?: number;
+    }): Promise<ChatSearchHit[]>;
+    /**
+     * 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.
+     */
+    linkPreviewsFor(messageIds: string[]): Promise<Record<string, ChatLinkPreview[]>>;
     /**
      * 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.
      */
     upload(conversationId: string, userId: string, file: Blob | ArrayBuffer, opts: {
         name: string;
         contentType: string;
         id?: string;
+        onProgress?: UploadProgress;
+        signal?: AbortSignal;
     }): Promise<string>;
     /** Signed links for files, cached until shortly before they expire. */
     fileUrls(paths: string[]): Promise<Record<string, string>>;
     /** Your inbox's live hints (a new message anywhere you are, a membership change). */
     subscribeInbox(userId: string, onSignal: (s: ChatSignal) => void): Subscription;
     /**
-     * A conversation's live hints, plus who is typing or recording. `onReconnect`
-     * runs whenever the channel (re)joins, the moment to fetch what was missed.
+     * 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: string, me: string, handlers: {
-        onSignal: (s: ChatSignal) => void;
-        onActivity?: (a: ChatActivity) => void;
-        onReconnect?: () => void;
-    }): ConversationChannel;
+    subscribeConversation(conversationId: string, me: string, handlers: ConversationHandlers): ConversationChannel;
 };
 type ChatClient = ReturnType<typeof createChatClient>;
 
-export { type AttachmentKind as A, type ChatClient as C, type MessagePage as M, type PendingMessage as P, type SendInput as S, type ChatConversation as a, type ChatMember as b, type ChatRole as c, type ChatKindRules as d, type ChatMessage as e, type ChatActivity as f, type ChatSignal as g, type ChatInboxItem as h, type ChatSupabase as i, type ChatAttachment as j, type AttachmentInput as k, type PendingFile as l, type AttachmentProvider as m, CHAT_BUCKET as n, CHAT_SCHEMA as o, type ChatClientOptions as p, ChatError as q, type ChatPreview as r, type ChatReaction as s, type ConversationChannel as t, type Subscription as u, conversationTopic as v, createChatClient as w, toAttachment as x, toMessage as y, userTopic as z };
+export { type AttachmentInput as A, type PendingMessage as B, type ChatAvailability as C, type ScheduledMessage as D, type SendBytesOptions as E, type SendInput as F, type Subscription as G, type HostedAttachment as H, conversationTopic as I, createChatClient as J, sendBytes as K, toAttachment as L, type MessagePage as M, toAvailability as N, toLinkPreview as O, type PendingFile as P, toMessage as Q, toScheduled as R, type ScheduleInput as S, type TopicInput as T, type UploadProgress as U, toSearchHit as V, type Weekday as W, toTopic as X, userTopic as Y, type WorkingHours as a, type AttachmentKind as b, type AttachmentProvider as c, type AvailabilityInput as d, CHAT_BUCKET as e, CHAT_SCHEMA as f, type ChatActivity as g, type ChatAttachment as h, type ChatClient as i, type ChatClientOptions as j, type ChatConversation as k, ChatError as l, type ChatInboxItem as m, type ChatKindRules as n, type ChatLinkPreview as o, type ChatMember as p, type ChatMessage as q, type ChatPreview as r, type ChatReaction as s, type ChatRole as t, type ChatSearchHit as u, type ChatSignal as v, type ChatSupabase as w, type ChatTopic as x, type ConversationChannel as y, type ConversationHandlers as z };

package/dist/index.d.ts

@@ -1,185 +1,100 @@
-import { A as AttachmentKind, e as ChatMessage, P as PendingMessage, f as ChatActivity, k as AttachmentInput, C as ChatClient, l as PendingFile, S as SendInput } from './client-BtdALFCx.js';
-export { m as AttachmentProvider, n as CHAT_BUCKET, o as CHAT_SCHEMA, j as ChatAttachment, p as ChatClientOptions, a as ChatConversation, q as ChatError, h as ChatInboxItem, d as ChatKindRules, b as ChatMember, r as ChatPreview, s as ChatReaction, c as ChatRole, g as ChatSignal, i as ChatSupabase, t as ConversationChannel, M as MessagePage, u as Subscription, v as conversationTopic, w as createChatClient, x as toAttachment, y as toMessage, z as userTopic } from './client-BtdALFCx.js';
+import { W as Weekday, C as ChatAvailability, a as WorkingHours } from './client-DUIG1hum.js';
+export { A as AttachmentInput, b as AttachmentKind, c as AttachmentProvider, d as AvailabilityInput, e as CHAT_BUCKET, f as CHAT_SCHEMA, g as ChatActivity, h as ChatAttachment, i as ChatClient, j as ChatClientOptions, k as ChatConversation, l as ChatError, m as ChatInboxItem, n as ChatKindRules, o as ChatLinkPreview, p as ChatMember, q as ChatMessage, r as ChatPreview, s as ChatReaction, t as ChatRole, u as ChatSearchHit, v as ChatSignal, w as ChatSupabase, x as ChatTopic, y as ConversationChannel, z as ConversationHandlers, H as HostedAttachment, M as MessagePage, P as PendingFile, B as PendingMessage, S as ScheduleInput, D as ScheduledMessage, E as SendBytesOptions, F as SendInput, G as Subscription, T as TopicInput, U as UploadProgress, I as conversationTopic, J as createChatClient, K as sendBytes, L as toAttachment, N as toAvailability, O as toLinkPreview, Q as toMessage, R as toScheduled, V as toSearchHit, X as toTopic, Y as userTopic } from './client-DUIG1hum.js';
+export { A as ALLOWED_EXTENSIONS, C as CHAT_LIMITS, H as HostedUpload, a as HostedUploadOptions, b as HostedUploadRecord, c as HostedUploadStart, L as LocalFile, O as Outbox, d as OutboxOptions, e as OutboxStore, P as PLAYBACK_RATES, Q as QueuedMessage, S as StorageUpload, f as attachmentKindFor, g as createOutbox, h as fileExtension, i as formatDuration, j as isAllowedExtension, m as memoryOutboxStore, n as nextPlaybackRate, r as randomId, k as recordingLimitMs, l as releaseObjectUrl, w as waveformFromMetering, o as waveformPeaks } from './outbox-B9NAWQ58.js';
+export { R as ReactionSummary, T as ThreadItem, a as activityLine, c as currentActivity, d as dayLabel, f as firstUnreadId, i as itemSender, b as itemTime, m as mergeThread, p as parseMentions, e as previewText, s as sameDay, g as startsDay, h as startsGroup, j as summarizeReactions, t as throttle, u as upsertMessages } from './thread-oPra7pkW.js';
 import '@supabase/supabase-js';
 
 /**
  * @feat:chat
- * Media rules shared by every platform: which files may be sent (the same list
- * migration 0001 checks), what kind an upload becomes, the default limits, and
- * the waveform a voice note carries so its bubble draws before the audio loads.
+ * Availability, the same on every platform: is someone inside their working hours (read in
+ * their own time zone), are they away, and the one line a thread shows about it ("Mark
+ * replies Mon–Fri, 9–5 (Eastern)", "Away until Monday: Back Monday"). Pure: `now` is passed
+ * in, and time zones come from Intl.
  */
 
+declare const WEEKDAYS: readonly Weekday[];
+/** "09:30" → 570; a bad value (anything but such a string) → null. "24:00" is allowed as the end of a day. */
+declare function minutesOf(hhmm: unknown): number | null;
+/** At most this many ranges a day, as the database allows. */
+declare const MAX_RANGES_PER_DAY = 4;
 /**
- * A random UUID (v4): `crypto.randomUUID` where the platform has it (some React Native
- * runtimes don't), else `crypto.getRandomValues`, else Math.random as a last resort. Ids
- * only need to be unique per sender: the server checks (sender, client_id).
+ * Working hours as they may safely be read: only mon..sun, each an array of `["HH:MM", "HH:MM"]`
+ * string pairs (at most four a day); every other day, range or value is dropped. Null when
+ * nothing is left. Hours come from other people, so they are never trusted as typed.
  */
-declare function randomId(): string;
-/** Mirrors genesis_chat.allowed_extension. Never SVG or HTML, which a browser runs as a page. */
-declare const ALLOWED_EXTENSIONS: readonly ["png", "jpg", "jpeg", "webp", "gif", "heic", "heif", "m4a", "aac", "mp3", "ogg", "oga", "opus", "weba", "webm", "mp4", "mov", "pdf", "txt", "csv", "docx", "xlsx", "pptx"];
-/** The extension a file is stored under: from its content type, else its name. */
-declare function fileExtension(name: string, contentType?: string): string;
-declare function isAllowedExtension(ext: string): boolean;
-/** What an upload becomes in a message. */
-declare function attachmentKindFor(contentType: string, opts?: {
-    recordedVoice?: boolean;
-}): AttachmentKind;
-/** Default limits (decision 5): an app may lower them, not raise them past the bucket's 100 MB. */
-declare const CHAT_LIMITS: {
-    /** Voice notes and videos, for members. */
-    readonly recordingMs: number;
-    /** For owners, admins and observers (coaches, staff). */
-    readonly staffRecordingMs: number;
-    readonly fileBytes: number;
-    readonly videoBytes: number;
-    readonly attachmentsPerMessage: 20;
-    readonly bodyChars: 10000;
+declare function normalizeHours(raw: unknown): WorkingHours | null;
+/** The weekday and minute of the day at `now` in `timeZone` (the device's zone when null or unknown). */
+declare function localClock(now: Date, timeZone?: string | null): {
+    day: Weekday;
+    minutes: number;
 };
-/** The longest recording this role may make. */
-declare function recordingLimitMs(role: string | null | undefined): number;
 /**
- * Peaks for a waveform: `count` values 0–100 from raw samples (-1…1), the loudest
- * in each bucket, scaled so the loudest bucket is 100. Quiet recordings still show
- * a shape; silence shows a flat line.
+ * Is `now` inside these working hours, read in `timeZone`? No hours set means always.
+ * A range whose end is at or before its start runs overnight into the next day
+ * (`fri: [["22:00","02:00"]]` covers Friday 22:00 to Saturday 02:00).
  */
-declare function waveformPeaks(samples: ArrayLike<number>, count?: number): number[];
+declare function isWithinWorkingHours(raw: WorkingHours | null | undefined, timeZone: string | null | undefined, now?: Date): boolean;
+/** Away now: an away message with no end date, or an end date still ahead. */
+declare function isAway(a: Pick<ChatAvailability, "awayMessage" | "awayUntil"> | null | undefined, now?: Date): boolean;
+/** "Mon–Fri, 9–5", "Mon–Thu, 9–5; Fri, 9–1". Days with the same hours are grouped. Empty when none. */
+declare function hoursSummary(raw: WorkingHours | null | undefined): string;
+/** "Eastern" for America/New_York (the zone's generic name, less " Time"); the city when Intl has no name. */
+declare function timeZoneLabel(timeZone: string | null | undefined, locale?: string): string;
+/** "3:00 PM" today, "Monday" within the week, else "12 Mar". */
+declare function untilLabel(iso: string, now?: Date, locale?: string, timeZone?: string | null): string;
+interface AwayLineOptions {
+    now?: Date;
+    locale?: string;
+    /** Show the hours line even inside working hours (a profile, not a banner). */
+    always?: boolean;
+}
 /**
- * Peaks from a level meter read while recording (expo-audio's `metering`, in dB,
- * about -160…0): resampled to `count` values 0–100.
+ * The line a thread shows about someone, or null when they are around:
+ * - away with a date: "Away until Monday: Back Monday" (the away message after the colon);
+ * - away with no date: "Mark is away: On a retreat";
+ * - outside working hours: "Mark replies Mon–Fri, 9–5 (Eastern)".
  */
-declare function waveformFromMetering(levelsDb: number[], count?: number): number[];
-/** 0:42, 1:05:09. */
-declare function formatDuration(ms: number | null | undefined): string;
-/** Playback speeds offered for voice and video (free for everyone, decision 5). */
-declare const PLAYBACK_RATES: readonly [1, 1.5, 2];
-declare function nextPlaybackRate(rate: number): number;
-
-/**
- * @feat:chat
- * Pure thread logic, the same on every platform: merging the server's messages
- * with ones still on their way, grouping a run of messages from one sender,
- * day dividers, the unread line, reactions by emoji, and the typing line.
- */
-
-type ThreadItem = {
-    type: "message";
-    message: ChatMessage;
-    pending?: undefined;
-} | {
-    type: "pending";
-    pending: PendingMessage;
-    message?: undefined;
-};
+declare function awayLine(a: ChatAvailability | null | undefined, name: string, opts?: AwayLineOptions): string | null;
+/** "Sam", "Sam and Lee", "Sam, Lee and 3 others": at most two names. */
+declare function namesLine(names: string[]): string;
 /**
- * The server's messages (by seq), then what is still sending, oldest first. A
- * pending message the server already has (same clientId) is dropped, so a send
- * that landed never shows twice.
+ * The line for several people (a group's members): one person's full `awayLine`, or for more
+ * "Sam and Lee are away", "Sam, Lee and 2 others are outside their hours", or "… are away or
+ * outside their hours" when it's a mix. Null when everyone is around.
  */
-declare function mergeThread(server: ChatMessage[], pending: PendingMessage[]): ThreadItem[];
-/** Adds or replaces messages in a page, keeping it sorted and free of duplicates. */
-declare function upsertMessages(existing: ChatMessage[], incoming: ChatMessage[]): ChatMessage[];
-declare function itemSender(item: ThreadItem): string | null;
-declare function itemTime(item: ThreadItem): string;
-/** Runs of one sender within five minutes share a header (name, avatar). */
-declare function startsGroup(items: ThreadItem[], index: number, gapMs?: number): boolean;
-declare function sameDay(a: string, b: string): boolean;
-/** A day divider goes before this item. */
-declare function startsDay(items: ThreadItem[], index: number): boolean;
-/** "Today", "Yesterday", "Monday", or "12 Mar 2026". */
-declare function dayLabel(iso: string, now?: Date, locale?: string): string;
-/** The first message after what you had read, from someone else: where "New" goes. */
-declare function firstUnreadId(messages: ChatMessage[], lastReadSeq: number, me: string): string | null;
-interface ReactionSummary {
-    emoji: string;
-    count: number;
-    mine: boolean;
-    userIds: string[];
-}
-/** Reactions by emoji, most first, then in first-used order. */
-declare function summarizeReactions(message: ChatMessage, me: string): ReactionSummary[];
-/** Who is doing what now: activity older than six seconds has stopped. */
-declare function currentActivity(activity: ChatActivity[], now?: number, staleMs?: number): ChatActivity[];
-/** "Sam is typing…", "Sam and Lee are typing…", "Sam is recording a voice message…". */
-declare function activityLine(activity: ChatActivity[], nameOf: (userId: string) => string): string | null;
-/** Sends activity at most once every `everyMs`. */
-declare function throttle(fn: () => void, everyMs?: number): () => void;
-/** The ids @mentioned in markdown written as `@[Name](user:<uuid>)`. */
-declare function parseMentions(body: string): string[];
-/** A one-line preview: text, or what was attached. */
-declare function previewText(body: string, attachment: string | null | undefined, deleted?: boolean): string;
+declare function awaySummary(people: {
+    availability: ChatAvailability | null | undefined;
+    name: string;
+}[], opts?: AwayLineOptions): string | null;
 
 /**
  * @feat:chat
- * The send queue: a message shows at once as pending, its files upload, then it
- * is sent with the clientId made when it was written, so a retry (after a lost
- * connection, a closed app) never posts twice. Messages to one conversation go
- * in the order they were written. Storage is the platform's (memory by default;
- * localStorage on web, MMKV or SQLite on native), behind OutboxStore.
+ * Small pure helpers for migration 0002's features, shared by every platform: the links a
+ * message's text carries (the same rule the database uses to queue previews), https checks
+ * for preview images, search snippets split at their « » marks, scheduling quick picks, and
+ * topic keys.
  */
-
-/** A file still on the device, uploaded when its message is sent. */
-interface LocalFile {
-    /** The bytes, or (native) a file URI the platform reads in `readFile`. */
-    data: Blob | ArrayBuffer | string;
-    name: string;
-    contentType: string;
-    /** A preview to show while it uploads (an object URL, a file URI). */
-    previewUrl?: string;
-    /** Known up front: a voice note's duration and waveform, a photo's size. */
-    meta?: Partial<Omit<AttachmentInput, "path" | "kind">> & {
-        kind?: AttachmentInput["kind"];
-    };
+/** The https links in a message's text that get a preview, at most three, as genesis_chat.message_links finds them. */
+declare function extractLinks(body: string, max?: number): string[];
+/** An absolute https URL with a host: the only kind a preview image may load from. */
+declare function isHttpsUrl(url: string | null | undefined): url is string;
+interface SnippetPart {
+    text: string;
+    match: boolean;
 }
-interface QueuedMessage extends Omit<PendingMessage, "files"> {
-    files: LocalFile[];
-    /** What each file is, kept with the saved copy (PendingMessage.files). */
-    pendingFiles?: PendingFile[];
-    /** Files lost on a relaunch (bytes that weren't persisted). */
-    lostFiles?: number;
-    attempts: number;
+/** "a «word» here" → [{a }, {word, match}, { here}]. Unbalanced marks are kept as text. */
+declare function snippetParts(snippet: string): SnippetPart[];
+interface QuickPick {
+    label: string;
+    at: Date;
 }
-interface OutboxStore {
-    load(): Promise<QueuedMessage[]>;
-    save(queue: QueuedMessage[]): Promise<void>;
-}
-declare const memoryOutboxStore: () => OutboxStore;
-interface OutboxOptions {
-    client: ChatClient;
-    userId: string;
-    store?: OutboxStore;
-    /** Reads a native file URI into bytes for upload. */
-    readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
-    /** Upload hook, e.g. resumable uploads on native. Defaults to client.upload. */
-    upload?: (conversationId: string, file: LocalFile) => Promise<string>;
-    /** Called with every change, for the UI. */
-    onChange?: (queue: QueuedMessage[]) => void;
-    /** Called when a message lands. */
-    onSent?: (message: ChatMessage, clientId: string) => void;
-    /** Makes client ids. Default: a random UUID (works where crypto.randomUUID is missing). */
-    newId?: () => string;
-    /**
-     * Keeps a file held as bytes (a pasted image, a recording) between launches: write it
-     * somewhere and return a URI `readFile` can read (native: the app's cache directory).
-     * Without it, such a file isn't saved, and after a relaunch its message asks for it again.
-     */
-    persistFile?: (file: LocalFile) => Promise<string>;
-}
-declare function createOutbox(opts: OutboxOptions): {
-    /** Queues a message; it shows at once and sends in order. Returns its clientId. */
-    send(input: Omit<SendInput, "clientId"> & {
-        clientId?: string;
-    }, files?: LocalFile[]): Promise<string>;
-    retry(clientId: string): Promise<void>;
-    /** Gives a message whose files were lost on a relaunch its files again, and sends it. */
-    reattach(clientId: string, files: LocalFile[]): Promise<void>;
-    /** Retries every failed message (after the connection comes back). */
-    retryAll(): Promise<void>;
-    discard(clientId: string): Promise<void>;
-    pending(conversationId?: string): PendingMessage[];
-    /** A new client id, made the way this outbox makes them. */
-    newId: typeof randomId;
-    load: () => Promise<void>;
-};
-type Outbox = ReturnType<typeof createOutbox>;
+/** "Tomorrow, 9:00 AM" and "Monday, 9:00 AM" (the next Monday after tomorrow; one pick when they're the same day). */
+declare function scheduleQuickPicks(now?: Date, locale?: string): QuickPick[];
+/** When a scheduled message goes: "Tomorrow, 9:00 AM", "Mon 12 Oct, 9:00 AM". */
+declare function scheduleLabel(iso: string | Date, now?: Date, locale?: string): string;
+/** The send time the database accepts: at least a minute and at most a year ahead. */
+declare function isSchedulable(at: Date, now?: Date): boolean;
+/** A topic's key from its title: "Week 1: Habits" → "week-1-habits" (at most 120 characters). */
+declare function topicKey(title: string): string;
 
-export { ALLOWED_EXTENSIONS, AttachmentInput, AttachmentKind, CHAT_LIMITS, ChatActivity, ChatClient, ChatMessage, type LocalFile, type Outbox, type OutboxOptions, type OutboxStore, PLAYBACK_RATES, PendingFile, PendingMessage, type QueuedMessage, type ReactionSummary, SendInput, type ThreadItem, activityLine, attachmentKindFor, createOutbox, currentActivity, dayLabel, fileExtension, firstUnreadId, formatDuration, isAllowedExtension, itemSender, itemTime, memoryOutboxStore, mergeThread, nextPlaybackRate, parseMentions, previewText, randomId, recordingLimitMs, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages, waveformFromMetering, waveformPeaks };
+export { type AwayLineOptions, ChatAvailability, MAX_RANGES_PER_DAY, type QuickPick, type SnippetPart, WEEKDAYS, Weekday, WorkingHours, awayLine, awaySummary, extractLinks, hoursSummary, isAway, isHttpsUrl, isSchedulable, isWithinWorkingHours, localClock, minutesOf, namesLine, normalizeHours, scheduleLabel, scheduleQuickPicks, snippetParts, timeZoneLabel, topicKey, untilLabel };

package/dist/index.js

@@ -1,4 +1,5 @@
-export { activityLine, createOutbox, currentActivity, dayLabel, firstUnreadId, itemSender, itemTime, memoryOutboxStore, mergeThread, parseMentions, previewText, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages } from './chunk-SAY24E6V.js';
-export { ALLOWED_EXTENSIONS, CHAT_BUCKET, CHAT_LIMITS, CHAT_SCHEMA, ChatError, PLAYBACK_RATES, attachmentKindFor, conversationTopic, createChatClient, fileExtension, formatDuration, isAllowedExtension, nextPlaybackRate, randomId, recordingLimitMs, toAttachment, toMessage, userTopic, waveformFromMetering, waveformPeaks } from './chunk-JQXZUEEL.js';
+export { extractLinks, isHttpsUrl, isSchedulable, scheduleLabel, scheduleQuickPicks, snippetParts, topicKey } from './chunk-BJCE5O7V.js';
+export { activityLine, createOutbox, currentActivity, dayLabel, firstUnreadId, itemSender, itemTime, memoryOutboxStore, mergeThread, parseMentions, previewText, releaseObjectUrl, sameDay, startsDay, startsGroup, summarizeReactions, throttle, upsertMessages } from './chunk-A4YJX7KT.js';
+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 } from './chunk-GBJ3YI4E.js';
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map