@ai-matrx/messaging 0.0.0 → 0.1.1

package/dist/index.cjs

@@ -0,0 +1,1893 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/index.ts
+var src_exports = {};
+__export(src_exports, {
+  MESSAGING_EVENTS: () => MESSAGING_EVENTS,
+  MESSAGING_SCHEMA: () => MESSAGING_SCHEMA,
+  MessagingError: () => MessagingError,
+  RPCS: () => RPCS,
+  TABLES: () => TABLES,
+  asClientMessageId: () => asClientMessageId,
+  asConversationId: () => asConversationId,
+  asMessageId: () => asMessageId,
+  asOrganizationId: () => asOrganizationId,
+  asUserId: () => asUserId,
+  avatarPaletteIndex: () => avatarPaletteIndex,
+  composeFence: () => composeFence,
+  conversationTopic: () => conversationTopic,
+  createActionRegistry: () => createActionRegistry,
+  createMemoryOutboxStorage: () => createMemoryOutboxStorage,
+  createMessagingAi: () => createMessagingAi,
+  createMessagingEngine: () => createMessagingEngine,
+  createMessagingRepository: () => createMessagingRepository,
+  createMessagingStore: () => createMessagingStore,
+  createOutbox: () => createOutbox,
+  createReadCache: () => createReadCache,
+  createWebOutboxStorage: () => createWebOutboxStorage,
+  extractReferences: () => extractReferences,
+  formatConversationTime: () => formatConversationTime,
+  formatDateSeparator: () => formatDateSeparator,
+  formatLastSeen: () => formatLastSeen,
+  formatMessageTime: () => formatMessageTime,
+  formatTypists: () => formatTypists,
+  getInitials: () => getInitials,
+  groupMessages: () => groupMessages,
+  inboxTopic: () => inboxTopic,
+  invalidResponse: () => invalidResponse,
+  isSameDay: () => isSameDay,
+  messagingClientId: () => messagingClientId,
+  normalizeMessagingError: () => normalizeMessagingError,
+  optimisticMessage: () => optimisticMessage,
+  participantNames: () => participantNames,
+  projectConversationSummary: () => projectConversationSummary,
+  projectMessage: () => projectMessage,
+  projectMessageAction: () => projectMessageAction,
+  projectParticipantRole: () => projectParticipantRole,
+  projectUserSummary: () => projectUserSummary,
+  resolveActor: () => resolveActor,
+  splitText: () => splitText,
+  summarizeText: () => summarizeText
+});
+module.exports = __toCommonJS(src_exports);
+
+// 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/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/core/ai.ts
+var import_matrx = require("@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 (0, import_matrx.runAgentToCompletion)(
+      options.transport,
+      agentId,
+      {
+        ...(0, import_matrx.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/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/channels.ts
+var import_realtime = require("@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: (0, import_realtime.defineChannelNamespace)({
+      namespace: "messaging-inbox",
+      parts: ["userId"],
+      description: "One user's conversation list: new messages anywhere they participate, membership changes, and read-state updates."
+    }),
+    conversation: (0, import_realtime.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/engine.ts
+var import_realtime3 = require("@ai-matrx/realtime");
+
+// src/core/outbox.ts
+var import_realtime2 = require("@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-${(0, import_realtime2.randomId)()}`;
+      entries = [
+        ...entries,
+        {
+          id: (0, import_realtime2.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();
+    },
+    applyLastMessage(message, args = {}) {
+      const existing = conversations.find(
+        (item) => item.conversation.id === message.conversationId
+      );
+      if (existing === void 0) return;
+      if (message.deliveryState === "sending" || message.deletedAt !== null) return;
+      if (existing.lastMessageAt !== null && message.createdAt < existing.lastMessageAt) return;
+      const isActive = activeConversationId === message.conversationId;
+      const shouldCount = args.incrementUnread === true && !isActive;
+      conversations = normalizeConversations(
+        conversations.map(
+          (item) => item.conversation.id === message.conversationId ? {
+            ...item,
+            lastMessageContent: message.content,
+            lastMessageSenderId: message.senderId,
+            lastMessageAt: message.createdAt,
+            sortAt: message.createdAt,
+            unreadCount: shouldCount ? item.unreadCount + 1 : item.unreadCount
+          } : item
+        )
+      );
+      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);
+      store.applyLastMessage(message);
+      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 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);
+              const isMine = message.senderId === identity.userId;
+              store.applyLastMessage(message, { incrementUnread: !isMine });
+              if (!isMine) options.onIncoming?.(message);
+            }
+          },
+          {
+            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 (0, import_realtime3.clientSessionId)();
+}
+
+// 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/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/core/types.ts
+var asConversationId = (value) => value;
+var asMessageId = (value) => value;
+var asUserId = (value) => value;
+var asOrganizationId = (value) => value;
+var asClientMessageId = (value) => value;
+//# sourceMappingURL=index.cjs.map