@ai-matrx/messaging 0.0.0 → 0.1.0

package/dist/react.js

@@ -0,0 +1,2980 @@
+"use client";
+"use client";
+
+// src/react/provider.tsx
+import {
+  createContext,
+  useContext,
+  useEffect,
+  useMemo,
+  useRef,
+  useSyncExternalStore
+} from "react";
+import { RealtimeProvider, useRealtimeManager } from "@ai-matrx/realtime/react";
+
+// src/core/actions.ts
+function receiptKey(kind, messageId, actorId) {
+  return `${kind}::${messageId}::${actorId}`;
+}
+function createActionRegistry() {
+  const handlers = /* @__PURE__ */ new Map();
+  const receipts = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  const registry = {
+    register(handler) {
+      handlers.set(handler.kind, handler);
+    },
+    resolve(action) {
+      const handler = handlers.get(action.kind);
+      if (handler === void 0) return null;
+      return handler.versions.includes(action.version) ? handler : null;
+    },
+    choicesFor(action) {
+      const handler = registry.resolve(action);
+      return handler === null ? [] : handler.choices(action.payload);
+    },
+    summarize(action) {
+      const handler = registry.resolve(action);
+      if (handler?.summarize === void 0) return null;
+      return handler.summarize(action.payload);
+    },
+    execute(action, context) {
+      const key = receiptKey(action.kind, context.messageId, context.actorId);
+      const settled = receipts.get(key);
+      if (settled !== void 0) return Promise.resolve(settled);
+      const running = inFlight.get(key);
+      if (running !== void 0) return running;
+      const handler = registry.resolve(action);
+      if (handler === null) {
+        const receipt = {
+          kind: action.kind,
+          messageId: context.messageId,
+          actorId: context.actorId,
+          outcome: "unavailable",
+          label: "Not available in this app version",
+          settledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          detail: `No handler registered for "${action.kind}" v${action.version}. Update the app, or register a handler on <MessagingProvider actions={...}>.`
+        };
+        return Promise.resolve(receipt);
+      }
+      const started = handler.execute(action.payload, context).then((receipt) => {
+        if (receipt.outcome === "applied" || receipt.outcome === "already") {
+          receipts.set(key, receipt);
+        }
+        return receipt;
+      }).finally(() => {
+        inFlight.delete(key);
+      });
+      inFlight.set(key, started);
+      return started;
+    },
+    receiptFor(kind, messageId, actorId) {
+      return receipts.get(receiptKey(kind, messageId, actorId)) ?? null;
+    },
+    observeReceipt(receipt) {
+      if (receipt.outcome === "applied" || receipt.outcome === "already") {
+        receipts.set(receiptKey(receipt.kind, receipt.messageId, receipt.actorId), receipt);
+      }
+    },
+    known() {
+      return [...handlers.keys()];
+    }
+  };
+  return registry;
+}
+
+// src/core/ai.ts
+import {
+  newEphemeralConversationStart,
+  runAgentToCompletion
+} from "@ai-matrx/agents/matrx";
+
+// src/core/errors.ts
+var MessagingError = class extends Error {
+  code;
+  /** The remedy. Nothing fails silently, and nothing fails without saying what to do. */
+  remedy;
+  cause;
+  constructor(code, message, remedy, cause) {
+    super(message);
+    this.name = "MessagingError";
+    this.code = code;
+    this.remedy = remedy;
+    if (cause !== void 0) this.cause = cause;
+  }
+  /** True when retrying after the host re-establishes a session is the fix. */
+  get isRetryable() {
+    return this.code === "session-unavailable" || this.code === "transport";
+  }
+};
+var FORBIDDEN_CODES = /* @__PURE__ */ new Set(["42501", "PGRST301", "PGRST302"]);
+var NOT_FOUND_CODES = /* @__PURE__ */ new Set(["PGRST116", "PGRST205"]);
+var CONFLICT_CODES = /* @__PURE__ */ new Set(["23505"]);
+var SESSION_MARKERS = [
+  "auth session missing",
+  "jwt expired",
+  "no api key found",
+  "refresh_token_not_found",
+  "invalid claim: missing sub claim"
+];
+function normalizeMessagingError(error, operation) {
+  if (error instanceof MessagingError) return error;
+  const raw = error;
+  const message = typeof raw?.message === "string" ? raw.message : String(error);
+  const code = typeof raw?.code === "string" ? raw.code : void 0;
+  const lowered = message.toLowerCase();
+  if (raw?.name === "SessionUnavailableError" || SESSION_MARKERS.some((marker) => lowered.includes(marker))) {
+    return new MessagingError(
+      "session-unavailable",
+      `${operation}: no Supabase session available (${message})`,
+      "Normal during sign-in and token refresh. The package retries once after the host's session source resolves; log it as a warning, never as an error.",
+      error
+    );
+  }
+  if (code !== void 0 && FORBIDDEN_CODES.has(code)) {
+    return new MessagingError(
+      "forbidden",
+      `${operation}: denied by the database (${code}: ${message})`,
+      "Authorization is RLS + auth-checked RPCs (R5). Fix the policy or the caller's membership \u2014 never work around it with a service-role client in a browser.",
+      error
+    );
+  }
+  if (code !== void 0 && NOT_FOUND_CODES.has(code)) {
+    return new MessagingError(
+      "not-found",
+      `${operation}: not found (${code}: ${message})`,
+      "The row is gone, or RLS hides it from this user. Re-read the conversation list.",
+      error
+    );
+  }
+  if (code !== void 0 && CONFLICT_CODES.has(code)) {
+    return new MessagingError(
+      "conflict",
+      `${operation}: unique violation (${code}: ${message})`,
+      "A concurrent writer won. For messages this is the client_message_id idempotency key doing its job \u2014 re-read the row rather than retrying the insert.",
+      error
+    );
+  }
+  return new MessagingError(
+    "transport",
+    `${operation}: ${message}`,
+    "Transient transport failure. The package retries reads; a write is surfaced to the outbox so the typed message is never lost.",
+    error
+  );
+}
+function invalidResponse(operation, detail) {
+  return new MessagingError(
+    "invalid-response",
+    `${operation}: ${detail}`,
+    "The database returned a shape this package does not accept. Rendering it would put a lie on the screen, so it is refused here. Fix the RPC's return contract."
+  );
+}
+
+// src/core/references.ts
+var FENCE = /```matrx\s*\n([\s\S]*?)\n?```/g;
+function parseFenceBody(body) {
+  let parsed;
+  try {
+    parsed = JSON.parse(body);
+  } catch {
+    return [];
+  }
+  const entries = Array.isArray(parsed) ? parsed : [parsed];
+  const references = [];
+  for (const entry of entries) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry;
+    const entityType = record["entityType"] ?? record["entity_type"] ?? record["type"];
+    const entityId = record["entityId"] ?? record["entity_id"] ?? record["id"];
+    if (typeof entityType !== "string" || typeof entityId !== "string") continue;
+    if (entityType.length === 0 || entityId.length === 0) continue;
+    const label = record["label"] ?? record["title"] ?? record["name"];
+    const href = record["href"] ?? record["url"];
+    references.push({
+      entityType,
+      entityId,
+      label: typeof label === "string" && label.length > 0 ? label : entityId,
+      ...typeof href === "string" && href.length > 0 ? { href } : {}
+    });
+  }
+  return references;
+}
+function extractReferences(content, structured = []) {
+  const seen = /* @__PURE__ */ new Map();
+  const add = (reference) => {
+    seen.set(`${reference.entityType}:${reference.entityId}`, reference);
+  };
+  structured.forEach(add);
+  for (const match of content.matchAll(FENCE)) {
+    parseFenceBody(match[1] ?? "").forEach(add);
+  }
+  return [...seen.values()];
+}
+function splitText(content) {
+  const segments = [];
+  let cursor = 0;
+  for (const match of content.matchAll(FENCE)) {
+    const start = match.index ?? 0;
+    if (start > cursor) {
+      segments.push({ type: "text", value: content.slice(cursor, start) });
+    }
+    parseFenceBody(match[1] ?? "").forEach((reference) => {
+      segments.push({ type: "reference", reference });
+    });
+    cursor = start + match[0].length;
+  }
+  if (cursor < content.length) {
+    segments.push({ type: "text", value: content.slice(cursor) });
+  }
+  return segments.filter(
+    (segment) => segment.type === "reference" || segment.value.trim().length > 0
+  );
+}
+function summarizeText(content, maxLength = 140) {
+  const parts = splitText(content).map(
+    (segment) => segment.type === "text" ? segment.value : segment.reference.label
+  );
+  const flattened = parts.join(" ").replace(/\s+/g, " ").trim();
+  if (flattened.length <= maxLength) return flattened;
+  return `${flattened.slice(0, maxLength - 1).trimEnd()}\u2026`;
+}
+function composeFence(references) {
+  if (references.length === 0) return "";
+  return `\`\`\`matrx
+${JSON.stringify(references, null, 2)}
+\`\`\``;
+}
+
+// src/core/ai.ts
+function nameOf(participants, senderId) {
+  return participants.find((p) => p.userId === senderId)?.displayName ?? senderId;
+}
+function buildTranscript(messages, participants, limit, since) {
+  const relevant = messages.filter((message) => {
+    if (message.deletedAt !== null) return false;
+    if (since === null) return true;
+    return message.createdAt > since;
+  });
+  const windowed = relevant.slice(-limit);
+  return windowed.map((message) => ({
+    at: message.createdAt,
+    author: nameOf(participants, message.senderId),
+    // The transcript is TEXT. A reference fence becomes its label, never JSON —
+    // the same collapse the inbox preview uses.
+    text: summarizeText(message.content, 2e3)
+  }));
+}
+function createMessagingAi(options) {
+  const limit = options.maxTranscriptMessages ?? 200;
+  function agentFor(capability) {
+    const agentId = options.agents[capability];
+    if (typeof agentId !== "string" || agentId.length === 0) {
+      throw new MessagingError(
+        "misconfigured",
+        `Messaging AI capability "${capability}" has no agent configured`,
+        `Pass agents={{ ${capability}: "<agent-id>" }} to <MessagingProvider>. Agent definitions live in the database, never in this package \u2014 the id is the only part a host injects. Until then the UI hides this action rather than offering a button that cannot work.`
+      );
+    }
+    return agentId;
+  }
+  async function run(capability, variables, userInput, signal) {
+    const agentId = agentFor(capability);
+    const completed = await runAgentToCompletion(
+      options.transport,
+      agentId,
+      {
+        ...newEphemeralConversationStart(),
+        organization_id: options.organizationId,
+        source_app: options.sourceApp ?? "ai-matrx",
+        source_feature: options.sourceFeature ?? `messaging.${capability}`,
+        initiation: "user",
+        // THE USER-INPUT LAW: structured content is NEVER here.
+        ...userInput !== null ? { user_input: userInput } : {},
+        variables
+      },
+      signal !== void 0 ? { signal } : {}
+    );
+    return {
+      capability,
+      text: completed.text.trim(),
+      conversationId: completed.conversationId
+    };
+  }
+  function variablesFor(args) {
+    const transcript = buildTranscript(
+      args.messages,
+      args.participants,
+      limit,
+      args.since ?? null
+    );
+    return {
+      conversation_id: args.conversationId,
+      participants: args.participants.map((participant) => ({
+        user_id: participant.userId,
+        display_name: participant.displayName,
+        is_agent: participant.isAgent
+      })),
+      transcript: transcript.map((entry) => ({
+        at: entry.at,
+        author: entry.author,
+        text: entry.text
+      })),
+      transcript_message_count: transcript.length,
+      // Honest about the cut, so an agent can say "showing the last 200".
+      transcript_truncated: args.messages.length > transcript.length,
+      ...args.since != null ? { unread_since: args.since } : {}
+    };
+  }
+  return {
+    available: () => ["catchUp", "summarize", "actionItems", "draftReply"].filter(
+      (capability) => {
+        const id = options.agents[capability];
+        return typeof id === "string" && id.length > 0;
+      }
+    ),
+    isAvailable(capability) {
+      const id = options.agents[capability];
+      return typeof id === "string" && id.length > 0;
+    },
+    catchMeUp: (args) => run("catchUp", variablesFor(args), null, args.signal),
+    summarize: (args) => run("summarize", variablesFor(args), null, args.signal),
+    extractActionItems: (args) => run("actionItems", variablesFor(args), null, args.signal),
+    draftReply: (args) => run(
+      "draftReply",
+      variablesFor(args),
+      // The ONE genuine human utterance in this module: what the user asked
+      // the drafter for. Everything else rode `variables`.
+      args.instruction !== void 0 && args.instruction.trim().length > 0 ? args.instruction.trim() : null,
+      args.signal
+    )
+  };
+}
+
+// src/core/engine.ts
+import {
+  clientSessionId
+} from "@ai-matrx/realtime";
+
+// src/core/channels.ts
+import { defineChannelNamespace } from "@ai-matrx/realtime";
+
+// src/core/slot.ts
+var NAMESPACE = "ai-matrx.messaging";
+function globalSlot(name, create) {
+  const key = /* @__PURE__ */ Symbol.for(`${NAMESPACE}.${name}`);
+  const host = globalThis;
+  const existing = host[key];
+  if (existing !== void 0) return existing;
+  const created = create();
+  host[key] = created;
+  return created;
+}
+
+// src/core/channels.ts
+function namespaces() {
+  return globalSlot("channel-namespaces", () => ({
+    inbox: defineChannelNamespace({
+      namespace: "messaging-inbox",
+      parts: ["userId"],
+      description: "One user's conversation list: new messages anywhere they participate, membership changes, and read-state updates."
+    }),
+    conversation: defineChannelNamespace({
+      namespace: "messaging-conversation",
+      parts: ["conversationId"],
+      description: "One conversation: message inserts/updates, presence, and typing \u2014 deliberately one channel, because they are one room."
+    })
+  }));
+}
+function inboxTopic(userId) {
+  return namespaces().inbox.topic({ userId });
+}
+function conversationTopic(conversationId) {
+  return namespaces().conversation.topic({ conversationId });
+}
+var MESSAGING_EVENTS = {
+  /** A freshly sent message, broadcast beside the Postgres Changes row so a
+   *  receiver gets it on whichever path arrives first (both are deduped). */
+  message: "mx.message",
+  /** A message edited or soft-deleted. */
+  messageUpdated: "mx.message.updated",
+  /** An action receipt, so every viewer's chip settles at once. */
+  actionSettled: "mx.action.settled"
+};
+
+// src/core/outbox.ts
+import { randomId } from "@ai-matrx/realtime";
+function createMemoryOutboxStorage() {
+  let held = [];
+  return {
+    name: "memory",
+    durable: false,
+    load: () => held,
+    save: (entries) => {
+      held = entries;
+    }
+  };
+}
+function createWebOutboxStorage(args) {
+  const key = args.key ?? "ai-matrx.messaging.outbox";
+  let storage = args.storage ?? null;
+  if (storage === null) {
+    try {
+      const candidate = globalThis.localStorage;
+      storage = candidate ?? null;
+    } catch {
+      storage = null;
+    }
+  }
+  if (storage === null) {
+    args.onFallback?.(
+      "localStorage is unavailable, so queued messages will NOT survive a reload. Inject an OutboxStorage on <MessagingProvider> to restore durability."
+    );
+    return createMemoryOutboxStorage();
+  }
+  const backing = storage;
+  return {
+    name: "web-storage",
+    durable: true,
+    load() {
+      try {
+        const raw = backing.getItem(key);
+        if (raw === null) return [];
+        const parsed = JSON.parse(raw);
+        return Array.isArray(parsed) ? parsed : [];
+      } catch {
+        return [];
+      }
+    },
+    save(entries) {
+      try {
+        backing.setItem(key, JSON.stringify(entries));
+      } catch {
+        args.onFallback?.(
+          "Writing the outbox to localStorage failed (quota or private mode); queued messages are in memory only for this session."
+        );
+      }
+    }
+  };
+}
+var DEFAULT_BACKOFF = [0, 1e3, 3e3, 8e3, 2e4];
+function createOutbox(options) {
+  const timers = options.timers ?? {
+    setTimeout: (run, ms) => setTimeout(run, ms),
+    clearTimeout: (handle) => clearTimeout(handle),
+    now: () => Date.now()
+  };
+  const storage = options.storage ?? createMemoryOutboxStorage();
+  const maxAttempts = options.maxAttempts ?? DEFAULT_BACKOFF.length;
+  const backoff = options.backoffMs ?? DEFAULT_BACKOFF;
+  let entries = [...storage.load()].map((entry) => ({
+    ...entry,
+    // Anything found mid-`sending` after a reload is genuinely unknown: it may
+    // or may not have reached the database. It goes back to `queued` and the
+    // idempotency key makes the re-send safe — that is exactly what the key is
+    // for. Marking it failed instead would strand a message that was typed.
+    state: entry.state === "sending" ? "queued" : entry.state
+  }));
+  let timer = null;
+  let disposed = false;
+  function persist() {
+    storage.save(entries);
+    options.onChange(entries);
+  }
+  function delayFor(attempts) {
+    return backoff[Math.min(attempts, backoff.length - 1)] ?? 0;
+  }
+  function schedule(ms) {
+    if (disposed || timer !== null) return;
+    timer = timers.setTimeout(() => {
+      timer = null;
+      void pump();
+    }, ms);
+  }
+  async function pump() {
+    if (disposed) return;
+    const next = entries.find((entry) => entry.state === "queued");
+    if (next === void 0) return;
+    entries = entries.map(
+      (entry) => entry.id === next.id ? { ...entry, state: "sending" } : entry
+    );
+    persist();
+    try {
+      const message = await options.send(next.draft, next.clientMessageId);
+      entries = entries.filter((entry) => entry.id !== next.id);
+      persist();
+      options.onSent(next, message);
+      schedule(0);
+    } catch (error) {
+      const attempts = next.attempts + 1;
+      const reason = error instanceof MessagingError ? error.message : String(error?.message ?? error);
+      const exhausted = attempts >= maxAttempts;
+      entries = entries.map(
+        (entry) => entry.id === next.id ? {
+          ...entry,
+          attempts,
+          state: exhausted ? "failed" : "queued",
+          failureReason: reason
+        } : entry
+      );
+      persist();
+      if (exhausted) {
+        options.onDiagnostic?.(
+          `Message could not be sent after ${attempts} attempts: ${reason}. It is still in the outbox \u2014 offer the user Retry or Discard; never drop it.`
+        );
+        schedule(0);
+      } else {
+        schedule(delayFor(attempts));
+      }
+    }
+  }
+  const outbox = {
+    entries: () => entries,
+    enqueue(draft) {
+      const clientMessageId = `mx-${randomId()}`;
+      entries = [
+        ...entries,
+        {
+          id: randomId(),
+          clientMessageId,
+          draft,
+          queuedAt: timers.now(),
+          attempts: 0,
+          state: "queued",
+          failureReason: null
+        }
+      ];
+      persist();
+      schedule(0);
+      return clientMessageId;
+    },
+    retry(entryId) {
+      entries = entries.map(
+        (entry) => entry.id === entryId ? { ...entry, state: "queued", attempts: 0, failureReason: null } : entry
+      );
+      persist();
+      schedule(0);
+    },
+    discard(entryId) {
+      entries = entries.filter((entry) => entry.id !== entryId);
+      persist();
+    },
+    flush() {
+      entries = entries.map(
+        (entry) => entry.state === "failed" ? { ...entry, state: "queued", attempts: 0 } : entry
+      );
+      persist();
+      schedule(0);
+    },
+    pendingFor(conversationId) {
+      return entries.filter((entry) => entry.draft.conversationId === conversationId);
+    },
+    dispose() {
+      disposed = true;
+      if (timer !== null) timers.clearTimeout(timer);
+      timer = null;
+    }
+  };
+  if (entries.length > 0) {
+    options.onDiagnostic?.(
+      `Restored ${entries.length} unsent message(s) from the ${storage.name} outbox.`
+    );
+    schedule(0);
+  }
+  return outbox;
+}
+
+// src/core/projection.ts
+function str(row, key) {
+  const value = row[key];
+  return typeof value === "string" && value.length > 0 ? value : null;
+}
+function requiredStr(row, key, operation) {
+  const value = str(row, key);
+  if (value === null) {
+    throw invalidResponse(operation, `required field "${key}" was ${JSON.stringify(row[key])}`);
+  }
+  return value;
+}
+function bool(row, key, fallback) {
+  const value = row[key];
+  return typeof value === "boolean" ? value : fallback;
+}
+function jsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : {};
+}
+var CONVERSATION_TYPES = /* @__PURE__ */ new Set(["direct", "group", "org"]);
+var MESSAGE_KINDS = /* @__PURE__ */ new Set([
+  "text",
+  "image",
+  "video",
+  "audio",
+  "file",
+  "system",
+  "action"
+]);
+var ROLES = /* @__PURE__ */ new Set(["owner", "admin", "member"]);
+var DELIVERY_STATES = /* @__PURE__ */ new Set([
+  "sending",
+  "sent",
+  "delivered",
+  "read",
+  "failed"
+]);
+function projectUserSummary(row) {
+  const userId = requiredStr(row, "user_id", "projectUserSummary");
+  const displayName = str(row, "display_name") ?? str(row, "email") ?? userId;
+  return {
+    userId,
+    displayName,
+    email: str(row, "email"),
+    avatarUrl: str(row, "avatar_url"),
+    isAgent: bool(row, "is_agent", false)
+  };
+}
+function projectParticipants(value, operation) {
+  if (value === null || value === void 0) return [];
+  if (!Array.isArray(value)) {
+    throw invalidResponse(
+      operation,
+      `"participants" was ${typeof value}, not an array \u2014 the RPC's jsonb aggregate is malformed`
+    );
+  }
+  const summaries = [];
+  for (const entry of value) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry;
+    const id = str(record, "user_id") ?? str(record, "id");
+    if (id === null) continue;
+    summaries.push(
+      projectUserSummary({
+        ...record,
+        user_id: id
+      })
+    );
+  }
+  return summaries;
+}
+function projectMessageAction(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return null;
+  const record = value;
+  const kind = record["kind"];
+  if (typeof kind !== "string" || kind.length === 0) return null;
+  const version = record["version"];
+  return {
+    kind,
+    // A payload without a version is version 1 — the shape that predates the
+    // envelope. Refusing it would silently blank every message sent before the
+    // envelope existed.
+    version: typeof version === "number" && Number.isFinite(version) ? version : 1,
+    payload: jsonObject(record["payload"])
+  };
+}
+function projectAttachments(metadata) {
+  const raw = metadata["attachments"];
+  if (!Array.isArray(raw)) return [];
+  const attachments = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry;
+    const fileId = str(record, "fileId") ?? str(record, "file_id");
+    if (fileId === null) continue;
+    const size = record["sizeBytes"] ?? record["size_bytes"];
+    const width = record["width"];
+    const height = record["height"];
+    attachments.push({
+      fileId,
+      fileName: str(record, "fileName") ?? str(record, "file_name") ?? fileId,
+      mimeType: str(record, "mimeType") ?? str(record, "mime_type"),
+      sizeBytes: typeof size === "number" ? size : null,
+      width: typeof width === "number" ? width : null,
+      height: typeof height === "number" ? height : null
+    });
+  }
+  return attachments;
+}
+function projectReferences(metadata) {
+  const raw = metadata["references"];
+  if (!Array.isArray(raw)) return [];
+  const references = [];
+  for (const entry of raw) {
+    if (typeof entry !== "object" || entry === null) continue;
+    const record = entry;
+    const entityType = str(record, "entityType") ?? str(record, "entity_type");
+    const entityId = str(record, "entityId") ?? str(record, "entity_id");
+    if (entityType === null || entityId === null) continue;
+    const href = str(record, "href");
+    references.push({
+      entityType,
+      entityId,
+      label: str(record, "label") ?? entityId,
+      ...href !== null ? { href } : {}
+    });
+  }
+  return references;
+}
+function projectMessage(row, fallbackOrganizationId) {
+  const operation = "projectMessage";
+  const metadata = jsonObject(row["metadata"]);
+  const kindRaw = str(row, "message_type") ?? "text";
+  const stateRaw = str(row, "status") ?? "sent";
+  const replyTo = str(row, "reply_to_id");
+  const clientMessageId = str(row, "client_message_id");
+  const action = projectMessageAction(row["action_data"]);
+  return {
+    id: requiredStr(row, "id", operation),
+    conversationId: requiredStr(row, "conversation_id", operation),
+    senderId: requiredStr(row, "sender_id", operation),
+    organizationId: str(row, "organization_id") ?? fallbackOrganizationId,
+    content: typeof row["content"] === "string" ? row["content"] : "",
+    kind: MESSAGE_KINDS.has(kindRaw) ? kindRaw : "text",
+    // A row read from the DB is at least `sent`. `sending`/`failed` are outbox
+    // states and can never be projected from a persisted row.
+    deliveryState: DELIVERY_STATES.has(stateRaw) && stateRaw !== "sending" && stateRaw !== "failed" ? stateRaw : "sent",
+    replyToId: replyTo === null ? null : replyTo,
+    clientMessageId: clientMessageId === null ? null : clientMessageId,
+    createdAt: requiredStr(row, "created_at", operation),
+    editedAt: str(row, "edited_at"),
+    deletedAt: str(row, "deleted_at"),
+    deletedForEveryone: bool(row, "deleted_for_everyone", false),
+    action,
+    attachments: projectAttachments(metadata),
+    references: projectReferences(metadata),
+    metadata
+  };
+}
+function projectParticipantRole(value) {
+  return typeof value === "string" && ROLES.has(value) ? value : "member";
+}
+function projectConversationSummary(row, viewerId, fallbackOrganizationId) {
+  const operation = "projectConversationSummary";
+  const id = requiredStr(row, "conversation_id", operation);
+  const typeRaw = str(row, "conversation_type") ?? "direct";
+  const type = CONVERSATION_TYPES.has(typeRaw) ? typeRaw : "direct";
+  const participants = projectParticipants(row["participants"], operation);
+  const groupName = str(row, "group_name");
+  const groupImageUrl = str(row, "group_image_url");
+  const createdBy = str(row, "created_by");
+  const updatedAt = str(row, "conversation_updated_at") ?? str(row, "updated_at");
+  const createdAt = str(row, "conversation_created_at") ?? str(row, "created_at") ?? updatedAt;
+  const lastMessageAt = str(row, "last_message_at");
+  const lastSender = str(row, "last_message_sender_id");
+  const unreadRaw = row["unread_count"];
+  if (createdAt === null || updatedAt === null) {
+    throw invalidResponse(operation, `conversation ${id} carried no timestamps`);
+  }
+  const others = participants.filter((participant) => participant.userId !== viewerId);
+  const displayName = type === "direct" ? others[0]?.displayName ?? "Direct message" : groupName ?? "Group conversation";
+  const displayImageUrl = type === "direct" ? others[0]?.avatarUrl ?? null : groupImageUrl;
+  return {
+    conversation: {
+      id,
+      type,
+      groupName,
+      groupImageUrl,
+      createdBy: createdBy === null ? null : createdBy,
+      organizationId: str(row, "organization_id") ?? fallbackOrganizationId,
+      createdAt,
+      updatedAt,
+      metadata: jsonObject(row["metadata"])
+    },
+    participants,
+    lastMessageContent: str(row, "last_message_content"),
+    lastMessageSenderId: lastSender === null ? null : lastSender,
+    lastMessageAt,
+    unreadCount: typeof unreadRaw === "number" && Number.isFinite(unreadRaw) && unreadRaw > 0 ? Math.floor(unreadRaw) : 0,
+    isMuted: bool(row, "is_muted", false),
+    isArchived: bool(row, "is_archived", false),
+    displayName,
+    displayImageUrl,
+    // The keyset sort value: the last message if there is one, else the
+    // conversation's own update stamp. Empty conversations must still sort.
+    sortAt: lastMessageAt ?? updatedAt
+  };
+}
+
+// src/core/store.ts
+function timeOf(message) {
+  const stamp = message.editedAt ?? message.createdAt;
+  const parsed = Date.parse(stamp);
+  return Number.isFinite(parsed) ? parsed : 0;
+}
+function compare(a, b) {
+  if (a.createdAt !== b.createdAt) return a.createdAt < b.createdAt ? -1 : 1;
+  return a.id < b.id ? -1 : a.id > b.id ? 1 : 0;
+}
+function sameMessage(a, b) {
+  if (a.id === b.id) return true;
+  const key = b.clientMessageId;
+  return key !== null && a.clientMessageId === key;
+}
+function insertOrdered(messages, message) {
+  const next = [...messages];
+  let index = next.length;
+  while (index > 0) {
+    const candidate = next[index - 1];
+    if (candidate === void 0 || compare(candidate, message) <= 0) break;
+    index -= 1;
+  }
+  next.splice(index, 0, message);
+  return next;
+}
+function createMessagingStore() {
+  let conversations = [];
+  let hasMoreConversations = false;
+  let hasLoadedConversations = false;
+  let threads = /* @__PURE__ */ new Map();
+  let activeConversationId = null;
+  const listeners = /* @__PURE__ */ new Set();
+  let cached = null;
+  function snapshot() {
+    if (cached !== null) return cached;
+    cached = {
+      conversations,
+      hasMoreConversations,
+      hasLoadedConversations,
+      threads,
+      activeConversationId,
+      totalUnreadConversations: conversations.filter((item) => item.unreadCount > 0).length
+    };
+    return cached;
+  }
+  function emit() {
+    cached = null;
+    const next = snapshot();
+    listeners.forEach((listener) => listener(next));
+  }
+  function normalizeConversations(items) {
+    const active = activeConversationId;
+    const zeroed = active === null ? items : items.map(
+      (item) => item.conversation.id === active && item.unreadCount !== 0 ? { ...item, unreadCount: 0 } : item
+    );
+    return [...zeroed].sort((a, b) => a.sortAt < b.sortAt ? 1 : a.sortAt > b.sortAt ? -1 : 0);
+  }
+  function threadFor(id) {
+    return threads.get(id) ?? {
+      conversationId: id,
+      messages: [],
+      hasMoreOlder: false,
+      latestAt: null
+    };
+  }
+  function writeThread(thread) {
+    const next = new Map(threads);
+    const latest = thread.messages.at(-1);
+    next.set(thread.conversationId, {
+      ...thread,
+      latestAt: latest?.createdAt ?? thread.latestAt
+    });
+    threads = next;
+  }
+  const store = {
+    snapshot,
+    subscribe(listener) {
+      listeners.add(listener);
+      return () => {
+        listeners.delete(listener);
+      };
+    },
+    setConversations(items, hasMore) {
+      conversations = normalizeConversations(items);
+      hasMoreConversations = hasMore;
+      hasLoadedConversations = true;
+      emit();
+    },
+    appendConversations(items, hasMore) {
+      const byId = new Map(conversations.map((item) => [item.conversation.id, item]));
+      items.forEach((item) => byId.set(item.conversation.id, item));
+      conversations = normalizeConversations([...byId.values()]);
+      hasMoreConversations = hasMore;
+      emit();
+    },
+    upsertConversation(item) {
+      const byId = new Map(conversations.map((entry) => [entry.conversation.id, entry]));
+      byId.set(item.conversation.id, item);
+      conversations = normalizeConversations([...byId.values()]);
+      emit();
+    },
+    removeConversation(id) {
+      conversations = conversations.filter((item) => item.conversation.id !== id);
+      const next = new Map(threads);
+      next.delete(id);
+      threads = next;
+      emit();
+    },
+    setActiveConversation(id) {
+      activeConversationId = id;
+      conversations = normalizeConversations(conversations);
+      emit();
+    },
+    setThread(id, messages, args = {}) {
+      writeThread({
+        conversationId: id,
+        messages: [...messages].sort(compare),
+        hasMoreOlder: args.hasMoreOlder ?? false,
+        latestAt: null
+      });
+      emit();
+    },
+    prependOlder(id, messages, hasMoreOlder) {
+      const thread = threadFor(id);
+      const known = new Set(thread.messages.map((message) => message.id));
+      const fresh = messages.filter((message) => !known.has(message.id));
+      writeThread({
+        ...thread,
+        messages: [...fresh, ...thread.messages].sort(compare),
+        hasMoreOlder
+      });
+      emit();
+    },
+    ingest(message) {
+      const thread = threadFor(message.conversationId);
+      const index = thread.messages.findIndex((held2) => sameMessage(held2, message));
+      if (index === -1) {
+        writeThread({ ...thread, messages: insertOrdered(thread.messages, message) });
+        emit();
+        return "added";
+      }
+      const held = thread.messages[index];
+      if (held === void 0) return "dropped-duplicate";
+      const heldIsOptimistic = held.deliveryState === "sending" || held.deliveryState === "failed";
+      if (!heldIsOptimistic && timeOf(message) < timeOf(held)) return "dropped-stale";
+      if (!heldIsOptimistic && held.id === message.id && timeOf(message) === timeOf(held)) {
+        return "dropped-duplicate";
+      }
+      const merged = {
+        ...held,
+        ...message,
+        // Never lose the client key — it is what future echoes match on.
+        clientMessageId: message.clientMessageId ?? held.clientMessageId
+      };
+      const messages = [...thread.messages];
+      messages[index] = merged;
+      writeThread({ ...thread, messages: messages.sort(compare) });
+      emit();
+      return "merged";
+    },
+    ingestMany(messages) {
+      messages.forEach((message) => {
+        store.ingest(message);
+      });
+    },
+    removeMessage(conversationId, messageId) {
+      const thread = threadFor(conversationId);
+      writeThread({
+        ...thread,
+        messages: thread.messages.filter((message) => message.id !== messageId)
+      });
+      emit();
+    },
+    markConversationRead(id) {
+      conversations = conversations.map(
+        (item) => item.conversation.id === id ? { ...item, unreadCount: 0 } : item
+      );
+      emit();
+    },
+    setUnreadCount(id, count) {
+      conversations = normalizeConversations(
+        conversations.map(
+          (item) => item.conversation.id === id ? { ...item, unreadCount: Math.max(0, count) } : item
+        )
+      );
+      emit();
+    }
+  };
+  return store;
+}
+function optimisticMessage(args) {
+  const at = new Date(args.now?.() ?? Date.now()).toISOString();
+  return {
+    // A temporary id that can never collide with a uuid from the database.
+    id: `optimistic:${args.clientMessageId}`,
+    conversationId: args.conversationId,
+    senderId: args.senderId,
+    organizationId: args.organizationId,
+    content: args.content,
+    kind: args.kind ?? "text",
+    deliveryState: "sending",
+    replyToId: args.replyToId ?? null,
+    clientMessageId: args.clientMessageId,
+    createdAt: at,
+    editedAt: null,
+    deletedAt: null,
+    deletedForEveryone: false,
+    action: args.action ?? null,
+    attachments: args.attachments ?? [],
+    references: args.references ?? [],
+    metadata: {}
+  };
+}
+
+// src/core/engine.ts
+function createMessagingEngine(options) {
+  const { repository, manager, identity } = options;
+  const store = createMessagingStore();
+  const conversationPageSize = options.conversationPageSize ?? 30;
+  const messagePageSize = options.messagePageSize ?? 50;
+  const openChannels = /* @__PURE__ */ new Map();
+  let inboxChannel = null;
+  let conversationCursor = null;
+  let disposed = false;
+  function report(event) {
+    options.onDiagnostic?.(event);
+  }
+  function reportError(error, operation) {
+    const normalized = normalizeMessagingError(error, operation);
+    report({
+      // A missing session is a NORMAL lifecycle moment, not a red error. This
+      // one line is the cure for "909 captured errors in 0.6s".
+      level: normalized.code === "session-unavailable" ? "warn" : "error",
+      message: normalized.message,
+      remedy: normalized.remedy
+    });
+  }
+  const outbox = createOutbox({
+    ...options.outboxStorage !== void 0 ? { storage: options.outboxStorage } : {},
+    send: (draft, clientMessageId) => repository.insertMessage(draft, clientMessageId),
+    onSent: (entry, message) => {
+      store.ingest(message);
+      broadcastMessage(message);
+      void refreshConversationRow(message.conversationId);
+      void entry;
+    },
+    onChange: (entries) => {
+      entries.forEach((entry) => {
+        store.ingest(
+          optimisticMessage({
+            conversationId: entry.draft.conversationId,
+            senderId: identity.userId,
+            organizationId: identity.organizationId,
+            content: entry.draft.content,
+            clientMessageId: entry.clientMessageId,
+            ...entry.draft.kind !== void 0 ? { kind: entry.draft.kind } : {},
+            ...entry.draft.replyToId !== void 0 ? { replyToId: entry.draft.replyToId } : {},
+            ...entry.draft.action !== void 0 ? { action: entry.draft.action } : {},
+            ...entry.draft.attachments !== void 0 ? { attachments: [...entry.draft.attachments] } : {},
+            ...entry.draft.references !== void 0 ? { references: [...entry.draft.references] } : {}
+          })
+        );
+      });
+    },
+    onDiagnostic: (message) => report({ level: "warn", message })
+  });
+  function broadcastMessage(message) {
+    openChannels.get(message.conversationId)?.send(MESSAGING_EVENTS.message, message);
+  }
+  async function refreshConversationRow(id) {
+    try {
+      const page = await repository.listConversations({ limit: conversationPageSize });
+      const row = page.items.find((item) => item.conversation.id === id);
+      if (row !== void 0) store.upsertConversation(row);
+    } catch (error) {
+      reportError(error, "refreshConversationRow");
+    }
+  }
+  async function reloadInbox() {
+    const page = await repository.listConversations({ limit: conversationPageSize });
+    conversationCursor = page.nextCursor;
+    store.setConversations(page.items, page.hasMore);
+  }
+  async function backfillConversation(id) {
+    const thread = store.snapshot().threads.get(id);
+    const since = thread?.latestAt ?? null;
+    try {
+      if (since === null) {
+        const page = await repository.listMessages(id, { limit: messagePageSize });
+        store.setThread(id, page.items, { hasMoreOlder: page.hasMore });
+        return;
+      }
+      const missed = await repository.messagesSince(id, since);
+      store.ingestMany(missed);
+      if (missed.length > 0) {
+        report({
+          level: "info",
+          message: `Recovered ${missed.length} message(s) missed while disconnected.`
+        });
+      }
+    } catch (error) {
+      reportError(error, "backfillConversation");
+    }
+  }
+  const engine = {
+    store,
+    outbox,
+    identity,
+    async start() {
+      await reloadInbox();
+      if (disposed || inboxChannel !== null) return;
+      inboxChannel = manager.open({
+        topic: inboxTopic(identity.userId),
+        postgresChanges: [
+          {
+            event: "INSERT",
+            schema: "communication",
+            table: "dm_messages",
+            rowId: (row) => typeof row["id"] === "string" ? row["id"] : void 0,
+            onChange: ({ row }) => {
+              if (row === null) return;
+              const message = projectMessage(row, identity.organizationId);
+              const known = store.snapshot().conversations.some((item) => item.conversation.id === message.conversationId);
+              if (!known) {
+                void reloadInbox();
+                return;
+              }
+              store.ingest(message);
+              if (message.senderId !== identity.userId) {
+                options.onIncoming?.(message);
+              }
+              void refreshConversationRow(message.conversationId);
+            }
+          },
+          {
+            event: "*",
+            schema: "communication",
+            table: "dm_conversation_participants",
+            filter: `user_id=eq.${identity.userId}`,
+            rowId: (row) => typeof row["id"] === "string" ? row["id"] : void 0,
+            onChange: () => {
+              void reloadInbox();
+            }
+          }
+        ],
+        // THE BACKFILL DOOR for the inbox.
+        onBackfill: () => {
+          void reloadInbox().catch((error) => reportError(error, "inboxBackfill"));
+          outbox.flush();
+        }
+      });
+    },
+    async loadMoreConversations() {
+      if (conversationCursor === null) return;
+      try {
+        const page = await repository.listConversations({
+          limit: conversationPageSize,
+          cursor: conversationCursor
+        });
+        conversationCursor = page.nextCursor;
+        store.appendConversations(page.items, page.hasMore);
+      } catch (error) {
+        reportError(error, "loadMoreConversations");
+      }
+    },
+    async openConversation(id) {
+      store.setActiveConversation(id);
+      try {
+        const page = await repository.listMessages(id, { limit: messagePageSize });
+        store.setThread(id, page.items, { hasMoreOlder: page.hasMore });
+      } catch (error) {
+        reportError(error, "openConversation");
+      }
+      if (openChannels.has(id) || disposed) return;
+      const handle = manager.open({
+        topic: conversationTopic(id),
+        postgresChanges: [
+          {
+            event: "*",
+            schema: "communication",
+            table: "dm_messages",
+            filter: `conversation_id=eq.${id}`,
+            rowId: (row) => typeof row["id"] === "string" ? row["id"] : void 0,
+            fingerprint: (row) => typeof row["content"] === "string" ? row["content"] : void 0,
+            updatedAtField: "updated_at",
+            updatedByField: "updated_by",
+            onChange: ({ row }) => {
+              if (row === null) return;
+              store.ingest(projectMessage(row, identity.organizationId));
+            }
+          }
+        ],
+        broadcast: [
+          {
+            event: MESSAGING_EVENTS.message,
+            onMessage: ({ data }) => {
+              if (typeof data !== "object" || data === null) return;
+              store.ingest(data);
+            }
+          }
+        ],
+        onBackfill: () => {
+          void backfillConversation(id);
+          outbox.flush();
+        }
+      });
+      openChannels.set(id, handle);
+    },
+    closeConversation(id) {
+      openChannels.get(id)?.close();
+      openChannels.delete(id);
+      if (store.snapshot().activeConversationId === id) {
+        store.setActiveConversation(null);
+      }
+    },
+    async loadOlderMessages(id) {
+      const thread = store.snapshot().threads.get(id);
+      const oldest = thread?.messages[0];
+      if (thread === void 0 || oldest === void 0 || !thread.hasMoreOlder) return;
+      try {
+        const page = await repository.listMessages(id, {
+          limit: messagePageSize,
+          cursor: { beforeCreatedAt: oldest.createdAt, beforeMessageId: oldest.id }
+        });
+        store.prependOlder(id, page.items, page.hasMore);
+      } catch (error) {
+        reportError(error, "loadOlderMessages");
+      }
+    },
+    send(draft) {
+      if (draft.content.trim().length === 0 && (draft.attachments ?? []).length === 0) {
+        throw new MessagingError(
+          "misconfigured",
+          "send: empty draft",
+          "A message needs text or at least one attachment. The composer disables Send for an empty draft rather than queueing nothing."
+        );
+      }
+      return outbox.enqueue(draft);
+    },
+    retry: (entryId) => outbox.retry(entryId),
+    discard: (entryId) => outbox.discard(entryId),
+    async editMessage(id, conversationId, content) {
+      try {
+        const message = await repository.editMessage(id, content);
+        store.ingest(message);
+        broadcastMessage(message);
+      } catch (error) {
+        reportError(error, "editMessage");
+        throw normalizeMessagingError(error, "editMessage");
+      }
+      void conversationId;
+    },
+    async deleteMessage(id, conversationId, forEveryone) {
+      try {
+        await repository.deleteMessage(id, forEveryone);
+        store.removeMessage(conversationId, id);
+      } catch (error) {
+        reportError(error, "deleteMessage");
+        throw normalizeMessagingError(error, "deleteMessage");
+      }
+    },
+    async markRead(id) {
+      store.markConversationRead(id);
+      try {
+        await repository.markRead(id);
+      } catch (error) {
+        reportError(error, "markRead");
+      }
+    },
+    async startDirectConversation(otherUserId) {
+      const id = await repository.getOrCreateDirectConversation(otherUserId);
+      await reloadInbox();
+      return id;
+    },
+    dispose() {
+      disposed = true;
+      outbox.dispose();
+      openChannels.forEach((handle) => handle.close());
+      openChannels.clear();
+      inboxChannel?.close();
+      inboxChannel = null;
+    }
+  };
+  return engine;
+}
+function messagingClientId() {
+  return clientSessionId();
+}
+
+// src/core/cache.ts
+function createReadCache(options) {
+  const now = options.now ?? (() => Date.now());
+  const maxEntries = options.maxEntries ?? 500;
+  const resolved = /* @__PURE__ */ new Map();
+  const inFlight = /* @__PURE__ */ new Map();
+  function evictIfNeeded() {
+    while (resolved.size > maxEntries) {
+      const oldest = resolved.keys().next();
+      if (oldest.done === true) return;
+      resolved.delete(oldest.value);
+    }
+  }
+  return {
+    read(key, load) {
+      const hit = resolved.get(key);
+      if (hit !== void 0 && hit.expiresAt > now()) {
+        return Promise.resolve(hit.value);
+      }
+      if (hit !== void 0) resolved.delete(key);
+      const pending = inFlight.get(key);
+      if (pending !== void 0) return pending;
+      const started = load().then((value) => {
+        resolved.set(key, { value, expiresAt: now() + options.ttlMs });
+        evictIfNeeded();
+        return value;
+      }).finally(() => {
+        inFlight.delete(key);
+      });
+      inFlight.set(key, started);
+      return started;
+    },
+    invalidate(key) {
+      resolved.delete(key);
+      inFlight.delete(key);
+    },
+    clear() {
+      resolved.clear();
+      inFlight.clear();
+    },
+    size() {
+      return resolved.size;
+    }
+  };
+}
+
+// src/core/repository.ts
+var MESSAGING_SCHEMA = "communication";
+var TABLES = {
+  conversations: "dm_conversations",
+  participants: "dm_conversation_participants",
+  messages: "dm_messages"
+};
+var RPCS = {
+  /** Atomic direct-conversation creation. Advisory-locks the unordered pair. */
+  getOrCreateDirect: "dm_get_or_create_direct_conversation",
+  /** Conversation list + participants + last message + unread, keyset paged. */
+  conversationsWithDetails: "get_dm_conversations_with_details",
+  unreadCount: "get_dm_unread_count",
+  userInfo: "get_dm_user_info",
+  isParticipant: "is_dm_participant"
+};
+var MESSAGE_COLUMNS = "id,conversation_id,sender_id,organization_id,content,message_type,status,reply_to_id,client_message_id,action_data,media_url,media_thumbnail_url,media_metadata,created_at,edited_at,deleted_at,deleted_for_everyone,metadata";
+var CONVERSATION_COLUMNS = "id,type,group_name,group_image_url,created_by,organization_id,created_at,updated_at,metadata";
+function requireOrg(organizationId, operation) {
+  if (typeof organizationId !== "string" || organizationId.length === 0) {
+    throw new MessagingError(
+      "misconfigured",
+      `${operation}: no organization_id`,
+      "Every conversation and message write carries an explicit organization_id (R5). Pass a real org on <MessagingProvider>; the package refuses the write rather than letting an unscoped row reach the database."
+    );
+  }
+  return organizationId;
+}
+function createMessagingRepository(options) {
+  const { client, identity } = options;
+  const org = requireOrg(identity.organizationId, "createMessagingRepository");
+  const userCache = createReadCache({
+    ttlMs: options.userTtlMs ?? 5 * 6e4,
+    ...options.now !== void 0 ? { now: options.now } : {}
+  });
+  const db = () => client.schema(MESSAGING_SCHEMA);
+  async function withSessionRetry(operation, run) {
+    try {
+      return await run();
+    } catch (error) {
+      const normalized = normalizeMessagingError(error, operation);
+      if (normalized.code !== "session-unavailable" || options.resolveSession === void 0) {
+        throw normalized;
+      }
+      await options.resolveSession();
+      try {
+        return await run();
+      } catch (retryError) {
+        throw normalizeMessagingError(retryError, operation);
+      }
+    }
+  }
+  async function rpc(fn, args, operation) {
+    const { data, error } = await db().rpc(fn, args);
+    if (error !== null) throw normalizeMessagingError(error, operation);
+    return data;
+  }
+  async function getUsers(userIds) {
+    const unique = [...new Set(userIds)];
+    const found = /* @__PURE__ */ new Map();
+    const results = await Promise.all(
+      unique.map(async (id) => {
+        try {
+          return await repository.getUser(id);
+        } catch {
+          return null;
+        }
+      })
+    );
+    results.forEach((summary) => {
+      if (summary !== null) found.set(summary.userId, summary);
+    });
+    return found;
+  }
+  const repository = {
+    identity,
+    async listConversations(args = {}) {
+      const limit = args.limit ?? 30;
+      const operation = "listConversations";
+      const rows = await withSessionRetry(
+        operation,
+        () => rpc(
+          RPCS.conversationsWithDetails,
+          {
+            p_user_id: identity.userId,
+            p_limit: limit + 1,
+            p_before_sort_at: args.cursor?.beforeSortAt ?? null,
+            p_before_conversation_id: args.cursor?.beforeConversationId ?? null
+          },
+          operation
+        )
+      );
+      if (rows !== null && !Array.isArray(rows)) {
+        throw invalidResponse(operation, `${RPCS.conversationsWithDetails} did not return rows`);
+      }
+      const projected = (rows ?? []).map(
+        (row) => projectConversationSummary(row, identity.userId, org)
+      );
+      const hasMore = projected.length > limit;
+      const items = hasMore ? projected.slice(0, limit) : projected;
+      const last = items.at(-1);
+      return {
+        items,
+        hasMore,
+        nextCursor: hasMore && last !== void 0 ? { beforeSortAt: last.sortAt, beforeConversationId: last.conversation.id } : null
+      };
+    },
+    async getConversation(id) {
+      const operation = "getConversation";
+      const { data, error } = await withSessionRetry(
+        operation,
+        async () => db().from(TABLES.conversations).select(CONVERSATION_COLUMNS).eq("id", id).single()
+      );
+      if (error !== null) throw normalizeMessagingError(error, operation);
+      if (data === null) throw invalidResponse(operation, `conversation ${id} returned no row`);
+      const summary = projectConversationSummary(
+        {
+          conversation_id: data["id"],
+          conversation_type: data["type"],
+          group_name: data["group_name"],
+          group_image_url: data["group_image_url"],
+          conversation_created_at: data["created_at"],
+          conversation_updated_at: data["updated_at"],
+          organization_id: data["organization_id"],
+          created_by: data["created_by"],
+          metadata: data["metadata"],
+          participants: [],
+          unread_count: 0
+        },
+        identity.userId,
+        org
+      );
+      return summary.conversation;
+    },
+    async listMessages(conversationId, args = {}) {
+      const limit = args.limit ?? 50;
+      const operation = "listMessages";
+      const rows = await withSessionRetry(operation, async () => {
+        let query = db().from(TABLES.messages).select(MESSAGE_COLUMNS).eq("conversation_id", conversationId);
+        const cursor = args.cursor;
+        if (cursor != null) {
+          query = query.or(
+            `created_at.lt.${cursor.beforeCreatedAt},and(created_at.eq.${cursor.beforeCreatedAt},id.lt.${cursor.beforeMessageId})`
+          );
+        }
+        const { data, error } = await query.order("created_at", { ascending: false }).order("id", { ascending: false }).limit(limit + 1);
+        if (error !== null) throw normalizeMessagingError(error, operation);
+        return data ?? [];
+      });
+      const hasMore = rows.length > limit;
+      const page = hasMore ? rows.slice(0, limit) : rows;
+      const oldest = page.at(-1);
+      const items = page.map((row) => projectMessage(row, org)).reverse();
+      return {
+        items,
+        hasMore,
+        nextCursor: hasMore && oldest !== void 0 ? {
+          beforeCreatedAt: String(oldest["created_at"]),
+          beforeMessageId: String(oldest["id"])
+        } : null
+      };
+    },
+    async messagesSince(conversationId, since) {
+      const operation = "messagesSince";
+      const rows = await withSessionRetry(operation, async () => {
+        const { data, error } = await db().from(TABLES.messages).select(MESSAGE_COLUMNS).eq("conversation_id", conversationId).gt("created_at", since).order("created_at", { ascending: true }).limit(500);
+        if (error !== null) throw normalizeMessagingError(error, operation);
+        return data ?? [];
+      });
+      return rows.map((row) => projectMessage(row, org));
+    },
+    async getOrCreateDirectConversation(otherUserId) {
+      const operation = "getOrCreateDirectConversation";
+      const id = await withSessionRetry(
+        operation,
+        () => rpc(
+          RPCS.getOrCreateDirect,
+          {
+            // The RPC's own guard requires an `authenticated` caller to pass
+            // THEMSELVES as user1; passing them in the other slot is a denial,
+            // not a preference.
+            p_user1_id: identity.userId,
+            p_user2_id: otherUserId,
+            p_organization_id: org
+          },
+          operation
+        )
+      );
+      if (typeof id !== "string" || id.length === 0) {
+        throw invalidResponse(operation, `${RPCS.getOrCreateDirect} returned no conversation id`);
+      }
+      return id;
+    },
+    async createGroupConversation({ name, memberIds }) {
+      const operation = "createGroupConversation";
+      const { data, error } = await withSessionRetry(
+        operation,
+        async () => db().from(TABLES.conversations).insert({
+          type: "group",
+          group_name: name,
+          organization_id: org,
+          created_by: identity.userId
+        }).select("id").single()
+      );
+      if (error !== null) throw normalizeMessagingError(error, operation);
+      const conversationId = data?.["id"];
+      if (typeof conversationId !== "string") {
+        throw invalidResponse(operation, "insert returned no conversation id");
+      }
+      const members = [.../* @__PURE__ */ new Set([identity.userId, ...memberIds])];
+      const { error: memberError } = await db().from(TABLES.participants).insert(
+        members.map((userId) => ({
+          conversation_id: conversationId,
+          user_id: userId,
+          role: userId === identity.userId ? "owner" : "member",
+          organization_id: org,
+          created_by: identity.userId
+        }))
+      );
+      if (memberError !== null) throw normalizeMessagingError(memberError, operation);
+      return conversationId;
+    },
+    async insertMessage(draft, clientMessageId) {
+      const operation = "insertMessage";
+      const { data, error } = await db().from(TABLES.messages).insert({
+        conversation_id: draft.conversationId,
+        sender_id: identity.userId,
+        organization_id: org,
+        created_by: identity.userId,
+        content: draft.content,
+        message_type: draft.kind ?? "text",
+        status: "sent",
+        reply_to_id: draft.replyToId ?? null,
+        // THE IDEMPOTENCY KEY. It is what makes a retried send exactly-once
+        // and what lets a receiver collapse the optimistic bubble with the
+        // confirmed row instead of showing the message twice.
+        client_message_id: clientMessageId,
+        action_data: draft.action ?? null,
+        metadata: {
+          ...draft.metadata ?? {},
+          ...draft.attachments !== void 0 && draft.attachments.length > 0 ? { attachments: draft.attachments } : {},
+          ...draft.references !== void 0 && draft.references.length > 0 ? { references: draft.references } : {}
+        }
+      }).select(MESSAGE_COLUMNS).single();
+      if (error !== null) throw normalizeMessagingError(error, operation);
+      if (data === null) throw invalidResponse(operation, "insert returned no row");
+      return projectMessage(data, org);
+    },
+    async editMessage(id, content) {
+      const operation = "editMessage";
+      const { data, error } = await db().from(TABLES.messages).update({
+        content,
+        edited_at: (/* @__PURE__ */ new Date()).toISOString(),
+        updated_by: identity.userId
+      }).eq("id", id).select(MESSAGE_COLUMNS).single();
+      if (error !== null) throw normalizeMessagingError(error, operation);
+      if (data === null) throw invalidResponse(operation, "update returned no row");
+      return projectMessage(data, org);
+    },
+    async deleteMessage(id, forEveryone) {
+      const operation = "deleteMessage";
+      const { error } = await db().from(TABLES.messages).update({
+        deleted_at: (/* @__PURE__ */ new Date()).toISOString(),
+        deleted_for_everyone: forEveryone,
+        updated_by: identity.userId
+      }).eq("id", id);
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    async markRead(conversationId, at) {
+      const operation = "markRead";
+      const { error } = await db().from(TABLES.participants).update({ last_read_at: at ?? (/* @__PURE__ */ new Date()).toISOString(), updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", identity.userId);
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    async setConversationFlags(conversationId, flags) {
+      const operation = "setConversationFlags";
+      const patch = { updated_by: identity.userId };
+      if (flags.isMuted !== void 0) patch["is_muted"] = flags.isMuted;
+      if (flags.isArchived !== void 0) patch["is_archived"] = flags.isArchived;
+      const { error } = await db().from(TABLES.participants).update(patch).eq("conversation_id", conversationId).eq("user_id", identity.userId);
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    async addMembers(conversationId, memberIds) {
+      const operation = "addMembers";
+      const { error } = await db().from(TABLES.participants).insert(
+        memberIds.map((userId) => ({
+          conversation_id: conversationId,
+          user_id: userId,
+          role: "member",
+          organization_id: org,
+          created_by: identity.userId
+        }))
+      );
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    async removeMember(conversationId, memberId) {
+      const operation = "removeMember";
+      const { error } = await db().from(TABLES.participants).update({ deleted_at: (/* @__PURE__ */ new Date()).toISOString(), updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", memberId);
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    async setMemberRole(conversationId, memberId, role) {
+      const operation = "setMemberRole";
+      const { error } = await db().from(TABLES.participants).update({ role, updated_by: identity.userId }).eq("conversation_id", conversationId).eq("user_id", memberId);
+      if (error !== null) throw normalizeMessagingError(error, operation);
+    },
+    getUser(userId) {
+      const operation = "getUser";
+      return userCache.read(userId, async () => {
+        const rows = await withSessionRetry(
+          operation,
+          () => rpc(
+            RPCS.userInfo,
+            { p_user_id: userId },
+            operation
+          )
+        );
+        const row = Array.isArray(rows) ? rows[0] : null;
+        return row === void 0 || row === null ? null : projectUserSummary(row);
+      });
+    },
+    getUsers,
+    async searchMessages({ query, conversationId = null, limit = 50 }) {
+      const operation = "searchMessages";
+      const trimmed = query.trim();
+      if (trimmed.length === 0) return [];
+      const rows = await withSessionRetry(operation, async () => {
+        let base = db().from(TABLES.messages).select(MESSAGE_COLUMNS).is("deleted_at", null);
+        if (conversationId !== null) base = base.eq("conversation_id", conversationId);
+        const safe = trimmed.replace(/[%,()*]/g, " ").trim();
+        const { data, error } = await base.or(`content.ilike.*${safe}*`).order("created_at", { ascending: false }).limit(limit);
+        if (error !== null) throw normalizeMessagingError(error, operation);
+        return data ?? [];
+      });
+      return rows.map((row) => projectMessage(row, org));
+    },
+    invalidateUser(userId) {
+      userCache.invalidate(userId);
+    }
+  };
+  return repository;
+}
+
+// src/react/provider.tsx
+import { jsx } from "react/jsx-runtime";
+var MessagingContext = createContext(null);
+function defaultDiagnostics(event) {
+  const line = `[@ai-matrx/messaging] ${event.message}${event.remedy !== void 0 ? `
+  \u2192 ${event.remedy}` : ""}`;
+  if (event.level === "error") console.error(line);
+  else if (event.level === "warn") console.warn(line);
+  else console.info(line);
+}
+function MessagingProvider(props) {
+  const { client, userId, organizationId } = props;
+  const ready = client != null && typeof userId === "string" && userId.length > 0 && typeof organizationId === "string" && organizationId.length > 0;
+  return /* @__PURE__ */ jsx(RealtimeProvider, { client: ready ? client : null, actorId: userId ?? void 0, children: /* @__PURE__ */ jsx(MessagingRuntime, { ...props }) });
+}
+function MessagingRuntime(props) {
+  const { client, userId, organizationId, children } = props;
+  const manager = useRealtimeManager();
+  const diagnosticRef = useRef(props.onDiagnostic);
+  diagnosticRef.current = props.onDiagnostic;
+  const incomingRef = useRef(props.onIncomingMessage);
+  incomingRef.current = props.onIncomingMessage;
+  const referenceRef = useRef(props.onOpenReference);
+  referenceRef.current = props.onOpenReference;
+  const actionRegistry = useMemo(() => createActionRegistry(), []);
+  const handlers = props.actions;
+  useEffect(() => {
+    (handlers ?? []).forEach((handler) => {
+      actionRegistry.register(handler);
+    });
+  }, [actionRegistry, handlers]);
+  const ready = client != null && manager !== null && typeof userId === "string" && userId.length > 0 && typeof organizationId === "string" && organizationId.length > 0;
+  const engine = useMemo(() => {
+    if (!ready || manager === null) return null;
+    const identity = {
+      userId,
+      organizationId
+    };
+    const report = (event) => {
+      (diagnosticRef.current ?? defaultDiagnostics)(event);
+    };
+    const repository = createMessagingRepository({
+      client,
+      identity,
+      ...props.resolveSession !== void 0 ? { resolveSession: props.resolveSession } : {}
+    });
+    return createMessagingEngine({
+      repository,
+      manager,
+      identity,
+      outboxStorage: props.outboxStorage ?? createWebOutboxStorage({
+        key: `ai-matrx.messaging.outbox.${identity.userId}`,
+        onFallback: (message) => report({ level: "warn", message })
+      }),
+      onDiagnostic: report,
+      onIncoming: (message) => incomingRef.current?.(message)
+    });
+  }, [ready, manager, userId, organizationId]);
+  useEffect(() => {
+    if (engine === null) return void 0;
+    void engine.start().catch((error) => {
+      (diagnosticRef.current ?? defaultDiagnostics)({
+        level: "error",
+        message: `Messaging failed to start: ${String(error?.message ?? error)}`,
+        remedy: "Check the signed-in session and organization, then reload the surface."
+      });
+    });
+    return () => {
+      engine.dispose();
+    };
+  }, [engine]);
+  const transport = props.transport;
+  const agents = props.agents;
+  const ai = useMemo(() => {
+    if (transport === void 0 || agents === void 0 || !ready) return null;
+    return createMessagingAi({
+      transport,
+      organizationId,
+      agents
+    });
+  }, [transport, agents, ready, organizationId]);
+  const host = useMemo(() => {
+    if (engine === null) return null;
+    return {
+      engine,
+      actions: actionRegistry,
+      ai,
+      identity: engine.identity,
+      openReference: referenceRef.current ?? null
+    };
+  }, [engine, actionRegistry, ai]);
+  return /* @__PURE__ */ jsx(MessagingContext.Provider, { value: host, children });
+}
+function useMessagingHost() {
+  return useContext(MessagingContext);
+}
+function useRequiredMessagingHost() {
+  const host = useMessagingHost();
+  if (host === null) {
+    throw new Error(
+      "[@ai-matrx/messaging] No messaging host. Wrap this tree in <MessagingProvider client={supabase} userId={userId} organizationId={orgId}> and render it only once auth has resolved."
+    );
+  }
+  return host;
+}
+function useMessagingSnapshot() {
+  const host = useMessagingHost();
+  const store = host?.engine.store ?? null;
+  const empty = useRef(null);
+  return useSyncExternalStore(
+    (listener) => store === null ? () => void 0 : store.subscribe(listener),
+    () => store === null ? empty.current : store.snapshot(),
+    () => store === null ? empty.current : store.snapshot()
+  );
+}
+
+// src/react/hooks.ts
+import { useCallback, useEffect as useEffect2, useMemo as useMemo2, useRef as useRef2, useState } from "react";
+import { useTyping, usePresence } from "@ai-matrx/realtime/react";
+
+// src/core/format.ts
+var MINUTE = 6e4;
+var HOUR = 60 * MINUTE;
+var DAY = 24 * HOUR;
+function isSameDay(a, b) {
+  return a.getFullYear() === b.getFullYear() && a.getMonth() === b.getMonth() && a.getDate() === b.getDate();
+}
+function formatConversationTime(isoString, now = Date.now(), locale) {
+  if (isoString === null) return "";
+  const parsed = Date.parse(isoString);
+  if (!Number.isFinite(parsed)) return "";
+  const then = new Date(parsed);
+  const today = new Date(now);
+  if (isSameDay(then, today)) {
+    return then.toLocaleTimeString(locale, { hour: "numeric", minute: "2-digit" });
+  }
+  const yesterday = new Date(now - DAY);
+  if (isSameDay(then, yesterday)) return "Yesterday";
+  if (now - parsed < 7 * DAY) return then.toLocaleDateString(locale, { weekday: "short" });
+  return then.toLocaleDateString(locale, { month: "short", day: "numeric" });
+}
+function formatMessageTime(isoString, locale) {
+  const parsed = Date.parse(isoString);
+  if (!Number.isFinite(parsed)) return "";
+  return new Date(parsed).toLocaleTimeString(locale, {
+    hour: "numeric",
+    minute: "2-digit"
+  });
+}
+function formatDateSeparator(isoString, now = Date.now(), locale) {
+  const parsed = Date.parse(isoString);
+  if (!Number.isFinite(parsed)) return "";
+  const then = new Date(parsed);
+  const today = new Date(now);
+  if (isSameDay(then, today)) return "Today";
+  if (isSameDay(then, new Date(now - DAY))) return "Yesterday";
+  if (then.getFullYear() === today.getFullYear()) {
+    return then.toLocaleDateString(locale, { month: "long", day: "numeric" });
+  }
+  return then.toLocaleDateString(locale, {
+    year: "numeric",
+    month: "long",
+    day: "numeric"
+  });
+}
+function getInitials(name) {
+  const parts = name.trim().split(/\s+/).filter(Boolean);
+  if (parts.length === 0) return "?";
+  const first = parts[0]?.[0] ?? "";
+  const last = parts.length > 1 ? parts.at(-1)?.[0] ?? "" : "";
+  return `${first}${last}`.toUpperCase() || "?";
+}
+function avatarPaletteIndex(seed, buckets = 8) {
+  let hash = 0;
+  for (let index = 0; index < seed.length; index += 1) {
+    hash = hash * 31 + seed.charCodeAt(index) | 0;
+  }
+  return Math.abs(hash) % buckets;
+}
+function groupMessages(messages, args = {}) {
+  const windowMs = args.windowMs ?? 5 * MINUTE;
+  const now = args.now ?? Date.now();
+  const groups = [];
+  let current = null;
+  let previousDay = null;
+  for (const message of messages) {
+    const day = message.createdAt.slice(0, 10);
+    const startsNewDay = day !== previousDay;
+    previousDay = day;
+    const last = current?.messages.at(-1);
+    const withinWindow = last !== void 0 && Math.abs(Date.parse(message.createdAt) - Date.parse(last.createdAt)) <= windowMs;
+    if (current !== null && current.senderId === message.senderId && withinWindow && !startsNewDay) {
+      current.messages.push(message);
+      continue;
+    }
+    if (current !== null) groups.push(current);
+    current = {
+      senderId: message.senderId,
+      messages: [message],
+      dateSeparator: startsNewDay ? formatDateSeparator(message.createdAt, now, args.locale) : null
+    };
+  }
+  if (current !== null) groups.push(current);
+  return groups;
+}
+function formatTypists(names) {
+  if (names.length === 0) return null;
+  if (names.length === 1) return `${names[0]} is typing\u2026`;
+  if (names.length === 2) return `${names[0]} and ${names[1]} are typing\u2026`;
+  return `${names.length} people are typing\u2026`;
+}
+function participantNames(participants, excluding) {
+  return participants.filter((participant) => participant.userId !== excluding).map((participant) => participant.displayName);
+}
+function formatLastSeen(lastSeenMs, now = Date.now()) {
+  if (lastSeenMs === null) return "";
+  const elapsed = now - lastSeenMs;
+  if (elapsed < 2 * MINUTE) return "Active now";
+  if (elapsed < HOUR) return `Active ${Math.round(elapsed / MINUTE)}m ago`;
+  if (elapsed < DAY) return `Active ${Math.round(elapsed / HOUR)}h ago`;
+  return `Active ${Math.round(elapsed / DAY)}d ago`;
+}
+
+// src/react/hooks.ts
+function useConversations() {
+  const host = useMessagingHost();
+  const snapshot = useMessagingSnapshot();
+  const select = useCallback(
+    (id) => {
+      void host?.engine.openConversation(id);
+      void host?.engine.markRead(id);
+    },
+    [host]
+  );
+  return {
+    conversations: snapshot?.conversations ?? [],
+    hasMore: snapshot?.hasMoreConversations ?? false,
+    // "Not loaded yet" is a FACT from the store, never a guess. Showing
+    // "No conversations yet" before the first read is a screen telling a lie.
+    isInitialLoading: snapshot === null || !snapshot.hasLoadedConversations,
+    totalUnreadConversations: snapshot?.totalUnreadConversations ?? 0,
+    loadMore: () => {
+      void host?.engine.loadMoreConversations();
+    },
+    select,
+    activeConversationId: snapshot?.activeConversationId ?? null,
+    startDirect: async (otherUserId) => {
+      if (host === null) {
+        throw new Error("[@ai-matrx/messaging] startDirect called before the host was ready.");
+      }
+      const id = await host.engine.startDirectConversation(otherUserId);
+      select(id);
+      return id;
+    }
+  };
+}
+function useConversation(id) {
+  const host = useMessagingHost();
+  const snapshot = useMessagingSnapshot();
+  const [outboxTick, setOutboxTick] = useState(0);
+  useEffect2(() => {
+    if (host === null || id === null) return void 0;
+    void host.engine.openConversation(id);
+    return () => {
+      host.engine.closeConversation(id);
+    };
+  }, [host, id]);
+  useEffect2(() => {
+    const timer = setInterval(() => setOutboxTick((tick) => tick + 1), 1e3);
+    return () => clearInterval(timer);
+  }, []);
+  const thread = id === null ? null : snapshot?.threads.get(id) ?? null;
+  const summary = id === null ? null : snapshot?.conversations.find((item) => item.conversation.id === id) ?? null;
+  const pending = useMemo2(() => {
+    void outboxTick;
+    return id === null ? [] : host?.engine.outbox.pendingFor(id) ?? [];
+  }, [host, id, outboxTick]);
+  return {
+    summary,
+    thread,
+    messages: thread?.messages ?? [],
+    participants: summary?.participants ?? [],
+    isLoading: id !== null && thread === null,
+    hasMoreOlder: thread?.hasMoreOlder ?? false,
+    loadOlder: () => {
+      if (id !== null) void host?.engine.loadOlderMessages(id);
+    },
+    pending,
+    retry: (entryId) => host?.engine.retry(entryId),
+    discard: (entryId) => host?.engine.discard(entryId),
+    edit: async (messageId, content) => {
+      if (host !== null && id !== null) await host.engine.editMessage(messageId, id, content);
+    },
+    remove: async (messageId, forEveryone) => {
+      if (host !== null && id !== null) {
+        await host.engine.deleteMessage(messageId, id, forEveryone);
+      }
+    }
+  };
+}
+function useComposer(conversationId) {
+  const host = useMessagingHost();
+  const [drafts, setDrafts] = useState({});
+  const [replyTo, setReplyTo] = useState(null);
+  const value = conversationId === null ? "" : drafts[conversationId] ?? "";
+  const typing = useTyping(
+    {
+      topic: conversationId === null ? "" : conversationTopic(conversationId),
+      identity: { userId: host?.identity.userId ?? "" }
+    },
+    { enabled: conversationId !== null && host !== null }
+  );
+  const setValue = useCallback(
+    (next) => {
+      if (conversationId === null) return;
+      setDrafts((current) => ({ ...current, [conversationId]: next }));
+    },
+    [conversationId]
+  );
+  return {
+    value,
+    setValue,
+    canSend: value.trim().length > 0 && conversationId !== null && host !== null,
+    send: () => {
+      if (host === null || conversationId === null) return;
+      const content = value.trim();
+      if (content.length === 0) return;
+      const draft = {
+        conversationId,
+        content,
+        ...replyTo !== null ? { replyToId: replyTo.id } : {}
+      };
+      host.engine.send(draft);
+      setDrafts((current) => ({ ...current, [conversationId]: "" }));
+      setReplyTo(null);
+      typing.stopTyping();
+    },
+    onKeystroke: typing.onKeystroke,
+    replyTo,
+    setReplyTo
+  };
+}
+function useTypists(conversationId, participants) {
+  const host = useMessagingHost();
+  const typing = useTyping(
+    {
+      topic: conversationId === null ? "" : conversationTopic(conversationId),
+      identity: { userId: host?.identity.userId ?? "" }
+    },
+    { enabled: conversationId !== null && host !== null }
+  );
+  const selfId = host?.identity.userId;
+  const others = typing.typists.filter((typist) => {
+    const userId = typist.state["userId"];
+    return typeof userId === "string" && userId !== selfId;
+  });
+  const names = others.map((typist) => {
+    const userId = typist.state["userId"];
+    const match = participants.find((participant) => participant.userId === userId);
+    return match?.displayName ?? "Someone";
+  });
+  return {
+    label: formatTypists(names),
+    userIds: others.flatMap((typist) => {
+      const userId = typist.state["userId"];
+      return typeof userId === "string" ? [userId] : [];
+    })
+  };
+}
+function useOnlineUserIds(conversationId) {
+  const host = useMessagingHost();
+  const presence = usePresence(
+    {
+      topic: conversationId === null ? "" : conversationTopic(conversationId),
+      presence: { state: { userId: host?.identity.userId ?? "" } }
+    },
+    { enabled: conversationId !== null && host !== null }
+  );
+  return useMemo2(
+    () => new Set(presence.members.map((member) => member.state.userId).filter(Boolean)),
+    [presence.members]
+  );
+}
+function useMessagingAi(conversationId) {
+  const host = useMessagingHost();
+  const conversation = useConversation(conversationId);
+  const [isRunning, setRunning] = useState(false);
+  const [result, setResult] = useState(null);
+  const [error, setError] = useState(null);
+  const abortRef = useRef2(null);
+  useEffect2(
+    () => () => {
+      abortRef.current?.abort();
+    },
+    []
+  );
+  const ai = host?.ai ?? null;
+  return {
+    available: ai?.available() ?? [],
+    isRunning,
+    result,
+    error,
+    clear: () => {
+      setResult(null);
+      setError(null);
+    },
+    run: (capability, args = {}) => {
+      if (ai === null || conversationId === null) return;
+      abortRef.current?.abort();
+      const controller = new AbortController();
+      abortRef.current = controller;
+      setRunning(true);
+      setError(null);
+      const base = {
+        conversationId,
+        messages: conversation.messages,
+        participants: conversation.participants,
+        signal: controller.signal
+      };
+      const call = () => {
+        switch (capability) {
+          case "catchUp": {
+            const summary = conversation.summary;
+            const self = summary?.participants.find(
+              (participant) => participant.userId === host?.identity.userId
+            );
+            void self;
+            return ai.catchMeUp({ ...base, since: null });
+          }
+          case "summarize":
+            return ai.summarize(base);
+          case "actionItems":
+            return ai.extractActionItems(base);
+          case "draftReply":
+            return ai.draftReply({
+              ...base,
+              ...args.instruction !== void 0 ? { instruction: args.instruction } : {}
+            });
+          default:
+            return Promise.reject(new Error(`Unknown capability ${String(capability)}`));
+        }
+      };
+      call().then((next) => {
+        if (!controller.signal.aborted) setResult(next);
+      }).catch((cause) => {
+        if (controller.signal.aborted) return;
+        setError(String(cause?.message ?? cause));
+      }).finally(() => {
+        if (!controller.signal.aborted) setRunning(false);
+      });
+    }
+  };
+}
+function useMessageAction(message) {
+  const host = useRequiredMessagingHost();
+  const action = message.action;
+  const [receipt, setReceipt] = useState(
+    () => action === null ? null : host.actions.receiptFor(action.kind, message.id, host.identity.userId)
+  );
+  const [isRunning, setRunning] = useState(false);
+  return {
+    choices: action === null ? [] : host.actions.choicesFor(action),
+    receipt,
+    isRunning,
+    execute: (choice) => {
+      if (action === null || isRunning || receipt !== null) return;
+      setRunning(true);
+      const context = {
+        messageId: message.id,
+        actorId: host.identity.userId,
+        organizationId: host.identity.organizationId,
+        choice
+      };
+      host.actions.execute(action, context).then(setReceipt).catch((cause) => {
+        setReceipt({
+          kind: action.kind,
+          messageId: message.id,
+          actorId: host.identity.userId,
+          outcome: "declined",
+          label: "Could not complete",
+          settledAt: (/* @__PURE__ */ new Date()).toISOString(),
+          detail: String(cause?.message ?? cause)
+        });
+      }).finally(() => setRunning(false));
+    }
+  };
+}
+
+// src/react/components.tsx
+import { useEffect as useEffect3, useMemo as useMemo3, useRef as useRef3, useState as useState2 } from "react";
+
+// src/core/actor.ts
+function readActorHint(metadata) {
+  const raw = metadata["actor"];
+  if (typeof raw !== "object" || raw === null || Array.isArray(raw)) return null;
+  const record = raw;
+  const agentId = record["agentId"] ?? record["agent_id"];
+  if (typeof agentId !== "string" || agentId.length === 0) return null;
+  const name = record["agentName"] ?? record["agent_name"];
+  const avatar = record["agentAvatarUrl"] ?? record["agent_avatar_url"];
+  return {
+    agentId,
+    ...typeof name === "string" && name.length > 0 ? { agentName: name } : {},
+    ...typeof avatar === "string" && avatar.length > 0 ? { agentAvatarUrl: avatar } : {}
+  };
+}
+function resolveActor(message, sender) {
+  const hint = readActorHint(message.metadata);
+  const humanName = sender?.displayName ?? message.senderId;
+  if (hint !== null) {
+    return {
+      // An agent NEVER inherits the human's name or avatar. When the agent did
+      // not name itself, it is labeled generically — an honest "Agent" beats a
+      // colleague's face on a message they did not write.
+      displayName: hint.agentName ?? "Agent",
+      avatarUrl: hint.agentAvatarUrl ?? null,
+      isAgent: true,
+      onBehalfOfName: humanName,
+      principalUserId: message.senderId
+    };
+  }
+  if (sender?.isAgent === true) {
+    return {
+      displayName: sender.displayName,
+      avatarUrl: sender.avatarUrl,
+      isAgent: true,
+      onBehalfOfName: null,
+      principalUserId: message.senderId
+    };
+  }
+  return {
+    displayName: humanName,
+    avatarUrl: sender?.avatarUrl ?? null,
+    isAgent: false,
+    onBehalfOfName: null,
+    principalUserId: message.senderId
+  };
+}
+
+// src/react/icons.tsx
+import { jsx as jsx2 } from "react/jsx-runtime";
+function Icon(props) {
+  const { paths: declared, ...rest } = props;
+  const paths = typeof declared === "string" ? [declared] : declared;
+  return /* @__PURE__ */ jsx2(
+    "svg",
+    {
+      viewBox: "0 0 24 24",
+      width: "1em",
+      height: "1em",
+      fill: "none",
+      stroke: "currentColor",
+      strokeWidth: 2,
+      strokeLinecap: "round",
+      strokeLinejoin: "round",
+      "aria-hidden": "true",
+      focusable: "false",
+      ...rest,
+      children: paths.map((path) => /* @__PURE__ */ jsx2("path", { d: path }, path))
+    }
+  );
+}
+var SendIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M22 2 11 13", "M22 2l-7 20-4-9-9-4 20-7z"] });
+var PaperclipIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: "M21.44 11.05l-9.19 9.19a6 6 0 0 1-8.49-8.49l9.19-9.19a4 4 0 0 1 5.66 5.66l-9.2 9.19a2 2 0 0 1-2.83-2.83l8.49-8.48"
+  }
+);
+var SparklesIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: [
+      "M12 3l1.9 4.6L18.5 9.5l-4.6 1.9L12 16l-1.9-4.6L5.5 9.5l4.6-1.9L12 3z",
+      "M19 15l.9 2.1L22 18l-2.1.9L19 21l-.9-2.1L16 18l2.1-.9L19 15z"
+    ]
+  }
+);
+var CheckIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: "M20 6L9 17l-5-5" });
+var DoubleCheckIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M18 6L7 17l-4-4", "M22 6l-8.5 8.5"] });
+var ClockIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18z", "M12 7v5l3 2"] });
+var AlertIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: ["M12 21a9 9 0 1 0 0-18 9 9 0 0 0 0 18z", "M12 8v5", "M12 16.5v.01"]
+  }
+);
+var SearchIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M11 19a8 8 0 1 0 0-16 8 8 0 0 0 0 16z", "M21 21l-4.3-4.3"] });
+var PlusIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M12 5v14", "M5 12h14"] });
+var CloseIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M18 6L6 18", "M6 6l12 12"] });
+var ChevronLeftIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: "M15 18l-6-6 6-6" });
+var ReplyIcon = (props) => /* @__PURE__ */ jsx2(Icon, { ...props, paths: ["M9 17l-5-5 5-5", "M4 12h11a5 5 0 0 1 5 5v3"] });
+var LinkIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: [
+      "M10 13a5 5 0 0 0 7.07 0l3-3a5 5 0 0 0-7.07-7.07l-1.72 1.71",
+      "M14 11a5 5 0 0 0-7.07 0l-3 3a5 5 0 0 0 7.07 7.07l1.71-1.71"
+    ]
+  }
+);
+var BotIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: [
+      "M12 3v4",
+      "M6 7h12a2 2 0 0 1 2 2v8a2 2 0 0 1-2 2H6a2 2 0 0 1-2-2V9a2 2 0 0 1 2-2z",
+      "M9 13v.01",
+      "M15 13v.01"
+    ]
+  }
+);
+var UsersIcon = (props) => /* @__PURE__ */ jsx2(
+  Icon,
+  {
+    ...props,
+    paths: [
+      "M16 20v-2a4 4 0 0 0-4-4H6a4 4 0 0 0-4 4v2",
+      "M9 10a3.5 3.5 0 1 0 0-7 3.5 3.5 0 0 0 0 7z",
+      "M22 20v-2a4 4 0 0 0-3-3.87",
+      "M16 3.13a4 4 0 0 1 0 7.75"
+    ]
+  }
+);
+
+// src/react/parts.tsx
+import { jsx as jsx3, jsxs } from "react/jsx-runtime";
+function Avatar(props) {
+  const seed = props.seed ?? props.name;
+  const paletteIndex = avatarPaletteIndex(seed);
+  const className = `mx-msg__avatar${props.small === true ? " mx-msg__avatar--sm" : ""}`;
+  return /* @__PURE__ */ jsxs(
+    "span",
+    {
+      className,
+      style: { background: `var(--mx-msg-avatar-${paletteIndex})` },
+      "aria-hidden": "true",
+      children: [
+        props.imageUrl != null && props.imageUrl.length > 0 ? /* @__PURE__ */ jsx3("img", { className: "mx-msg__avatar-img", src: props.imageUrl, alt: "", loading: "lazy" }) : getInitials(props.name),
+        props.online === true ? /* @__PURE__ */ jsx3("i", { className: "mx-msg__presence" }) : null
+      ]
+    }
+  );
+}
+function DeliveryTick(props) {
+  switch (props.state) {
+    case "sending":
+      return /* @__PURE__ */ jsx3(ClockIcon, { "aria-label": "Sending", role: "img" });
+    case "sent":
+      return /* @__PURE__ */ jsx3(CheckIcon, { "aria-label": "Sent", role: "img" });
+    case "delivered":
+      return /* @__PURE__ */ jsx3(DoubleCheckIcon, { "aria-label": "Delivered", role: "img" });
+    case "read":
+      return /* @__PURE__ */ jsx3(
+        DoubleCheckIcon,
+        {
+          "aria-label": "Read",
+          role: "img",
+          style: { color: "var(--mx-msg-accent)" }
+        }
+      );
+    case "failed":
+      return /* @__PURE__ */ jsx3(AlertIcon, { "aria-label": "Not sent", role: "img" });
+    default:
+      return null;
+  }
+}
+function ReferenceCard(props) {
+  const { reference, onOpen } = props;
+  const href = reference.href;
+  if (onOpen == null && (href === void 0 || href.length === 0)) {
+    return /* @__PURE__ */ jsxs(
+      "span",
+      {
+        className: "mx-msg__reference mx-msg__reference--inert",
+        title: "This app has not wired reference opening. Pass onOpenReference to <MessagingProvider> to make it open.",
+        children: [
+          /* @__PURE__ */ jsx3(LinkIcon, {}),
+          /* @__PURE__ */ jsx3("span", { className: "mx-msg__reference-type", children: reference.entityType }),
+          reference.label
+        ]
+      }
+    );
+  }
+  return /* @__PURE__ */ jsxs(
+    "button",
+    {
+      type: "button",
+      className: "mx-msg__reference",
+      onClick: () => {
+        if (onOpen != null) onOpen(reference);
+        else if (href !== void 0) globalThis.location?.assign(href);
+      },
+      children: [
+        /* @__PURE__ */ jsx3(LinkIcon, {}),
+        /* @__PURE__ */ jsx3("span", { className: "mx-msg__reference-type", children: reference.entityType }),
+        reference.label
+      ]
+    }
+  );
+}
+function AgentTag() {
+  return /* @__PURE__ */ jsxs("span", { className: "mx-msg__agent-tag", children: [
+    /* @__PURE__ */ jsx3(BotIcon, {}),
+    "Agent"
+  ] });
+}
+function TypingDots() {
+  return /* @__PURE__ */ jsxs("span", { className: "mx-msg__dots", "aria-hidden": "true", children: [
+    /* @__PURE__ */ jsx3("i", {}),
+    /* @__PURE__ */ jsx3("i", {}),
+    /* @__PURE__ */ jsx3("i", {})
+  ] });
+}
+function ConversationSkeleton(props) {
+  return /* @__PURE__ */ jsx3("div", { "aria-busy": "true", "aria-label": "Loading conversations", children: Array.from({ length: props.rows ?? 6 }, (_, index) => /* @__PURE__ */ jsxs("div", { className: "mx-msg__skeleton-row", children: [
+    /* @__PURE__ */ jsx3(
+      "span",
+      {
+        className: "mx-msg__skeleton",
+        style: { width: 38, height: 38, borderRadius: "50%" }
+      }
+    ),
+    /* @__PURE__ */ jsxs("span", { style: { flex: 1, display: "grid", gap: 6 }, children: [
+      /* @__PURE__ */ jsx3("span", { className: "mx-msg__skeleton", style: { height: 11, width: "45%" } }),
+      /* @__PURE__ */ jsx3("span", { className: "mx-msg__skeleton", style: { height: 10, width: "78%" } })
+    ] })
+  ] }, index)) });
+}
+function EmptyState(props) {
+  return /* @__PURE__ */ jsxs("div", { className: "mx-msg__empty", children: [
+    /* @__PURE__ */ jsx3("h3", { children: props.title }),
+    props.body !== void 0 ? /* @__PURE__ */ jsx3("p", { children: props.body }) : null,
+    props.action
+  ] });
+}
+
+// src/react/components.tsx
+import { Fragment, jsx as jsx4, jsxs as jsxs2 } from "react/jsx-runtime";
+var AI_LABELS = {
+  catchUp: "Catch me up",
+  summarize: "Summarize",
+  actionItems: "Action items",
+  draftReply: "Draft a reply"
+};
+function ConversationList(props) {
+  const { conversations, hasMore, isInitialLoading, loadMore, select, activeConversationId } = useConversations();
+  const [query, setQuery] = useState2("");
+  const visible = useMemo3(() => {
+    const needle = query.trim().toLowerCase();
+    if (needle.length === 0) return conversations;
+    return conversations.filter(
+      (item) => item.displayName.toLowerCase().includes(needle) || (item.lastMessageContent ?? "").toLowerCase().includes(needle)
+    );
+  }, [conversations, query]);
+  return /* @__PURE__ */ jsxs2("div", { className: `mx-msg__list${props.className !== void 0 ? ` ${props.className}` : ""}`, children: [
+    /* @__PURE__ */ jsxs2("div", { className: "mx-msg__search", children: [
+      /* @__PURE__ */ jsx4(SearchIcon, { style: { color: "var(--mx-msg-text-faint)" } }),
+      /* @__PURE__ */ jsx4(
+        "input",
+        {
+          type: "search",
+          value: query,
+          placeholder: "Search conversations",
+          "aria-label": "Search conversations",
+          onChange: (event) => setQuery(event.target.value)
+        }
+      ),
+      props.onNewConversation !== void 0 ? /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__button mx-msg__button--ghost",
+          style: { minWidth: 36, minHeight: 36 },
+          onClick: props.onNewConversation,
+          "aria-label": "New conversation",
+          children: /* @__PURE__ */ jsx4(PlusIcon, {})
+        }
+      ) : null
+    ] }),
+    /* @__PURE__ */ jsxs2("div", { className: "mx-msg__scroll", children: [
+      isInitialLoading ? /* @__PURE__ */ jsx4(ConversationSkeleton, {}) : visible.length === 0 ? /* @__PURE__ */ jsx4(
+        EmptyState,
+        {
+          title: query.length > 0 ? "No matches" : "No conversations yet",
+          body: query.length > 0 ? "Try a different name or word." : "Start one and it will appear here."
+        }
+      ) : /* @__PURE__ */ jsx4("ul", { className: "mx-msg__rows", children: visible.map((item) => /* @__PURE__ */ jsx4("li", { children: /* @__PURE__ */ jsx4(
+        ConversationRow,
+        {
+          summary: item,
+          isActive: item.conversation.id === activeConversationId,
+          onSelect: () => {
+            select(item.conversation.id);
+            props.onSelect?.(item.conversation.id);
+          }
+        }
+      ) }, item.conversation.id)) }),
+      hasMore && !isInitialLoading ? /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__chip",
+          style: { margin: "8px auto", display: "block" },
+          onClick: loadMore,
+          children: "Load older conversations"
+        }
+      ) : null
+    ] })
+  ] });
+}
+function ConversationRow(props) {
+  const { summary } = props;
+  return /* @__PURE__ */ jsxs2(
+    "button",
+    {
+      type: "button",
+      className: "mx-msg__row",
+      "aria-current": props.isActive,
+      onClick: props.onSelect,
+      children: [
+        /* @__PURE__ */ jsx4(
+          Avatar,
+          {
+            name: summary.displayName,
+            imageUrl: summary.displayImageUrl,
+            seed: summary.conversation.id
+          }
+        ),
+        /* @__PURE__ */ jsxs2("span", { className: "mx-msg__row-body", children: [
+          /* @__PURE__ */ jsxs2("span", { className: "mx-msg__row-top", children: [
+            /* @__PURE__ */ jsx4("span", { className: "mx-msg__row-name", children: summary.displayName }),
+            /* @__PURE__ */ jsx4("span", { className: "mx-msg__row-time", children: formatConversationTime(summary.lastMessageAt) })
+          ] }),
+          /* @__PURE__ */ jsxs2("span", { className: "mx-msg__row-preview", children: [
+            /* @__PURE__ */ jsx4("span", { children: summarizeText(summary.lastMessageContent ?? "", 90) || "No messages yet" }),
+            summary.unreadCount > 0 ? /* @__PURE__ */ jsx4("span", { className: "mx-msg__badge", "aria-label": `${summary.unreadCount} unread`, children: summary.unreadCount > 99 ? "99+" : summary.unreadCount }) : null
+          ] })
+        ] })
+      ]
+    }
+  );
+}
+function ConversationView(props) {
+  const { conversationId } = props;
+  const host = useMessagingHost();
+  const conversation = useConversation(conversationId);
+  const typists = useTypists(conversationId, conversation.participants);
+  const online = useOnlineUserIds(conversationId);
+  const composer = useComposer(conversationId);
+  const ai = useMessagingAi(conversationId);
+  const scrollRef = useRef3(null);
+  const selfId = host?.identity.userId ?? "";
+  const messages = conversation.messages;
+  const lastId = messages.at(-1)?.id ?? null;
+  useEffect3(() => {
+    const node = scrollRef.current;
+    if (node === null) return;
+    const distance = node.scrollHeight - node.scrollTop - node.clientHeight;
+    if (distance < 240) node.scrollTop = node.scrollHeight;
+  }, [lastId]);
+  if (conversationId === null) {
+    return /* @__PURE__ */ jsx4("div", { className: `mx-msg__thread${props.className !== void 0 ? ` ${props.className}` : ""}`, children: /* @__PURE__ */ jsx4(
+      EmptyState,
+      {
+        title: "Pick a conversation",
+        body: "Your messages, mentions, and agent replies live here."
+      }
+    ) });
+  }
+  const others = conversation.participants.filter(
+    (participant) => participant.userId !== selfId
+  );
+  const anyOnline = others.some((participant) => online.has(participant.userId));
+  return /* @__PURE__ */ jsxs2("div", { className: `mx-msg__thread${props.className !== void 0 ? ` ${props.className}` : ""}`, children: [
+    /* @__PURE__ */ jsxs2("header", { className: "mx-msg__header", children: [
+      props.onBack !== void 0 ? /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__button mx-msg__button--ghost",
+          style: { minWidth: 36, minHeight: 36 },
+          onClick: props.onBack,
+          "aria-label": "Back to conversations",
+          children: /* @__PURE__ */ jsx4(ChevronLeftIcon, {})
+        }
+      ) : null,
+      /* @__PURE__ */ jsx4(
+        Avatar,
+        {
+          name: conversation.summary?.displayName ?? "Conversation",
+          imageUrl: conversation.summary?.displayImageUrl ?? null,
+          seed: conversationId,
+          online: anyOnline,
+          small: true
+        }
+      ),
+      /* @__PURE__ */ jsxs2("span", { style: { minWidth: 0 }, children: [
+        /* @__PURE__ */ jsx4("span", { className: "mx-msg__header-title", children: conversation.summary?.displayName ?? "Conversation" }),
+        /* @__PURE__ */ jsx4("span", { className: "mx-msg__header-subtitle", children: typists.label ?? (conversation.summary?.conversation.type === "direct" ? anyOnline ? "Active now" : "" : `${conversation.participants.length} members`) })
+      ] }),
+      /* @__PURE__ */ jsx4("span", { className: "mx-msg__header-actions", children: conversation.summary?.conversation.type !== "direct" ? /* @__PURE__ */ jsx4(
+        "span",
+        {
+          className: "mx-msg__button mx-msg__button--ghost",
+          style: { minWidth: 36, minHeight: 36 },
+          "aria-label": `${conversation.participants.length} members`,
+          children: /* @__PURE__ */ jsx4(UsersIcon, {})
+        }
+      ) : null })
+    ] }),
+    ai.available.length > 0 ? /* @__PURE__ */ jsx4("div", { className: "mx-msg__ai-bar", children: ai.available.map((capability) => /* @__PURE__ */ jsxs2(
+      "button",
+      {
+        type: "button",
+        className: "mx-msg__chip",
+        disabled: ai.isRunning,
+        onClick: () => ai.run(capability),
+        children: [
+          /* @__PURE__ */ jsx4(SparklesIcon, { style: { marginRight: 4, verticalAlign: "-0.12em" } }),
+          AI_LABELS[capability]
+        ]
+      },
+      capability
+    )) }) : null,
+    ai.isRunning ? /* @__PURE__ */ jsx4("p", { className: "mx-msg__ai-output", "aria-busy": "true", children: /* @__PURE__ */ jsx4("span", { className: "mx-msg__skeleton", style: { display: "block", height: 11, width: "72%" } }) }) : ai.error !== null ? /* @__PURE__ */ jsx4("p", { className: "mx-msg__ai-output", style: { color: "var(--mx-msg-danger)" }, children: ai.error }) : ai.result !== null ? /* @__PURE__ */ jsxs2("p", { className: "mx-msg__ai-output", children: [
+      ai.result.text,
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__button mx-msg__button--ghost",
+          style: { minWidth: 28, minHeight: 28, float: "right" },
+          onClick: ai.clear,
+          "aria-label": "Dismiss",
+          children: /* @__PURE__ */ jsx4(CloseIcon, {})
+        }
+      )
+    ] }) : null,
+    /* @__PURE__ */ jsx4("div", { className: "mx-msg__scroll", ref: scrollRef, children: conversation.isLoading ? /* @__PURE__ */ jsx4(ConversationSkeleton, { rows: 4 }) : messages.length === 0 ? /* @__PURE__ */ jsx4(EmptyState, { title: "No messages yet", body: "Say something to get started." }) : /* @__PURE__ */ jsxs2("div", { className: "mx-msg__messages", children: [
+      conversation.hasMoreOlder ? /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__chip",
+          style: { margin: "4px auto 12px", display: "block" },
+          onClick: conversation.loadOlder,
+          children: "Load earlier messages"
+        }
+      ) : null,
+      groupMessages(messages).map((group) => {
+        const first = group.messages[0];
+        if (first === void 0) return null;
+        const isMine = group.senderId === selfId;
+        const sender = conversation.participants.find(
+          (participant) => participant.userId === group.senderId
+        ) ?? null;
+        return /* @__PURE__ */ jsxs2("div", { children: [
+          group.dateSeparator !== null ? /* @__PURE__ */ jsx4("div", { className: "mx-msg__day", children: group.dateSeparator }) : null,
+          /* @__PURE__ */ jsx4(
+            MessageGroupView,
+            {
+              messages: group.messages,
+              sender,
+              isMine,
+              onRetry: conversation.retry,
+              onReply: composer.setReplyTo,
+              pendingIds: new Set(
+                conversation.pending.filter((entry) => entry.state === "failed").map((entry) => entry.clientMessageId)
+              ),
+              failedEntryIdByClientId: new Map(
+                conversation.pending.map((entry) => [entry.clientMessageId, entry.id])
+              )
+            }
+          )
+        ] }, first.id);
+      })
+    ] }) }),
+    /* @__PURE__ */ jsx4("div", { className: "mx-msg__typing", "aria-live": "polite", children: typists.label !== null ? /* @__PURE__ */ jsxs2(Fragment, { children: [
+      /* @__PURE__ */ jsx4(TypingDots, {}),
+      typists.label
+    ] }) : null }),
+    /* @__PURE__ */ jsx4(Composer, { conversationId })
+  ] });
+}
+function MessageGroupView(props) {
+  const first = props.messages[0];
+  if (first === void 0) return null;
+  const actor = resolveActor(first, props.sender);
+  return /* @__PURE__ */ jsxs2("div", { className: `mx-msg__group${props.isMine ? " mx-msg__group--mine" : ""}`, children: [
+    /* @__PURE__ */ jsx4(
+      Avatar,
+      {
+        name: actor.displayName,
+        imageUrl: actor.avatarUrl,
+        seed: actor.isAgent ? `agent:${actor.displayName}` : actor.principalUserId,
+        small: true
+      }
+    ),
+    /* @__PURE__ */ jsxs2("div", { className: "mx-msg__group-body", children: [
+      !props.isMine || actor.isAgent ? /* @__PURE__ */ jsxs2("div", { className: "mx-msg__author", children: [
+        actor.displayName,
+        actor.isAgent ? /* @__PURE__ */ jsx4(AgentTag, {}) : null,
+        actor.onBehalfOfName !== null ? /* @__PURE__ */ jsxs2("span", { style: { fontWeight: 400, color: "var(--mx-msg-text-faint)" }, children: [
+          "via ",
+          actor.onBehalfOfName
+        ] }) : null
+      ] }) : null,
+      props.messages.map((message, index) => /* @__PURE__ */ jsx4(
+        MessageBubble,
+        {
+          message,
+          isMine: props.isMine,
+          isLast: index === props.messages.length - 1,
+          onRetry: props.onRetry,
+          onReply: props.onReply,
+          failedEntryId: message.clientMessageId !== null ? props.failedEntryIdByClientId.get(message.clientMessageId) ?? null : null
+        },
+        message.id
+      ))
+    ] })
+  ] });
+}
+function MessageBubble(props) {
+  const { message, isMine } = props;
+  const host = useMessagingHost();
+  if (message.deletedAt !== null) {
+    return /* @__PURE__ */ jsx4("div", { className: "mx-msg__bubble mx-msg__bubble--deleted", children: "Message deleted" });
+  }
+  const classes = [
+    "mx-msg__bubble",
+    isMine ? "mx-msg__bubble--mine" : "",
+    props.isLast ? "mx-msg__bubble--tail" : "",
+    message.deliveryState === "sending" ? "mx-msg__bubble--pending" : "",
+    message.deliveryState === "failed" ? "mx-msg__bubble--failed" : ""
+  ].filter(Boolean).join(" ");
+  return /* @__PURE__ */ jsxs2(Fragment, { children: [
+    /* @__PURE__ */ jsxs2("div", { className: classes, children: [
+      splitText(message.content).map(
+        (segment, index) => segment.type === "text" ? /* @__PURE__ */ jsx4("span", { children: segment.value }, index) : /* @__PURE__ */ jsx4(
+          ReferenceCard,
+          {
+            reference: segment.reference,
+            onOpen: host?.openReference ?? null
+          },
+          `${segment.reference.entityType}:${segment.reference.entityId}`
+        )
+      ),
+      message.references.map((reference) => /* @__PURE__ */ jsx4(
+        ReferenceCard,
+        {
+          reference,
+          onOpen: host?.openReference ?? null
+        },
+        `structured:${reference.entityType}:${reference.entityId}`
+      )),
+      message.action !== null ? /* @__PURE__ */ jsx4(MessageActionChips, { message }) : null
+    ] }),
+    /* @__PURE__ */ jsxs2(
+      "div",
+      {
+        className: `mx-msg__meta${message.deliveryState === "failed" ? " mx-msg__meta--failed" : ""}`,
+        children: [
+          props.isLast ? formatMessageTime(message.createdAt) : null,
+          message.editedAt !== null ? " \xB7 edited" : null,
+          isMine ? /* @__PURE__ */ jsx4(DeliveryTick, { state: message.deliveryState }) : null,
+          message.deliveryState === "failed" && props.failedEntryId != null && props.onRetry !== void 0 ? /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              className: "mx-msg__chip mx-msg__chip--danger",
+              style: { minHeight: 24, padding: "2px 8px" },
+              onClick: () => props.onRetry?.(props.failedEntryId),
+              children: "Retry"
+            }
+          ) : null,
+          props.onReply !== void 0 && message.deliveryState !== "sending" ? /* @__PURE__ */ jsx4(
+            "button",
+            {
+              type: "button",
+              className: "mx-msg__button mx-msg__button--ghost",
+              style: { minWidth: 24, minHeight: 24, fontSize: 13 },
+              onClick: () => props.onReply?.(message),
+              "aria-label": "Reply",
+              children: /* @__PURE__ */ jsx4(ReplyIcon, {})
+            }
+          ) : null
+        ]
+      }
+    )
+  ] });
+}
+function MessageActionChips(props) {
+  const action = useMessageAction(props.message);
+  if (action.receipt !== null) {
+    return /* @__PURE__ */ jsxs2("span", { className: "mx-msg__receipt", children: [
+      action.receipt.label,
+      action.receipt.outcome === "already" ? " (already done)" : ""
+    ] });
+  }
+  if (action.choices.length === 0) return null;
+  return /* @__PURE__ */ jsx4("div", { className: "mx-msg__chips", children: action.choices.map((choice) => /* @__PURE__ */ jsx4(
+    "button",
+    {
+      type: "button",
+      className: `mx-msg__chip${choice.tone === "primary" ? " mx-msg__chip--primary" : choice.tone === "danger" ? " mx-msg__chip--danger" : ""}`,
+      disabled: action.isRunning,
+      onClick: () => action.execute(choice.id),
+      children: choice.label
+    },
+    choice.id
+  )) });
+}
+function Composer(props) {
+  const composer = useComposer(props.conversationId);
+  const textareaRef = useRef3(null);
+  useEffect3(() => {
+    const node = textareaRef.current;
+    if (node === null) return;
+    node.style.height = "auto";
+    node.style.height = `${node.scrollHeight}px`;
+  }, [composer.value]);
+  return /* @__PURE__ */ jsxs2("div", { className: "mx-msg__composer", children: [
+    composer.replyTo !== null ? /* @__PURE__ */ jsxs2("div", { className: "mx-msg__reply-bar", children: [
+      /* @__PURE__ */ jsx4(ReplyIcon, {}),
+      /* @__PURE__ */ jsx4("span", { children: summarizeText(composer.replyTo.content, 70) }),
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__button mx-msg__button--ghost",
+          style: { minWidth: 26, minHeight: 26, marginLeft: "auto" },
+          onClick: () => composer.setReplyTo(null),
+          "aria-label": "Cancel reply",
+          children: /* @__PURE__ */ jsx4(CloseIcon, {})
+        }
+      )
+    ] }) : null,
+    /* @__PURE__ */ jsxs2("div", { className: "mx-msg__composer-row", children: [
+      /* @__PURE__ */ jsx4(
+        "textarea",
+        {
+          ref: textareaRef,
+          className: "mx-msg__input",
+          rows: 1,
+          value: composer.value,
+          placeholder: "Message",
+          "aria-label": "Message",
+          disabled: props.conversationId === null,
+          onChange: (event) => {
+            composer.setValue(event.target.value);
+            composer.onKeystroke();
+          },
+          onKeyDown: (event) => {
+            if (event.key !== "Enter" || event.shiftKey) return;
+            const isTouch = typeof globalThis.matchMedia === "function" && globalThis.matchMedia("(pointer: coarse)").matches;
+            if (isTouch) return;
+            event.preventDefault();
+            composer.send();
+          }
+        }
+      ),
+      /* @__PURE__ */ jsx4(
+        "button",
+        {
+          type: "button",
+          className: "mx-msg__button",
+          disabled: !composer.canSend,
+          onClick: composer.send,
+          "aria-label": "Send",
+          children: /* @__PURE__ */ jsx4(SendIcon, {})
+        }
+      )
+    ] })
+  ] });
+}
+function MessagingInbox(props) {
+  const host = useMessagingHost();
+  const [selected, setSelected] = useState2(props.conversationId ?? null);
+  useEffect3(() => {
+    if (props.conversationId !== void 0) setSelected(props.conversationId);
+  }, [props.conversationId]);
+  if (host === null) {
+    return /* @__PURE__ */ jsxs2("div", { className: `mx-msg${props.className !== void 0 ? ` ${props.className}` : ""}`, children: [
+      /* @__PURE__ */ jsx4("div", { className: "mx-msg__list", children: /* @__PURE__ */ jsx4(ConversationSkeleton, {}) }),
+      /* @__PURE__ */ jsx4("div", { className: "mx-msg__thread" })
+    ] });
+  }
+  const choose = (id) => {
+    setSelected(id);
+    props.onConversationChange?.(id);
+  };
+  return /* @__PURE__ */ jsxs2(
+    "div",
+    {
+      className: `mx-msg${props.className !== void 0 ? ` ${props.className}` : ""}`,
+      "data-pane": selected === null ? "list" : "thread",
+      children: [
+        /* @__PURE__ */ jsx4(
+          ConversationList,
+          {
+            onSelect: choose,
+            ...props.onNewConversation !== void 0 ? { onNewConversation: props.onNewConversation } : {}
+          }
+        ),
+        /* @__PURE__ */ jsx4(ConversationView, { conversationId: selected, onBack: () => choose(null) })
+      ]
+    }
+  );
+}
+
+// src/core/types.ts
+var asConversationId = (value) => value;
+var asMessageId = (value) => value;
+var asUserId = (value) => value;
+var asOrganizationId = (value) => value;
+var asClientMessageId = (value) => value;
+export {
+  AgentTag,
+  AlertIcon,
+  Avatar,
+  BotIcon,
+  CheckIcon,
+  ChevronLeftIcon,
+  ClockIcon,
+  CloseIcon,
+  Composer,
+  ConversationList,
+  ConversationSkeleton,
+  ConversationView,
+  DeliveryTick,
+  DoubleCheckIcon,
+  EmptyState,
+  LinkIcon,
+  MESSAGING_EVENTS,
+  MESSAGING_SCHEMA,
+  MessageActionChips,
+  MessageBubble,
+  MessagingError,
+  MessagingInbox,
+  MessagingProvider,
+  PaperclipIcon,
+  PlusIcon,
+  RPCS,
+  ReferenceCard,
+  ReplyIcon,
+  SearchIcon,
+  SendIcon,
+  SparklesIcon,
+  TABLES,
+  TypingDots,
+  UsersIcon,
+  asClientMessageId,
+  asConversationId,
+  asMessageId,
+  asOrganizationId,
+  asUserId,
+  avatarPaletteIndex,
+  composeFence,
+  conversationTopic,
+  createActionRegistry,
+  createMemoryOutboxStorage,
+  createMessagingAi,
+  createMessagingEngine,
+  createMessagingRepository,
+  createMessagingStore,
+  createOutbox,
+  createReadCache,
+  createWebOutboxStorage,
+  extractReferences,
+  formatConversationTime,
+  formatDateSeparator,
+  formatLastSeen,
+  formatMessageTime,
+  formatTypists,
+  getInitials,
+  groupMessages,
+  inboxTopic,
+  invalidResponse,
+  isSameDay,
+  messagingClientId,
+  normalizeMessagingError,
+  optimisticMessage,
+  participantNames,
+  projectConversationSummary,
+  projectMessage,
+  projectMessageAction,
+  projectParticipantRole,
+  projectUserSummary,
+  resolveActor,
+  splitText,
+  summarizeText,
+  useComposer,
+  useConversation,
+  useConversations,
+  useMessageAction,
+  useMessagingAi,
+  useMessagingHost,
+  useMessagingSnapshot,
+  useOnlineUserIds,
+  useRequiredMessagingHost,
+  useTypists
+};
+//# sourceMappingURL=react.js.map