@dittolive/ditto-chat-core 0.0.1 → 0.1.1

package/dist/index.es.js

@@ -0,0 +1,1764 @@
+import k, { useMemo as Fe } from "react";
+const ze = {
+  canCreateRoom: !0,
+  canEditOwnMessage: !0,
+  canDeleteOwnMessage: !0,
+  canAddReaction: !0,
+  canRemoveOwnReaction: !0,
+  canMentionUsers: !0,
+  canSubscribeToRoom: !0
+}, He = (e, t, { rbacConfig: r = {} }) => ({
+  rbacConfig: r,
+  /**
+   * Check if a specific permission action is allowed.
+   *
+   * This method evaluates the RBAC configuration to determine
+   * if an action is permitted. Uses a permissive-by-default approach.
+   *
+   * Workflow:
+   * 1. Gets current RBAC config from state
+   * 2. Checks if permission is explicitly set
+   * 3. Returns explicit value or default (true)
+   *
+   * @param action - Permission key to check (e.g., 'canCreateRoom')
+   * @returns boolean indicating if action is allowed
+   */
+  canPerformAction: (s) => {
+    const a = t().rbacConfig[s];
+    return a !== void 0 ? a : ze[s];
+  },
+  /**
+   * Update the RBAC permission configuration.
+   *
+   * This method merges new permissions with the existing config,
+   * allowing partial updates without overwriting unrelated permissions.
+   *
+   * Workflow:
+   * 1. Merges provided config with existing rbacConfig
+   * 2. Updates state with combined configuration
+   *
+   * @param config - Partial RBAC config with permissions to update
+   */
+  updateRBACConfig: (s) => {
+    e((o) => ({
+      ...o,
+      rbacConfig: {
+        ...o.rbacConfig,
+        ...s
+      }
+    }));
+  }
+});
+var Ae = /* @__PURE__ */ Symbol.for("immer-nothing"), ye = /* @__PURE__ */ Symbol.for("immer-draftable"), O = /* @__PURE__ */ Symbol.for("immer-state"), Le = process.env.NODE_ENV !== "production" ? [
+  // All error codes, starting by 0:
+  function(e) {
+    return `The plugin for '${e}' has not been loaded into Immer. To enable the plugin, import and call \`enable${e}()\` when initializing your application.`;
+  },
+  function(e) {
+    return `produce can only be called on things that are draftable: plain objects, arrays, Map, Set or classes that are marked with '[immerable]: true'. Got '${e}'`;
+  },
+  "This object has been frozen and should not be mutated",
+  function(e) {
+    return "Cannot use a proxy that has been revoked. Did you pass an object from inside an immer function to an async process? " + e;
+  },
+  "An immer producer returned a new value *and* modified its draft. Either return a new value *or* modify the draft.",
+  "Immer forbids circular references",
+  "The first or second argument to `produce` must be a function",
+  "The third argument to `produce` must be a function or undefined",
+  "First argument to `createDraft` must be a plain object, an array, or an immerable object",
+  "First argument to `finishDraft` must be a draft returned by `createDraft`",
+  function(e) {
+    return `'current' expects a draft, got: ${e}`;
+  },
+  "Object.defineProperty() cannot be used on an Immer draft",
+  "Object.setPrototypeOf() cannot be used on an Immer draft",
+  "Immer only supports deleting array indices",
+  "Immer only supports setting array indices and the 'length' property",
+  function(e) {
+    return `'original' expects a draft, got: ${e}`;
+  }
+  // Note: if more errors are added, the errorOffset in Patches.ts should be increased
+  // See Patches.ts for additional errors
+] : [];
+function T(e, ...t) {
+  if (process.env.NODE_ENV !== "production") {
+    const r = Le[e], n = typeof r == "function" ? r.apply(null, t) : r;
+    throw new Error(`[Immer] ${n}`);
+  }
+  throw new Error(
+    `[Immer] minified error nr: ${e}. Full error at: https://bit.ly/3cXEKWf`
+  );
+}
+var B = Object.getPrototypeOf;
+function N(e) {
+  return !!e && !!e[O];
+}
+function U(e) {
+  return e ? ve(e) || Array.isArray(e) || !!e[ye] || !!e.constructor?.[ye] || H(e) || X(e) : !1;
+}
+var $e = Object.prototype.constructor.toString(), ge = /* @__PURE__ */ new WeakMap();
+function ve(e) {
+  if (!e || typeof e != "object")
+    return !1;
+  const t = Object.getPrototypeOf(e);
+  if (t === null || t === Object.prototype)
+    return !0;
+  const r = Object.hasOwnProperty.call(t, "constructor") && t.constructor;
+  if (r === Object)
+    return !0;
+  if (typeof r != "function")
+    return !1;
+  let n = ge.get(r);
+  return n === void 0 && (n = Function.toString.call(r), ge.set(r, n)), n === $e;
+}
+function q(e, t, r = !0) {
+  V(e) === 0 ? (r ? Reflect.ownKeys(e) : Object.keys(e)).forEach((s) => {
+    t(s, e[s], e);
+  }) : e.forEach((n, s) => t(s, n, e));
+}
+function V(e) {
+  const t = e[O];
+  return t ? t.type_ : Array.isArray(e) ? 1 : H(e) ? 2 : X(e) ? 3 : 0;
+}
+function oe(e, t) {
+  return V(e) === 2 ? e.has(t) : Object.prototype.hasOwnProperty.call(e, t);
+}
+function Me(e, t, r) {
+  const n = V(e);
+  n === 2 ? e.set(t, r) : n === 3 ? e.add(r) : e[t] = r;
+}
+function je(e, t) {
+  return e === t ? e !== 0 || 1 / e === 1 / t : e !== e && t !== t;
+}
+function H(e) {
+  return e instanceof Map;
+}
+function X(e) {
+  return e instanceof Set;
+}
+function M(e) {
+  return e.copy_ || e.base_;
+}
+function ie(e, t) {
+  if (H(e))
+    return new Map(e);
+  if (X(e))
+    return new Set(e);
+  if (Array.isArray(e))
+    return Array.prototype.slice.call(e);
+  const r = ve(e);
+  if (t === !0 || t === "class_only" && !r) {
+    const n = Object.getOwnPropertyDescriptors(e);
+    delete n[O];
+    let s = Reflect.ownKeys(n);
+    for (let o = 0; o < s.length; o++) {
+      const a = s[o], c = n[a];
+      c.writable === !1 && (c.writable = !0, c.configurable = !0), (c.get || c.set) && (n[a] = {
+        configurable: !0,
+        writable: !0,
+        // could live with !!desc.set as well here...
+        enumerable: c.enumerable,
+        value: e[a]
+      });
+    }
+    return Object.create(B(e), n);
+  } else {
+    const n = B(e);
+    if (n !== null && r)
+      return { ...e };
+    const s = Object.create(n);
+    return Object.assign(s, e);
+  }
+}
+function fe(e, t = !1) {
+  return Z(e) || N(e) || !U(e) || (V(e) > 1 && Object.defineProperties(e, {
+    set: W,
+    add: W,
+    clear: W,
+    delete: W
+  }), Object.freeze(e), t && Object.values(e).forEach((r) => fe(r, !0))), e;
+}
+function We() {
+  T(2);
+}
+var W = {
+  value: We
+};
+function Z(e) {
+  return e === null || typeof e != "object" ? !0 : Object.isFrozen(e);
+}
+var Ge = {};
+function P(e) {
+  const t = Ge[e];
+  return t || T(0, e), t;
+}
+var F;
+function Ce() {
+  return F;
+}
+function qe(e, t) {
+  return {
+    drafts_: [],
+    parent_: e,
+    immer_: t,
+    // Whenever the modified draft contains a draft from another scope, we
+    // need to prevent auto-freezing so the unowned draft can be finalized.
+    canAutoFreeze_: !0,
+    unfinalizedDrafts_: 0
+  };
+}
+function he(e, t) {
+  t && (P("Patches"), e.patches_ = [], e.inversePatches_ = [], e.patchListener_ = t);
+}
+function ae(e) {
+  ce(e), e.drafts_.forEach(Qe), e.drafts_ = null;
+}
+function ce(e) {
+  e === F && (F = e.parent_);
+}
+function be(e) {
+  return F = qe(F, e);
+}
+function Qe(e) {
+  const t = e[O];
+  t.type_ === 0 || t.type_ === 1 ? t.revoke_() : t.revoked_ = !0;
+}
+function _e(e, t) {
+  t.unfinalizedDrafts_ = t.drafts_.length;
+  const r = t.drafts_[0];
+  return e !== void 0 && e !== r ? (r[O].modified_ && (ae(t), T(4)), U(e) && (e = Q(t, e), t.parent_ || Y(t, e)), t.patches_ && P("Patches").generateReplacementPatches_(
+    r[O].base_,
+    e,
+    t.patches_,
+    t.inversePatches_
+  )) : e = Q(t, r, []), ae(t), t.patches_ && t.patchListener_(t.patches_, t.inversePatches_), e !== Ae ? e : void 0;
+}
+function Q(e, t, r) {
+  if (Z(t))
+    return t;
+  const n = e.immer_.shouldUseStrictIteration(), s = t[O];
+  if (!s)
+    return q(
+      t,
+      (o, a) => we(e, s, t, o, a, r),
+      n
+    ), t;
+  if (s.scope_ !== e)
+    return t;
+  if (!s.modified_)
+    return Y(e, s.base_, !0), s.base_;
+  if (!s.finalized_) {
+    s.finalized_ = !0, s.scope_.unfinalizedDrafts_--;
+    const o = s.copy_;
+    let a = o, c = !1;
+    s.type_ === 3 && (a = new Set(o), o.clear(), c = !0), q(
+      a,
+      (d, y) => we(
+        e,
+        s,
+        o,
+        d,
+        y,
+        r,
+        c
+      ),
+      n
+    ), Y(e, o, !1), r && e.patches_ && P("Patches").generatePatches_(
+      s,
+      r,
+      e.patches_,
+      e.inversePatches_
+    );
+  }
+  return s.copy_;
+}
+function we(e, t, r, n, s, o, a) {
+  if (s == null || typeof s != "object" && !a)
+    return;
+  const c = Z(s);
+  if (!(c && !a)) {
+    if (process.env.NODE_ENV !== "production" && s === r && T(5), N(s)) {
+      const d = o && t && t.type_ !== 3 && // Set objects are atomic since they have no keys.
+      !oe(t.assigned_, n) ? o.concat(n) : void 0, y = Q(e, s, d);
+      if (Me(r, n, y), N(y))
+        e.canAutoFreeze_ = !1;
+      else
+        return;
+    } else a && r.add(s);
+    if (U(s) && !c) {
+      if (!e.immer_.autoFreeze_ && e.unfinalizedDrafts_ < 1 || t && t.base_ && t.base_[n] === s && c)
+        return;
+      Q(e, s), (!t || !t.scope_.parent_) && typeof n != "symbol" && (H(r) ? r.has(n) : Object.prototype.propertyIsEnumerable.call(r, n)) && Y(e, s);
+    }
+  }
+}
+function Y(e, t, r = !1) {
+  !e.parent_ && e.immer_.autoFreeze_ && e.canAutoFreeze_ && fe(t, r);
+}
+function Ye(e, t) {
+  const r = Array.isArray(e), n = {
+    type_: r ? 1 : 0,
+    // Track which produce call this is associated with.
+    scope_: t ? t.scope_ : Ce(),
+    // True for both shallow and deep changes.
+    modified_: !1,
+    // Used during finalization.
+    finalized_: !1,
+    // Track which properties have been assigned (true) or deleted (false).
+    assigned_: {},
+    // The parent draft state.
+    parent_: t,
+    // The base state.
+    base_: e,
+    // The base proxy.
+    draft_: null,
+    // set below
+    // The base copy with any updated values.
+    copy_: null,
+    // Called by the `produce` function.
+    revoke_: null,
+    isManual_: !1
+  };
+  let s = n, o = me;
+  r && (s = [n], o = z);
+  const { revoke: a, proxy: c } = Proxy.revocable(s, o);
+  return n.draft_ = c, n.revoke_ = a, c;
+}
+var me = {
+  get(e, t) {
+    if (t === O)
+      return e;
+    const r = M(e);
+    if (!oe(r, t))
+      return Ve(e, r, t);
+    const n = r[t];
+    return e.finalized_ || !U(n) ? n : n === ee(e.base_, t) ? (te(e), e.copy_[t] = le(n, e)) : n;
+  },
+  has(e, t) {
+    return t in M(e);
+  },
+  ownKeys(e) {
+    return Reflect.ownKeys(M(e));
+  },
+  set(e, t, r) {
+    const n = Ue(M(e), t);
+    if (n?.set)
+      return n.set.call(e.draft_, r), !0;
+    if (!e.modified_) {
+      const s = ee(M(e), t), o = s?.[O];
+      if (o && o.base_ === r)
+        return e.copy_[t] = r, e.assigned_[t] = !1, !0;
+      if (je(r, s) && (r !== void 0 || oe(e.base_, t)))
+        return !0;
+      te(e), ue(e);
+    }
+    return e.copy_[t] === r && // special case: handle new props with value 'undefined'
+    (r !== void 0 || t in e.copy_) || // special case: NaN
+    Number.isNaN(r) && Number.isNaN(e.copy_[t]) || (e.copy_[t] = r, e.assigned_[t] = !0), !0;
+  },
+  deleteProperty(e, t) {
+    return ee(e.base_, t) !== void 0 || t in e.base_ ? (e.assigned_[t] = !1, te(e), ue(e)) : delete e.assigned_[t], e.copy_ && delete e.copy_[t], !0;
+  },
+  // Note: We never coerce `desc.value` into an Immer draft, because we can't make
+  // the same guarantee in ES5 mode.
+  getOwnPropertyDescriptor(e, t) {
+    const r = M(e), n = Reflect.getOwnPropertyDescriptor(r, t);
+    return n && {
+      writable: !0,
+      configurable: e.type_ !== 1 || t !== "length",
+      enumerable: n.enumerable,
+      value: r[t]
+    };
+  },
+  defineProperty() {
+    T(11);
+  },
+  getPrototypeOf(e) {
+    return B(e.base_);
+  },
+  setPrototypeOf() {
+    T(12);
+  }
+}, z = {};
+q(me, (e, t) => {
+  z[e] = function() {
+    return arguments[0] = arguments[0][0], t.apply(this, arguments);
+  };
+});
+z.deleteProperty = function(e, t) {
+  return process.env.NODE_ENV !== "production" && isNaN(parseInt(t)) && T(13), z.set.call(this, e, t, void 0);
+};
+z.set = function(e, t, r) {
+  return process.env.NODE_ENV !== "production" && t !== "length" && isNaN(parseInt(t)) && T(14), me.set.call(this, e[0], t, r, e[0]);
+};
+function ee(e, t) {
+  const r = e[O];
+  return (r ? M(r) : e)[t];
+}
+function Ve(e, t, r) {
+  const n = Ue(t, r);
+  return n ? "value" in n ? n.value : (
+    // This is a very special case, if the prop is a getter defined by the
+    // prototype, we should invoke it with the draft as context!
+    n.get?.call(e.draft_)
+  ) : void 0;
+}
+function Ue(e, t) {
+  if (!(t in e))
+    return;
+  let r = B(e);
+  for (; r; ) {
+    const n = Object.getOwnPropertyDescriptor(r, t);
+    if (n)
+      return n;
+    r = B(r);
+  }
+}
+function ue(e) {
+  e.modified_ || (e.modified_ = !0, e.parent_ && ue(e.parent_));
+}
+function te(e) {
+  e.copy_ || (e.copy_ = ie(
+    e.base_,
+    e.scope_.immer_.useStrictShallowCopy_
+  ));
+}
+var Xe = class {
+  constructor(e) {
+    this.autoFreeze_ = !0, this.useStrictShallowCopy_ = !1, this.useStrictIteration_ = !0, this.produce = (t, r, n) => {
+      if (typeof t == "function" && typeof r != "function") {
+        const o = r;
+        r = t;
+        const a = this;
+        return function(d = o, ...y) {
+          return a.produce(d, (p) => r.call(this, p, ...y));
+        };
+      }
+      typeof r != "function" && T(6), n !== void 0 && typeof n != "function" && T(7);
+      let s;
+      if (U(t)) {
+        const o = be(this), a = le(t, void 0);
+        let c = !0;
+        try {
+          s = r(a), c = !1;
+        } finally {
+          c ? ae(o) : ce(o);
+        }
+        return he(o, n), _e(s, o);
+      } else if (!t || typeof t != "object") {
+        if (s = r(t), s === void 0 && (s = t), s === Ae && (s = void 0), this.autoFreeze_ && fe(s, !0), n) {
+          const o = [], a = [];
+          P("Patches").generateReplacementPatches_(t, s, o, a), n(o, a);
+        }
+        return s;
+      } else
+        T(1, t);
+    }, this.produceWithPatches = (t, r) => {
+      if (typeof t == "function")
+        return (a, ...c) => this.produceWithPatches(a, (d) => t(d, ...c));
+      let n, s;
+      return [this.produce(t, r, (a, c) => {
+        n = a, s = c;
+      }), n, s];
+    }, typeof e?.autoFreeze == "boolean" && this.setAutoFreeze(e.autoFreeze), typeof e?.useStrictShallowCopy == "boolean" && this.setUseStrictShallowCopy(e.useStrictShallowCopy), typeof e?.useStrictIteration == "boolean" && this.setUseStrictIteration(e.useStrictIteration);
+  }
+  createDraft(e) {
+    U(e) || T(8), N(e) && (e = Ze(e));
+    const t = be(this), r = le(e, void 0);
+    return r[O].isManual_ = !0, ce(t), r;
+  }
+  finishDraft(e, t) {
+    const r = e && e[O];
+    (!r || !r.isManual_) && T(9);
+    const { scope_: n } = r;
+    return he(n, t), _e(void 0, n);
+  }
+  /**
+   * Pass true to automatically freeze all copies created by Immer.
+   *
+   * By default, auto-freezing is enabled.
+   */
+  setAutoFreeze(e) {
+    this.autoFreeze_ = e;
+  }
+  /**
+   * Pass true to enable strict shallow copy.
+   *
+   * By default, immer does not copy the object descriptors such as getter, setter and non-enumrable properties.
+   */
+  setUseStrictShallowCopy(e) {
+    this.useStrictShallowCopy_ = e;
+  }
+  /**
+   * Pass false to use faster iteration that skips non-enumerable properties
+   * but still handles symbols for compatibility.
+   *
+   * By default, strict iteration is enabled (includes all own properties).
+   */
+  setUseStrictIteration(e) {
+    this.useStrictIteration_ = e;
+  }
+  shouldUseStrictIteration() {
+    return this.useStrictIteration_;
+  }
+  applyPatches(e, t) {
+    let r;
+    for (r = t.length - 1; r >= 0; r--) {
+      const s = t[r];
+      if (s.path.length === 0 && s.op === "replace") {
+        e = s.value;
+        break;
+      }
+    }
+    r > -1 && (t = t.slice(r + 1));
+    const n = P("Patches").applyPatches_;
+    return N(e) ? n(e, t) : this.produce(
+      e,
+      (s) => n(s, t)
+    );
+  }
+};
+function le(e, t) {
+  const r = H(e) ? P("MapSet").proxyMap_(e, t) : X(e) ? P("MapSet").proxySet_(e, t) : Ye(e, t);
+  return (t ? t.scope_ : Ce()).drafts_.push(r), r;
+}
+function Ze(e) {
+  return N(e) || T(10, e), Pe(e);
+}
+function Pe(e) {
+  if (!U(e) || Z(e))
+    return e;
+  const t = e[O];
+  let r, n = !0;
+  if (t) {
+    if (!t.modified_)
+      return t.base_;
+    t.finalized_ = !0, r = ie(e, t.scope_.immer_.useStrictShallowCopy_), n = t.scope_.immer_.shouldUseStrictIteration();
+  } else
+    r = ie(e, !0);
+  return q(
+    r,
+    (s, o) => {
+      Me(r, s, Pe(o));
+    },
+    n
+  ), t && (t.finalized_ = !1), r;
+}
+var Je = new Xe(), C = Je.produce;
+const E = [];
+for (let e = 0; e < 256; ++e)
+  E.push((e + 256).toString(16).slice(1));
+function Ke(e, t = 0) {
+  return (E[e[t + 0]] + E[e[t + 1]] + E[e[t + 2]] + E[e[t + 3]] + "-" + E[e[t + 4]] + E[e[t + 5]] + "-" + E[e[t + 6]] + E[e[t + 7]] + "-" + E[e[t + 8]] + E[e[t + 9]] + "-" + E[e[t + 10]] + E[e[t + 11]] + E[e[t + 12]] + E[e[t + 13]] + E[e[t + 14]] + E[e[t + 15]]).toLowerCase();
+}
+let re;
+const et = new Uint8Array(16);
+function tt() {
+  if (!re) {
+    if (typeof crypto > "u" || !crypto.getRandomValues)
+      throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+    re = crypto.getRandomValues.bind(crypto);
+  }
+  return re(et);
+}
+const rt = typeof crypto < "u" && crypto.randomUUID && crypto.randomUUID.bind(crypto), pe = { randomUUID: rt };
+function nt(e, t, r) {
+  e = e || {};
+  const n = e.random ?? e.rng?.() ?? tt();
+  if (n.length < 16)
+    throw new Error("Random bytes length must be >= 16");
+  return n[6] = n[6] & 15 | 64, n[8] = n[8] & 63 | 128, Ke(n);
+}
+function Ne(e, t, r) {
+  return pe.randomUUID && !e ? pe.randomUUID() : nt(e);
+}
+function Ee(e, t, r) {
+  if (r.items.length === 0)
+    return;
+  const n = r.items.map((s) => {
+    const o = t().messagesPublisher;
+    return o(s.value), s.value;
+  });
+  e((s) => C(s, (o) => {
+    const a = s.rooms.filter(
+      (c) => c.collectionId !== n[0].collectionId
+    );
+    return o.rooms = a.concat(n), o.roomsLoading = !1, o;
+  }));
+}
+async function ne({
+  ditto: e,
+  currentUserId: t,
+  name: r,
+  collectionId: n,
+  messagesId: s,
+  participants: o = [],
+  retentionDays: a,
+  isGenerated: c = !1,
+  id: d
+}) {
+  if (e)
+    try {
+      const p = {
+        _id: d || Ne(),
+        name: r,
+        messagesId: s,
+        collectionId: n,
+        isGenerated: c,
+        createdBy: t,
+        createdOn: (/* @__PURE__ */ new Date()).toISOString(),
+        participants: o || void 0,
+        ...a !== void 0 && { retentionDays: a }
+      }, S = `INSERT INTO \`${n}\` DOCUMENTS (:newDoc) ON ID CONFLICT DO UPDATE`;
+      return await e.store.execute(S, { newDoc: p }), p;
+    } catch (y) {
+      console.error(`Error creating ${n}:`, y);
+    }
+}
+const st = (e, t, { ditto: r, userId: n }) => {
+  const s = {
+    rooms: [],
+    dmRooms: [],
+    generatedRooms: [],
+    roomsLoading: !0,
+    roomsObserver: null,
+    roomsSubscription: null,
+    dmRoomsObserver: null,
+    dmRoomsSubscription: null,
+    /**
+     * Creates a new public room with RBAC permission checks.
+     *
+     * This function creates a new regular (non-DM) room in the chat application.
+     * The creation process includes:
+     *
+     * 1. **Permission Check**:
+     *    - Verifies the user has "canCreateRoom" permission via RBAC
+     *    - Returns undefined immediately if permission is denied
+     *    - Logs a warning for debugging permission issues
+     *
+     * 2. **User Context**:
+     *    - Retrieves the current user from state
+     *    - Falls back to the userId parameter if currentUser is not available
+     *    - Ensures proper creator attribution
+     *
+     * 3. **Room Creation**:
+     *    - Delegates to createRoomBase with appropriate parameters
+     *    - Sets collectionId to "rooms" for regular rooms
+     *    - Sets messagesId to "messages" collection
+     *    - Passes through optional retentionDays parameter
+     *
+     * This approach ensures:
+     * - RBAC integration prevents unauthorized room creation
+     * - Consistent room creation through shared base function
+     * - Optional custom retention policies per room
+     *
+     * @param name - Display name for the new room
+     * @param options - Optional configuration for the room
+     * @param options.retentionDays - Optional custom message retention period (overrides global default)
+     * @param options.isGenerated - Optional flag to mark room as generated (hidden from main list)
+     * @returns Promise resolving to the created Room object, or undefined if permission denied
+     */
+    createRoom(o, a) {
+      if (!t().canPerformAction("canCreateRoom"))
+        return console.warn("Permission denied: canCreateRoom is false"), Promise.resolve(void 0);
+      const c = t().currentUser;
+      return ne({
+        ditto: r,
+        currentUserId: c?._id || n,
+        name: o,
+        collectionId: "rooms",
+        messagesId: "messages",
+        retentionDays: a?.retentionDays,
+        isGenerated: a?.isGenerated ?? !1
+      });
+    },
+    /**
+     * Creates a new direct message (DM) room between two users.
+     *
+     * This function creates a private one-on-one chat room between the current
+     * user and another user. The creation process includes:
+     *
+     * 1. **Validation**:
+     *    - Ensures both current user and DM user have valid IDs
+     *    - Throws an error if either user ID is missing
+     *    - Prevents creation of invalid DM rooms
+     *
+     * 2. **Room Naming**:
+     *    - Generates a room name combining both users' names
+     *    - Format: "CurrentUser & OtherUser"
+     *    - Provides clear identification of DM participants
+     *
+     * 3. **DM Room Creation**:
+     *    - Delegates to createRoomBase with DM-specific parameters
+     *    - Sets collectionId to "dm_rooms" for DM storage
+     *    - Sets messagesId to "dm_messages" collection
+     *    - Includes both user IDs in participants array
+     *
+     * This approach ensures:
+     * - Proper participant tracking for DM rooms
+     * - Separation of DM rooms from regular rooms in storage
+     * - User-friendly room naming for DM conversations
+     *
+     * @param dmUser - The ChatUser to create a DM room with
+     * @returns Promise resolving to the created DM Room object
+     * @throws Error if either user ID is invalid or missing
+     */
+    createDMRoom(o) {
+      const a = t().currentUser;
+      if (!a?._id || !o?._id)
+        throw Error("Invalid users");
+      return ne({
+        ditto: r,
+        currentUserId: a?._id || n,
+        name: `${a?.name} & ${o.name}`,
+        collectionId: "dm_rooms",
+        messagesId: "dm_messages",
+        participants: [a?._id, o._id]
+      });
+    },
+    /**
+     * Creates a generated room (comment room) with a specific ID.
+     *
+     * Generated rooms are used for programmatic use cases like comment threads
+     * on products, articles, or other entities. They are hidden from the main
+     * chat list but can be accessed directly when needed.
+     *
+     * @param id - Custom ID for the room (e.g., "comments-product-123")
+     * @param name - Display name for the room
+     * @returns Promise resolving to the created Room object
+     */
+    async createGeneratedRoom(o, a) {
+      const c = t().currentUser, d = await ne({
+        ditto: r,
+        currentUserId: c?._id || n,
+        name: a,
+        collectionId: "rooms",
+        messagesId: "messages",
+        isGenerated: !0,
+        id: o
+      });
+      return d && e((y) => y.generatedRooms.some((S) => S._id === d._id) ? y : {
+        ...y,
+        generatedRooms: [...y.generatedRooms, d]
+      }), d;
+    },
+    /**
+     * Returns all public rooms, filtering out generated rooms.
+     *
+     * This selector provides the list of rooms that should be displayed
+     * in the main chat list, excluding generated/comment rooms.
+     *
+     * @returns Array of non-generated rooms
+     */
+    getPublicRooms() {
+      return t().rooms.filter((o) => !o.isGenerated);
+    }
+  };
+  if (r) {
+    const o = "SELECT * from rooms WHERE isGenerated = false OR isGenerated IS NULL", a = "SELECT * from dm_rooms where (array_contains(participants, :userId))";
+    s.roomsSubscription = r.sync.registerSubscription(o), s.dmRoomsSubscription = r.sync.registerSubscription(a, {
+      userId: n
+    }), s.roomsObserver = r.store.registerObserver(
+      o,
+      (c) => {
+        Ee(e, t, c);
+      }
+    ), s.dmRoomsObserver = r.store.registerObserver(
+      a,
+      (c) => {
+        Ee(e, t, c);
+      },
+      {
+        userId: n
+      }
+    );
+  }
+  return s;
+}, Te = (e) => {
+  let t;
+  const r = /* @__PURE__ */ new Set(), n = (y, p) => {
+    const S = typeof y == "function" ? y(t) : y;
+    if (!Object.is(S, t)) {
+      const x = t;
+      t = p ?? (typeof S != "object" || S === null) ? S : Object.assign({}, t, S), r.forEach((L) => L(t, x));
+    }
+  }, s = () => t, c = { setState: n, getState: s, getInitialState: () => d, subscribe: (y) => (r.add(y), () => r.delete(y)) }, d = t = e(n, s, c);
+  return c;
+}, ot = ((e) => e ? Te(e) : Te), it = (e) => e;
+function xe(e, t = it) {
+  const r = k.useSyncExternalStore(
+    e.subscribe,
+    k.useCallback(() => t(e.getState()), [e, t]),
+    k.useCallback(() => t(e.getInitialState()), [e, t])
+  );
+  return k.useDebugValue(r), r;
+}
+const Se = (e) => Symbol.iterator in e, Oe = (e) => (
+  // HACK: avoid checking entries type
+  "entries" in e
+), Re = (e, t) => {
+  const r = e instanceof Map ? e : new Map(e.entries()), n = t instanceof Map ? t : new Map(t.entries());
+  if (r.size !== n.size)
+    return !1;
+  for (const [s, o] of r)
+    if (!n.has(s) || !Object.is(o, n.get(s)))
+      return !1;
+  return !0;
+}, at = (e, t) => {
+  const r = e[Symbol.iterator](), n = t[Symbol.iterator]();
+  let s = r.next(), o = n.next();
+  for (; !s.done && !o.done; ) {
+    if (!Object.is(s.value, o.value))
+      return !1;
+    s = r.next(), o = n.next();
+  }
+  return !!s.done && !!o.done;
+};
+function ct(e, t) {
+  return Object.is(e, t) ? !0 : typeof e != "object" || e === null || typeof t != "object" || t === null || Object.getPrototypeOf(e) !== Object.getPrototypeOf(t) ? !1 : Se(e) && Se(t) ? Oe(e) && Oe(t) ? Re(e, t) : at(e, t) : Re(
+    { entries: () => Object.entries(e) },
+    { entries: () => Object.entries(t) }
+  );
+}
+function ut(e) {
+  const t = k.useRef(void 0);
+  return (r) => {
+    const n = e(r);
+    return ct(t.current, n) ? t.current : t.current = n;
+  };
+}
+const lt = (e, t, { ditto: r, userId: n, userCollectionKey: s }) => {
+  const o = {
+    usersLoading: !0,
+    currentUser: null,
+    userObserver: null,
+    userSubscription: null,
+    allUsers: [],
+    allUsersObserver: null,
+    allUsersSubscription: null,
+    /**
+     * Add a new user to the users collection.
+     *
+     * This method creates or updates a user document in the Ditto store.
+     * Uses upsert behavior to handle both new and existing users.
+     *
+     * Workflow:
+     * 1. Validates Ditto is initialized
+     * 2. Executes INSERT with ON ID CONFLICT DO UPDATE
+     * 3. Creates new user or updates existing if ID matches
+     *
+     * @param user - User object (with optional _id for upsert)
+     */
+    async addUser(a) {
+      if (r)
+        try {
+          await r.store.execute(
+            `INSERT INTO ${s} DOCUMENTS (:newUser) ON ID CONFLICT DO UPDATE`,
+            { newUser: a }
+          );
+        } catch (c) {
+          console.error("Error in addUser:", c);
+        }
+    },
+    /**
+     * Update an existing user's fields.
+     *
+     * This method merges patch data with existing user data and persists.
+     * Only the specified fields are updated; others remain unchanged.
+     *
+     * Workflow:
+     * 1. Validates Ditto and user ID
+     * 2. Fetches current user data
+     * 3. Merges patch with existing user
+     * 4. Persists updated user document
+     *
+     * @param params - Object with _id and fields to update
+     */
+    async updateUser({ _id: a, ...c }) {
+      if (r && a)
+        try {
+          const d = await t().findUserById(a);
+          if (!d)
+            return;
+          const y = { ...d, ...c };
+          await r.store.execute(
+            `INSERT INTO ${s} DOCUMENTS (:newUser) ON ID CONFLICT DO UPDATE`,
+            { newUser: y }
+          );
+        } catch (d) {
+          console.error("Error in updateUser:", d);
+        }
+    },
+    /**
+     * Find a user by their unique ID.
+     *
+     * This method queries the users collection for a specific user.
+     *
+     * Workflow:
+     * 1. Validates Ditto is initialized
+     * 2. Executes SELECT query with user ID
+     * 3. Returns user object or null if not found
+     *
+     * @param userId - The unique identifier of the user
+     * @returns Promise resolving to ChatUser or null
+     */
+    async findUserById(a) {
+      if (!r)
+        return null;
+      try {
+        return (await r.store.execute(
+          `SELECT * FROM ${s} WHERE _id = :id`,
+          { id: a }
+        )).items?.[0]?.value;
+      } catch (c) {
+        return console.error("Error in findUserById:", c), null;
+      }
+    },
+    /**
+     * Mark a room's messages as read for the current user.
+     *
+     * This method updates the user's subscription timestamp and clears
+     * any pending mentions for the specified room.
+     *
+     * Workflow:
+     * 1. Validates Ditto and user ID
+     * 2. Fetches current user data
+     * 3. Updates subscription timestamp if subscribed
+     * 4. Clears mentions array for the room
+     * 5. Persists updated user document
+     *
+     * @param roomId - ID of the room to mark as read
+     */
+    async markRoomAsRead(a) {
+      if (!(!r || !n))
+        try {
+          let c = !1;
+          const d = await t().findUserById(n);
+          if (!d)
+            return;
+          const y = d.subscriptions || {}, p = d.mentions || {};
+          if (y[a]) {
+            const S = (/* @__PURE__ */ new Date()).toISOString();
+            y[a] = S, c = !0;
+          }
+          p[a] && (p[a] = [], c = !0), c && await t().updateUser({ _id: n, subscriptions: y, mentions: p });
+        } catch (c) {
+          console.error("Error in markRoomAsRead:", c);
+        }
+    },
+    /**
+     * Toggle subscription status for a room.
+     *
+     * This method subscribes to or unsubscribes from a room's notifications.
+     * When subscribed, user receives notifications for new messages.
+     *
+     * Workflow:
+     * 1. Checks canSubscribeToRoom permission
+     * 2. Fetches current user data
+     * 3. Toggles subscription (null = unsubscribed, timestamp = subscribed)
+     * 4. Persists updated subscriptions map
+     *
+     * @param roomId - ID of the room to toggle subscription for
+     */
+    async toggleRoomSubscription(a) {
+      if (!(!r || !n)) {
+        if (!t().canPerformAction("canSubscribeToRoom")) {
+          console.warn("Permission denied: canSubscribeToRoom is false");
+          return;
+        }
+        try {
+          const c = await t().findUserById(n);
+          if (!c)
+            return;
+          const d = { ...c.subscriptions };
+          if (a in d && d[a] !== null)
+            d[a] = null;
+          else {
+            const y = (/* @__PURE__ */ new Date()).toISOString();
+            d[a] = y;
+          }
+          await t().updateUser({
+            _id: n,
+            subscriptions: d
+          });
+        } catch (c) {
+          console.error("Error in toggleRoomSubscription:", c);
+        }
+      }
+    }
+  };
+  if (r) {
+    const a = `SELECT * FROM ${s} WHERE _id = :id`, c = `SELECT * FROM ${s}`, d = { id: n };
+    o.userSubscription = r.sync.registerSubscription(
+      a,
+      d
+    ), o.userObserver = r.store.registerObserver(
+      a,
+      (y) => {
+        e({ currentUser: y.items?.[0]?.value });
+      },
+      d
+    ), o.allUsersSubscription = r.sync.registerSubscription(c), o.allUsersObserver = r.store.registerObserver(
+      c,
+      (y) => {
+        e({
+          allUsers: y.items.map((p) => p.value),
+          usersLoading: !1
+        });
+      }
+    );
+  }
+  return o;
+}, Ie = 30, ft = 1e4, G = 282, mt = (e, t, {
+  ditto: r,
+  userId: n,
+  userCollectionKey: s,
+  retentionDays: o,
+  notificationHandler: a
+}) => {
+  const c = async (i) => {
+    if (!r)
+      throw new Error("Ditto not initialized");
+    const u = await r.store.execute(
+      `SELECT * FROM ${i.collectionId || "rooms"} WHERE _id = :id`,
+      { id: i._id }
+    );
+    if (u.items.length === 0)
+      throw new Error("Room not found");
+    return u.items[0].value;
+  }, d = async () => {
+    if (!r || !n)
+      throw new Error("Ditto not initialized or user not found");
+    const u = (await r.store.execute(
+      `SELECT * FROM ${s} WHERE _id = :id`,
+      { id: n }
+    )).items?.[0]?.value;
+    return {
+      id: n,
+      name: u?.name ?? n
+    };
+  }, y = () => {
+    e((i) => C(i, (u) => {
+      u.messagesLoading = !u.rooms.every(
+        (l) => l._id in u.messagesByRoom
+      );
+    }));
+  }, p = (i, u, l, f) => {
+    const m = {
+      message: l,
+      user: f,
+      id: l._id
+    }, g = {
+      ...m,
+      message: m.message,
+      user: m.user
+    }, b = i.findIndex((h) => h.id === l._id);
+    if (b === -1 && !l.archivedMessage && S(l, u) && a && t().activeRoomId !== u._id) {
+      const _ = f?.name || "Unknown User", w = u.name, D = u.collectionId === "dm_rooms" ? `New message from ${_}` : `#${w}: ${_}`, A = l.text ? l.text.substring(0, 30) + (l.text.length > 30 ? "..." : "") : "Sent an attachment";
+      a(D, A);
+    }
+    if (l.archivedMessage) {
+      const h = i.findIndex(
+        (_) => _.id === l.archivedMessage
+      );
+      h !== -1 ? i[h] = g : b === -1 ? i.push(g) : i[b] = g;
+    } else
+      b === -1 ? i.push(g) : i[b] = g;
+  }, S = (i, u) => {
+    const f = t().currentUser, m = i.userId === f?._id, g = new Date(i.createdOn).getTime() > Date.now() - ft, b = f?.subscriptions?.[u._id], h = i.mentions?.some(
+      (w) => w.userId === f?._id
+    ), _ = u.collectionId === "dm_rooms";
+    return !m && g && (b || _ || h);
+  }, x = async (i, u, l = "") => {
+    if (!r || !n)
+      throw new Error("Ditto not initialized or user not found");
+    const f = await c(i), m = u._id || Ne(), g = {
+      _id: m,
+      roomId: i._id,
+      userId: n,
+      createdOn: (/* @__PURE__ */ new Date()).toISOString(),
+      isArchived: !1,
+      archivedMessage: null,
+      largeImageToken: null,
+      thumbnailImageToken: null,
+      fileAttachmentToken: null,
+      isEdited: !1,
+      isDeleted: !1,
+      ...u,
+      mentions: u.mentions?.map((h) => ({ ...h })) || [],
+      reactions: u.reactions?.map((h) => ({ ...h })) || []
+    }, b = l ? `COLLECTION ${f.messagesId} ${l}` : f.messagesId;
+    if (await r.store.execute(
+      `INSERT INTO ${b} DOCUMENTS (:newDoc) ON ID CONFLICT DO UPDATE`,
+      { newDoc: g }
+    ), u.mentions && u.mentions.length > 0) {
+      const h = t().allUsers;
+      await Promise.all(
+        u.mentions.map((_) => {
+          const w = h.find((D) => D._id === _.userId);
+          if (!w)
+            return;
+          const R = {
+            ...w.mentions || {},
+            [i._id]: [...w.mentions?.[i._id] || [], m]
+          };
+          return r.store.execute(
+            "UPDATE users SET mentions = :mentions WHERE _id = :id",
+            { id: w._id, mentions: R }
+          );
+        })
+      );
+    }
+    return g;
+  }, L = async (i, u, l) => {
+    if (!r)
+      throw new Error("Ditto not initialized");
+    return await r.store.execute(
+      `UPDATE ${u.messagesId} SET isArchived = :isArchived WHERE _id = :id`,
+      { id: i._id, isArchived: !0 }
+    ), x(u, {
+      text: "",
+      createdOn: i.createdOn,
+      archivedMessage: i._id,
+      ...l
+    });
+  }, de = async (i, u, l, f) => {
+    if (!r || !n)
+      throw new Error("Ditto not initialized or user not found");
+    const m = await d(), g = {
+      thumbnailImageToken: null,
+      largeImageToken: null,
+      fileAttachmentToken: null
+    };
+    if (f === "image") {
+      const h = await dt(u), _ = await De(h), w = new Uint8Array(await _.arrayBuffer());
+      g.thumbnailImageToken = await r.store.newAttachment(
+        w,
+        se(m.id, m.name, "thumbnail", u)
+      );
+      const R = await De(await ke(u)), D = new Uint8Array(await R.arrayBuffer());
+      g.largeImageToken = await r.store.newAttachment(
+        D,
+        se(m.id, m.name, "large", u)
+      );
+    } else {
+      const h = new Uint8Array(await u.arrayBuffer());
+      g.fileAttachmentToken = await r.store.newAttachment(
+        h,
+        se(m.id, m.name, "file", u)
+      );
+    }
+    const b = f === "image" ? "(thumbnailImageToken ATTACHMENT, largeImageToken ATTACHMENT)" : "(fileAttachmentToken ATTACHMENT)";
+    await x(
+      i,
+      {
+        text: l || (f === "file" ? u.name : ""),
+        ...g
+      },
+      b
+    );
+  };
+  return {
+    messagesLoading: !0,
+    messagesByRoom: {},
+    messageObserversByRoom: {},
+    messageSubscriptionsByRoom: {},
+    notificationHandler: null,
+    /**
+     * Register a notification handler for new messages.
+     *
+     * This method sets up a callback to be invoked when new messages
+     * arrive and meet notification criteria (subscribed rooms, mentions, DMs).
+     *
+     * Use case: Displaying toast notifications or browser notifications
+     *
+     * @param handler - Callback function receiving (title, preview) parameters
+     */
+    registerNotificationHandler(i) {
+      e({ notificationHandler: i });
+    },
+    /**
+     * Subscribe to and observe messages for a room.
+     *
+     * This method sets up real-time sync and observation for messages in a room.
+     * It's automatically called for each room when the chat store initializes.
+     *
+     * Workflow:
+     * 1. Validates Ditto is initialized and no existing subscription
+     * 2. Calculates retention date based on room/global settings
+     * 3. Creates sync subscription for message documents
+     * 4. Sets up store observer to update state on changes
+     * 5. Triggers notifications for new messages from other users
+     *
+     * @param room - Room to subscribe to messages for
+     * @param retentionDays - Optional override for message retention period
+     */
+    async messagesPublisher(i, u) {
+      if (!r)
+        return;
+      const l = i._id;
+      if (t().messageSubscriptionsByRoom[l])
+        return;
+      const f = u ?? i.retentionDays ?? o ?? Ie, m = new Date(
+        Date.now() - f * 24 * 60 * 60 * 1e3
+      ), g = `SELECT * FROM COLLECTION ${i.messagesId} (thumbnailImageToken ATTACHMENT, largeImageToken ATTACHMENT, fileAttachmentToken ATTACHMENT)
+        WHERE roomId = :roomId AND createdOn >= :date AND isArchived = false
+        ORDER BY createdOn ASC`, b = {
+        roomId: i._id,
+        date: m.toISOString()
+      };
+      try {
+        const h = r.sync.registerSubscription(g, b), _ = t().allUsers, w = r.store.registerObserver(
+          g,
+          async (R) => {
+            e((D) => C(D, (A) => {
+              if (A.messagesByRoom[i._id] || (A.messagesByRoom[i._id] = []), R.items.length === 0)
+                return A;
+              for (const v of R.items) {
+                const $ = v.value, j = A.messagesByRoom[i._id], J = _.find((K) => K._id === $.userId);
+                p(j, i, $, J);
+              }
+              return A;
+            })), y();
+          },
+          b
+        );
+        e({
+          messageSubscriptionsByRoom: {
+            ...t().messageSubscriptionsByRoom,
+            [l]: h
+          },
+          messageObserversByRoom: {
+            ...t().messageObserversByRoom,
+            [l]: w
+          }
+        });
+      } catch (h) {
+        console.error("Error in messagesPublisher:", h);
+      }
+    },
+    /**
+     * Subscribe to messages for a specific room on-demand.
+     *
+     * This method enables dynamic subscription management for generated rooms.
+     * Unlike messagesPublisher which is called automatically for all rooms,
+     * this method is explicitly called when a component mounts to view a room.
+     *
+     * Workflow:
+     * 1. Validates Ditto is initialized
+     * 2. Checks for existing subscription (prevents duplicates)
+     * 3. Creates subscription and observer using same logic as messagesPublisher
+     * 4. Stores subscription/observer references in state
+     *
+     * Use case: ChatView component mounting to display a generated room
+     *
+     * @param roomId - Room ID to subscribe to
+     * @param messagesId - Collection ID for messages ("messages" or "dm_messages")
+     * @param retentionDays - Optional message retention override
+     */
+    async subscribeToRoomMessages(i, u, l) {
+      if (!r || t().messageSubscriptionsByRoom[i])
+        return;
+      const f = l ?? o ?? Ie, m = new Date(
+        Date.now() - f * 24 * 60 * 60 * 1e3
+      ), g = `SELECT * FROM COLLECTION ${u} (thumbnailImageToken ATTACHMENT, largeImageToken ATTACHMENT, fileAttachmentToken ATTACHMENT)
+        WHERE roomId = :roomId AND createdOn >= :date AND isArchived = false
+        ORDER BY createdOn ASC`, b = {
+        roomId: i,
+        date: m.toISOString()
+      };
+      try {
+        const h = r.sync.registerSubscription(g, b), _ = t().allUsers, w = r.store.registerObserver(
+          g,
+          async (R) => {
+            const D = {
+              _id: i,
+              name: "",
+              messagesId: u,
+              collectionId: "rooms",
+              createdBy: "",
+              createdOn: "",
+              isGenerated: !0
+            };
+            e((A) => C(A, (v) => {
+              if (v.messagesByRoom[i] || (v.messagesByRoom[i] = []), R.items.length === 0)
+                return v;
+              for (const $ of R.items) {
+                const j = $.value, J = v.messagesByRoom[i], K = _.find((Be) => Be._id === j.userId);
+                p(J, D, j, K);
+              }
+              return v;
+            })), y();
+          },
+          b
+        );
+        e({
+          messageSubscriptionsByRoom: {
+            ...t().messageSubscriptionsByRoom,
+            [i]: h
+          },
+          messageObserversByRoom: {
+            ...t().messageObserversByRoom,
+            [i]: w
+          }
+        });
+      } catch (h) {
+        console.error("Error in subscribeToRoomMessages:", h);
+      }
+    },
+    /**
+     * Unsubscribe from messages for a specific room.
+     *
+     * This method cleans up subscriptions when a component unmounts.
+     * Essential for preventing memory leaks with dynamic subscriptions.
+     *
+     * Workflow:
+     * 1. Retrieves subscription and observer from state
+     * 2. Cancels subscription (stops sync)
+     * 3. Cancels observer (stops state updates)
+     * 4. Removes messages from state
+     * 5. Removes subscription/observer references from state
+     *
+     * Use case: ChatView component unmounting after viewing a generated room
+     *
+     * @param roomId - Room ID to unsubscribe from
+     */
+    unsubscribeFromRoomMessages(i) {
+      const u = t().messageSubscriptionsByRoom[i], l = t().messageObserversByRoom[i];
+      u && !u.isCancelled && u.cancel(), l && !l.isCancelled && l.cancel(), e((f) => C(f, (m) => (delete m.messagesByRoom[i], delete m.messageSubscriptionsByRoom[i], delete m.messageObserversByRoom[i], m)));
+    },
+    /**
+     * Create a new text message in a room.
+     *
+     * This method creates and persists a new message document with optional mentions.
+     * Mention permission is checked before including mentions in the message.
+     *
+     * Workflow:
+     * 1. Validates Ditto connection and user
+     * 2. Checks mention permission if mentions provided
+     * 3. Creates message document with text and filtered mentions
+     * 4. Updates mentioned users' mention records
+     *
+     * @param room - Room to create message in
+     * @param text - Message text content
+     * @param mentions - Optional array of user mentions
+     */
+    async createMessage(i, u, l = []) {
+      if (!r || !n)
+        return;
+      const f = t().canPerformAction("canMentionUsers"), m = l.length > 0 && !f ? [] : l;
+      l.length > 0 && !f && console.warn("Permission denied: canMentionUsers is false");
+      try {
+        await x(i, {
+          text: u,
+          mentions: m
+        });
+      } catch (g) {
+        console.error("Error in createMessage:", g);
+      }
+    },
+    /**
+     * Save edits to an existing message.
+     *
+     * This method archives the original message and creates a new version
+     * with updated content while preserving attachments and reactions.
+     *
+     * Workflow:
+     * 1. Checks canEditOwnMessage permission
+     * 2. Archives original message (sets isArchived = true)
+     * 3. Creates new message with archivedMessage reference
+     * 4. Preserves attachments, mentions, and reactions
+     *
+     * @param message - Message with updated text content
+     * @param room - Room containing the message
+     */
+    async saveEditedTextMessage(i, u) {
+      if (!t().canPerformAction("canEditOwnMessage")) {
+        console.warn("Permission denied: canEditOwnMessage is false");
+        return;
+      }
+      try {
+        await L(i, u, {
+          text: i.text,
+          largeImageToken: i.largeImageToken || null,
+          thumbnailImageToken: i.thumbnailImageToken || null,
+          fileAttachmentToken: i.fileAttachmentToken || null,
+          isEdited: !0,
+          isDeleted: !1,
+          mentions: i.mentions,
+          reactions: i.reactions
+        });
+      } catch (l) {
+        console.error("Error in saveEditedTextMessage:", l);
+      }
+    },
+    /**
+     * Soft-delete a message by replacing its content.
+     *
+     * This method archives the original message and creates a placeholder
+     * indicating deletion. Attachments are removed and content is replaced.
+     *
+     * Workflow:
+     * 1. Checks canDeleteOwnMessage permission
+     * 2. Archives original message
+     * 3. Creates replacement with "[deleted ...]" text
+     * 4. Removes all attachments and mentions
+     *
+     * @param message - Message to delete
+     * @param room - Room containing the message
+     * @param type - Type of content: 'text', 'image', or 'file'
+     */
+    async saveDeletedMessage(i, u, l = "text") {
+      if (!t().canPerformAction("canDeleteOwnMessage")) {
+        console.warn("Permission denied: canDeleteOwnMessage is false");
+        return;
+      }
+      const f = {
+        text: "[deleted message]",
+        image: "[deleted image]",
+        file: "[deleted file]"
+      }[l];
+      try {
+        await L(i, u, {
+          text: f,
+          createdOn: (/* @__PURE__ */ new Date()).toISOString(),
+          largeImageToken: null,
+          thumbnailImageToken: null,
+          fileAttachmentToken: null,
+          isEdited: !1,
+          isDeleted: !0,
+          mentions: []
+        });
+      } catch (m) {
+        console.error("Error in saveDeletedMessage:", m);
+      }
+    },
+    /**
+     * Create a message with an image attachment.
+     *
+     * This method creates a message with both thumbnail and full-size
+     * image attachments for efficient loading in the UI.
+     *
+     * Workflow:
+     * 1. Creates thumbnail version of image
+     * 2. Uploads both thumbnail and large image as attachments
+     * 3. Creates message document with attachment tokens
+     *
+     * @param room - Room to create message in
+     * @param imageFile - Image file to attach
+     * @param text - Optional caption text
+     */
+    async createImageMessage(i, u, l) {
+      try {
+        await de(i, u, l, "image");
+      } catch (f) {
+        console.error("Error in createImageMessage:", f);
+      }
+    },
+    /**
+     * Create a message with a file attachment.
+     *
+     * This method uploads a file and creates a message with the
+     * file attachment token. The filename is used as default text.
+     *
+     * Workflow:
+     * 1. Uploads file as attachment with metadata
+     * 2. Creates message document with file attachment token
+     * 3. Uses filename as message text if not provided
+     *
+     * @param room - Room to create message in
+     * @param file - File to attach
+     * @param text - Optional text (defaults to filename)
+     */
+    async createFileMessage(i, u, l) {
+      try {
+        await de(i, u, l, "file");
+      } catch (f) {
+        console.error("Error in createFileMessage:", f);
+      }
+    },
+    /**
+     * Fetch attachment data with progress tracking.
+     *
+     * This method downloads attachment data from Ditto's attachment store,
+     * providing progress updates during download and handling various states.
+     *
+     * Workflow:
+     * 1. Validates Ditto and token are available
+     * 2. Initiates attachment fetch with event handler
+     * 3. Reports progress via onProgress callback
+     * 4. Returns data and metadata on completion
+     * 5. Handles deletion and error states
+     *
+     * @param token - Attachment token from message
+     * @param onProgress - Callback receiving progress (0-1)
+     * @param onComplete - Callback receiving AttachmentResult
+     */
+    fetchAttachment(i, u, l) {
+      if (!r) {
+        l({
+          success: !1,
+          error: new Error("Ditto not initialized")
+        });
+        return;
+      }
+      if (!i) {
+        l({
+          success: !1,
+          error: new Error("No attachment token provided")
+        });
+        return;
+      }
+      try {
+        r.store.fetchAttachment(i, async (f) => {
+          switch (f.type) {
+            case "Progress": {
+              const m = Number(f.downloadedBytes) / (Number(f.totalBytes) || 1);
+              u(m);
+              break;
+            }
+            case "Completed":
+              try {
+                const m = f.attachment.getData(), g = m instanceof Promise ? await m : m;
+                l({
+                  success: !0,
+                  data: g,
+                  metadata: f.attachment.metadata || {}
+                });
+              } catch (m) {
+                l({
+                  success: !1,
+                  error: m instanceof Error ? m : new Error("Unknown error getting attachment data")
+                });
+              }
+              break;
+            case "Deleted":
+              l({
+                success: !1,
+                error: new Error("Attachment was deleted")
+              });
+              break;
+          }
+        });
+      } catch (f) {
+        l({
+          success: !1,
+          error: f instanceof Error ? f : new Error("Failed to fetch attachment")
+        });
+      }
+    },
+    /**
+     * Updates message reactions using an optimistic update pattern.
+     *
+     * This function implements optimistic UI updates to provide instant feedback
+     * to users without waiting for database operations to complete. The pattern
+     * works in two phases:
+     *
+     * 1. **Optimistic Update (Immediate)**:
+     *    - Updates the local state immediately with the new reactions
+     *    - Provides instant UI feedback for a responsive user experience
+     *    - Users see their reaction changes without any delay
+     *
+     * 2. **Database Persistence (Async)**:
+     *    - Asynchronously persists the changes to the Ditto database
+     *    - If the database update fails, automatically rolls back the UI changes
+     *    - Restores the previous reactions state to maintain data consistency
+     *
+     * This approach ensures:
+     * - Quick UI interactions without perceived latency
+     * - Data consistency through automatic rollback on errors
+     * - Better user experience compared to waiting for DB operations
+     *
+     * @param message - The message whose reactions are being updated
+     * @param room - The room containing the message
+     * @param reactions - The new array of reactions to apply
+     */
+    async updateMessageReactions(i, u, l) {
+      if (!r || !n)
+        return;
+      const f = u._id, m = t().messagesByRoom[f] || [], g = m.findIndex((_) => _.id === i._id);
+      if (g === -1)
+        throw new Error("Message not found");
+      const b = m[g].message, h = b.reactions || [];
+      e(
+        (_) => C(_, (w) => {
+          w.messagesByRoom[f][g].message.reactions = l;
+        })
+      ), setTimeout(async () => {
+        try {
+          await r.store.execute(
+            `UPDATE ${u.messagesId} SET reactions = :reactions WHERE _id = :id`,
+            { id: b._id, reactions: l }
+          );
+        } catch (_) {
+          console.error("Error updating reactions, rolling back:", _), e(
+            (w) => C(w, (R) => {
+              R.messagesByRoom[f][g].message.reactions = h;
+            })
+          );
+        }
+      }, 0);
+    },
+    /**
+     * Add a reaction to a message.
+     *
+     * This method adds a new reaction to a message's reactions array
+     * using optimistic updates for instant UI feedback.
+     *
+     * Workflow:
+     * 1. Checks canAddReaction permission
+     * 2. Finds message in state
+     * 3. Appends reaction to existing reactions
+     * 4. Calls updateMessageReactions for optimistic update
+     *
+     * @param message - Message to add reaction to
+     * @param room - Room containing the message
+     * @param reaction - Reaction object with emoji and userId
+     */
+    async addReactionToMessage(i, u, l) {
+      if (!r || !n)
+        return;
+      if (!t().canPerformAction("canAddReaction")) {
+        console.warn("Permission denied: canAddReaction is false");
+        return;
+      }
+      const f = t().messagesByRoom[u._id], m = f.findIndex((h) => h.id === i._id);
+      if (m === -1)
+        throw new Error("Message not found");
+      const g = f[m].message, b = [...g.reactions || [], l];
+      await t().updateMessageReactions(g, u, b);
+    },
+    /**
+     * Remove a reaction from a message.
+     *
+     * This method removes a user's reaction from a message using
+     * optimistic updates for instant UI feedback.
+     *
+     * Workflow:
+     * 1. Checks canRemoveOwnReaction permission
+     * 2. Finds message in state
+     * 3. Filters out matching reaction (emoji + userId)
+     * 4. Calls updateMessageReactions for optimistic update
+     *
+     * @param message - Message to remove reaction from
+     * @param room - Room containing the message
+     * @param reaction - Reaction to remove (matched by emoji and userId)
+     */
+    async removeReactionFromMessage(i, u, l) {
+      if (!r || !n)
+        return;
+      if (!t().canPerformAction("canRemoveOwnReaction")) {
+        console.warn("Permission denied: canRemoveOwnReaction is false");
+        return;
+      }
+      const f = t().messagesByRoom[u._id], m = f.findIndex((h) => h.id === i._id);
+      if (m === -1)
+        throw new Error("Message not found");
+      const g = f[m].message, b = (g.reactions || []).filter(
+        (h) => !(h.emoji === l.emoji && h.userId === l.userId)
+      );
+      await t().updateMessageReactions(g, u, b);
+    }
+  };
+};
+async function dt(e) {
+  const t = await ke(e), r = document.createElement("canvas"), n = r.getContext("2d");
+  if (!n)
+    throw new Error("Failed to get 2D context");
+  let { width: s, height: o } = t;
+  return s > o ? (o = G / s * o, s = G) : (s = G / o * s, o = G), r.width = s, r.height = o, n.drawImage(t, 0, 0, s, o), r;
+}
+function ke(e) {
+  return new Promise((t, r) => {
+    const n = new FileReader();
+    n.onload = (s) => {
+      const o = new Image();
+      o.onload = () => t(o), o.onerror = r, o.src = String(s.target?.result);
+    }, n.onerror = r, n.readAsDataURL(e);
+  });
+}
+async function De(e) {
+  return new Promise((t, r) => {
+    const n = (s) => {
+      s.toBlob(
+        (o) => o ? t(o) : r(new Error("Failed to convert to blob")),
+        "image/jpeg",
+        1
+      );
+    };
+    if (e instanceof HTMLCanvasElement)
+      n(e);
+    else {
+      const s = document.createElement("canvas");
+      s.width = e.width, s.height = e.height;
+      const o = s.getContext("2d");
+      if (!o) {
+        r(new Error("Failed to get 2D context"));
+        return;
+      }
+      o.drawImage(e, 0, 0), n(s);
+    }
+  });
+}
+function se(e, t, r, n) {
+  const s = (/* @__PURE__ */ new Date()).toISOString(), o = t.replace(/\s/g, "-"), a = s.replace(/:/g, "-"), c = r === "file" ? n.name.split(".").pop() || "bin" : "jpg";
+  return {
+    filename: `${o}_${r}_${a}.${c}`,
+    userId: e,
+    username: t,
+    fileformat: `.${c}`,
+    filesize: n.size.toString(),
+    timestamp: s,
+    originalName: n.name
+  };
+}
+function I(e) {
+  e && !e.isCancelled && e.cancel();
+}
+function ht(e) {
+  const t = Fe(() => (globalThis.__DITTO_CHAT_STORE__ ? console.log("Reusing EXISTING global chatStore instance") : (console.log("Creating NEW global chatStore instance"), globalThis.__DITTO_CHAT_STORE__ = ot()(
+    (r, n) => ({
+      ...st(r, n, e),
+      ...lt(r, n, e),
+      ...mt(r, n, e),
+      ...He(r, n, e),
+      activeRoomId: null,
+      setActiveRoomId: (s) => r({ activeRoomId: s }),
+      chatLogout: () => {
+        const s = n();
+        I(s.roomsSubscription), I(s.roomsObserver), I(s.dmRoomsSubscription), I(s.dmRoomsObserver), Object.values(s.messageSubscriptionsByRoom || {}).map(
+          (o) => I(o)
+        ), Object.values(s.messageObserversByRoom || {}).map(
+          (o) => I(o)
+        ), I(s.userObserver), I(s.userSubscription), I(s.allUsersObserver), I(s.allUsersSubscription);
+      }
+    })
+  )), globalThis.__DITTO_CHAT_STORE__), [e]);
+  return xe(t);
+}
+function bt(e) {
+  if (!globalThis.__DITTO_CHAT_STORE__)
+    throw new Error(
+      "chatStore must be initialized before useDittoChatStore. use useDittoChat for initialization"
+    );
+  const t = ut(
+    e || ((n) => n)
+  );
+  return xe(globalThis.__DITTO_CHAT_STORE__, t);
+}
+function _t() {
+  return globalThis.__DITTO_CHAT_STORE__;
+}
+function wt() {
+  globalThis.__DITTO_CHAT_STORE__ = void 0;
+}
+export {
+  ze as DEFAULT_PERMISSIONS,
+  I as cancelSubscriptionOrObserver,
+  He as createRBACSlice,
+  st as createRoomSlice,
+  _t as getChatStore,
+  wt as resetChatStore,
+  ht as useDittoChat,
+  bt as useDittoChatStore
+};