@marktiderman/genesis-chat 0.0.0-stage → 0.1.0

package/dist/server.js

@@ -0,0 +1,562 @@
+import { CHAT_SCHEMA, CHAT_BUCKET } from './chunk-JQXZUEEL.js';
+
+// src/server/runner.ts
+var CHAT_MAX_ATTEMPTS = 8;
+var ALL_KINDS = ["push", "transcribe", "storage.remove", "video.remove"];
+var SIGNED_URL_SECONDS = 600;
+function errorText(fn, error) {
+  return new Error(`${fn}: ${error?.code ?? error?.message ?? "error"}`);
+}
+function str(value) {
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+async function pool(items, limit, work) {
+  let next = 0;
+  const lanes = Array.from({ length: Math.min(limit, items.length) }, async () => {
+    while (next < items.length) await work(items[next++]);
+  });
+  await Promise.all(lanes);
+}
+function createChatRunner(options) {
+  const { supabase, deliver } = options;
+  const kinds = [...options.kinds ?? ALL_KINDS];
+  const limit = Math.min(Math.max(options.batch?.limit ?? 50, 1), 500);
+  const concurrency = Math.max(options.batch?.concurrency ?? 4, 1);
+  const directKinds = new Set(options.directKinds ?? ["direct"]);
+  const log = options.log ?? (() => {
+  });
+  const db = () => supabase.schema(CHAT_SCHEMA);
+  async function rpc(fn, args) {
+    const { data, error } = await db().rpc(fn, args);
+    if (error) throw errorText(fn, error);
+    return data;
+  }
+  async function nameOf(userId) {
+    if (!userId || !options.resolveName) return null;
+    try {
+      return str(await options.resolveName(userId));
+    } catch {
+      return null;
+    }
+  }
+  async function push(effect) {
+    const messageId = str(effect.payload.message_id);
+    if (!messageId) return;
+    const targets = await rpc("push_targets", { p_message_id: messageId }) ?? [];
+    if (targets.length === 0) return;
+    const first = targets[0];
+    const conversationId = first.conversation_id;
+    const { data: conversation, error } = await db().from("conversations").select("kind").eq("id", conversationId).maybeSingle();
+    if (error) throw errorText("conversations", error);
+    const direct = conversation ? directKinds.has(conversation.kind) : false;
+    const { data: numbered } = await db().from("messages").select("seq").eq("id", messageId).maybeSingle();
+    const seq = numbered?.seq ?? null;
+    const senderName = await nameOf(first.sender_id);
+    const preview = first.preview ?? "New message";
+    const title = str(first.title) ?? senderName ?? "New message";
+    const body = !direct && senderName ? `${senderName}: ${preview}` : preview;
+    const notification = {
+      category: "messages",
+      messageId,
+      conversationId,
+      recipients: targets.map((t) => ({ userId: t.user_id, badge: t.unread_total ?? 0, mentioned: t.mentioned === true })),
+      title,
+      body,
+      senderId: first.sender_id,
+      collapseKey: `chat:${conversationId}`,
+      threadKey: conversationId,
+      idempotencyKey: `push:${messageId}`,
+      data: { url: options.linkFor?.(conversationId, messageId) ?? `/messages/${conversationId}`, conversationId, messageId, seq }
+    };
+    await deliver(notification);
+  }
+  async function storageRemove(effect) {
+    const path = str(effect.payload.path);
+    if (!path) return;
+    const bucket = str(effect.payload.bucket) ?? CHAT_BUCKET;
+    const { error } = await supabase.storage.from(bucket).remove([path]);
+    if (!error) return;
+    const status = String(error.statusCode ?? "");
+    if (status === "404" || /not.?found/i.test(error.message ?? "")) return;
+    throw new Error(`storage.remove: ${status || error.message || "error"}`);
+  }
+  async function transcribe(effect) {
+    const id = str(effect.payload.attachment_id);
+    if (!id) return;
+    const { data: row, error } = await db().from("attachments").select("id, kind, provider, path, mime, duration_ms, transcript_status").eq("id", id).maybeSingle();
+    if (error) throw errorText("attachments", error);
+    if (!row || row.transcript_status !== "pending" && row.transcript_status !== null) return;
+    if (row.provider !== "storage") return;
+    if (!options.transcriber || !row.path) {
+      await rpc("update_attachment", { p_attachment_id: id, p_patch: { transcript_status: "off" } });
+      return;
+    }
+    const signed = await supabase.storage.from(CHAT_BUCKET).createSignedUrl(row.path, SIGNED_URL_SECONDS);
+    if (signed.error || !signed.data?.signedUrl) throw errorText("createSignedUrl", signed.error);
+    try {
+      const result = await options.transcriber.transcribe({
+        url: signed.data.signedUrl,
+        mime: row.mime,
+        durationMs: row.duration_ms,
+        language: options.transcriptLanguage
+      });
+      await rpc("update_attachment", { p_attachment_id: id, p_patch: { transcript: result.text.slice(0, 1e5), transcript_status: "ready" } });
+    } catch (e) {
+      if (effect.attempts >= CHAT_MAX_ATTEMPTS) {
+        await rpc("update_attachment", { p_attachment_id: id, p_patch: { transcript_status: "failed" } }).catch(() => {
+        });
+      }
+      throw e;
+    }
+  }
+  async function videoRemove(effect) {
+    const providerId = str(effect.payload.provider_id);
+    if (!providerId || !options.video) return;
+    const provider = str(effect.payload.provider);
+    if (provider && provider !== options.video.name) {
+      throw new Error(`video.remove: no adapter for ${provider} (this runner has ${options.video.name})`);
+    }
+    await options.video.remove(providerId);
+  }
+  async function handle(effect) {
+    switch (effect.kind) {
+      case "push":
+        return push(effect);
+      case "transcribe":
+        return transcribe(effect);
+      case "storage.remove":
+        return storageRemove(effect);
+      case "video.remove":
+        return videoRemove(effect);
+      default:
+        throw new Error(`no handler for ${effect.kind}`);
+    }
+  }
+  async function run() {
+    const claimed = await rpc("claim_effects", { p_kinds: kinds, p_limit: limit }) ?? [];
+    const report = { claimed: claimed.length, done: 0, failed: 0 };
+    const byKind = /* @__PURE__ */ new Map();
+    for (const effect of claimed) byKind.set(effect.kind, [...byKind.get(effect.kind) ?? [], effect]);
+    await Promise.all(
+      [...byKind.values()].map(
+        (effects) => pool(effects, concurrency, async (effect) => {
+          let failure = null;
+          try {
+            await handle({ ...effect, payload: effect.payload ?? {} });
+          } catch (e) {
+            failure = (e instanceof Error ? e.message : String(e)).slice(0, 500) || "error";
+          }
+          try {
+            await rpc("complete_effect", { p_id: effect.id, p_error: failure });
+          } catch (e) {
+            log(`genesis-chat: settling effect ${effect.id} failed: ${e instanceof Error ? e.message : "error"}`);
+            failure ??= "unsettled";
+          }
+          if (failure) {
+            report.failed++;
+            log(`genesis-chat: ${effect.kind} effect ${effect.id} (attempt ${effect.attempts}) failed: ${failure}`);
+          } else report.done++;
+        })
+      )
+    );
+    return report;
+  }
+  return { run, handle };
+}
+
+// src/server/transcribers.ts
+var TIMEOUT_MS = 12e4;
+async function failed(name, response) {
+  await response.body?.cancel().catch(() => {
+  });
+  throw new Error(`${name} answered HTTP ${response.status}`);
+}
+function deepgramTranscriber(options) {
+  const fetchFn = options.fetch ?? fetch;
+  const model = options.model ?? "nova-3";
+  return {
+    name: "deepgram",
+    async transcribe(input) {
+      const params = new URLSearchParams({ model, smart_format: "true" });
+      if (input.language) params.set("language", input.language);
+      else params.set("detect_language", "true");
+      const response = await fetchFn(`https://api.deepgram.com/v1/listen?${params}`, {
+        method: "POST",
+        headers: { authorization: `Token ${options.apiKey}`, "content-type": "application/json", accept: "application/json" },
+        body: JSON.stringify({ url: input.url }),
+        signal: AbortSignal.timeout(TIMEOUT_MS)
+      });
+      if (!response.ok) return failed("Deepgram", response);
+      const json3 = await response.json();
+      const channel = json3.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 };
+    }
+  };
+}
+var EXTENSIONS = {
+  "audio/mp4": "m4a",
+  "audio/x-m4a": "m4a",
+  "audio/aac": "m4a",
+  "audio/mpeg": "mp3",
+  "audio/webm": "webm",
+  "audio/ogg": "ogg",
+  "audio/wav": "wav",
+  "video/mp4": "mp4",
+  "video/webm": "webm"
+};
+var OPENAI_MAX_BYTES = 25 * 1024 * 1024;
+function openAiTranscriber(options) {
+  const fetchFn = options.fetch ?? fetch;
+  const model = options.model ?? "gpt-4o-mini-transcribe";
+  return {
+    name: "openai",
+    async transcribe(input) {
+      const file = await fetchFn(input.url, { signal: AbortSignal.timeout(TIMEOUT_MS) });
+      if (!file.ok) return failed("Storage", file);
+      const blob = await file.blob();
+      if (blob.size > OPENAI_MAX_BYTES) throw new Error("OpenAI transcription: file over 25 MB");
+      const mime = input.mime ?? (blob.type || "audio/mp4");
+      const form = new FormData();
+      form.set("file", new Blob([blob], { type: mime }), `audio.${EXTENSIONS[mime] ?? "m4a"}`);
+      form.set("model", model);
+      form.set("response_format", "json");
+      if (input.language) form.set("language", input.language);
+      const response = await fetchFn("https://api.openai.com/v1/audio/transcriptions", {
+        method: "POST",
+        headers: { authorization: `Bearer ${options.apiKey}` },
+        body: form,
+        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 };
+    }
+  };
+}
+
+// src/server/crypto.ts
+var encoder = new TextEncoder();
+async function sha256(value) {
+  return new Uint8Array(await crypto.subtle.digest("SHA-256", encoder.encode(value)));
+}
+async function safeEqual(a, b) {
+  const [x, y] = await Promise.all([sha256(a), sha256(b)]);
+  let diff = 0;
+  for (let i = 0; i < x.length; i++) diff |= x[i] ^ y[i];
+  return diff === 0;
+}
+async function hmacSha256Hex(secret, message) {
+  const key = await crypto.subtle.importKey("raw", encoder.encode(secret), { name: "HMAC", hash: "SHA-256" }, false, ["sign"]);
+  const mac = new Uint8Array(await crypto.subtle.sign("HMAC", key, encoder.encode(message)));
+  return Array.from(mac, (b) => b.toString(16).padStart(2, "0")).join("");
+}
+function base64ToBytes(value) {
+  const binary = atob(value.replace(/\s+/g, ""));
+  const out = new Uint8Array(binary.length);
+  for (let i = 0; i < binary.length; i++) out[i] = binary.charCodeAt(i);
+  return out;
+}
+function base64Url(bytes) {
+  const b = typeof bytes === "string" ? encoder.encode(bytes) : bytes;
+  let binary = "";
+  for (const byte of b) binary += String.fromCharCode(byte);
+  return btoa(binary).replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
+}
+function derLength(n) {
+  if (n < 128) return [n];
+  const bytes = [];
+  for (let v = n; v > 0; v >>= 8) bytes.unshift(v & 255);
+  return [128 | bytes.length, ...bytes];
+}
+function der(tag, body) {
+  const len = derLength(body.length);
+  const out = new Uint8Array(1 + len.length + body.length);
+  out[0] = tag;
+  out.set(len, 1);
+  out.set(body, 1 + len.length);
+  return out;
+}
+function pkcs1ToPkcs8(pkcs1) {
+  const version = new Uint8Array([2, 1, 0]);
+  const algorithm = new Uint8Array([48, 13, 6, 9, 42, 134, 72, 134, 247, 13, 1, 1, 1, 5, 0]);
+  const octets = der(4, pkcs1);
+  const body = new Uint8Array(version.length + algorithm.length + octets.length);
+  body.set(version, 0);
+  body.set(algorithm, version.length);
+  body.set(octets, version.length + algorithm.length);
+  return der(48, body);
+}
+async function importRsaPrivateKey(key) {
+  const pem = key.includes("-----BEGIN") ? key : new TextDecoder().decode(base64ToBytes(key));
+  const match = /-----BEGIN (RSA )?PRIVATE KEY-----([\s\S]+?)-----END (RSA )?PRIVATE KEY-----/.exec(pem);
+  if (!match) throw new Error("importRsaPrivateKey: not a PEM private key");
+  const bytes = base64ToBytes(match[2]);
+  const pkcs8 = match[1] ? pkcs1ToPkcs8(bytes) : bytes;
+  return crypto.subtle.importKey("pkcs8", pkcs8, { name: "RSASSA-PKCS1-v1_5", hash: "SHA-256" }, false, ["sign"]);
+}
+async function signJwtRs256(header, claims, key) {
+  const input = `${base64Url(JSON.stringify({ alg: "RS256", typ: "JWT", ...header }))}.${base64Url(JSON.stringify(claims))}`;
+  const signature = new Uint8Array(await crypto.subtle.sign("RSASSA-PKCS1-v1_5", key, encoder.encode(input)));
+  return `${input}.${base64Url(signature)}`;
+}
+
+// src/server/mux.ts
+var API = "https://api.mux.com/video/v1";
+var TOLERANCE_SECONDS = 300;
+var UUID = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+async function verifyMuxSignature(header, body, secret, options = {}) {
+  if (!header || !secret) return false;
+  let timestamp = null;
+  const signatures = [];
+  for (const part of header.split(",")) {
+    const [k, v] = part.split("=", 2).map((s) => s.trim());
+    if (k === "t" && v) timestamp = v;
+    else if (k === "v1" && v) signatures.push(v.toLowerCase());
+  }
+  if (!timestamp || !/^\d{1,12}$/.test(timestamp) || signatures.length === 0) return false;
+  const now = Math.floor((options.now ?? Date.now()) / 1e3);
+  if (Math.abs(now - Number(timestamp)) > (options.toleranceSeconds ?? TOLERANCE_SECONDS)) return false;
+  const expected = await hmacSha256Hex(secret, `${timestamp}.${body}`);
+  let ok = false;
+  for (const signature of signatures) if (await safeEqual(signature, expected)) ok = true;
+  return ok;
+}
+async function muxPlaybackUrl(playbackId, key, options = {}) {
+  const token = await muxPlaybackToken(playbackId, key, options);
+  return `https://stream.mux.com/${playbackId}${options.path ?? ".m3u8"}?token=${token}`;
+}
+async function muxPlaybackToken(playbackId, key, options = {}) {
+  const now = Math.floor((options.now ?? Date.now()) / 1e3);
+  const privateKey = await importRsaPrivateKey(key.privateKey);
+  return signJwtRs256(
+    { kid: key.signingKeyId },
+    { sub: playbackId, aud: options.audience ?? "v", exp: now + (options.expiresInSeconds ?? 6 * 3600) },
+    privateKey
+  );
+}
+var json = (status, body) => new Response(JSON.stringify(body), { status, headers: { "content-type": "application/json" } });
+function muxVideo(options) {
+  const fetchFn = options.fetch ?? fetch;
+  const policy = options.playbackPolicy ?? "public";
+  const captions = options.captions === false ? null : { languageCode: options.captions?.languageCode ?? "en", name: options.captions?.name ?? "English (auto)" };
+  const auth = `Basic ${btoa(`${options.tokenId}:${options.tokenSecret}`)}`;
+  async function api(method, path, body) {
+    return fetchFn(`${API}${path}`, {
+      method,
+      headers: { authorization: auth, accept: "application/json", ...body ? { "content-type": "application/json" } : {} },
+      ...body ? { body: JSON.stringify(body) } : {},
+      signal: AbortSignal.timeout(15e3)
+    });
+  }
+  async function update(supabase, id, patch) {
+    const { error } = await supabase.schema(CHAT_SCHEMA).rpc("update_attachment", { p_attachment_id: id, p_patch: patch });
+    if (error) throw new Error(`update_attachment: ${error.code ?? "error"}`);
+  }
+  async function find(supabase, ids) {
+    const table = () => supabase.schema(CHAT_SCHEMA).from("attachments").select("id, playback_id, transcript_status").eq("provider", "mux");
+    if (ids.passthrough && UUID.test(ids.passthrough)) {
+      const { data, error } = await table().eq("id", ids.passthrough).maybeSingle();
+      if (error) throw new Error(`attachments: ${error.code ?? "error"}`);
+      if (data) return data;
+    }
+    for (const providerId of ids.providerIds) {
+      if (!providerId) continue;
+      const { data, error } = await table().eq("provider_id", providerId).limit(1).maybeSingle();
+      if (error) throw new Error(`attachments: ${error.code ?? "error"}`);
+      if (data) return data;
+    }
+    return null;
+  }
+  async function transcriptOf(playbackId, trackId) {
+    let url = `https://stream.mux.com/${playbackId}/text/${trackId}.txt`;
+    if (policy === "signed") {
+      if (!options.signing) return null;
+      url += `?token=${await muxPlaybackToken(playbackId, options.signing, { expiresInSeconds: 600 })}`;
+    }
+    const response = await fetchFn(url, { signal: AbortSignal.timeout(15e3) });
+    if (!response.ok) {
+      await response.body?.cancel().catch(() => {
+      });
+      throw new Error(`Mux text track answered HTTP ${response.status}`);
+    }
+    return (await response.text()).trim();
+  }
+  return {
+    name: "mux",
+    async createUpload({ corsOrigin, passthrough }) {
+      const response = await api("POST", "/uploads", {
+        cors_origin: corsOrigin,
+        new_asset_settings: {
+          playback_policies: [policy],
+          video_quality: options.videoQuality ?? "basic",
+          ...passthrough ? { passthrough: passthrough.slice(0, 255) } : {},
+          ...captions ? { inputs: [{ generated_subtitles: [{ language_code: captions.languageCode, name: captions.name }] }] } : {}
+        }
+      });
+      if (!response.ok) {
+        await response.body?.cancel().catch(() => {
+        });
+        throw new Error(`Mux uploads answered HTTP ${response.status}`);
+      }
+      const body = await response.json();
+      if (!body.data?.id || !body.data.url) throw new Error("Mux uploads answered without an upload");
+      return { uploadId: body.data.id, url: body.data.url };
+    },
+    async remove(assetId) {
+      const response = await api("DELETE", `/assets/${encodeURIComponent(assetId)}`);
+      await response.body?.cancel().catch(() => {
+      });
+      if (response.ok || response.status === 404) return;
+      throw new Error(`Mux delete asset answered HTTP ${response.status}`);
+    },
+    playbackUrl(playbackId, opts) {
+      if (policy !== "signed") return Promise.resolve(`https://stream.mux.com/${playbackId}.m3u8`);
+      if (!options.signing) return Promise.reject(new Error("muxVideo: signed playback needs `signing`"));
+      return muxPlaybackUrl(playbackId, options.signing, opts);
+    },
+    async handleWebhook(request, { supabase }) {
+      if (request.method !== "POST") return json(405, { error: "method not allowed" });
+      const body = await request.text();
+      const ok = await verifyMuxSignature(request.headers.get("mux-signature"), body, options.webhookSecret, {
+        ...options.now ? { now: options.now() } : {}
+      });
+      if (!ok) return json(401, { error: "bad signature" });
+      let event;
+      try {
+        event = JSON.parse(body);
+      } catch {
+        return json(400, { error: "bad json" });
+      }
+      const data = event.data ?? {};
+      switch (event.type) {
+        case "video.asset.ready":
+        case "video.asset.errored": {
+          const attachment = await find(supabase, { passthrough: data.passthrough, providerIds: [data.upload_id, data.id] });
+          if (!attachment) return json(404, { error: "attachment not found" });
+          if (event.type === "video.asset.errored") {
+            await update(supabase, attachment.id, { status: "failed", ...data.id ? { provider_id: data.id } : {} });
+          } else {
+            const playback = data.playback_ids?.find((p) => p.policy === policy) ?? data.playback_ids?.[0];
+            await update(supabase, attachment.id, {
+              status: "ready",
+              ...data.id ? { provider_id: data.id } : {},
+              ...playback?.id ? { playback_id: playback.id } : {},
+              ...typeof data.duration === "number" ? { duration_ms: Math.round(data.duration * 1e3) } : {},
+              // No captions asked for: nothing will fill the transcript.
+              ...!captions ? { transcript_status: "off" } : {}
+            });
+          }
+          return json(200, { ok: true });
+        }
+        case "video.asset.track.ready":
+        case "video.asset.track.errored": {
+          if (data.type !== "text" || data.text_source !== "generated_vod") return json(200, { ignored: true });
+          const attachment = await find(supabase, { providerIds: [data.asset_id] });
+          if (!attachment) return json(404, { error: "attachment not found" });
+          if (event.type === "video.asset.track.errored") {
+            await update(supabase, attachment.id, { transcript_status: "failed" });
+            return json(200, { ok: true });
+          }
+          if (!attachment.playback_id || !data.id) return json(404, { error: "no playback id yet" });
+          const text = await transcriptOf(attachment.playback_id, data.id);
+          if (text === null) return json(200, { ignored: "signed playback without a signing key" });
+          await update(supabase, attachment.id, { transcript: text.slice(0, 1e5), transcript_status: "ready" });
+          return json(200, { ok: true });
+        }
+        default:
+          return json(200, { ignored: true });
+      }
+    }
+  };
+}
+
+// src/server/expo.ts
+var EXPO_SEND_URL = "https://exp.host/--/api/v2/push/send";
+var EXPO_BATCH = 100;
+function createExpoDeliver(options) {
+  const fetchFn = options.fetch ?? fetch;
+  return async (notification) => {
+    const badges = new Map(notification.recipients.map((r) => [r.userId, r.badge]));
+    const devices = await options.tokensFor([...badges.keys()]);
+    const messages = devices.map(
+      (d) => ({
+        userId: d.userId,
+        to: d.token,
+        title: notification.title,
+        body: notification.body,
+        data: notification.data,
+        sound: options.sound === void 0 ? "default" : options.sound,
+        badge: badges.get(d.userId) ?? 0,
+        threadId: notification.threadKey,
+        ...options.collapse ? { collapseId: notification.collapseKey } : {},
+        channelId: options.channelId ?? "messages",
+        categoryId: options.categoryId ?? "messages"
+      })
+    );
+    const tickets = [];
+    let sent = 0;
+    let lastError = null;
+    for (let i = 0; i < messages.length; i += EXPO_BATCH) {
+      const chunk = messages.slice(i, i + EXPO_BATCH);
+      let answer = null;
+      try {
+        const response = await fetchFn(EXPO_SEND_URL, {
+          method: "POST",
+          headers: {
+            accept: "application/json",
+            "content-type": "application/json",
+            ...options.accessToken ? { authorization: `Bearer ${options.accessToken}` } : {}
+          },
+          body: JSON.stringify(chunk.map(({ userId: _userId, ...m }) => m)),
+          signal: AbortSignal.timeout(15e3)
+        });
+        if (!response.ok) {
+          await response.body?.cancel().catch(() => {
+          });
+          throw new Error(`Expo push answered HTTP ${response.status}`);
+        }
+        const json3 = await response.json();
+        answer = Array.isArray(json3.data) ? json3.data : [];
+        sent += chunk.length;
+      } catch (e) {
+        lastError = e;
+      }
+      chunk.forEach((m, j) => {
+        const t = answer?.[j];
+        tickets.push({
+          userId: m.userId,
+          token: m.to,
+          ticket: t && (t.status === "ok" || t.status === "error") ? t : { status: "error", details: { error: answer ? "NoTicket" : "RequestFailed" } }
+        });
+      });
+    }
+    if (messages.length > 0 && sent === 0) throw lastError instanceof Error ? lastError : new Error("Expo push failed");
+    return tickets;
+  };
+}
+function deadTokens(tickets) {
+  return tickets.filter((t) => t.ticket.status === "error" && t.ticket.details?.error === "DeviceNotRegistered").map((t) => t.token);
+}
+
+// src/server/handler.ts
+var json2 = (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" });
+    const match = /^Bearer\s+(\S+)$/i.exec(request.headers.get("authorization") ?? "");
+    if (!match || !await safeEqual(match[1], options.secret)) return json2(401, { error: "unauthorized" });
+    try {
+      return json2(200, await options.runner.run());
+    } catch (e) {
+      return json2(500, { error: e instanceof Error ? e.message.slice(0, 200) : "run failed" });
+    }
+  };
+}
+
+export { CHAT_MAX_ATTEMPTS, EXPO_BATCH, EXPO_SEND_URL, chatRunnerHandler, createChatRunner, createExpoDeliver, deadTokens, deepgramTranscriber, muxPlaybackToken, muxPlaybackUrl, muxVideo, openAiTranscriber, verifyMuxSignature };
+//# sourceMappingURL=server.js.map
+//# sourceMappingURL=server.js.map