@snakechat/commskit-node 0.0.0-stage → 0.1.0

package/dist/chunk-6I27CI32.js

@@ -0,0 +1,586 @@
+import {
+  HttpError,
+  dbTimestamp,
+  detectDialect,
+  firstQuery,
+  ok,
+  validationError
+} from "./chunk-GR4PMGCS.js";
+import {
+  iso,
+  pyBool
+} from "./chunk-KLKRK6OG.js";
+import {
+  logger
+} from "./chunk-5BJ2SNM5.js";
+
+// src/moderation/service.ts
+var REPORT_CATEGORIES = ["spam", "harassment", "inappropriate", "fake_profile", "scam", "underage", "other"];
+var REPORT_STATUSES = ["open", "resolved", "dismissed"];
+var MAX_NOTE_CHARS = 4e3;
+var MAX_REASON_CHARS = 2e3;
+var MAX_CATEGORY_CHARS = 64;
+function reportDict(r) {
+  return {
+    report_id: Number(r.id),
+    reporter_id: r.reporter_id ?? null,
+    reported_id: r.reported_id ?? null,
+    reason: r.reason ?? null,
+    category: r.category ?? null,
+    message_id: r.message_id === null || r.message_id === void 0 ? null : Number(r.message_id),
+    status: r.status,
+    created_at: iso(r.created_at),
+    resolved_at: iso(r.resolved_at),
+    resolved_by: r.resolved_by ?? null,
+    note: r.note ?? null
+  };
+}
+var isUniqueViolation = (err) => /unique|duplicate/i.test(String(err?.message ?? err)) || err?.code === "23505";
+var ModerationService = class {
+  constructor(db, dialect) {
+    this.db = db;
+    this.dialect = dialect ?? detectDialect(db);
+  }
+  db;
+  dialect;
+  // --------------------------------------------------------------- blocks
+  /** True if a new block was stored (blocking twice is a no-op). */
+  async block(blockerId, blockedId) {
+    if (await this.hasBlocked(blockerId, blockedId)) return false;
+    try {
+      await this.db.insertInto("comms_blocks").values({ blocker_id: blockerId, blocked_id: blockedId, created_at: dbTimestamp(this.dialect) }).execute();
+    } catch (err) {
+      if (isUniqueViolation(err)) return false;
+      throw err;
+    }
+    return true;
+  }
+  async unblock(blockerId, blockedId) {
+    const r = await this.db.deleteFrom("comms_blocks").where("blocker_id", "=", blockerId).where("blocked_id", "=", blockedId).executeTakeFirst();
+    return Number(r.numDeletedRows) > 0;
+  }
+  async hasBlocked(blockerId, blockedId) {
+    const r = await this.db.selectFrom("comms_blocks").select("id").where("blocker_id", "=", blockerId).where("blocked_id", "=", blockedId).limit(1).executeTakeFirst();
+    return r !== void 0;
+  }
+  /** Either direction. */
+  async isBlockedBetween(userA, userB) {
+    const r = await this.db.selectFrom("comms_blocks").select("id").where(
+      (eb) => eb.or([
+        eb.and([eb("blocker_id", "=", userA), eb("blocked_id", "=", userB)]),
+        eb.and([eb("blocker_id", "=", userB), eb("blocked_id", "=", userA)])
+      ])
+    ).limit(1).executeTakeFirst();
+    return r !== void 0;
+  }
+  /** `{otherId: [isBlocked, blockedByOther]}` for ids with any block. */
+  async blockStatus(viewerId, otherIds) {
+    const ids = [...new Set(otherIds)].filter(Boolean);
+    if (!ids.length) return {};
+    const rows = await this.db.selectFrom("comms_blocks").select(["blocker_id", "blocked_id"]).where(
+      (eb) => eb.or([
+        eb.and([eb("blocker_id", "=", viewerId), eb("blocked_id", "in", ids)]),
+        eb.and([eb("blocked_id", "=", viewerId), eb("blocker_id", "in", ids)])
+      ])
+    ).execute();
+    const status = {};
+    for (const { blocker_id: blocker, blocked_id: blocked } of rows) {
+      if (blocker === viewerId) {
+        const cur = status[blocked] ?? [false, false];
+        status[blocked] = [true, cur[1]];
+      } else {
+        const cur = status[blocker] ?? [false, false];
+        status[blocker] = [cur[0], true];
+      }
+    }
+    return status;
+  }
+  /** `[blockedId, blockedAt]`, newest first. */
+  async listBlocked(blockerId) {
+    const rows = await this.db.selectFrom("comms_blocks").select(["blocked_id", "created_at"]).where("blocker_id", "=", blockerId).orderBy("created_at", "desc").orderBy("id", "desc").execute();
+    return rows.map((r) => [r.blocked_id, r.created_at]);
+  }
+  // -------------------------------------------------------------- reports
+  async createReport(reporterId, reportedId, opts = {}) {
+    const reason = opts.reason === null || opts.reason === void 0 ? null : String(opts.reason).trim().slice(0, MAX_REASON_CHARS) || null;
+    const category = opts.category === null || opts.category === void 0 ? null : String(opts.category).trim().toLowerCase().slice(0, MAX_CATEGORY_CHARS) || null;
+    const messageId = opts.messageId ?? null;
+    const now = /* @__PURE__ */ new Date();
+    const r = await this.db.insertInto("comms_reports").values({ reporter_id: reporterId, reported_id: reportedId, reason, category, message_id: messageId, status: "open", created_at: dbTimestamp(this.dialect, now) }).returning("id").executeTakeFirstOrThrow();
+    return { id: Number(r.id), reporter_id: reporterId, reported_id: reportedId, reason, category, message_id: messageId, status: "open", created_at: now, blocked: false };
+  }
+  // --------------------------------------------------------- admin review
+  async getReport(reportId) {
+    const row = await this.db.selectFrom("comms_reports").selectAll().where("id", "=", reportId).executeTakeFirst();
+    return row ? reportDict(row) : null;
+  }
+  /** Newest first; `status` filters (open | resolved | dismissed). */
+  async listReports(status, limit = 50, offset = 0) {
+    let q = this.db.selectFrom("comms_reports").selectAll();
+    if (status) q = q.where("status", "=", status);
+    const rows = await q.orderBy("created_at", "desc").orderBy("id", "desc").limit(limit).offset(offset).execute();
+    return rows.map(reportDict);
+  }
+  /** Set a report to resolved / dismissed (or back to open). Null if it doesn't exist; throws Error on a bad status. */
+  async resolveReport(reportId, status, resolvedBy = null, note = null) {
+    if (!REPORT_STATUSES.includes(status)) throw new Error(`status must be one of: ${REPORT_STATUSES.join(", ")}`);
+    const row = await this.db.selectFrom("comms_reports").selectAll().where("id", "=", reportId).executeTakeFirst();
+    if (!row) return null;
+    const patch = { status };
+    if (status === "open") {
+      patch.resolved_at = null;
+      patch.resolved_by = null;
+    } else {
+      patch.resolved_at = dbTimestamp(this.dialect);
+      patch.resolved_by = resolvedBy === null || resolvedBy === void 0 ? null : String(resolvedBy).slice(0, 50) || null;
+    }
+    if (note !== null && note !== void 0) patch.note = String(note).trim().slice(0, MAX_NOTE_CHARS) || null;
+    await this.db.updateTable("comms_reports").set(patch).where("id", "=", reportId).execute();
+    return reportDict({ ...row, ...patch });
+  }
+  // ------------------------------------------------------------- deletion
+  /**
+   * Account deletion: drop every block involving `userId`; keep reports (moderation history) but replace the user's id
+   * with NULL as reporter and as reported user. Use a transaction handle (`trx`) for `db` to make it atomic.
+   */
+  async deleteUserData(userId) {
+    const blocks = await this.db.deleteFrom("comms_blocks").where((eb) => eb.or([eb("blocker_id", "=", userId), eb("blocked_id", "=", userId)])).executeTakeFirst();
+    const asReporter = await this.db.updateTable("comms_reports").set({ reporter_id: null }).where("reporter_id", "=", userId).executeTakeFirst();
+    const asReported = await this.db.updateTable("comms_reports").set({ reported_id: null }).where("reported_id", "=", userId).executeTakeFirst();
+    return { blocks: Number(blocks.numDeletedRows), reports_anonymized: Number(asReporter.numUpdatedRows) + Number(asReported.numUpdatedRows) };
+  }
+};
+
+// src/moderation/handlers.ts
+var BLOCKED_TEXT = "User blocked successfully";
+var BLOCKED_BY_TEXT = "You have been blocked by this user";
+var UNBLOCKED_TEXT = "User unblocked successfully";
+var UNBLOCKED_BY_TEXT = "You have been unblocked by this user";
+var moderationError = (error, extra = {}) => ({
+  type: "error",
+  error,
+  ...extra,
+  context: "moderation"
+});
+var ModerationError = class extends Error {
+};
+function targetId(userId, value) {
+  if (value === null || value === void 0 || String(value).trim() === "") {
+    throw new ModerationError("Missing required fields: candidate_user_id");
+  }
+  const target = String(value).trim();
+  if (target === userId) throw new ModerationError("You cannot block or report yourself.");
+  return target;
+}
+function messageIdOf(value) {
+  if (value === null || value === void 0 || value === "") return null;
+  const s = String(value).trim();
+  if (!/^[+-]?\d+$/.test(s)) throw new ModerationError("message_id must be an integer");
+  return Number(s);
+}
+var ModerationActions = class {
+  constructor(feature) {
+    this.feature = feature;
+  }
+  feature;
+  get hub() {
+    return this.feature.hub;
+  }
+  async block(db, userId, target) {
+    const created = await new ModerationService(db, this.hub.dialect).block(userId, target);
+    await this.hub.send(userId, { type: "user_blocked", candidate_user_id: target, message: BLOCKED_TEXT });
+    if (this.feature.notifyBlockedUser) {
+      await this.hub.send(target, { type: "blocked_by_user", candidate_user_id: userId, message: BLOCKED_BY_TEXT });
+    }
+    await this.hub.events.emit("moderation.blocked", userId, target);
+    return created;
+  }
+  async unblock(db, userId, target) {
+    const removed = await new ModerationService(db, this.hub.dialect).unblock(userId, target);
+    await this.hub.send(userId, { type: "user_unblocked", candidate_user_id: target, message: UNBLOCKED_TEXT });
+    if (this.feature.notifyBlockedUser && removed) {
+      await this.hub.send(target, { type: "unblocked_by_user", candidate_user_id: userId, message: UNBLOCKED_BY_TEXT });
+    }
+    if (removed) await this.hub.events.emit("moderation.unblocked", userId, target);
+    return removed;
+  }
+  async report(db, userId, target, opts = {}) {
+    let info = await new ModerationService(db, this.hub.dialect).createReport(userId, target, {
+      reason: opts.reason === null || opts.reason === void 0 ? null : String(opts.reason),
+      category: opts.category === null || opts.category === void 0 ? null : String(opts.category),
+      messageId: messageIdOf(opts.messageId)
+    });
+    if (opts.block ?? true) {
+      await this.block(db, userId, target);
+      info = { ...info, blocked: true };
+    }
+    await this.hub.send(userId, { type: "report_received", report_id: info.id, candidate_user_id: target });
+    await this.hub.events.emit("moderation.reported", info);
+    const hook = this.feature.onReport;
+    if (hook) {
+      const reported = info;
+      this.hub.spawn(async () => {
+        try {
+          await hook(reported);
+        } catch (err) {
+          logger.error(`onReport hook failed for report ${reported.id}`, err);
+        }
+      });
+    }
+    return info;
+  }
+};
+var ModerationHandlers = class {
+  constructor(feature) {
+    this.feature = feature;
+  }
+  feature;
+  get hub() {
+    return this.feature.hub;
+  }
+  register() {
+    this.hub.on("report_and_block", this.guard((u, m, db) => this.reportAndBlock(u, m, db), "Failed to report user"));
+    this.hub.on("block", this.guard((u, m, db) => this.block(u, m, db), "Failed to block user"));
+    this.hub.on("unblock", this.guard((u, m, db) => this.unblock(u, m, db), "Failed to unblock user"));
+  }
+  guard(fn, label) {
+    return async (userId, message, db) => {
+      try {
+        await fn(userId, message, db);
+      } catch (err) {
+        if (err instanceof ModerationError) {
+          await this.hub.send(userId, moderationError(err.message));
+          return;
+        }
+        logger.error(`${message.type} handler failed`, err);
+        await this.hub.reportHandlerError(userId, message, err);
+        await this.hub.send(userId, moderationError(`${label}: ${err?.message ?? err}`));
+      }
+    };
+  }
+  async reportAndBlock(userId, message, db) {
+    const target = targetId(userId, message.candidate_user_id);
+    await this.feature.actions.report(db, userId, target, {
+      reason: message.reason,
+      category: message.category,
+      messageId: message.message_id,
+      block: message.block !== false
+    });
+  }
+  async block(userId, message, db) {
+    await this.feature.actions.block(db, userId, targetId(userId, message.candidate_user_id));
+  }
+  async unblock(userId, message, db) {
+    await this.feature.actions.unblock(db, userId, targetId(userId, message.candidate_user_id));
+  }
+};
+
+// src/moderation/policy.ts
+var CHAT_REFUSAL = "Cannot send message. User is blocked.";
+var CALL_REFUSAL = "Cannot call. User is blocked.";
+var ModerationChatPolicy = class {
+  constructor(inner = null, blockedMessage = CHAT_REFUSAL) {
+    this.inner = inner;
+    this.blockedMessage = blockedMessage;
+  }
+  inner;
+  blockedMessage;
+  /**
+   * The chat feature reads `refusalMessage` right after `canMessage` returned false; `lastRefusal` remembers whose refusal
+   * it was (the block list or the inner policy). Both messages are constant per policy, so concurrent frames cannot mix
+   * up different texts except when the host policy's message differs from the block text.
+   */
+  lastRefusal = null;
+  get refusalMessage() {
+    return this.lastRefusal ?? this.inner?.refusalMessage ?? this.blockedMessage;
+  }
+  async canMessage(db, senderId, recipientId) {
+    if (await new ModerationService(db).isBlockedBetween(senderId, recipientId)) {
+      this.lastRefusal = this.blockedMessage;
+      return false;
+    }
+    if (this.inner && !await this.inner.canMessage(db, senderId, recipientId)) {
+      this.lastRefusal = this.inner.refusalMessage || this.blockedMessage;
+      return false;
+    }
+    this.lastRefusal = null;
+    return true;
+  }
+  /** Kit block list OR the inner policy's (e.g. a legacy host block table). */
+  async blockStatus(db, viewerId, otherIds) {
+    const merged = { ...await new ModerationService(db).blockStatus(viewerId, otherIds) };
+    if (this.inner) {
+      for (const [other, [blocked, byOther]] of Object.entries(await this.inner.blockStatus(db, viewerId, otherIds))) {
+        const mine = merged[other] ?? [false, false];
+        merged[other] = [mine[0] || Boolean(blocked), mine[1] || Boolean(byOther)];
+      }
+    }
+    return merged;
+  }
+  async extraConversationInfo(db, viewerId, otherId) {
+    if (this.inner) return this.inner.extraConversationInfo(db, viewerId, otherId);
+    return { chat_consent_given: true };
+  }
+};
+var ModerationCallPolicy = class {
+  constructor(inner = null, blockedMessage = CALL_REFUSAL) {
+    this.inner = inner;
+    this.blockedMessage = blockedMessage;
+  }
+  inner;
+  blockedMessage;
+  async authorize(db, callerId, receiverId, message) {
+    if (await new ModerationService(db).isBlockedBetween(callerId, receiverId)) {
+      return { allowed: false, error: { error: this.blockedMessage, reason: "blocked" } };
+    }
+    if (this.inner) return this.inner.authorize(db, callerId, receiverId, message);
+    return { allowed: true };
+  }
+};
+
+// src/moderation/router.ts
+function bodyObject(ctx) {
+  const b = ctx.body;
+  if (b === null || typeof b !== "object" || Array.isArray(b)) {
+    throw new HttpError(422, [{ type: "missing", loc: ["body"], msg: "Field required", input: null }]);
+  }
+  return b;
+}
+function intParam(where, name, raw, def, min, max) {
+  if (raw === void 0) {
+    if (def === void 0) throw validationError(where, name, "missing", "Field required");
+    return def;
+  }
+  if (!/^\s*[+-]?\d+\s*$/.test(raw)) {
+    throw validationError(where, name, "int_parsing", "Input should be a valid integer, unable to parse string as an integer", raw);
+  }
+  const n = Number(raw);
+  if (min !== void 0 && n < min) throw validationError(where, name, "greater_than_equal", `Input should be greater than or equal to ${min}`, raw);
+  if (max !== void 0 && n > max) throw validationError(where, name, "less_than_equal", `Input should be less than or equal to ${max}`, raw);
+  return n;
+}
+function buildModerationRoutes(feature) {
+  const hub = feature.hub;
+  const actions = feature.actions;
+  const targetOr422 = (userId, value) => {
+    try {
+      return targetId(userId, value);
+    } catch (err) {
+      if (err instanceof ModerationError) throw new HttpError(422, err.message);
+      throw err;
+    }
+  };
+  const routes = [
+    {
+      method: "GET",
+      path: "/moderation/blocks",
+      handler: async (ctx) => {
+        const rows = await new ModerationService(hub.db, hub.dialect).listBlocked(ctx.userId);
+        const profiles = await hub.profiles(rows.map((r) => r[0]));
+        return ok(
+          rows.map(([blockedId, blockedAt]) => {
+            const p = profiles[blockedId];
+            return { user_id: blockedId, username: p?.name ? p.name : blockedId, avatar: p ? p.avatar ?? null : null, blocked_at: iso(blockedAt) };
+          })
+        );
+      }
+    },
+    {
+      method: "POST",
+      path: "/moderation/blocks",
+      handler: async (ctx) => {
+        const target = targetOr422(ctx.userId, bodyObject(ctx).user_id);
+        await actions.block(hub.db, ctx.userId, target);
+        return ok({ status: true });
+      }
+    },
+    {
+      method: "DELETE",
+      path: "/moderation/blocks/:blockedId",
+      handler: async (ctx) => {
+        await actions.unblock(hub.db, ctx.userId, targetOr422(ctx.userId, ctx.params.blockedId));
+        return ok({ status: true });
+      }
+    },
+    {
+      method: "POST",
+      path: "/moderation/reports",
+      handler: async (ctx) => {
+        const p = bodyObject(ctx);
+        const target = targetOr422(ctx.userId, p.user_id);
+        if (p.reason === null || p.reason === void 0 || !String(p.reason).trim()) throw new HttpError(422, "reason is required");
+        try {
+          const info = await actions.report(hub.db, ctx.userId, target, {
+            reason: p.reason,
+            category: p.category,
+            messageId: p.message_id,
+            block: pyBool(p.block ?? false)
+          });
+          return ok({ report_id: info.id });
+        } catch (err) {
+          if (err instanceof ModerationError) throw new HttpError(422, err.message);
+          throw err;
+        }
+      }
+    }
+  ];
+  const admin = feature.adminDependency;
+  if (admin) {
+    routes.push(
+      {
+        method: "GET",
+        path: "/moderation/admin/reports",
+        auth: false,
+        handler: async (ctx) => {
+          await admin(ctx);
+          const status = firstQuery(ctx.query, "status");
+          if (status !== void 0 && !REPORT_STATUSES.includes(status)) {
+            throw new HttpError(422, `status must be one of: ${REPORT_STATUSES.join(", ")}`);
+          }
+          const limit = intParam("query", "limit", firstQuery(ctx.query, "limit"), 50, 1, 200);
+          const offset = intParam("query", "offset", firstQuery(ctx.query, "offset"), 0, 0);
+          return ok(await feature.listReports(status ?? null, { limit, offset }));
+        }
+      },
+      {
+        method: "POST",
+        path: "/moderation/admin/reports/:reportId",
+        auth: false,
+        handler: async (ctx) => {
+          const adminId = await admin(ctx);
+          const reportId = intParam("path", "report_id", ctx.params.reportId);
+          const p = bodyObject(ctx);
+          if (!["resolved", "dismissed", "open"].includes(p.status)) throw new HttpError(422, "status must be resolved or dismissed");
+          const report = await feature.resolveReport(reportId, p.status, {
+            resolvedBy: adminId === null || adminId === void 0 ? null : String(adminId),
+            note: p.note === null || p.note === void 0 ? null : String(p.note)
+          });
+          if (!report) throw new HttpError(404, "Report not found");
+          return ok(report);
+        }
+      },
+      {
+        method: "GET",
+        path: "/moderation/admin/reports/:reportId/context",
+        auth: false,
+        handler: async (ctx) => {
+          await admin(ctx);
+          const reportId = intParam("path", "report_id", ctx.params.reportId);
+          const before = intParam("query", "before", firstQuery(ctx.query, "before"), 20, 0, 200);
+          const after = intParam("query", "after", firstQuery(ctx.query, "after"), 20, 0, 200);
+          const context = await feature.reportContext(reportId, { before, after });
+          if (!context) throw new HttpError(404, "Report not found");
+          return ok(context);
+        }
+      }
+    );
+  }
+  return routes;
+}
+
+// src/moderation/feature.ts
+var ModerationFeature = class {
+  name = "moderation";
+  onReport;
+  notifyBlockedUser;
+  adminDependency;
+  contextProvider;
+  actions;
+  handlers;
+  /** Set by linkModeration. */
+  link = null;
+  _hub = null;
+  constructor(opts = {}) {
+    this.onReport = opts.onReport;
+    this.notifyBlockedUser = opts.notifyBlockedUser ?? true;
+    this.adminDependency = opts.adminDependency;
+    this.contextProvider = opts.contextProvider;
+  }
+  get hub() {
+    if (!this._hub) throw new Error("ModerationFeature is not installed; call hub.install(feature) first");
+    return this._hub;
+  }
+  install(hub) {
+    hub.registerFeature(this.name, this);
+    this._hub = hub;
+    this.actions = new ModerationActions(this);
+    this.handlers = new ModerationHandlers(this);
+    this.handlers.register();
+    hub.includeRoutes(buildModerationRoutes(this));
+    return this;
+  }
+  service(db) {
+    return new ModerationService(db ?? this.hub.db, this.hub.dialect);
+  }
+  // ------------------------------------------------------------ policies
+  /** ChatPolicy: refuses a blocked pair, otherwise asks `inner` (allow-all if null). */
+  chatPolicy(inner = null) {
+    return new ModerationChatPolicy(inner);
+  }
+  /** CallPolicy: denies a blocked pair (`reason: "blocked"`), otherwise `inner`. */
+  callPolicy(inner = null) {
+    return new ModerationCallPolicy(inner);
+  }
+  // -------------------------------------------------------------- queries
+  /** `{otherId: [isBlocked, blockedByOther]}` for `res_users` / `res_messages.info`. */
+  blockStatus(viewerId, otherIds, db) {
+    return this.service(db).blockStatus(viewerId, otherIds);
+  }
+  isBlockedBetween(userA, userB, db) {
+    return this.service(db).isBlockedBetween(userA, userB);
+  }
+  // --------------------------------------------------------- admin review
+  listReports(status = null, opts = {}) {
+    return this.service().listReports(status, opts.limit ?? 50, opts.offset ?? 0);
+  }
+  /** `status`: resolved | dismissed (| open). Null if the report doesn't exist. */
+  async resolveReport(reportId, status, opts = {}) {
+    const report = await this.service().resolveReport(reportId, status, opts.resolvedBy ?? null, opts.note ?? null);
+    if (report) await this.hub.events.emit("moderation.report_resolved", report);
+    return report;
+  }
+  /**
+   * `{report, messages}`: messages around the reported message (or the latest between the pair), newest first, from
+   * `contextProvider` (empty without one, e.g. call-only apps).
+   */
+  async reportContext(reportId, opts = {}) {
+    const report = await this.service().getReport(reportId);
+    if (!report) return null;
+    let messages = [];
+    if (this.contextProvider && report.reporter_id && report.reported_id) {
+      messages = [...await this.contextProvider(report.reporter_id, report.reported_id, report.message_id, Math.max(0, opts.before ?? 20), Math.max(0, opts.after ?? 20))];
+    }
+    return { report, messages };
+  }
+  // ------------------------------------------------------------- deletion
+  /**
+   * Account deletion: blocks involving the user are deleted; reports are kept for the moderation history with the user's
+   * id set to NULL (as reporter and as reported user).
+   */
+  async deleteUserData(userId) {
+    const hub = this.hub;
+    return hub.db.transaction().execute((trx) => new ModerationService(trx, hub.dialect).deleteUserData(String(userId)));
+  }
+};
+
+export {
+  REPORT_CATEGORIES,
+  REPORT_STATUSES,
+  reportDict,
+  ModerationService,
+  BLOCKED_TEXT,
+  BLOCKED_BY_TEXT,
+  UNBLOCKED_TEXT,
+  UNBLOCKED_BY_TEXT,
+  moderationError,
+  ModerationError,
+  targetId,
+  ModerationActions,
+  ModerationHandlers,
+  CHAT_REFUSAL,
+  CALL_REFUSAL,
+  ModerationChatPolicy,
+  ModerationCallPolicy,
+  ModerationFeature
+};
+//# sourceMappingURL=chunk-6I27CI32.js.map