@marktiderman/genesis-chat 0.2.0 → 0.2.1

package/dist/{outbox-B0y3phE0.d.ts → outbox-B9NAWQ58.d.ts}

@@ -1,4 +1,4 @@
-import { b as AttachmentKind, A as AttachmentInput, i as ChatClient, B as PendingMessage, P as PendingFile, q as ChatMessage, E as SendInput } from './client-DMa2j7kz.js';
+import { b as AttachmentKind, A as AttachmentInput, U as UploadProgress, H as HostedAttachment, i as ChatClient, B as PendingMessage, P as PendingFile, q as ChatMessage, F as SendInput } from './client-DUIG1hum.js';
 
 /**
  * @feat:chat
@@ -62,6 +62,13 @@ declare function nextPlaybackRate(rate: number): number;
  * and only sent again by hand. `clear()` (sign-out) stops sends in flight: none
  * posts, or saves anything, afterwards. Storage is the platform's (memory by default;
  * localStorage on web, MMKV or SQLite on native), behind OutboxStore.
+ *
+ * A hosted video (`LocalFile.hosted`, with `hostedUpload`) doesn't wait for its bytes: the
+ * upload is started (the provider's upload id minted), the message is sent in its place in the
+ * order with the attachment `pending`, and the bytes carry on going up; the provider's webhook
+ * marks it ready. The message stays here (hidden from the thread once the server has it) until
+ * its bytes are up, so a relaunch carries the upload on (`resume`) and sends the message again
+ * with the same clientId, which posts nothing twice.
  */
 
 /** A file still on the device, uploaded when its message is sent. */
@@ -76,7 +83,47 @@ interface LocalFile {
     meta?: Partial<Omit<AttachmentInput, "path" | "kind">> & {
         kind?: AttachmentInput["kind"];
     };
+    /**
+     * Send it to the hosted video provider (the outbox's `hostedUpload`) instead of storage: the
+     * message goes at once, in order, with the attachment pending, while the bytes go up. Without
+     * a `hostedUpload` it goes to storage like any file.
+     */
+    hosted?: boolean;
+}
+/** A hosted upload as the outbox keeps it (saved with the message), so it can be carried on. */
+interface HostedUploadRecord {
+    provider: HostedAttachment["provider"];
+    providerId: string;
+    /** Where the bytes go, when the hook returned it: what a resume needs. */
+    url?: string;
+    /** Every byte is there. */
+    uploaded?: boolean;
+}
+/** What `hostedUpload` resolves with as soon as the upload exists (before the bytes are up). */
+interface HostedUploadStart extends HostedAttachment {
+    /** Where the bytes go; kept with the message, handed back as `resume.url`. */
+    url?: string;
+    /** Settles when every byte is there (rejects when the transfer fails). Absent: already there. */
+    done?: Promise<void>;
 }
+interface HostedUploadOptions {
+    /** Aborts when the message is discarded or the outbox cleared. */
+    signal?: AbortSignal;
+    onProgress?: UploadProgress;
+    /**
+     * The upload started before (a relaunch, a retry after the transfer failed): carry it on and
+     * resolve with the same `providerId`. A message may already be posted with it, so mint a new
+     * one only when the old upload is gone; that message's video then stays pending.
+     */
+    resume?: HostedUploadRecord;
+}
+/** Starts (or carries on) a hosted upload; resolves once the provider's upload id exists. */
+type HostedUpload = (conversationId: string, file: LocalFile, opts: HostedUploadOptions) => Promise<HostedUploadStart>;
+/** Uploads a file to storage and resolves with its path. */
+type StorageUpload = (conversationId: string, file: LocalFile, opts?: {
+    signal?: AbortSignal;
+    onProgress?: UploadProgress;
+}) => Promise<string>;
 interface QueuedMessage extends Omit<PendingMessage, "files"> {
     files: LocalFile[];
     /** What each file is, kept with the saved copy (PendingMessage.files). */
@@ -84,6 +131,10 @@ interface QueuedMessage extends Omit<PendingMessage, "files"> {
     /** Files lost on a relaunch (bytes that weren't persisted). */
     lostFiles?: number;
     attempts: number;
+    /** Hosted uploads started, by file slot. */
+    hosted?: Record<number, HostedUploadRecord>;
+    /** Posted (this message's id): it waits here only for its hosted bytes to finish. */
+    sentMessageId?: string;
 }
 interface OutboxStore {
     load(): Promise<QueuedMessage[]>;
@@ -96,10 +147,18 @@ interface OutboxOptions {
     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. `signal` aborts when the message is discarded or the outbox cleared. */
-    upload?: (conversationId: string, file: LocalFile, opts?: {
-        signal?: AbortSignal;
-    }) => Promise<string>;
+    /**
+     * Upload hook, e.g. resumable uploads on native. Defaults to client.upload. `signal` aborts
+     * when the message is discarded or the outbox cleared; call `onProgress(sent, total)` as bytes
+     * go, and the pending bubble shows it (`PendingMessage.files[i].progress`).
+     */
+    upload?: StorageUpload;
+    /**
+     * Starts a hosted video upload for a file marked `hosted` and resolves once the provider's
+     * upload id exists, with `done` for the bytes. See HostedUpload; without it, hosted files go
+     * to storage.
+     */
+    hostedUpload?: HostedUpload;
     /** Called with every change, for the UI. */
     onChange?: (queue: QueuedMessage[]) => void;
     /** Called when a message lands. */
@@ -141,6 +200,15 @@ declare function createOutbox(opts: OutboxOptions): {
     /** Forgets every queued message, here and in the store (call it on sign-out). */
     clear(): Promise<void>;
     discard(clientId: string): Promise<void>;
+    /**
+     * Uploads one file to storage the way the outbox does (the `upload` hook, or `readFile` then
+     * the client's upload) and resolves with its path: for files sent outside the queue, such as
+     * a scheduled message's.
+     */
+    uploadFile(conversationId: string, file: LocalFile, o?: {
+        signal?: AbortSignal;
+        onProgress?: UploadProgress;
+    }): Promise<string>;
     pending(conversationId?: string): PendingMessage[];
     /** A new client id, made the way this outbox makes them. */
     newId: typeof randomId;
@@ -148,4 +216,4 @@ declare function createOutbox(opts: OutboxOptions): {
 };
 type Outbox = ReturnType<typeof createOutbox>;
 
-export { ALLOWED_EXTENSIONS as A, CHAT_LIMITS as C, type LocalFile as L, type Outbox as O, PLAYBACK_RATES as P, type QueuedMessage as Q, type OutboxOptions as a, type OutboxStore as b, attachmentKindFor as c, createOutbox as d, formatDuration as e, fileExtension as f, recordingLimitMs as g, releaseObjectUrl as h, isAllowedExtension as i, waveformPeaks as j, memoryOutboxStore as m, nextPlaybackRate as n, randomId as r, waveformFromMetering as w };
+export { ALLOWED_EXTENSIONS as A, CHAT_LIMITS as C, type HostedUpload as H, type LocalFile as L, type Outbox as O, PLAYBACK_RATES as P, type QueuedMessage as Q, type StorageUpload as S, type HostedUploadOptions as a, type HostedUploadRecord as b, type HostedUploadStart as c, type OutboxOptions as d, type OutboxStore as e, attachmentKindFor as f, createOutbox as g, fileExtension as h, formatDuration as i, isAllowedExtension as j, recordingLimitMs as k, releaseObjectUrl as l, memoryOutboxStore as m, nextPlaybackRate as n, waveformPeaks as o, randomId as r, waveformFromMetering as w };

package/dist/push.d.ts

@@ -1,5 +1,5 @@
-import { i as ChatClient } from './client-DMa2j7kz.js';
-import { O as Outbox, b as OutboxStore, Q as QueuedMessage } from './outbox-B0y3phE0.js';
+import { i as ChatClient } from './client-DUIG1hum.js';
+import { O as Outbox, e as OutboxStore, Q as QueuedMessage } from './outbox-B9NAWQ58.js';
 import '@supabase/supabase-js';
 
 /**

package/dist/react.d.ts

@@ -1,9 +1,9 @@
 import * as _tanstack_query_core from '@tanstack/query-core';
-import { h as ChatAttachment, i as ChatClient, k as ChatConversation, p as ChatMember, t as ChatRole, n as ChatKindRules, q as ChatMessage, g as ChatActivity, E as SendInput, M as MessagePage, C as ChatAvailability, d as AvailabilityInput, v as ChatSignal, m as ChatInboxItem, o as ChatLinkPreview, D as ScheduledMessage, S as ScheduleInput, u as ChatSearchHit, x as ChatTopic, T as TopicInput } from './client-DMa2j7kz.js';
+import { h as ChatAttachment, i as ChatClient, k as ChatConversation, p as ChatMember, t as ChatRole, n as ChatKindRules, q as ChatMessage, g as ChatActivity, F as SendInput, M as MessagePage, C as ChatAvailability, d as AvailabilityInput, v as ChatSignal, m as ChatInboxItem, o as ChatLinkPreview, D as ScheduledMessage, S as ScheduleInput, u as ChatSearchHit, x as ChatTopic, T as TopicInput } from './client-DUIG1hum.js';
 import * as react from 'react';
 import { ReactNode } from 'react';
-import { b as OutboxStore, L as LocalFile, O as Outbox, Q as QueuedMessage } from './outbox-B0y3phE0.js';
-import { T as ThreadItem } from './thread-DWXHKPdw.js';
+import { e as OutboxStore, S as StorageUpload, H as HostedUpload, L as LocalFile, O as Outbox, Q as QueuedMessage } from './outbox-B9NAWQ58.js';
+import { T as ThreadItem } from './thread-oPra7pkW.js';
 import '@supabase/supabase-js';
 
 declare const chatKeys: {
@@ -33,9 +33,11 @@ type MessagesData = MessagePage;
 /** Does a messages list (`[genesis-chat, conversation, id, messages, threadRootId, topic]`) hold this message? */
 declare function belongsTo(key: readonly unknown[], m: ChatMessage): boolean;
 /**
- * Hosted video uploads (Mux direct uploads): your server makes an upload and returns its URL;
- * the renderer PUTs the recording there and sends `{ kind: "video", provider: "mux", providerId,
- * status: "pending" }`. Without it, videos go to storage as files.
+ * Hosted video uploads (Mux direct uploads): your server makes an upload and returns its URL
+ * (`createVideoUploadHandler` in /server). A video the composer marks `hosted` is sent through
+ * the outbox at once, in order, with `{ kind: "video", provider, providerId, status: "pending" }`,
+ * while its bytes are PUT to that URL (see `hostedUploadFrom`). Without it, videos go to storage
+ * as files.
  */
 interface ChatVideoUpload {
     create(conversationId: string): Promise<{
@@ -44,16 +46,33 @@ interface ChatVideoUpload {
         provider: "mux";
     }>;
 }
+/**
+ * The outbox's `hostedUpload` from a `ChatVideoUpload`: mints the upload (or, resuming, reuses
+ * the one minted before), resolves at once with its id, and PUTs the whole file to its URL in
+ * the background (XMLHttpRequest where there is one, for progress). A native file URI is read
+ * with `readFile`. Native apps with chunked, resumable uploads pass their own `hostedUpload`.
+ */
+declare function hostedUploadFrom(videoUpload: ChatVideoUpload, options?: {
+    readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
+    fetch?: typeof fetch;
+}): HostedUpload;
+/** What a kind's `title`, `subtitle` and `action` are told besides the attachment. */
+interface ChatCardContext {
+    /** The card is on a message you sent (your own check-in reads "Sent", not "Answer"). */
+    mine: boolean;
+}
 /** What an app attachment kind's card shows (a form, a check-in): plain data, drawn by each renderer. */
 interface ChatAttachmentKind {
-    title(attachment: ChatAttachment): string;
-    subtitle?(attachment: ChatAttachment): string | null | undefined;
+    title(attachment: ChatAttachment, ctx?: ChatCardContext): string;
+    subtitle?(attachment: ChatAttachment, ctx?: ChatCardContext): string | null | undefined;
     /** The card's button: a link (`href`) or a handler (`onPress`). */
-    action?(attachment: ChatAttachment): {
+    action?(attachment: ChatAttachment, ctx?: ChatCardContext): {
         label: string;
         href?: string;
         onPress?: () => void;
     } | null | undefined;
+    /** What previews call it (the inbox's last message, "Check-in"); the title by default. */
+    label?: string;
 }
 interface ChatContextValue {
     client: ChatClient;
@@ -78,10 +97,17 @@ interface ChatProviderProps {
     outboxStore?: OutboxStore;
     /** Reads a native file URI for upload. */
     readFile?: (uri: string) => Promise<Blob | ArrayBuffer>;
-    /** Replaces the plain upload (resumable uploads on native). `signal` aborts when the message is discarded or the outbox cleared. */
-    upload?: (conversationId: string, file: LocalFile, opts?: {
-        signal?: AbortSignal;
-    }) => Promise<string>;
+    /**
+     * Replaces the plain upload (resumable uploads on native). `signal` aborts when the message is
+     * discarded or the outbox cleared; `onProgress(sent, total)` fills the pending bubble's bar.
+     */
+    upload?: StorageUpload;
+    /**
+     * Starts a hosted upload for files marked `hosted` (see HostedUpload): resolve with
+     * `{ provider, providerId, status: "pending", url?, done }` once the upload id exists. Default:
+     * `hostedUploadFrom(videoUpload)` when `videoUpload` is given.
+     */
+    hostedUpload?: HostedUpload;
     /** Makes client ids (default: a random UUID that works without crypto.randomUUID). */
     newId?: () => string;
     /** Keeps a byte file (a pasted image, a recording) across launches: write it, return a URI. */
@@ -102,7 +128,7 @@ interface ChatPerson {
     avatarUrl?: string | null;
 }
 /** Puts chat in reach of every hook below it. Needs a TanStack QueryClientProvider above it. */
-declare function ChatProvider({ client, userId, outboxStore, readFile, upload, newId, persistFile, releasePreview, loadPeople, videoUpload, attachmentKinds, children, }: ChatProviderProps): react.JSX.Element;
+declare function ChatProvider({ client, userId, outboxStore, readFile, upload, hostedUpload, newId, persistFile, releasePreview, loadPeople, videoUpload, attachmentKinds, children, }: ChatProviderProps): react.JSX.Element;
 declare function useChat(): ChatContextValue;
 /** Your conversations, live. `kind` narrows to one kind; `archived` shows the archived ones. */
 declare function useInbox(opts?: {
@@ -142,10 +168,10 @@ declare function useConversation(conversationId: string | null | undefined, opts
     conversationLoading: boolean;
     /** Your role couldn't be loaded (offline): offer `refetchAccess`, don't say "can't post". */
     accessError: Error | null;
-    refetchAccess: (options?: _tanstack_query_core.RefetchOptions) => Promise<_tanstack_query_core.QueryObserverResult<NoInfer<{
-        role: ChatRole | null;
-        canPost: boolean;
-    }>, Error>>;
+    /** Retries everything this conversation loads (role, members, the conversation, topics, availability, pins), not only access. */
+    refetchAccess: () => Promise<undefined>;
+    /** Same as refetchAccess: every per-conversation lookup again, for a Retry after being offline. */
+    refetchConversation: () => Promise<undefined>;
     /** The kind's rules (max members, threads, who posts). */
     kind: NonNullable<NoInfer<ChatKindRules | null>> | null;
     /** May you pin here: owners and admins, or anyone in a two-person conversation. */
@@ -213,8 +239,9 @@ declare function useTopics(conversationId: string | null | undefined): {
 };
 /**
  * Your scheduled messages (in one conversation, or all), soonest first, with `schedule` and
- * `cancel`. `schedule` uploads byte files first (`LocalFile.data` a Blob or ArrayBuffer; a
- * native URI goes through the provider's `readFile`), then schedules them with the message.
+ * `cancel` (which also removes one that failed). `schedule` uploads its files to storage first,
+ * the way `send` does (the provider's `upload` hook, or a native URI read through `readFile`),
+ * then schedules them with the message. A file marked `hosted` goes to storage too.
  */
 declare function useScheduled(conversationId?: string | null, opts?: {
     enabled?: boolean;
@@ -276,4 +303,4 @@ declare const LINK_PREVIEW_CONCURRENCY = 4;
  */
 declare function useLinkPreviews(messageIds: (string | null | undefined)[]): Record<string, ChatLinkPreview[]>;
 
-export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, type ChatAttachmentKind, type ChatPerson, ChatProvider, type ChatProviderProps, type ChatVideoUpload, type ConversationState, LINK_PREVIEW_CONCURRENCY, LocalFile, type MessagesData, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal };
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, type ChatAttachmentKind, type ChatCardContext, type ChatPerson, ChatProvider, type ChatProviderProps, type ChatVideoUpload, type ConversationState, LINK_PREVIEW_CONCURRENCY, LocalFile, type MessagesData, QueuedMessage, ThreadItem, type UseConversationOptions, belongsTo, chatKeys, hostedUploadFrom, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal };

package/dist/react.js

@@ -1,5 +1,5 @@
-export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, ChatProvider, LINK_PREVIEW_CONCURRENCY, belongsTo, chatKeys, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal } from './chunk-PZTOY2LY.js';
-import './chunk-5D5A7I4Q.js';
-import './chunk-7S6HYNWW.js';
+export { CATCH_UP_MAX_PAGES, CATCH_UP_PAGE, ChatProvider, LINK_PREVIEW_CONCURRENCY, belongsTo, chatKeys, hostedUploadFrom, useAvailability, useBroadcast, useChat, useConversation, useDebouncedValue, useFileUrls, useInbox, useLinkPreviews, useMessageActions, usePeople, usePerson, usePins, useScheduled, useSearch, useStartConversation, useTopics, useUnreadTotal } from './chunk-JU2FAPBI.js';
+import './chunk-A4YJX7KT.js';
+import './chunk-GBJ3YI4E.js';
 //# sourceMappingURL=react.js.map
 //# sourceMappingURL=react.js.map

package/dist/server.d.ts

@@ -1,4 +1,4 @@
-import { w as ChatSupabase } from './client-DMa2j7kz.js';
+import { w as ChatSupabase } from './client-DUIG1hum.js';
 import '@supabase/supabase-js';
 
 /**
@@ -309,6 +309,47 @@ declare function muxVideo(options: MuxVideoOptions): VideoProvider & {
     }): Promise<string>;
 };
 
+/**
+ * A pretend hosted video service for local development, behind `VideoProvider`, so the hosted
+ * path (pending attachment, upload, ready) runs without a Mux account.
+ *
+ *   createUpload  a local upload URL (`uploadUrl?id=<upload id>`) and its id, `fake_<uuid>`
+ *   handler       the fetch handler to mount at `uploadUrl`: takes the PUT body, stores it in
+ *                 the genesis-chat bucket, then marks the attachment ready
+ *   markReady     what Mux's `video.asset.ready` webhook does: `update_attachment` with status
+ *                 ready, a playback id (`fake-<upload id>`) and a fake HLS URL
+ *   playbackUrl   a signed link to the stored file (the fake HLS URL when nothing was stored)
+ *
+ * It refuses to be made when NODE_ENV is `production`, unless `force` is set.
+ */
+
+interface FakeVideoProviderOptions {
+    /** A service-role client: it writes the bucket and calls `update_attachment`. */
+    supabase: ChatSupabase;
+    /** Where `handler` is mounted, e.g. `http://localhost:3000/api/chat/fake-video`. */
+    uploadUrl: string;
+    /** The `provider` value it stands in for. Default `mux`. */
+    name?: "mux" | "cloudflare";
+    /** Run even when NODE_ENV is `production`. */
+    force?: boolean;
+    /** NODE_ENV, read from `process.env` by default. */
+    env?: string | undefined;
+    /** How long `handler` waits for the message carrying the upload to arrive before answering 202 (default 10 s). */
+    readyWaitMs?: number;
+    newId?: () => string;
+    sleep?: (ms: number) => Promise<void>;
+}
+interface FakeReadyOptions {
+    durationMs?: number;
+    /** A poster image already in the genesis-chat bucket. */
+    posterPath?: string;
+}
+declare function fakeVideoProvider(options: FakeVideoProviderOptions): VideoProvider & {
+    markReady(providerId: string, ready?: FakeReadyOptions): Promise<void>;
+    handler(request: Request): Promise<Response>;
+    playbackUrl(playbackId: string): Promise<string>;
+};
+
 /**
  * A plain `deliver` for apps without genesis-notifications yet: one Expo push
  * per device token, in requests of 100 (https://docs.expo.dev/push-notifications/sending-notifications/).
@@ -797,4 +838,4 @@ interface VideoUploadHandlerOptions {
 }
 declare function createVideoUploadHandler(options: VideoUploadHandlerOptions): (request: Request) => Promise<Response>;
 
-export { ANTHROPIC_MESSAGES_URL, ANTHROPIC_VERSION, type AnthropicLike, type AssistantMessage, type AssistantResult, CHAT_ASSISTANT_MODEL, CHAT_MAX_ATTEMPTS, CHAT_NOTIFICATION_CATEGORIES, CHAT_NOTIFICATION_TYPES, CHAT_NOTIFICATION_TYPE_ID, type ChatAssistant, type ChatAssistantOptions, type ChatDeliver, type ChatEffect, type ChatEffectKind, type ChatNotification, type ChatNotifyInput, type ChatRecipient, type ChatRunReport, type ChatRunner, type ChatRunnerHandlerOptions, type ChatRunnerOptions, type ChatUploadBinding, type DeepgramOptions, type DraftReplyInput, EXPO_BATCH, EXPO_SEND_URL, type ExpoDeliverOptions, type ExpoDeliveryTicket, type ExpoPushMessage, type ExpoPushTicket, type LinkPreview, type LinkUnfurler, type LinkUnfurlerOptions, type ModerateInput, type ModerationResult, type ModerationThresholds, type ModerationVerdict, type Moderator, type MuxSigningKey, type MuxVideoOptions, type NotificationsDeliverOptions, OPENAI_MODERATIONS_URL, OPENAI_MODERATION_CATEGORIES, type OpenAiModeratorOptions, type OpenAiTranscriberOptions, type RecapInput, type TranscribeInput, type TranscribeResult, type Transcriber, type VideoProvider, type VideoUploadHandlerOptions, carriesCredential, chatNotifyInput, chatRunnerHandler, chatUploadPassthrough, createChatAssistant, createChatRunner, createExpoDeliver, createLinkUnfurler, createVideoUploadHandler, deadTokens, decodeEntities, deepgramTranscriber, draftPrompt, guardedLookup, isPrivateAddress, moderationVerdict, muxPlaybackToken, muxPlaybackUrl, muxVideo, notificationsDeliver, openAiModerator, openAiTranscriber, parseChatUploadPassthrough, parseOpenGraph, recapPrompt, transcriptLines, verifyMuxSignature };
+export { ANTHROPIC_MESSAGES_URL, ANTHROPIC_VERSION, type AnthropicLike, type AssistantMessage, type AssistantResult, CHAT_ASSISTANT_MODEL, CHAT_MAX_ATTEMPTS, CHAT_NOTIFICATION_CATEGORIES, CHAT_NOTIFICATION_TYPES, CHAT_NOTIFICATION_TYPE_ID, type ChatAssistant, type ChatAssistantOptions, type ChatDeliver, type ChatEffect, type ChatEffectKind, type ChatNotification, type ChatNotifyInput, type ChatRecipient, type ChatRunReport, type ChatRunner, type ChatRunnerHandlerOptions, type ChatRunnerOptions, type ChatUploadBinding, type DeepgramOptions, type DraftReplyInput, EXPO_BATCH, EXPO_SEND_URL, type ExpoDeliverOptions, type ExpoDeliveryTicket, type ExpoPushMessage, type ExpoPushTicket, type FakeReadyOptions, type FakeVideoProviderOptions, type LinkPreview, type LinkUnfurler, type LinkUnfurlerOptions, type ModerateInput, type ModerationResult, type ModerationThresholds, type ModerationVerdict, type Moderator, type MuxSigningKey, type MuxVideoOptions, type NotificationsDeliverOptions, OPENAI_MODERATIONS_URL, OPENAI_MODERATION_CATEGORIES, type OpenAiModeratorOptions, type OpenAiTranscriberOptions, type RecapInput, type TranscribeInput, type TranscribeResult, type Transcriber, type VideoProvider, type VideoUploadHandlerOptions, carriesCredential, chatNotifyInput, chatRunnerHandler, chatUploadPassthrough, createChatAssistant, createChatRunner, createExpoDeliver, createLinkUnfurler, createVideoUploadHandler, deadTokens, decodeEntities, deepgramTranscriber, draftPrompt, fakeVideoProvider, guardedLookup, isPrivateAddress, moderationVerdict, muxPlaybackToken, muxPlaybackUrl, muxVideo, notificationsDeliver, openAiModerator, openAiTranscriber, parseChatUploadPassthrough, parseOpenGraph, recapPrompt, transcriptLines, verifyMuxSignature };

package/dist/server.js

@@ -1,4 +1,4 @@
-import { CHAT_SCHEMA, CHAT_BUCKET } from './chunk-7S6HYNWW.js';
+import { CHAT_BUCKET, CHAT_SCHEMA } from './chunk-GBJ3YI4E.js';
 import { chatPushPayload } from './chunk-VEPZROQB.js';
 
 // src/server/runner.ts
@@ -321,8 +321,8 @@ function deepgramTranscriber(options) {
         signal: AbortSignal.timeout(TIMEOUT_MS)
       });
       if (!response.ok) return failed("Deepgram", response);
-      const json3 = await response.json();
-      const channel = json3.results?.channels?.[0];
+      const json4 = await response.json();
+      const channel = json4.results?.channels?.[0];
       const text = channel?.alternatives?.[0]?.transcript;
       if (typeof text !== "string") throw new Error("Deepgram answered without a transcript");
       return { text: text.trim(), language: channel?.detected_language ?? input.language };
@@ -364,9 +364,9 @@ function openAiTranscriber(options) {
         signal: AbortSignal.timeout(TIMEOUT_MS)
       });
       if (!response.ok) return failed("OpenAI", response);
-      const json3 = await response.json();
-      if (typeof json3.text !== "string") throw new Error("OpenAI answered without a transcript");
-      return { text: json3.text.trim(), language: input.language };
+      const json4 = await response.json();
+      if (typeof json4.text !== "string") throw new Error("OpenAI answered without a transcript");
+      return { text: json4.text.trim(), language: input.language };
     }
   };
 }
@@ -700,6 +700,106 @@ function muxVideo(options) {
   };
 }
 
+// src/server/fake-video.ts
+var json2 = (status, body, headers = {}) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", "cache-control": "no-store", ...headers } });
+var EXTENSIONS2 = { "video/mp4": "mp4", "video/webm": "webm", "video/quicktime": "mov" };
+var NotSentYet = class extends Error {
+};
+var nodeEnv = () => globalThis.process?.env?.NODE_ENV;
+function fakeVideoProvider(options) {
+  const env = "env" in options ? options.env : nodeEnv();
+  if (env === "production" && !options.force) {
+    throw new Error("fakeVideoProvider is for development: it won't run with NODE_ENV=production (pass `force: true` to override)");
+  }
+  const name = options.name ?? "mux";
+  const db = () => options.supabase.schema(CHAT_SCHEMA);
+  const uploads = /* @__PURE__ */ new Map();
+  const newId = options.newId ?? (() => crypto.randomUUID());
+  const sleep = options.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+  const fakeHls = (providerId) => `https://fake-video.invalid/${encodeURIComponent(providerId)}.m3u8`;
+  async function find(providerId) {
+    const { data, error } = await db().from("attachments").select("id").eq("provider", name).eq("provider_id", providerId).limit(1).maybeSingle();
+    if (error) throw new Error(`attachments: ${error.code ?? "error"}`);
+    return data ?? null;
+  }
+  async function markReady(providerId, ready = {}) {
+    const attachment = await find(providerId);
+    if (!attachment) throw new NotSentYet(`fakeVideoProvider: no ${name} attachment with provider_id ${providerId} (is its message sent?)`);
+    const { error } = await db().rpc("update_attachment", {
+      p_attachment_id: attachment.id,
+      p_patch: {
+        status: "ready",
+        playback_id: `fake-${providerId}`,
+        url: fakeHls(providerId),
+        transcript_status: "off",
+        ...typeof ready.durationMs === "number" ? { duration_ms: Math.round(ready.durationMs) } : {},
+        ...ready.posterPath ? { poster_path: ready.posterPath } : {}
+      }
+    });
+    if (error) throw new Error(`update_attachment: ${error.code ?? "error"}`);
+  }
+  return {
+    name,
+    async createUpload({ corsOrigin, passthrough }) {
+      const uploadId = `fake_${newId()}`;
+      uploads.set(uploadId, { passthrough, corsOrigin });
+      const url = new URL(options.uploadUrl);
+      url.searchParams.set("id", uploadId);
+      return { uploadId, url: url.toString() };
+    },
+    async remove(assetId) {
+      const id = assetId.replace(/^fake-/, "");
+      const path = uploads.get(id)?.path;
+      uploads.delete(id);
+      if (path) await options.supabase.storage.from(CHAT_BUCKET).remove([path]);
+    },
+    /** There is no webhook: `handler` (or `markReady`) does its work. */
+    async handleWebhook() {
+      return json2(200, { ignored: "the fake provider has no webhook; call markReady" });
+    },
+    markReady,
+    async playbackUrl(playbackId) {
+      const path = uploads.get(playbackId.replace(/^fake-/, ""))?.path;
+      if (!path) return fakeHls(playbackId.replace(/^fake-/, ""));
+      const { data, error } = await options.supabase.storage.from(CHAT_BUCKET).createSignedUrl(path, 3600);
+      if (error || !data?.signedUrl) throw new Error("fakeVideoProvider: couldn't sign the stored file");
+      return data.signedUrl;
+    },
+    async handler(request) {
+      const id = new URL(request.url).searchParams.get("id") ?? "";
+      const upload = uploads.get(id);
+      const cors = { "access-control-allow-origin": upload?.corsOrigin ?? "*", vary: "origin" };
+      if (request.method === "OPTIONS") {
+        return new Response(null, {
+          status: 204,
+          headers: { ...cors, "access-control-allow-methods": "PUT, OPTIONS", "access-control-allow-headers": "content-type, content-range", "access-control-max-age": "600" }
+        });
+      }
+      if (request.method !== "PUT") return json2(405, { error: "method not allowed" }, cors);
+      if (!upload) return json2(404, { error: "no such upload" }, cors);
+      const binding = parseChatUploadPassthrough(upload.passthrough);
+      const contentType = request.headers.get("content-type") ?? "video/mp4";
+      const path = `${binding?.conversationId ?? "fake-video"}/${binding?.userId ?? "fake-video"}/${id}.${EXTENSIONS2[contentType] ?? "mp4"}`;
+      const body = await request.arrayBuffer();
+      const { error } = await options.supabase.storage.from(CHAT_BUCKET).upload(path, body, { contentType, upsert: true });
+      if (error) return json2(502, { error: `storage: ${error.message}` }, cors);
+      upload.path = path;
+      const deadline = Date.now() + (options.readyWaitMs ?? 1e4);
+      for (; ; ) {
+        try {
+          await markReady(id);
+          return json2(200, { ok: true, providerId: id, path }, cors);
+        } catch (e) {
+          if (Date.now() >= deadline || !(e instanceof NotSentYet)) {
+            return json2(202, { stored: true, ready: false, providerId: id, path, error: e instanceof Error ? e.message : String(e) }, cors);
+          }
+          await sleep(500);
+        }
+      }
+    }
+  };
+}
+
 // src/server/expo.ts
 var EXPO_SEND_URL = "https://exp.host/--/api/v2/push/send";
 var EXPO_BATCH = 100;
@@ -746,8 +846,8 @@ function createExpoDeliver(options) {
           });
           throw new Error(`Expo push answered HTTP ${response.status}`);
         }
-        const json3 = await response.json();
-        answer = Array.isArray(json3.data) ? json3.data : [];
+        const json4 = await response.json();
+        answer = Array.isArray(json4.data) ? json4.data : [];
         sent += chunk.length;
       } catch (e) {
         lastError = e;
@@ -770,17 +870,17 @@ function deadTokens(tickets) {
 }
 
 // src/server/handler.ts
-var json2 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", "cache-control": "no-store" } });
+var json3 = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json", "cache-control": "no-store" } });
 function chatRunnerHandler(options) {
   return async (request) => {
-    if (!options.secret || options.secret.length < 32) return json2(500, { error: "runner secret missing or under 32 characters" });
-    if (request.method !== "POST" && request.method !== "GET") return json2(405, { error: "method not allowed" });
+    if (!options.secret || options.secret.length < 32) return json3(500, { error: "runner secret missing or under 32 characters" });
+    if (request.method !== "POST" && request.method !== "GET") return json3(405, { error: "method not allowed" });
     const match = /^Bearer\s+(\S+)$/i.exec(request.headers.get("authorization") ?? "");
-    if (!match || !await safeEqual(match[1], options.secret)) return json2(401, { error: "unauthorized" });
+    if (!match || !await safeEqual(match[1], options.secret)) return json3(401, { error: "unauthorized" });
     try {
-      return json2(200, await options.runner.run());
+      return json3(200, await options.runner.run());
     } catch (e) {
-      return json2(500, { error: e instanceof Error ? e.message.slice(0, 200) : "run failed" });
+      return json3(500, { error: e instanceof Error ? e.message.slice(0, 200) : "run failed" });
     }
   };
 }
@@ -1399,6 +1499,6 @@ function createChatAssistant(options) {
   };
 }
 
-export { ANTHROPIC_MESSAGES_URL, ANTHROPIC_VERSION, CHAT_ASSISTANT_MODEL, CHAT_MAX_ATTEMPTS, CHAT_NOTIFICATION_CATEGORIES, CHAT_NOTIFICATION_TYPES, CHAT_NOTIFICATION_TYPE_ID, EXPO_BATCH, EXPO_SEND_URL, OPENAI_MODERATIONS_URL, OPENAI_MODERATION_CATEGORIES, carriesCredential, chatNotifyInput, chatRunnerHandler, chatUploadPassthrough, createChatAssistant, createChatRunner, createExpoDeliver, createLinkUnfurler, createVideoUploadHandler, deadTokens, decodeEntities, deepgramTranscriber, draftPrompt, guardedLookup, isPrivateAddress, moderationVerdict, muxPlaybackToken, muxPlaybackUrl, muxVideo, notificationsDeliver, openAiModerator, openAiTranscriber, parseChatUploadPassthrough, parseOpenGraph, recapPrompt, transcriptLines, verifyMuxSignature };
+export { ANTHROPIC_MESSAGES_URL, ANTHROPIC_VERSION, CHAT_ASSISTANT_MODEL, CHAT_MAX_ATTEMPTS, CHAT_NOTIFICATION_CATEGORIES, CHAT_NOTIFICATION_TYPES, CHAT_NOTIFICATION_TYPE_ID, EXPO_BATCH, EXPO_SEND_URL, OPENAI_MODERATIONS_URL, OPENAI_MODERATION_CATEGORIES, carriesCredential, chatNotifyInput, chatRunnerHandler, chatUploadPassthrough, createChatAssistant, createChatRunner, createExpoDeliver, createLinkUnfurler, createVideoUploadHandler, deadTokens, decodeEntities, deepgramTranscriber, draftPrompt, fakeVideoProvider, guardedLookup, isPrivateAddress, moderationVerdict, muxPlaybackToken, muxPlaybackUrl, muxVideo, notificationsDeliver, openAiModerator, openAiTranscriber, parseChatUploadPassthrough, parseOpenGraph, recapPrompt, transcriptLines, verifyMuxSignature };
 //# sourceMappingURL=server.js.map
 //# sourceMappingURL=server.js.map