@arken/node 1.5.1 → 1.5.2

package/modules/core/core.service.ts

@@ -1,2824 +0,0 @@
-// arken/packages/node/modules/core/core.service.ts
-//
-import md5 from 'js-md5';
-import type {
-  RouterContext,
-  RouterInput,
-  RouterOutput,
-  Account,
-  Achievement,
-  Act,
-  Agent,
-  Application,
-  Badge,
-  BattlePass,
-  Biome,
-  BiomeFeature,
-  Bounty,
-  Collection,
-  Comment,
-  Community,
-  Company,
-  Conversation,
-  ConversationMessage,
-  Data,
-  Discussion,
-  Energy,
-  Event,
-  File,
-  Galaxy,
-  Guide,
-  Idea,
-  Leaderboard,
-  Log,
-  Lore,
-  Memory,
-  Message,
-  Metaverse,
-  NewsArticle,
-  Npc,
-  Offer,
-  Omniverse,
-  Order,
-  Payment,
-  Party,
-  Permission,
-  Person,
-  Planet,
-  Poll,
-  Project,
-  Proposal,
-  Quest,
-  Rating,
-  Realm,
-  RealmEvent,
-  RealmShard,
-  Revision,
-  Referral,
-  Review,
-  Role,
-  Season,
-  Session,
-  SolarSystem,
-  Star,
-  Stat,
-  Stash,
-  Stock,
-  Suggestion,
-  Tag,
-  Team,
-  Tournament,
-  Trade,
-  Universe,
-  Validator,
-  Vote,
-  WorldEvent,
-  WorldRecord,
-} from './core.types';
-import { Profile } from '../profile/profile.types';
-import { ARXError } from '../../util/rpc';
-import { getFilter } from '../../util/api';
-import { log, logError } from '../../util';
-import { deepMerge } from '../../util/object';
-import { Model } from '../../util/mongo';
-import { isValidRequest, getSignedRequest } from '../../util/web3';
-import type { EntityPatch } from '../../types';
-import { claimMailMessage } from './mail/applyPatchesOrMail';
-import { mailClaimablePatchesBatch } from './mail/mailClaimablePatchesBatch'; // adjust path
-
-export class Service {
-  /**
-   * Claim a message's patch-grant payload via your central handler.
-   */
-  async claimConversationMessage(
-    input: RouterInput['claimConversationMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['claimConversationMessage']> {
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = ctx.client.profile.id;
-    const messageId = String((input as any).messageId);
-    const characterId = (input as any)?.characterId ? String((input as any).characterId) : null;
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-    const Profile = ctx.app.model.Profile;
-
-    // Read message first (for authz + to know conversationId)
-    const msg = await ctx.app.model.ConversationMessage.findById(messageId).lean().exec();
-    if (!msg) throw new Error('Message not found');
-
-    // Must belong to a conversation the user is in
-    const convo = await Conversation.findOne({
-      // @ts-ignore
-      _id: msg.conversationId,
-      $or: [{ profileId }, { 'participants.profileId': profileId }],
-    })
-      .lean()
-      .exec();
-    if (!convo) throw new Error('Not authorized for this message');
-
-    // Load profile doc for applying profile.meta patches
-    const profile = await Profile.findById(profileId).populate('characters').exec();
-    if (!profile) throw new Error('Profile not found');
-
-    // Choose character if needed (claim payload might include character.* patches)
-    let character: any = null;
-    const chars = (profile as any).characters || [];
-    if (characterId) {
-      character = chars.find((c: any) => String(c._id) === characterId) ?? null;
-    } else {
-      character = chars?.[0] ?? null; // keep your current default assumption
-    }
-
-    // ✅ Central claim implementation from applyPatchesOrMail.ts
-    await claimMailMessage({
-      ctx,
-      profile,
-      character: character ?? undefined,
-      messageId,
-    });
-
-    return { ok: true, messageId } as any;
-  }
-
-  async distributeSantaChristmasTicket(
-    input: RouterInput['distributeSantaChristmasTicket'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['distributeSantaChristmasTicket']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    if (!ctx.client?.roles?.includes('admin')) throw new Error('Not authorized');
-
-    const year = 2025;
-    const dedupeKey = input?.dedupeKey || `broadcast:santa-christmas-ticket:${year}`;
-
-    // ✅ This matches your saveRound behavior:
-    // profile.meta.rewards.tokens['christmas' + year] += 1
-    const patches: EntityPatch[] = [
-      {
-        entityType: 'profile.meta',
-        entityId: 'broadcast', // not used for mail application, but keep consistent
-        // IMPORTANT: your applyPatchesWithInventoryViaMail expects this flag
-        // to decide “mail vs immediate”. Broadcast is mail-only.
-        claimable: true as any,
-        ops: [{ op: 'inc', key: `rewards.tokens.christmas${year}`, value: 1 }],
-      } as any,
-    ];
-
-    const result = await mailClaimablePatchesBatch({
-      ctx,
-      streamAllProfiles: true,
-      kind: 'mail',
-      conversationKey: 'system',
-      source: 'core.broadcastSantaChristmasTicket',
-      title: `Holiday Gift 🎁`,
-      body: `You received a Santa Christmas Ticket (${year}). Claim it to add it to your account.`,
-      dedupeKey,
-      claimablePatches: patches,
-      payloadUi: {
-        rewards: [{ type: 'token', id: `christmas${year}`, quantity: 1 }],
-      },
-      batchSize: input?.batchSize ?? 1000,
-    });
-
-    return {
-      ok: true,
-      year,
-      dedupeKey,
-      ...result,
-    } as any;
-  }
-
-  /**
-   * Starred messages for the logged-in user (across all conversations of a kind).
-   *
-   * Assumptions:
-   * - "starred" lives on ConversationMessage.metadata.starred (boolean)
-   *   (also supports metadata.isStarred as a fallback)
-   * - Viewer must be a participant (or legacy profileId owner) of the message's conversation.
-   */
-  async getConversationMessages(
-    input: { where: any; limit?: number; skip?: number; cursor?: string },
-    ctx: RouterContext
-  ) {
-    if (!input) throw new ARXError('NO_INPUT');
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = String(ctx.client.profile.id);
-
-    const baseFilter = getFilter(input); // derived from input.where
-    const limit = Math.min(200, Number(input.limit ?? 50));
-    const skip = Math.max(0, Number(input.skip ?? 0));
-    const cursor = input.cursor ? String(input.cursor) : null;
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-
-    // Pull any conversationId constraint from the filter (if present)
-    // Depending on your getFilter(), this might be:
-    // - a string/ObjectId
-    // - { $in: [...] }
-    // - undefined
-    const requestedConversationId = (baseFilter as any)?.conversationId;
-
-    // If caller is asking for a specific conversation (most common UI path)
-    // then do a direct authz check and only return that conversation's messages.
-    if (requestedConversationId && typeof requestedConversationId !== 'object') {
-      const convo = await Conversation.findOne({
-        _id: requestedConversationId,
-        $or: [{ profileId }, { 'participants.profileId': profileId }],
-      })
-        .select({ _id: 1 })
-        .lean()
-        .exec();
-
-      if (!convo) throw new Error('Not authorized for this conversation');
-
-      const msgFilter: any = {
-        ...baseFilter,
-        conversationId: requestedConversationId, // keep exact constraint
-      };
-
-      if (cursor) msgFilter._id = { $lt: cursor };
-
-      const items = await ctx.app.model.ConversationMessage.findJSON(msgFilter, null, {
-        sort: { _id: -1 },
-        skip,
-        limit,
-      });
-
-      const total = await ctx.app.model.ConversationMessage.countDocumentsFiltered(msgFilter);
-
-      return {
-        items,
-        total,
-        nextCursor: items.length ? String(items[items.length - 1]._id) : null,
-      };
-    }
-
-    // Otherwise: “global” query across all conversations user can access
-    // (needed for starred tab: where: { isStarred: true })
-    const convos = await Conversation.find({
-      $or: [{ profileId }, { 'participants.profileId': profileId }],
-    })
-      .select({ _id: 1 })
-      .lean()
-      .exec();
-
-    const convoIds = convos.map((c: any) => c._id);
-    if (!convoIds.length) return { items: [], total: 0, nextCursor: null };
-
-    // Intersect baseFilter’s conversationId (if it’s an $in) with allowed convos.
-    // If baseFilter.conversationId is something else object-y, we keep it and also constrain with $in.
-    const msgFilter: any = {
-      ...baseFilter,
-      conversationId: { $in: convoIds },
-    };
-
-    // If baseFilter had conversationId: { $in: [...] }, intersect it with allowed convoIds
-    if (requestedConversationId && typeof requestedConversationId === 'object' && requestedConversationId.$in) {
-      const wanted = (requestedConversationId.$in || []).map((x: any) => String(x));
-      const allowed = convoIds.map((x: any) => String(x));
-      const intersection = wanted.filter((id: string) => allowed.includes(id));
-      msgFilter.conversationId = { $in: intersection };
-      if (!intersection.length) return { items: [], total: 0, nextCursor: null };
-    }
-
-    if (cursor) msgFilter._id = { $lt: cursor };
-
-    const items = await ctx.app.model.ConversationMessage.findJSON(msgFilter, null, {
-      sort: { _id: -1 },
-      skip,
-      limit,
-    });
-
-    const total = await ctx.app.model.ConversationMessage.countDocumentsFiltered(msgFilter);
-
-    return {
-      items,
-      total,
-      nextCursor: items.length ? String(items[items.length - 1].id) : null,
-    };
-  }
-
-  async setConversationMessageStar(
-    input: { messageId: string; isStarred: boolean },
-    ctx: RouterContext
-  ): Promise<{ ok: true; messageId: string; isStarred: boolean }> {
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = String(ctx.client.profile.id);
-    const messageId = String(input.messageId);
-    const isStarred = !!input.isStarred;
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-
-    const msg = await ConversationMessage.findById(messageId).lean().exec();
-    if (!msg) throw new Error('Message not found');
-
-    const convo = await Conversation.findOne({
-      // @ts-ignore
-      _id: msg.conversationId,
-      $or: [{ profileId }, { 'participants.profileId': profileId }],
-    })
-      .select({ _id: 1 })
-      .lean()
-      .exec();
-
-    if (!convo) throw new Error('Not authorized for this message');
-
-    await ConversationMessage.updateOne({ _id: messageId }, { $set: { isStarred } }).exec();
-
-    return { ok: true, messageId, isStarred };
-  }
-
-  async distributeSantaChristmasTicketToProfile(
-    input: { profileId: string; dedupeKey?: string },
-    ctx: RouterContext
-  ): Promise<any> {
-    if (!input?.profileId) throw new ARXError('NO_INPUT');
-    if (!ctx.client?.roles?.includes('admin')) throw new Error('Not authorized');
-
-    const year = 2025;
-    const dedupeKey = input?.dedupeKey || `broadcast:santa-christmas-ticket:${year}`;
-
-    const patches: EntityPatch[] = [
-      {
-        entityType: 'profile.meta',
-        entityId: 'broadcast',
-        claimable: true as any,
-        ops: [{ op: 'inc', key: `rewards.tokens.christmas${year}`, value: 1 }],
-      } as any,
-    ];
-
-    // single-target run: use batch helper with explicit profileIds
-    const result = await mailClaimablePatchesBatch({
-      ctx,
-      profileIds: [input.profileId],
-      kind: 'mail',
-      conversationKey: 'system',
-      source: 'core.broadcastSantaChristmasTicket',
-      title: `Holiday Gift 🎁`,
-      body: `You received a Santa Christmas Ticket (${year}). Claim it to add it to your account.`,
-      dedupeKey,
-      claimablePatches: patches,
-      payloadUi: {
-        rewards: [{ type: 'token', id: `christmas${year}`, quantity: 1 }],
-      },
-      batchSize: 1,
-    });
-
-    return {
-      ok: true,
-      year,
-      dedupeKey,
-      profileId: input.profileId,
-      ...result,
-    } as any;
-  }
-  async readAndClaimLatestMail(
-    input: { conversationId: string; limit?: number; characterId?: string } | undefined,
-    ctx: RouterContext
-  ): Promise<{ ok: true; conversationId: string; readCount: number; claimedCount: number }> {
-    if (!input?.conversationId) throw new ARXError('NO_INPUT');
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = String(ctx.client.profile.id);
-    const conversationId = String(input.conversationId);
-    const limit = Math.max(1, Math.min(200, Number(input.limit ?? 50)));
-    const characterId = input?.characterId ? String(input.characterId) : null;
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-    const Profile = ctx.app.model.Profile;
-
-    const convo = await Conversation.findOne({
-      _id: conversationId,
-      $or: [{ profileId }, { 'participants.profileId': profileId }],
-    })
-      .lean()
-      .exec();
-
-    if (!convo) throw new Error('Not authorized');
-
-    // Load latest messages
-    const msgs = await ConversationMessage.find({
-      conversationId,
-      status: { $ne: 'Archived' },
-    })
-      .sort({ _id: -1 })
-      .limit(limit)
-      .lean()
-      .exec();
-
-    // Mark as read at conversation participant level
-    const now = new Date();
-    await Conversation.updateOne(
-      { _id: conversationId },
-      {
-        $set: {
-          'participants.$[p].lastReadDate': now,
-          'participants.$[p].unreadCount': 0,
-        },
-      },
-      {
-        arrayFilters: [
-          {
-            'p.profileId': (ctx.app as any).db?.mongoose?.Types?.ObjectId?.isValid?.(profileId)
-              ? (ctx.app as any).db.mongoose.Types.ObjectId(profileId)
-              : profileId,
-          },
-        ] as any,
-      }
-    )
-      .exec()
-      .catch(async () => {
-        // fallback if arrayFilters / ObjectId mismatch in your wrapper
-        await Conversation.updateOne(
-          { _id: conversationId, 'participants.profileId': profileId },
-          { $set: { 'participants.$.lastReadDate': now, 'participants.$.unreadCount': 0 } }
-        ).exec();
-      });
-
-    // Load profile+character once for all claims
-    const profile = await Profile.findById(profileId).populate('characters').exec();
-    if (!profile) throw new Error('Profile not found');
-
-    let character: any = null;
-    const chars = (profile as any).characters || [];
-    if (characterId) character = chars.find((c: any) => String(c._id) === characterId) ?? null;
-    else character = chars?.[0] ?? null;
-
-    let claimedCount = 0;
-
-    for (const m of msgs) {
-      const claimable = !!(m as any)?.claim?.isClaimable && !(m as any)?.claim?.claimedDate;
-      if (!claimable) continue;
-
-      try {
-        await claimMailMessage({
-          ctx,
-          profile,
-          character: character ?? undefined,
-          messageId: String((m as any)._id),
-        });
-        claimedCount += 1;
-      } catch {
-        // ignore already-claimed / races
-      }
-    }
-
-    return { ok: true, conversationId, readCount: msgs.length, claimedCount };
-  }
-  async archiveReadConversations(
-    input: { conversationId: string } | undefined,
-    ctx: RouterContext
-  ): Promise<{ ok: true; conversationId: string; archivedCount: number }> {
-    if (!input?.conversationId) throw new ARXError('NO_INPUT');
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = String(ctx.client.profile.id);
-    const conversationId = String(input.conversationId);
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-
-    const convo = await Conversation.findOne({
-      _id: conversationId,
-      $or: [{ profileId }, { 'participants.profileId': profileId }],
-    })
-      .lean()
-      .exec();
-
-    if (!convo) throw new Error('Not authorized');
-
-    const participant = Array.isArray((convo as any).participants)
-      ? (convo as any).participants.find((p: any) => String(p.profileId) === profileId)
-      : null;
-
-    const lastReadDate = participant?.lastReadDate ? new Date(participant.lastReadDate) : new Date(0);
-
-    const res = await ConversationMessage.updateMany(
-      {
-        conversationId,
-        status: { $ne: 'Archived' },
-        isStarred: { $ne: true }, // optional: don't delete starred
-        createdDate: { $lte: lastReadDate }, // assumes you have createdDate timestamps
-      },
-      { $set: { status: 'Archived' } }
-    ).exec();
-
-    const archivedCount = Number((res as any)?.modifiedCount ?? (res as any)?.nModified ?? 0);
-
-    return { ok: true, conversationId, archivedCount };
-  }
-  async markConversationRead(
-    input:
-      | {
-          // explicit IDs (preferred from UI)
-          messageIds?: string[];
-          // optional scoping (handy for server-side selection)
-          conversationId?: string;
-          // optional convenience: if messageIds omitted, mark latest N in conversation
-          limit?: number;
-        }
-      | undefined,
-    ctx: RouterContext
-  ): Promise<{ ok: true; updatedCount: number; messageIds?: string[] }> {
-    if (!ctx.client?.profile) throw new Error('Unauthorized');
-
-    const profileId = String(ctx.client.profile.id);
-
-    const Conversation = ctx.app.model.Conversation;
-    const ConversationMessage = ctx.app.model.ConversationMessage;
-
-    const messageIds = Array.isArray((input as any)?.messageIds)
-      ? (input as any).messageIds.map((x: any) => String(x)).filter(Boolean)
-      : [];
-
-    const conversationId = (input as any)?.conversationId ? String((input as any).conversationId) : null;
-    const limit = Math.min(200, Number((input as any)?.limit ?? 50));
-
-    // Build candidate message IDs if caller didn't provide them
-    let targetIds: string[] = messageIds;
-
-    if (!targetIds.length) {
-      if (!conversationId) {
-        // nothing to do
-        return { ok: true, updatedCount: 0 };
-      }
-
-      // Ensure user has access to this conversation
-      const convo = await Conversation.findOne({
-        _id: conversationId,
-        $or: [{ profileId }, { 'participants.profileId': profileId }],
-      })
-        .lean()
-        .exec();
-      if (!convo) throw new Error('Not authorized for this conversation');
-
-      // Pull latest N messages in that conversation
-      const docs = await ConversationMessage.find({ conversationId })
-        .sort({ _id: -1 })
-        .limit(limit)
-        .select({ _id: 1 })
-        .lean()
-        .exec();
-
-      targetIds = docs.map((d: any) => String(d._id));
-      if (!targetIds.length) return { ok: true, updatedCount: 0 };
-    } else {
-      // Authz: ensure messages are in conversations the user can access
-      const msgs = await ConversationMessage.find({ _id: { $in: targetIds } })
-        .select({ _id: 1, conversationId: 1 })
-        .lean()
-        .exec();
-
-      if (!msgs.length) return { ok: true, updatedCount: 0 };
-
-      const convoIds = Array.from(new Set(msgs.map((m: any) => String(m.conversationId))));
-      const allowed = await Conversation.find({
-        _id: { $in: convoIds },
-        $or: [{ profileId }, { 'participants.profileId': profileId }],
-      })
-        .select({ _id: 1 })
-        .lean()
-        .exec();
-
-      const allowedSet = new Set(allowed.map((c: any) => String(c._id)));
-
-      // Only mark read for messages in allowed conversations
-      targetIds = msgs.filter((m: any) => allowedSet.has(String(m.conversationId))).map((m: any) => String(m._id));
-
-      if (!targetIds.length) throw new Error('Not authorized for these messages');
-    }
-
-    // Update: pick ONE canonical read representation.
-    // If you already use `status` elsewhere (and archive expects status='Archived'),
-    // then use status='Read' here.
-    const res = await ConversationMessage.updateMany(
-      { _id: { $in: targetIds } },
-      {
-        $set: {
-          status: 'Read',
-          // optional: keep a timestamp if you want
-          readDate: new Date(),
-        },
-      }
-    ).exec();
-
-    const updatedCount = Number((res as any)?.modifiedCount ?? (res as any)?.nModified ?? 0);
-
-    return { ok: true, updatedCount, messageIds: targetIds };
-  }
-  // Conversation Methods
-  async getConversations(
-    input: RouterInput['getConversations'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getConversations']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    const filter = getFilter(input);
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-    const [items, total] = await Promise.all([
-      ctx.app.model.Conversation.findJSON(filter, null, { skip, limit }),
-      ctx.app.model.Conversation.find(filter).countDocuments().exec(),
-    ]);
-    return { items, total };
-  }
-  async getConversation(
-    input: RouterInput['getConversation'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getConversation']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getConversation', input);
-
-    const AUTO_CREATE_KEYS = new Set(['system', 'battles', 'reports', 'guild']);
-
-    function titleCase(s: string) {
-      if (!s) return s;
-      return s.charAt(0).toUpperCase() + s.slice(1);
-    }
-
-    function defaultsForKey(key: string) {
-      // Keep this minimal; anything not provided will fall back to schema defaults.
-      // Use fields you clearly already have on Conversation (from your logs).
-      if (key === 'system') {
-        return {
-          name: 'System',
-          category: 'system',
-          kind: 'mail',
-          isLocked: true,
-          allowUserSend: false,
-          importance: 0,
-        };
-      }
-
-      return {
-        name: titleCase(key), // Reports/Guild/Battles
-        category: key,
-        kind: 'mail',
-        isLocked: false,
-        allowUserSend: false,
-        importance: 0,
-      };
-    }
-
-    if (!ctx.client?.profile?.id) throw new Error('Unauthorized');
-
-    // Always scope to the caller
-    input.where = input.where || {};
-    input.where.profileId = { equals: ctx.client.profile.id };
-
-    const where = input.where || {};
-    const requestedKey =
-      typeof where?.key === 'string' ? where.key : typeof where?.key?.equals === 'string' ? where.key.equals : null;
-
-    // 1) Try to fetch existing
-    let conversation = await ctx.app.model.Conversation.findOneJSON(getFilter(input));
-    if (conversation) return conversation as any;
-
-    // 2) Auto-create only for the known mailbox keys
-    if (!requestedKey || !AUTO_CREATE_KEYS.has(requestedKey)) {
-      throw new Error('Conversation not found');
-    }
-
-    const profileId = String(ctx.client.profile.id);
-
-    // IMPORTANT:
-    // Use create/upsert in a way that's safe under races.
-    // If you have a unique index on (profileId, key, applicationId),
-    // a duplicate create could happen — so we "create, then refetch" and tolerate dup errors.
-    const createDoc: any = {
-      key: requestedKey,
-      profileId,
-      ...defaultsForKey(requestedKey),
-
-      // these fields exist in your logged response; seed them so UI behaves immediately
-      participants: [
-        {
-          profileId,
-          role: 'user',
-          lastReadAt: new Date(0),
-          unreadCount: 0,
-          isMuted: false,
-          isPinned: false,
-          isArchived: false,
-          isDeleted: false,
-        },
-      ],
-
-      messages: [],
-      messageCount: 0,
-      lastMessageDate: null,
-      lastMessagePreview: '',
-      meta: {},
-      data: {},
-      status: 'Active',
-    };
-
-    try {
-      await ctx.app.model.Conversation.create(createDoc as any);
-    } catch (err: any) {
-      // If a race created it first, just refetch.
-      // If you want to be stricter: check err.code === 11000 for dup key.
-      log('getConversation auto-create race/err', err?.message || err);
-    }
-
-    conversation = await ctx.app.model.Conversation.findOneJSON(getFilter(input));
-    if (!conversation) throw new Error('Conversation not found');
-    return conversation as any;
-  }
-  async createConversation(
-    input: RouterInput['createConversation'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createConversation']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createConversation', input);
-
-    const conversation = await ctx.app.model.Conversation.create(input.data);
-    return conversation as Conversation;
-  }
-  async updateConversation(
-    input: RouterInput['updateConversation'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateConversation']> {
-    if (!input) throw new ARXError('NO_INPUT');
-
-    const filters = getFilter(input);
-
-    if (!filters._id) throw new ARXError('BAD_REQUEST');
-
-    log('Core.Service.updateConversation', input);
-    const updatedConversation = await ctx.app.model.Conversation.findByIdAndUpdate(filters._id, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedConversation) throw new Error('Conversation update failed');
-    return updatedConversation as Conversation;
-  }
-  // ConversationMessage Methods
-  async getConversationMessage(
-    input: RouterInput['getConversationMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getConversationMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getConversationMessage', input);
-    const conversationMessage = await ctx.app.model.ConversationMessage.findOneJSON(getFilter(input));
-    if (!conversationMessage) throw new Error('ConversationMessage not found');
-    return conversationMessage as ConversationMessage;
-  }
-  async createConversationMessage(
-    input: RouterInput['createConversationMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createConversationMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createConversationMessage', input);
-    const conversationMessage = await ctx.app.model.ConversationMessage.create(input.data);
-    return conversationMessage as ConversationMessage;
-  }
-  async updateConversationMessage(
-    input: RouterInput['updateConversationMessage'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateConversationMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateConversationMessage', input);
-    const updatedConversationMessage = await ctx.app.model.ConversationMessage.findByIdAndUpdate(
-      input.where.id.equals,
-      input.data,
-      { new: true }
-    )
-      .lean()
-      .exec();
-    if (!updatedConversationMessage) throw new Error('ConversationMessage update failed');
-    return updatedConversationMessage as ConversationMessage;
-  }
-  // async deleteConversation(
-  //   input: RouterInput['deleteConversation'],
-  //   ctx: RouterContext
-  // ): Promise<RouterOutput['deleteConversation']> {
-  //   if (!input) throw new ARXError('NO_INPUT');
-  //   log('Core.Service.deleteConversation', input);
-  //   const deleted = await ctx.app.model.Conversation.findByIdAndDelete(input.where.id.equals).exec();
-  //   if (!deleted) throw new Error('Conversation not found');
-  //   return { id: input.where.id.equals };
-  // }
-  // async interact(input: RouterInput['interact'], ctx: RouterContext): Promise<RouterOutput['interact']> {
-  // if (!input) throw new TRPCError({
-  // code: 'BAD_REQUEST',
-  // message: 'No input provided',
-  // });
-  // log('Core.Service.interact', input);
-  // return {
-  // status: 1,
-  // };
-  // }
-  async updateSettings(
-    input: RouterInput['updateSettings'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSettings']> {
-    if (!ctx.client.profile) return;
-    type ProfileSettings = NonNullable<Profile['settings']>;
-    // 👇 These must be real keys of ProfileSettings or TS will error
-    const validKeys = ['warp', 'designer'] as const satisfies readonly (keyof ProfileSettings)[];
-    type ValidKey = (typeof validKeys)[number];
-    const incoming = input as Record<string, any>;
-    for (const key of Object.keys(incoming) as ValidKey[]) {
-      if (!validKeys.includes(key)) continue;
-      const prev = ctx.client.profile.settings[key] || {};
-      ctx.client.profile.settings[key] = deepMerge(prev, incoming[key]);
-    }
-    // If settings is Mixed/Map, make sure Mongoose knows it changed:
-    // @ts-ignore
-    ctx.client.profile.markModified('settings');
-    // @ts-ignore
-    await ctx.client.profile.save(); // writes to DB and keeps this doc in sync
-    return ctx.client.profile.settings as RouterOutput['updateSettings'];
-  } // Core.Service.ts (or wherever this class lives)
-
-  async ask(input: RouterInput['ask'], ctx: RouterContext): Promise<RouterOutput['ask']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.ask', input);
-
-    // Expecting: { conversationId, messages: [{ role, content, ... }, ...], ... }
-    const { conversationId, messages } = input.data;
-
-    if (!conversationId) {
-      throw new Error('NO_CONVERSATION_ID');
-    }
-
-    if (!Array.isArray(messages) || messages.length === 0) {
-      throw new Error('NO_MESSAGES');
-    }
-
-    // Take the last message as the "new" user message
-    const lastMessage = messages[messages.length - 1];
-    if (!lastMessage?.content) {
-      throw new Error('NO_MESSAGE_CONTENT');
-    }
-
-    const userRole = lastMessage.role || 'user';
-
-    // 1) Persist the user message
-    await ctx.app.model.ConversationMessage.create({
-      conversationId,
-      role: userRole,
-      content: lastMessage.content,
-    });
-
-    // 2) Call your real LLM / agent here (for now it's a stub)
-    //    You can replace this block with your actual LLM call later.
-    const assistantReply: RouterOutput['ask'] = {
-      content: 'Request success.',
-      role: 'assistant',
-    };
-
-    // 3) Persist the assistant reply
-    await ctx.app.model.ConversationMessage.create({
-      conversationId,
-      role: assistantReply.role,
-      content: assistantReply.content,
-    });
-
-    // 4) Return reply for streaming / UI
-    return assistantReply;
-  }
-
-  // Account Methods
-  async authorize(input: RouterInput['authorize'], ctx: RouterContext): Promise<RouterOutput['authorize']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.authorize', input);
-    // Validate token
-    const isValid = await isValidRequest(ctx.app.web3.bsc, {
-      signature: {
-        address: input.address,
-        hash: input.token,
-        data: input.data || 'evolution',
-      },
-    });
-
-    if (!isValid) throw new Error(`Invalid signature: ${input.address} ${input.token}`);
-
-    ctx.client.profile = await ctx.app.model.Profile.findOne({
-      address: input.address,
-    });
-
-    if (!ctx.client.profile) throw new Error('Profile not found: ' + input.address);
-
-    const roles = ['guest'];
-
-    if (
-      input.address.toLowerCase() === '0xDfA8f768d82D719DC68E12B199090bDc3691fFc7'.toLowerCase() || // realm
-      input.address.toLowerCase() === '0x81F8C054667046171C0EAdC73063Da557a828d6f'.toLowerCase() || // seer
-      input.address.toLowerCase() === '0x954246b18fee13712C48E5a7Da5b78D88e8891d5'.toLowerCase() // admin
-    ) {
-      roles.push('mod');
-      roles.push('admin');
-    }
-
-    roles.push('user');
-
-    ctx.client.roles = roles;
-
-    const permissions = {
-      'character.create': roles.includes('mod'),
-      'character.view': roles.includes('mod'),
-      'character.remove': roles.includes('mod'),
-      'character.update': roles.includes('mod'),
-      'rewards.distribute': roles.includes('admin'),
-      'character.data.write': roles.includes('mod'),
-      'character.inventory.write': roles.includes('mod'),
-      'profile.meta.write': roles.includes('mod'),
-      // optionally narrower scopes:
-      'character.data.write:evolution.quest.*': roles.includes('mod'),
-    };
-
-    ctx.client.permissions = permissions;
-
-    return {
-      token: input.token,
-    };
-  }
-  async syncGetPayloadsSince(
-    input: RouterInput['syncGetPayloadsSince'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['syncGetPayloadsSince']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.syncGetPayloadsSince', input);
-    const sinceDate = new Date(input.since);
-    const payloads = await ctx.app.model.SeerPayload.find({
-      createdDate: { $gt: sinceDate },
-    })
-      .lean()
-      .exec();
-    return { payloads };
-  }
-  // Account Methods
-  async getAccount(input: RouterInput['getAccount'], ctx: RouterContext): Promise<RouterOutput['getAccount']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getAccount', input);
-    const account = await ctx.app.model.Account.findOne(getFilter(input)).exec();
-    if (!account) throw new Error('Account not found');
-    return account as Account;
-  }
-  async getAccounts(ctx: RouterContext): Promise<RouterOutput['getAccounts']> {
-    log('Core.Service.getAccounts');
-    const accounts = await ctx.app.model.Account.find().exec();
-    return accounts as Account[];
-  }
-  async createAccount(input: RouterInput['createAccount'], ctx: RouterContext): Promise<RouterOutput['createAccount']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createAccount', input);
-    const account = await ctx.app.model.Account.create(input);
-    return account as Account;
-  }
-  async updateAccount(input: RouterInput['updateAccount'], ctx: RouterContext): Promise<RouterOutput['updateAccount']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateAccount', input);
-    const updatedAccount = await ctx.app.model.Account.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedAccount) throw new Error('Account update failed');
-    return updatedAccount as Account;
-  }
-  // Achievement Methods
-  async getAchievement(
-    input: RouterInput['getAchievement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getAchievement']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getAchievement', input);
-    const achievement = await ctx.app.model.Achievement.findOne(getFilter(input)).exec();
-    if (!achievement) throw new Error('Achievement not found');
-    return achievement as Achievement;
-  }
-  async getAchievements(ctx: RouterContext): Promise<RouterOutput['getAchievements']> {
-    log('Core.Service.getAchievements');
-    const achievements = await ctx.app.model.Achievement.find().exec();
-    return achievements as Achievement[];
-  }
-  async createAchievement(
-    input: RouterInput['createAchievement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createAchievement']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createAchievement', input);
-    const achievement = await ctx.app.model.Achievement.create(input);
-    return achievement as Achievement;
-  }
-  async updateAchievement(
-    input: RouterInput['updateAchievement'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateAchievement']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateAchievement', input);
-    const updatedAchievement = await ctx.app.model.Achievement.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedAchievement) throw new Error('Achievement update failed');
-    return updatedAchievement as Achievement;
-  }
-  async info(input: RouterInput['info'], ctx: RouterContext): Promise<RouterOutput['info']> {
-    return { version: '1.1.1' };
-  }
-  async stats(input: RouterInput['stats'], ctx: RouterContext): Promise<RouterOutput['stats']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.stats');
-    const stats = await ctx.app.model.Stat.find().sort({ number: -1 }).limit(1).exec();
-    return stats.map((stat) => stat.toObject()) as Stat[];
-  }
-  // Act Methods
-  // Get Act
-  async getAct(input: RouterInput['getAct'], ctx: RouterContext): Promise<RouterOutput['getAct']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getAct', input);
-    const act = await ctx.app.model.Act.findOne(getFilter(input)).exec();
-    if (!act) throw new Error('Act not found');
-    return act as Act;
-  }
-  async getActs(input: RouterInput['getActs'], ctx: RouterContext): Promise<RouterOutput['getActs']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    const filter = getFilter(input);
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-    const [items, total] = await Promise.all([
-      ctx.app.model.Act.find(filter).skip(skip).limit(limit).lean().exec(),
-      ctx.app.model.Act.find(filter).countDocuments().exec(),
-    ]);
-    return { items, total };
-  }
-  // Create Act
-  async createAct(input: RouterInput['createAct'], ctx: RouterContext): Promise<RouterOutput['createAct']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createAct', input);
-    const act = await ctx.app.model.Act.create(input);
-    return act as Act;
-  }
-  // Update Act
-  async updateAct(input: RouterInput['updateAct'], ctx: RouterContext): Promise<RouterOutput['updateAct']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateAct', input);
-    const updatedAct = await ctx.app.model.Act.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAct) throw new Error('Act update failed');
-    return updatedAct as Act;
-  }
-  // Agent Methods
-  // Get Agent
-  async getAgent(input: RouterInput['getAgent'], ctx: RouterContext): Promise<RouterOutput['getAgent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getAgent', input);
-    const agent = await ctx.app.model.Agent.findOne(getFilter(input)).exec();
-    if (!agent) throw new Error('Agent not found');
-    return agent as Agent;
-  }
-  // Create Agent
-  async createAgent(input: RouterInput['createAgent'], ctx: RouterContext): Promise<RouterOutput['createAgent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createAgent', input);
-    const agent = await ctx.app.model.Agent.create(input);
-    return agent as Agent;
-  }
-  // Update Agent
-  async updateAgent(input: RouterInput['updateAgent'], ctx: RouterContext): Promise<RouterOutput['updateAgent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateAgent', input);
-    const updatedAgent = await ctx.app.model.Agent.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedAgent) throw new Error('Agent update failed');
-    return updatedAgent as Agent;
-  }
-  // Application Methods
-  // Get Application
-  async getApplication(
-    input: RouterInput['getApplication'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getApplication']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getApplication', input);
-    const application = await ctx.app.model.Application.findOne(getFilter(input)).exec();
-    if (!application) throw new Error('Application not found');
-    return application as Application;
-  }
-  // Create Application
-  async createApplication(
-    input: RouterInput['createApplication'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createApplication']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createApplication', input);
-    const application = await ctx.app.model.Application.create(input);
-    return application as Application;
-  }
-  // Update Application
-  async updateApplication(
-    input: RouterInput['updateApplication'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateApplication']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateApplication', input);
-    const updatedApplication = await ctx.app.model.Application.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedApplication) throw new Error('Application update failed');
-    return updatedApplication as Application;
-  }
-  // Badge Methods
-  async getBadge(input: RouterInput['getBadge'], ctx: RouterContext): Promise<RouterOutput['getBadge']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getBadge', input);
-    const badge = await ctx.app.model.Badge.findOne(getFilter(input)).exec();
-    if (!badge) throw new Error('Badge not found');
-    return badge as Badge;
-  }
-  async createBadge(input: RouterInput['createBadge'], ctx: RouterContext): Promise<RouterOutput['createBadge']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createBadge', input);
-    const badge = await ctx.app.model.Badge.create(input);
-    return badge as Badge;
-  }
-  async updateBadge(input: RouterInput['updateBadge'], ctx: RouterContext): Promise<RouterOutput['updateBadge']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateBadge', input);
-    const updatedBadge = await ctx.app.model.Badge.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedBadge) throw new Error('Badge update failed');
-    return updatedBadge as Badge;
-  }
-  // BattlePass Methods
-  async getBattlePass(input: RouterInput['getBattlePass'], ctx: RouterContext): Promise<RouterOutput['getBattlePass']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getBattlePass', input);
-    const battlePass = await ctx.app.model.BattlePass.findOne(getFilter(input)).exec();
-    if (!battlePass) throw new Error('BattlePass not found');
-    return battlePass as BattlePass;
-  }
-  async createBattlePass(
-    input: RouterInput['createBattlePass'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createBattlePass']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createBattlePass', input);
-    const battlePass = await ctx.app.model.BattlePass.create(input);
-    return battlePass as BattlePass;
-  }
-  async updateBattlePass(
-    input: RouterInput['updateBattlePass'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateBattlePass']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateBattlePass', input);
-    const updatedBattlePass = await ctx.app.model.BattlePass.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedBattlePass) throw new Error('BattlePass update failed');
-    return updatedBattlePass as BattlePass;
-  }
-  // Biome Methods
-  async getBiome(input: RouterInput['getBiome'], ctx: RouterContext): Promise<RouterOutput['getBiome']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getBiome', input);
-    const biome = await ctx.app.model.Biome.findOne(getFilter(input)).exec();
-    if (!biome) throw new Error('Biome not found');
-    return biome as Biome;
-  }
-  async createBiome(input: RouterInput['createBiome'], ctx: RouterContext): Promise<RouterOutput['createBiome']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createBiome', input);
-    const biome = await ctx.app.model.Biome.create(input);
-    return biome as Biome;
-  }
-  async updateBiome(input: RouterInput['updateBiome'], ctx: RouterContext): Promise<RouterOutput['updateBiome']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateBiome', input);
-    const updatedBiome = await ctx.app.model.Biome.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedBiome) throw new Error('Biome update failed');
-    return updatedBiome as Biome;
-  }
-  // BiomeFeature Methods
-  async getBiomeFeature(
-    input: RouterInput['getBiomeFeature'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getBiomeFeature']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getBiomeFeature', input);
-    const biomeFeature = await ctx.app.model.BiomeFeature.findOne(getFilter(input)).exec();
-    if (!biomeFeature) throw new Error('BiomeFeature not found');
-    return biomeFeature as BiomeFeature;
-  }
-  async createBiomeFeature(
-    input: RouterInput['createBiomeFeature'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createBiomeFeature']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createBiomeFeature', input);
-    const biomeFeature = await ctx.app.model.BiomeFeature.create(input);
-    return biomeFeature as BiomeFeature;
-  }
-  async updateBiomeFeature(
-    input: RouterInput['updateBiomeFeature'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateBiomeFeature']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateBiomeFeature', input);
-    const updatedBiomeFeature = await ctx.app.model.BiomeFeature.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedBiomeFeature) throw new Error('BiomeFeature update failed');
-    return updatedBiomeFeature as BiomeFeature;
-  }
-  // Collection Methods
-  async getCollection(input: RouterInput['getCollection'], ctx: RouterContext): Promise<RouterOutput['getCollection']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getCollection', input);
-    const collection = await ctx.app.model.Collection.findOne(getFilter(input)).exec();
-    if (!collection) throw new Error('Collection not found');
-    return collection as Collection;
-  }
-  async createCollection(
-    input: RouterInput['createCollection'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createCollection']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createCollection', input);
-    const collection = await ctx.app.model.Collection.create(input);
-    return collection as Collection;
-  }
-  async updateCollection(
-    input: RouterInput['updateCollection'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateCollection']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateCollection', input);
-    const updatedCollection = await ctx.app.model.Collection.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedCollection) throw new Error('Collection update failed');
-    return updatedCollection as Collection;
-  }
-  // Comment Methods
-  async getComment(input: RouterInput['getComment'], ctx: RouterContext): Promise<RouterOutput['getComment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getComment', input);
-    const comment = await ctx.app.model.Comment.findOne(getFilter(input)).exec();
-    if (!comment) throw new Error('Comment not found');
-    return comment as Comment;
-  }
-  async createComment(input: RouterInput['createComment'], ctx: RouterContext): Promise<RouterOutput['createComment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createComment', input);
-    const comment = await ctx.app.model.Comment.create(input);
-    return comment as Comment;
-  }
-  async updateComment(input: RouterInput['updateComment'], ctx: RouterContext): Promise<RouterOutput['updateComment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateComment', input);
-    const updatedComment = await ctx.app.model.Comment.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedComment) throw new Error('Comment update failed');
-    return updatedComment as Comment;
-  }
-  // Community Methods
-  async getCommunity(input: RouterInput['getCommunity'], ctx: RouterContext): Promise<RouterOutput['getCommunity']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getCommunity', input);
-    const community = await ctx.app.model.Community.findOne(getFilter(input)).exec();
-    if (!community) throw new Error('Community not found');
-    return community as Community;
-  }
-  async createCommunity(
-    input: RouterInput['createCommunity'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createCommunity']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createCommunity', input);
-    const community = await ctx.app.model.Community.create(input);
-    return community as Community;
-  }
-  async updateCommunity(
-    input: RouterInput['updateCommunity'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateCommunity']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateCommunity', input);
-    const updatedCommunity = await ctx.app.model.Community.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedCommunity) throw new Error('Community update failed');
-    return updatedCommunity as Community;
-  }
-  // Company Methods
-  async getCompany(input: RouterInput['getCompany'], ctx: RouterContext): Promise<RouterOutput['getCompany']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getCompany', input);
-    const company = await ctx.app.model.Company.findOne(getFilter(input)).exec();
-    if (!company) throw new Error('Company not found');
-    return company as Company;
-  }
-  async createCompany(input: RouterInput['createCompany'], ctx: RouterContext): Promise<RouterOutput['createCompany']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createCompany', input);
-    const company = await ctx.app.model.Company.create(input);
-    return company as Company;
-  }
-  async updateCompany(input: RouterInput['updateCompany'], ctx: RouterContext): Promise<RouterOutput['updateCompany']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateCompany', input.where.id.equals, input.data);
-    const updatedCompany = await ctx.app.model.Company.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedCompany) throw new Error('Company update failed');
-    return updatedCompany as Company;
-  }
-  // Data Methods
-  async getData(input: RouterInput['getData'], ctx: RouterContext): Promise<RouterOutput['getData']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getData', input.where.id.equals);
-    const data = await ctx.app.model.Data.findOne(getFilter(input)).exec();
-    if (!data) throw new Error('Data not found');
-    return data as Data;
-  }
-  async createData(input: RouterInput['createData'], ctx: RouterContext): Promise<RouterOutput['createData']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createData', input);
-    const data = await ctx.app.model.Data.create(input);
-    return data as Data;
-  }
-  async updateData(input: RouterInput['updateData'], ctx: RouterContext): Promise<RouterOutput['updateData']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateData', input.where.id.equals, input.data);
-    const updatedData = await ctx.app.model.Data.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedData) throw new Error('Data update failed');
-    return updatedData as Data;
-  }
-  // Discussion Methods
-  async getDiscussion(input: RouterInput['getDiscussion'], ctx: RouterContext): Promise<RouterOutput['getDiscussion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getDiscussion', input.where.id.equals);
-    const discussion = await ctx.app.model.Discussion.findOne(getFilter(input)).exec();
-    if (!discussion) throw new Error('Discussion not found');
-    return discussion as Discussion;
-  }
-  async createDiscussion(
-    input: RouterInput['createDiscussion'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createDiscussion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createDiscussion', input);
-    const discussion = await ctx.app.model.Discussion.create(input);
-    return discussion as Discussion;
-  }
-  async updateDiscussion(
-    input: RouterInput['updateDiscussion'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateDiscussion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateDiscussion', input);
-    const updatedDiscussion = await ctx.app.model.Discussion.findByIdAndUpdate(input.where.id.equals, input.data, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedDiscussion) throw new Error('Discussion update failed');
-    return updatedDiscussion as Discussion;
-  }
-  // // Procedure Methods
-  // async runProcedure(input: RouterInput['runProcedure'], ctx: RouterContext): Promise<RouterOutput['runProcedure']> {
-  //   if (!input) throw new ARXError('NO_INPUT');
-  //   log('Core.Service.runProcedure', input);
-  //   // 1) Load procedure doc from Mongo by key (latest version or exact match)
-  //   const procDoc = await ctx.app.model.Procedure.findOne({ key: input.key }).lean().exec();
-  //   if (!procDoc) throw new ARXError('PROCEDURE_NOT_FOUND');
-
-  //   // 2) migrate v1 → v2 if needed
-  //   const proc = migrateProcedure(procDoc); // returns { run: ProcedureRunStep[] ... }
-
-  //   // 3) permission checks
-  //   // proc.run steps may declare permission; enforce in ctx
-  //   for (const step of proc.run) {
-  //     if (step.permission) {
-  //       await ctx.auth.require(step.permission);
-  //     }
-  //   }
-
-  //   // 4) execute: seer mode steps may themselves resolve to inline patches or connector calls
-  //   // But your new rule is: on seer, you decide what happens.
-  //   const character = await ctx.character();
-  //   const before = character.data || {};
-
-  //   const patchesApplied: any[] = [];
-
-  //   for (const step of proc.run) {
-  //     if (step.mode === 'inline') {
-  //       // evaluate patch formula in a sandboxed evaluator on server
-  //       const patchOps = evalPatch(step.patch, { character: { data: before }, args: input.args });
-  //       applyPatchesToCharacter(character, patchOps);
-  //       patchesApplied.push(...patchOps);
-  //       continue;
-  //     }
-
-  //     if (step.mode === 'seer') {
-  //       // This can either:
-  //       // - call a TRPC/internal service mutation
-  //       // - or interpret step.mutation as "quest.claimReward" etc
-  //       const result = await ctx.seer.executeMutation(step.mutation!, step.input ?? input.args);
-
-  //       // result could return patches or direct updated data
-  //       if (result?.patches) {
-  //         applyPatchesToCharacter(character, result.patches);
-  //         patchesApplied.push(...result.patches);
-  //       }
-  //     }
-  //   }
-
-  //   await character.save();
-
-  //   return { ok: true, patchesApplied, characterData: character.data };
-  // }
-
-  // Energy Methods
-  async getEnergy(input: RouterInput['getEnergy'], ctx: RouterContext): Promise<RouterOutput['getEnergy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getEnergy', input);
-    const energy = await ctx.app.model.Energy.findOne(getFilter(input)).exec();
-    if (!energy) throw new Error('Energy not found');
-    return energy as Energy;
-  }
-  async getEnergies(input: RouterInput['getEnergies'], ctx: RouterContext): Promise<RouterOutput['getEnergies']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getEnergies', input);
-    const filter = getFilter(input);
-    const limit = input.limit ?? 50;
-    const skip = input.skip ?? 0;
-    const [items, total] = await Promise.all([
-      ctx.app.model.Energy.find(filter).skip(skip).limit(limit).lean().exec(),
-      ctx.app.model.Energy.find(filter).countDocuments().exec(),
-    ]);
-    return { items, total };
-  }
-  async createEnergy(input: RouterInput['createEnergy'], ctx: RouterContext): Promise<RouterOutput['createEnergy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createEnergy', input);
-    const energy = await ctx.app.model.Energy.create(input);
-    return energy as Energy;
-  }
-  async updateEnergy(input: RouterInput['updateEnergy'], ctx: RouterContext): Promise<RouterOutput['updateEnergy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateEnergy', input);
-    const updatedEnergy = await ctx.app.model.Energy.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedEnergy) throw new Error('Energy update failed');
-    return updatedEnergy as Energy;
-  }
-  // Event Methods
-  async getEvent(input: RouterInput['getEvent'], ctx: RouterContext): Promise<RouterOutput['getEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getEvent', input);
-    const event = await ctx.app.model.Event.findOne(getFilter(input)).exec();
-    if (!event) throw new Error('Event not found');
-    return event as Event;
-  }
-  async createEvent(input: RouterInput['createEvent'], ctx: RouterContext): Promise<RouterOutput['createEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createEvent', input);
-    const event = await ctx.app.model.Event.create(input);
-    return event as Event;
-  }
-  async updateEvent(input: RouterInput['updateEvent'], ctx: RouterContext): Promise<RouterOutput['updateEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateEvent', input);
-    const updatedEvent = await ctx.app.model.Event.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedEvent) throw new Error('Event update failed');
-    return updatedEvent as Event;
-  }
-  // File Methods
-  async getFile(input: RouterInput['getFile'], ctx: RouterContext): Promise<RouterOutput['getFile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getFile', input);
-    const file = await ctx.app.model.File.findOne(getFilter(input)).exec();
-    if (!file) throw new Error('File not found');
-    return file as File;
-  }
-  async createFile(input: RouterInput['createFile'], ctx: RouterContext): Promise<RouterOutput['createFile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createFile', input);
-    const file = await ctx.app.model.File.create(input);
-    return file as File;
-  }
-  async updateFile(input: RouterInput['updateFile'], ctx: RouterContext): Promise<RouterOutput['updateFile']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateFile', input);
-    const updatedFile = await ctx.app.model.File.findByIdAndUpdate(input.where.id.equals, input.data, { new: true })
-      .lean()
-      .exec();
-    if (!updatedFile) throw new Error('File update failed');
-    return updatedFile as File;
-  }
-  // Galaxy Methods
-  async getGalaxy(input: RouterInput['getGalaxy'], ctx: RouterContext): Promise<RouterOutput['getGalaxy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getGalaxy', input);
-    const galaxy = await ctx.app.model.Galaxy.findOne(getFilter(input)).exec();
-    if (!galaxy) throw new Error('Galaxy not found');
-    return galaxy as Galaxy;
-  }
-  async createGalaxy(input: RouterInput['createGalaxy'], ctx: RouterContext): Promise<RouterOutput['createGalaxy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createGalaxy', input);
-    const galaxy = await ctx.app.model.Galaxy.create(input);
-    return galaxy as Galaxy;
-  }
-  async updateGalaxy(input: RouterInput['updateGalaxy'], ctx: RouterContext): Promise<RouterOutput['updateGalaxy']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateGalaxy', input);
-    const updatedGalaxy = await ctx.app.model.Galaxy.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedGalaxy) throw new Error('Galaxy update failed');
-    return updatedGalaxy as Galaxy;
-  }
-  // Guide Methods
-  async getGuide(input: RouterInput['getGuide'], ctx: RouterContext): Promise<RouterOutput['getGuide']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getGuide', input);
-    const guide = await ctx.app.model.Guide.findOne(getFilter(input)).exec();
-    if (!guide) throw new Error('Guide not found');
-    return guide as Guide;
-  }
-  async createGuide(input: RouterInput['createGuide'], ctx: RouterContext): Promise<RouterOutput['createGuide']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createGuide', input);
-    const guide = await ctx.app.model.Guide.create(input);
-    return guide as Guide;
-  }
-  async updateGuide(input: RouterInput['updateGuide'], ctx: RouterContext): Promise<RouterOutput['updateGuide']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateGuide', input);
-    const updatedGuide = await ctx.app.model.Guide.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedGuide) throw new Error('Guide update failed');
-    return updatedGuide as Guide;
-  }
-  // Idea Methods
-  async getIdea(input: RouterInput['getIdea'], ctx: RouterContext): Promise<RouterOutput['getIdea']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getIdea', input);
-    const idea = await ctx.app.model.Idea.findOne(getFilter(input)).exec();
-    if (!idea) throw new Error('Idea not found');
-    return idea as Idea;
-  }
-  async createIdea(input: RouterInput['createIdea'], ctx: RouterContext): Promise<RouterOutput['createIdea']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createIdea', input);
-    const idea = await ctx.app.model.Idea.create(input);
-    return idea as Idea;
-  }
-  async updateIdea(input: RouterInput['updateIdea'], ctx: RouterContext): Promise<RouterOutput['updateIdea']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateIdea', input);
-    const updatedIdea = await ctx.app.model.Idea.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedIdea) throw new Error('Idea update failed');
-    return updatedIdea as Idea;
-  }
-  // Leaderboard Methods
-  async getLeaderboard(
-    input: RouterInput['getLeaderboard'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getLeaderboard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getLeaderboard', input);
-    const leaderboard = await ctx.app.model.Leaderboard.findOne(getFilter(input)).exec();
-    if (!leaderboard) throw new Error('Leaderboard not found');
-    return leaderboard as Leaderboard;
-  }
-  async createLeaderboard(
-    input: RouterInput['createLeaderboard'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createLeaderboard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createLeaderboard', input);
-    const leaderboard = await ctx.app.model.Leaderboard.create(input);
-    return leaderboard as Leaderboard;
-  }
-  async updateLeaderboard(
-    input: RouterInput['updateLeaderboard'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateLeaderboard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateLeaderboard', input);
-    const updatedLeaderboard = await ctx.app.model.Leaderboard.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedLeaderboard) throw new Error('Leaderboard update failed');
-    return updatedLeaderboard as Leaderboard;
-  }
-  // Log Methods
-  async getLog(input: RouterInput['getLog'], ctx: RouterContext): Promise<RouterOutput['getLog']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getLog', input);
-    const item = await ctx.app.model.Log.findOne(getFilter(input)).exec();
-    if (!item) throw new Error('Log not found');
-    return item as Log;
-  }
-  async createLog(input: RouterInput['createLog'], ctx: RouterContext): Promise<RouterOutput['createLog']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createLog', input);
-    const item = await ctx.app.model.Log.create(input);
-    return item as Log;
-  }
-  async updateLog(input: RouterInput['updateLog'], ctx: RouterContext): Promise<RouterOutput['updateLog']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateLog', input);
-    const item = await ctx.app.model.Log.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!item) throw new Error('Log update failed');
-    return item as Log;
-  }
-  // Lore Methods
-  async getLore(input: RouterInput['getLore'], ctx: RouterContext): Promise<RouterOutput['getLore']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getLore', input);
-    const lore = await ctx.app.model.Lore.findOne(getFilter(input)).exec();
-    if (!lore) throw new Error('Lore not found');
-    return lore as Lore;
-  }
-  async createLore(input: RouterInput['createLore'], ctx: RouterContext): Promise<RouterOutput['createLore']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createLore', input);
-    const lore = await ctx.app.model.Lore.create(input);
-    return lore as Lore;
-  }
-  async updateLore(input: RouterInput['updateLore'], ctx: RouterContext): Promise<RouterOutput['updateLore']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateLore', input);
-    const updatedLore = await ctx.app.model.Lore.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedLore) throw new Error('Lore update failed');
-    return updatedLore as Lore;
-  }
-  // Memory Methods
-  async getMemory(input: RouterInput['getMemory'], ctx: RouterContext): Promise<RouterOutput['getMemory']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getMemory', input);
-    const memory = await ctx.app.model.Memory.findOne(getFilter(input)).exec();
-    if (!memory) throw new Error('Memory not found');
-    return memory as Memory;
-  }
-  async createMemory(input: RouterInput['createMemory'], ctx: RouterContext): Promise<RouterOutput['createMemory']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createMemory', input);
-    const memory = await ctx.app.model.Memory.create(input);
-    return memory as Memory;
-  }
-  async updateMemory(input: RouterInput['updateMemory'], ctx: RouterContext): Promise<RouterOutput['updateMemory']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateMemory', input);
-    const updatedMemory = await ctx.app.model.Memory.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedMemory) throw new Error('Memory update failed');
-    return updatedMemory as Memory;
-  }
-  // Message Methods
-  async getMessage(input: RouterInput['getMessage'], ctx: RouterContext): Promise<RouterOutput['getMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getMessage', input);
-    const message = await ctx.app.model.Message.findOne(getFilter(input)).exec();
-    if (!message) throw new Error('Message not found');
-    return message as Message;
-  }
-  async createMessage(input: RouterInput['createMessage'], ctx: RouterContext): Promise<RouterOutput['createMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createMessage', input);
-    const message = await ctx.app.model.Message.create(input);
-    return message as Message;
-  }
-  async updateMessage(input: RouterInput['updateMessage'], ctx: RouterContext): Promise<RouterOutput['updateMessage']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateMessage', input);
-    const updatedMessage = await ctx.app.model.Message.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedMessage) throw new Error('Message update failed');
-    return updatedMessage as Message;
-  }
-  // Metaverse Methods
-  async getMetaverse(input: RouterInput['getMetaverse'], ctx: RouterContext): Promise<RouterOutput['getMetaverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getMetaverse', input);
-    const metaverse = await ctx.app.model.Metaverse.findOne(getFilter(input)).exec();
-    if (!metaverse) throw new Error('Metaverse not found');
-    return metaverse as Metaverse;
-  }
-  async createMetaverse(
-    input: RouterInput['createMetaverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createMetaverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createMetaverse', input);
-    const metaverse = await ctx.app.model.Metaverse.create(input);
-    return metaverse as Metaverse;
-  }
-  async updateMetaverse(
-    input: RouterInput['updateMetaverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateMetaverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateMetaverse', input);
-    const updatedMetaverse = await ctx.app.model.Metaverse.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedMetaverse) throw new Error('Metaverse update failed');
-    return updatedMetaverse as Metaverse;
-  }
-  // NewsArticle Methods
-  async getNewsArticle(
-    input: RouterInput['getNewsArticle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getNewsArticle']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getNewsArticle', input);
-    const newsArticle = await ctx.app.model.NewsArticle.findOne(getFilter(input)).exec();
-    if (!newsArticle) throw new Error('NewsArticle not found');
-    return newsArticle as NewsArticle;
-  }
-  async createNewsArticle(
-    input: RouterInput['createNewsArticle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createNewsArticle']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createNewsArticle', input);
-    const newsArticle = await ctx.app.model.NewsArticle.create(input);
-    return newsArticle as NewsArticle;
-  }
-  async updateNewsArticle(
-    input: RouterInput['updateNewsArticle'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateNewsArticle']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateNewsArticle', input);
-    const updatedNewsArticle = await ctx.app.model.NewsArticle.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedNewsArticle) throw new Error('NewsArticle update failed');
-    return updatedNewsArticle as NewsArticle;
-  }
-  // Npc Methods
-  async getNpc(input: RouterInput['getNpc'], ctx: RouterContext): Promise<RouterOutput['getNpc']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getNpc', input);
-    const npc = await ctx.app.model.Npc.findOne(getFilter(input)).exec();
-    if (!npc) throw new Error('Npc not found');
-    return npc as Npc;
-  }
-  async createNpc(input: RouterInput['createNpc'], ctx: RouterContext): Promise<RouterOutput['createNpc']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createNpc', input);
-    const npc = await ctx.app.model.Npc.create(input);
-    return npc as Npc;
-  }
-  async updateNpc(input: RouterInput['updateNpc'], ctx: RouterContext): Promise<RouterOutput['updateNpc']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateNpc', input);
-    const updatedNpc = await ctx.app.model.Npc.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedNpc) throw new Error('Npc update failed');
-    return updatedNpc as Npc;
-  }
-  // Offer Methods
-  async getOffer(input: RouterInput['getOffer'], ctx: RouterContext): Promise<RouterOutput['getOffer']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getOffer', input);
-    const offer = await ctx.app.model.Offer.findOne(getFilter(input)).exec();
-    if (!offer) throw new Error('Offer not found');
-    return offer as Offer;
-  }
-  async createOffer(input: RouterInput['createOffer'], ctx: RouterContext): Promise<RouterOutput['createOffer']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createOffer', input);
-    const offer = await ctx.app.model.Offer.create(input);
-    return offer as Offer;
-  }
-  async updateOffer(input: RouterInput['updateOffer'], ctx: RouterContext): Promise<RouterOutput['updateOffer']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateOffer', input);
-    const updatedOffer = await ctx.app.model.Offer.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedOffer) throw new Error('Offer update failed');
-    return updatedOffer as Offer;
-  }
-  // Omniverse Methods
-  async getOmniverse(input: RouterInput['getOmniverse'], ctx: RouterContext): Promise<RouterOutput['getOmniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getOmniverse', input);
-    const omniverse = await ctx.app.model.Omniverse.findOne(getFilter(input)).exec();
-    if (!omniverse) throw new Error('Omniverse not found');
-    return omniverse as Omniverse;
-  }
-  async createOmniverse(
-    input: RouterInput['createOmniverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createOmniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createOmniverse', input);
-    const omniverse = await ctx.app.model.Omniverse.create(input);
-    return omniverse as Omniverse;
-  }
-  async updateOmniverse(
-    input: RouterInput['updateOmniverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateOmniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateOmniverse', input);
-    const updatedOmniverse = await ctx.app.model.Omniverse.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedOmniverse) throw new Error('Omniverse update failed');
-    return updatedOmniverse as Omniverse;
-  }
-  // Order Methods
-  async getOrder(input: RouterInput['getOrder'], ctx: RouterContext): Promise<RouterOutput['getOrder']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getOrder', input);
-    const order = await ctx.app.model.Order.findOne(getFilter(input)).exec();
-    if (!order) throw new Error('Order not found');
-    return order as Order;
-  }
-  async createOrder(input: RouterInput['createOrder'], ctx: RouterContext): Promise<RouterOutput['createOrder']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createOrder', input);
-    const order = await ctx.app.model.Order.create(input);
-    return order as Order;
-  }
-  async updateOrder(input: RouterInput['updateOrder'], ctx: RouterContext): Promise<RouterOutput['updateOrder']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateOrder', input);
-    const updatedOrder = await ctx.app.model.Order.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedOrder) throw new Error('Order update failed');
-    return updatedOrder as Order;
-  }
-  // Payment Methods
-  async getPayment(input: RouterInput['getPayment'], ctx: RouterContext): Promise<RouterOutput['getPayment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getPayment', input);
-    const payment = await ctx.app.model.Payment.findOne(getFilter(input)).exec();
-    if (!payment) throw new Error('Payment not found');
-    return payment as Payment;
-  }
-  async createPayment(input: RouterInput['createPayment'], ctx: RouterContext): Promise<RouterOutput['createPayment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createPayment', input);
-    const payment = await ctx.app.model.Payment.create(input);
-    return payment as Payment;
-  }
-  async updatePayment(input: RouterInput['updatePayment'], ctx: RouterContext): Promise<RouterOutput['updatePayment']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updatePayment', input);
-    const updatedPayment = await ctx.app.model.Payment.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedPayment) throw new Error('Payment update failed');
-    return updatedPayment as Payment;
-  }
-  // Permission Methods
-  async getPermission(input: RouterInput['getPermission'], ctx: RouterContext): Promise<RouterOutput['getPermission']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getPermission', input);
-    const permission = await ctx.app.model.Permission.findOne(getFilter(input)).exec();
-    if (!permission) throw new Error('Permission not found');
-    return permission as Permission;
-  }
-  async createPermission(
-    input: RouterInput['createPermission'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createPermission']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createPermission', input);
-    const permission = await ctx.app.model.Permission.create(input);
-    return permission as Permission;
-  }
-  async updatePermission(
-    input: RouterInput['updatePermission'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updatePermission']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updatePermission', input);
-    const updatedPermission = await ctx.app.model.Permission.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedPermission) throw new Error('Permission update failed');
-    return updatedPermission as Permission;
-  }
-  // Person Methods
-  async getPerson(input: RouterInput['getPerson'], ctx: RouterContext): Promise<RouterOutput['getPerson']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getPerson', input);
-    const person = await ctx.app.model.Person.findOne(getFilter(input)).exec();
-    if (!person) throw new Error('Person not found');
-    return person as Person;
-  }
-  async createPerson(input: RouterInput['createPerson'], ctx: RouterContext): Promise<RouterOutput['createPerson']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createPerson', input);
-    const person = await ctx.app.model.Person.create(input);
-    return person as Person;
-  }
-  async updatePerson(input: RouterInput['updatePerson'], ctx: RouterContext): Promise<RouterOutput['updatePerson']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updatePerson', input);
-    const updatedPerson = await ctx.app.model.Person.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedPerson) throw new Error('Person update failed');
-    return updatedPerson as Person;
-  }
-  // Planet Methods
-  async getPlanet(input: RouterInput['getPlanet'], ctx: RouterContext): Promise<RouterOutput['getPlanet']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getPlanet', input);
-    const planet = await ctx.app.model.Planet.findOne(getFilter(input)).exec();
-    if (!planet) throw new Error('Planet not found');
-    return planet as Planet;
-  }
-  async createPlanet(input: RouterInput['createPlanet'], ctx: RouterContext): Promise<RouterOutput['createPlanet']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createPlanet', input);
-    const planet = await ctx.app.model.Planet.create(input);
-    return planet as Planet;
-  }
-  async updatePlanet(input: RouterInput['updatePlanet'], ctx: RouterContext): Promise<RouterOutput['updatePlanet']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updatePlanet', input);
-    const updatedPlanet = await ctx.app.model.Planet.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedPlanet) throw new Error('Planet update failed');
-    return updatedPlanet as Planet;
-  }
-  // Poll Methods
-  async getPoll(input: RouterInput['getPoll'], ctx: RouterContext): Promise<RouterOutput['getPoll']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getPoll', input);
-    const poll = await ctx.app.model.Poll.findOne(getFilter(input)).exec();
-    if (!poll) throw new Error('Poll not found');
-    return poll as Poll;
-  }
-  async createPoll(input: RouterInput['createPoll'], ctx: RouterContext): Promise<RouterOutput['createPoll']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createPoll', input);
-    const poll = await ctx.app.model.Poll.create(input);
-    return poll as Poll;
-  }
-  async updatePoll(input: RouterInput['updatePoll'], ctx: RouterContext): Promise<RouterOutput['updatePoll']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updatePoll', input);
-    const updatedPoll = await ctx.app.model.Poll.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedPoll) throw new Error('Poll update failed');
-    return updatedPoll as Poll;
-  }
-  // Project Methods
-  async getProject(input: RouterInput['getProject'], ctx: RouterContext): Promise<RouterOutput['getProject']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getProject', input);
-    const project = await ctx.app.model.Project.findOne(getFilter(input)).exec();
-    if (!project) throw new Error('Project not found');
-    return project as Project;
-  }
-  async createProject(input: RouterInput['createProject'], ctx: RouterContext): Promise<RouterOutput['createProject']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createProject', input);
-    const project = await ctx.app.model.Project.create(input);
-    return project as Project;
-  }
-  async updateProject(input: RouterInput['updateProject'], ctx: RouterContext): Promise<RouterOutput['updateProject']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateProject', input);
-    const updatedProject = await ctx.app.model.Project.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedProject) throw new Error('Project update failed');
-    return updatedProject as Project;
-  }
-  // Proposal Methods
-  async getProposal(input: RouterInput['getProposal'], ctx: RouterContext): Promise<RouterOutput['getProposal']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getProposal', input);
-    const proposal = await ctx.app.model.Proposal.findOne(getFilter(input)).exec();
-    if (!proposal) throw new Error('Proposal not found');
-    return proposal as Proposal;
-  }
-  async createProposal(
-    input: RouterInput['createProposal'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createProposal']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createProposal', input);
-    const proposal = await ctx.app.model.Proposal.create(input);
-    return proposal as Proposal;
-  }
-  async updateProposal(
-    input: RouterInput['updateProposal'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateProposal']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateProposal', input);
-    const updatedProposal = await ctx.app.model.Proposal.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedProposal) throw new Error('Proposal update failed');
-    return updatedProposal as Proposal;
-  }
-  // Quest Methods
-  async getQuest(input: RouterInput['getQuest'], ctx: RouterContext): Promise<RouterOutput['getQuest']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getQuest', input);
-    const quest = await ctx.app.model.Quest.findOne(getFilter(input)).exec();
-    if (!quest) throw new Error('Quest not found');
-    return quest as Quest;
-  }
-  async createQuest(input: RouterInput['createQuest'], ctx: RouterContext): Promise<RouterOutput['createQuest']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createQuest', input);
-    const quest = await ctx.app.model.Quest.create(input);
-    return quest as Quest;
-  }
-  async updateQuest(input: RouterInput['updateQuest'], ctx: RouterContext): Promise<RouterOutput['updateQuest']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateQuest', input);
-    const updatedQuest = await ctx.app.model.Quest.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedQuest) throw new Error('Quest update failed');
-    return updatedQuest as Quest;
-  }
-  // Rating Methods
-  async getRating(input: RouterInput['getRating'], ctx: RouterContext): Promise<RouterOutput['getRating']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRating', input);
-    const rating = await ctx.app.model.Rating.findOne(getFilter(input)).exec();
-    if (!rating) throw new Error('Rating not found');
-    return rating as Rating;
-  }
-  async createRating(input: RouterInput['createRating'], ctx: RouterContext): Promise<RouterOutput['createRating']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRating', input);
-    const rating = await ctx.app.model.Rating.create(input);
-    return rating as Rating;
-  }
-  async updateRating(input: RouterInput['updateRating'], ctx: RouterContext): Promise<RouterOutput['updateRating']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRating', input);
-    const updatedRating = await ctx.app.model.Rating.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedRating) throw new Error('Rating update failed');
-    return updatedRating as Rating;
-  }
-  // Realm Methods
-  async getRealm(input: RouterInput['getRealm'], ctx: RouterContext): Promise<RouterOutput['getRealm']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRealm', input);
-    const realm = await ctx.app.model.Realm.findOne(getFilter(input)).exec();
-    if (!realm) throw new Error('Realm not found');
-    return realm as Realm;
-  }
-  async getRealms(input: RouterInput['getRealms'], ctx: RouterContext): Promise<RouterOutput['getRealms']> {
-    log('Core.Service.getRealms', input);
-    const filter = getFilter(input);
-    filter.status = 'Online';
-    let realms: Realm[] = await ctx.app.model.Realm.find(filter).exec();
-    console.log('getRealms', realms);
-    realms = [
-      {
-        status: 'Online',
-        clientCount: 1,
-        regionCode: 'EU',
-        endpoint: 'evolution-realm-1.arken.gg',
-        gameId: '673996aec43266df5f966da6',
-        realmShards: [
-          {
-            status: 'Online',
-            clientCount: 1,
-            endpoint: 'evolution-realm-shard-1.arken.gg',
-          },
-        ],
-      },
-    ];
-    return realms;
-  }
-  async createRealm(input: RouterInput['createRealm'], ctx: RouterContext): Promise<RouterOutput['createRealm']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRealm', input);
-    const realm = await ctx.app.model.Realm.create(input);
-    return realm as Realm;
-  }
-  async updateRealm(input: RouterInput['updateRealm'], ctx: RouterContext): Promise<RouterOutput['updateRealm']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRealm', input);
-    // const data = {};
-    // if (!this.realms[input.data.realmId]) this.realms[input.data.realmId] = {};
-    // const realm: Arken.Core.Types.Realm = this.realms[input.data.realmId];
-    // realm.status = input.data.status;
-    // realm.clientCount = input.data.clientCount;
-    // realm.regionCode = input.data.regionCode;
-    // realm.realmShards = input.data.realmShards;
-    const updatedRealm = await ctx.app.model.Realm.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedRealm) throw new Error('Realm update failed');
-    return updatedRealm as Realm;
-  }
-  // RealmEvent Methods
-  async getRealmEvent(input: RouterInput['getRealmEvent'], ctx: RouterContext): Promise<RouterOutput['getRealmEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRealmEvent', input);
-    const realmEvent = await ctx.app.model.RealmEvent.findOne(getFilter(input)).exec();
-    if (!realmEvent) throw new Error('RealmEvent not found');
-    return realmEvent as RealmEvent;
-  }
-  async getRealmEvents(
-    input: RouterInput['getRealmEvents'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getRealmEvents']> {
-    log('Core.Service.getRealmEvents', input);
-    const filter = getFilter(input);
-    filter.status = 'Online';
-    let realmEvents: RealmEvent[] = await ctx.app.model.RealmEvent.find(filter).exec();
-    console.log('getRealmEvents', realmEvents);
-    return realmEvents;
-  }
-  async createRealmEvent(
-    input: RouterInput['createRealmEvent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRealmEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRealmEvent', input);
-    const realmEvent = await ctx.app.model.RealmEvent.create(input);
-    return realmEvent as RealmEvent;
-  }
-  async updateRealmEvent(
-    input: RouterInput['updateRealmEvent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRealmEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRealmEvent', input);
-    // const data = {};
-    // if (!this.realms[input.data.realmId]) this.realms[input.data.realmId] = {};
-    // const realm: Arken.Core.Types.RealmEvent = this.realms[input.data.realmId];
-    // realm.status = input.data.status;
-    // realm.clientCount = input.data.clientCount;
-    // realm.regionCode = input.data.regionCode;
-    // realm.realmShards = input.data.realmShards;
-    const updatedRealmEvent = await ctx.app.model.RealmEvent.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedRealmEvent) throw new Error('RealmEvent update failed');
-    return updatedRealmEvent as RealmEvent;
-  }
-  // Revision Methods
-  async getRevision(input: RouterInput['getRevision'], ctx: RouterContext): Promise<RouterOutput['getRevision']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRevision', input);
-    const revision = await ctx.app.model.Revision.findOne(getFilter(input)).exec();
-    if (!revision) throw new Error('Revision not found');
-    return revision as Revision;
-  }
-  async createRevision(
-    input: RouterInput['createRevision'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRevision']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRevision', input);
-    const revision = await ctx.app.model.Revision.create(input);
-    return revision as Revision;
-  }
-  async updateRevision(
-    input: RouterInput['updateRevision'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRevision']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRevision', input);
-    const updatedRevision = await ctx.app.model.Revision.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedRevision) throw new Error('Revision update failed');
-    return updatedRevision as Revision;
-  }
-  // Referral Methods
-  async getReferral(input: RouterInput['getReferral'], ctx: RouterContext): Promise<RouterOutput['getReferral']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getReferral', input);
-    const referral = await ctx.app.model.Referral.findOne(getFilter(input)).exec();
-    if (!referral) throw new Error('Referral not found');
-    return referral as Referral;
-  }
-  async createReferral(
-    input: RouterInput['createReferral'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createReferral']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createReferral', input);
-    const referral = await ctx.app.model.Referral.create(input);
-    return referral as Referral;
-  }
-  async updateReferral(
-    input: RouterInput['updateReferral'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateReferral']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateReferral', input);
-    const updatedReferral = await ctx.app.model.Referral.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedReferral) throw new Error('Referral update failed');
-    return updatedReferral as Referral;
-  }
-  // Review Methods
-  async getReview(input: RouterInput['getReview'], ctx: RouterContext): Promise<RouterOutput['getReview']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getReview', input);
-    const review = await ctx.app.model.Review.findOne(getFilter(input)).exec();
-    if (!review) throw new Error('Review not found');
-    return review as Review;
-  }
-  async createReview(input: RouterInput['createReview'], ctx: RouterContext): Promise<RouterOutput['createReview']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createReview', input);
-    const review = await ctx.app.model.Review.create(input);
-    return review as Review;
-  }
-  async updateReview(input: RouterInput['updateReview'], ctx: RouterContext): Promise<RouterOutput['updateReview']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateReview', input);
-    const updatedReview = await ctx.app.model.Review.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedReview) throw new Error('Review update failed');
-    return updatedReview as Review;
-  }
-  // Role Methods
-  async getRole(input: RouterInput['getRole'], ctx: RouterContext): Promise<RouterOutput['getRole']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRole', input);
-    const role = await ctx.app.model.Role.findOne(getFilter(input)).exec();
-    if (!role) throw new Error('Role not found');
-    return role as Role;
-  }
-  async createRole(input: RouterInput['createRole'], ctx: RouterContext): Promise<RouterOutput['createRole']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRole', input);
-    const role = await ctx.app.model.Role.create(input);
-    return role as Role;
-  }
-  async updateRole(input: RouterInput['updateRole'], ctx: RouterContext): Promise<RouterOutput['updateRole']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRole', input);
-    const updatedRole = await ctx.app.model.Role.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedRole) throw new Error('Role update failed');
-    return updatedRole as Role;
-  }
-  // Season Methods
-  async getSeason(input: RouterInput['getSeason'], ctx: RouterContext): Promise<RouterOutput['getSeason']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getSeason', input);
-    const season = await ctx.app.model.Season.findOne(getFilter(input)).exec();
-    if (!season) throw new Error('Season not found');
-    return season as Season;
-  }
-  async createSeason(input: RouterInput['createSeason'], ctx: RouterContext): Promise<RouterOutput['createSeason']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createSeason', input);
-    const season = await ctx.app.model.Season.create(input);
-    return season as Season;
-  }
-  async updateSeason(input: RouterInput['updateSeason'], ctx: RouterContext): Promise<RouterOutput['updateSeason']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateSeason', input);
-    const updatedSeason = await ctx.app.model.Season.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSeason) throw new Error('Season update failed');
-    return updatedSeason as Season;
-  }
-  // RealmShard Methods
-  async getRealmShard(input: RouterInput['getRealmShard'], ctx: RouterContext): Promise<RouterOutput['getRealmShard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getRealmShard', input);
-    const server = await ctx.app.model.RealmShard.findOne(getFilter(input)).exec();
-    if (!server) throw new Error('RealmShard not found');
-    return server as RealmShard;
-  }
-  async getRealmShards(
-    input: RouterInput['getRealmShards'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getRealmShards']> {
-    log('Core.Service.getRealmShards', input);
-    const filter = getFilter(input);
-    filter.status = 'Active';
-    const servers = await ctx.app.model.RealmShard.find(filter).exec();
-    return servers as RealmShard[];
-  }
-  async createRealmShard(
-    input: RouterInput['createRealmShard'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createRealmShard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createRealmShard', input);
-    const server = await ctx.app.model.RealmShard.create(input);
-    return server as RealmShard;
-  }
-  async updateRealmShard(
-    input: RouterInput['updateRealmShard'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateRealmShard']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateRealmShard', input);
-    const updatedRealmShard = await ctx.app.model.RealmShard.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedRealmShard) throw new Error('RealmShard update failed');
-    return updatedRealmShard as RealmShard;
-  }
-  // Session Methods
-  async getSession(input: RouterInput['getSession'], ctx: RouterContext): Promise<RouterOutput['getSession']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getSession', input);
-    const session = await ctx.app.model.Session.findOne(getFilter(input)).exec();
-    if (!session) throw new Error('Session not found');
-    return session as Session;
-  }
-  async createSession(input: RouterInput['createSession'], ctx: RouterContext): Promise<RouterOutput['createSession']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createSession', input);
-    const session = await ctx.app.model.Session.create(input);
-    return session as Session;
-  }
-  async updateSession(input: RouterInput['updateSession'], ctx: RouterContext): Promise<RouterOutput['updateSession']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateSession', input);
-    const updatedSession = await ctx.app.model.Session.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedSession) throw new Error('Session update failed');
-    return updatedSession as Session;
-  }
-  // SolarSystem Methods
-  async getSolarSystem(
-    input: RouterInput['getSolarSystem'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getSolarSystem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getSolarSystem', input);
-    const solarSystem = await ctx.app.model.SolarSystem.findOne(getFilter(input)).exec();
-    if (!solarSystem) throw new Error('SolarSystem not found');
-    return solarSystem as SolarSystem;
-  }
-  async createSolarSystem(
-    input: RouterInput['createSolarSystem'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSolarSystem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createSolarSystem', input);
-    const solarSystem = await ctx.app.model.SolarSystem.create(input);
-    return solarSystem as SolarSystem;
-  }
-  async updateSolarSystem(
-    input: RouterInput['updateSolarSystem'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSolarSystem']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateSolarSystem', input);
-    const updatedSolarSystem = await ctx.app.model.SolarSystem.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedSolarSystem) throw new Error('SolarSystem update failed');
-    return updatedSolarSystem as SolarSystem;
-  }
-  // Star Methods
-  async getStar(input: RouterInput['getStar'], ctx: RouterContext): Promise<RouterOutput['getStar']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getStar', input);
-    const star = await ctx.app.model.Star.findOne(getFilter(input)).exec();
-    if (!star) throw new Error('Star not found');
-    return star as Star;
-  }
-  async createStar(input: RouterInput['createStar'], ctx: RouterContext): Promise<RouterOutput['createStar']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createStar', input);
-    const star = await ctx.app.model.Star.create(input);
-    return star as Star;
-  }
-  async updateStar(input: RouterInput['updateStar'], ctx: RouterContext): Promise<RouterOutput['updateStar']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateStar', input);
-    const updatedStar = await ctx.app.model.Star.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedStar) throw new Error('Star update failed');
-    return updatedStar as Star;
-  }
-  // Stash Methods
-  async getStash(input: RouterInput['getStash'], ctx: RouterContext): Promise<RouterOutput['getStash']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getStash', input);
-    const stash = await ctx.app.model.Stash.findOne(getFilter(input)).exec();
-    if (!stash) throw new Error('Stash not found');
-    return stash as Stash;
-  }
-  async createStash(input: RouterInput['createStash'], ctx: RouterContext): Promise<RouterOutput['createStash']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createStash', input);
-    const stash = await ctx.app.model.Stash.create(input);
-    return stash as Stash;
-  }
-  async updateStash(input: RouterInput['updateStash'], ctx: RouterContext): Promise<RouterOutput['updateStash']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateStash', input);
-    const updatedStash = await ctx.app.model.Stash.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedStash) throw new Error('Stash update failed');
-    return updatedStash as Stash;
-  }
-  // Stock Methods
-  async getStock(input: RouterInput['getStock'], ctx: RouterContext): Promise<RouterOutput['getStock']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getStock', input);
-    const stock = await ctx.app.model.Stock.findOne(getFilter(input)).exec();
-    if (!stock) throw new Error('Stock not found');
-    return stock as Stock;
-  }
-  async createStock(input: RouterInput['createStock'], ctx: RouterContext): Promise<RouterOutput['createStock']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createStock', input);
-    const stock = await ctx.app.model.Stock.create(input);
-    return stock as Stock;
-  }
-  async updateStock(input: RouterInput['updateStock'], ctx: RouterContext): Promise<RouterOutput['updateStock']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateStock', input);
-    const updatedStock = await ctx.app.model.Stock.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedStock) throw new Error('Stock update failed');
-    return updatedStock as Stock;
-  } // Suggestion Methods
-  async getSuggestion(input: RouterInput['getSuggestion'], ctx: RouterContext): Promise<RouterOutput['getSuggestion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getSuggestion', input);
-    const suggestion = await ctx.app.model.Suggestion.findOne(getFilter(input)).exec();
-    if (!suggestion) throw new Error('Suggestion not found');
-    return suggestion as Suggestion;
-  }
-  async createSuggestion(
-    input: RouterInput['createSuggestion'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createSuggestion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createSuggestion', input);
-    const suggestion = await ctx.app.model.Suggestion.create(input);
-    return suggestion as Suggestion;
-  }
-  async updateSuggestion(
-    input: RouterInput['updateSuggestion'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateSuggestion']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateSuggestion', input);
-    const updatedSuggestion = await ctx.app.model.Suggestion.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedSuggestion) throw new Error('Suggestion update failed');
-    return updatedSuggestion as Suggestion;
-  }
-  // Tag Methods
-  async getTag(input: RouterInput['getTag'], ctx: RouterContext): Promise<RouterOutput['getTag']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTag', input);
-    const tag = await ctx.app.model.Tag.findOne(getFilter(input)).exec();
-    if (!tag) throw new Error('Tag not found');
-    return tag as Tag;
-  }
-  async createTag(input: RouterInput['createTag'], ctx: RouterContext): Promise<RouterOutput['createTag']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createTag', input);
-    const tag = await ctx.app.model.Tag.create(input);
-    return tag as Tag;
-  }
-  async updateTag(input: RouterInput['updateTag'], ctx: RouterContext): Promise<RouterOutput['updateTag']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateTag', input);
-    const updatedTag = await ctx.app.model.Tag.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedTag) throw new Error('Tag update failed');
-    return updatedTag as Tag;
-  }
-  // Team Methods
-  async getTeam(input: RouterInput['getTeam'], ctx: RouterContext): Promise<RouterOutput['getTeam']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTeam', input);
-    const filter = getFilter(input);
-    const team = await ctx.app.model.Team.findOne(filter).exec();
-    if (!team) throw new Error('Team not found');
-    return team as Team;
-  }
-  async getTeams(input: RouterInput['getTeams'], ctx: RouterContext): Promise<RouterOutput['getTeams']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTeams', input);
-    const filter = getFilter(input);
-    const teams = await ctx.app.model.Team.find(filter)
-      .skip(input.skip || 0)
-      .limit(input.limit || 10)
-      .exec();
-    return teams as Team[];
-  }
-  async createTeam(input: RouterInput['createTeam'], ctx: RouterContext): Promise<RouterOutput['createTeam']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createTeam', input);
-    const team = await ctx.app.model.Team.create(input);
-    return team as Team;
-  }
-  async updateTeam(input: RouterInput['updateTeam'], ctx: RouterContext): Promise<RouterOutput['updateTeam']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateTeam', input);
-    const updatedTeam = await ctx.app.model.Team.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedTeam) throw new Error('Team update failed');
-    return updatedTeam as Team;
-  }
-  // Tournament Methods
-  async getTournament(input: RouterInput['getTournament'], ctx: RouterContext): Promise<RouterOutput['getTournament']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTournament', input);
-    const tournament = await ctx.app.model.Tournament.findOne(getFilter(input)).exec();
-    if (!tournament) throw new Error('Tournament not found');
-    return tournament as Tournament;
-  }
-  async createTournament(
-    input: RouterInput['createTournament'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createTournament']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createTournament', input);
-    const tournament = await ctx.app.model.Tournament.create(input);
-    return tournament as Tournament;
-  }
-  async updateTournament(
-    input: RouterInput['updateTournament'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateTournament']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateTournament', input);
-    const updatedTournament = await ctx.app.model.Tournament.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedTournament) throw new Error('Tournament update failed');
-    return updatedTournament as Tournament;
-  }
-  // Trade Methods
-  async getTrade(input: RouterInput['getTrade'], ctx: RouterContext): Promise<RouterOutput['getTrade']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTrade', input);
-    const trade = await ctx.app.model.Trade.findOne(getFilter(input)).exec();
-    if (!trade) throw new Error('Trade not found');
-    return trade as Trade;
-  }
-  async getTrades(input: RouterInput['getTrades'], ctx: RouterContext): Promise<RouterOutput['getTrades']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getTrades', input);
-    const trade = await ctx.app.model.Trade.find().limit(10).exec();
-    return trade as Trade[];
-  }
-  async createTrade(input: RouterInput['createTrade'], ctx: RouterContext): Promise<RouterOutput['createTrade']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createTrade', input);
-    const trade = await ctx.app.model.Trade.create(input);
-    return trade as Trade;
-  }
-  async updateTrade(input: RouterInput['updateTrade'], ctx: RouterContext): Promise<RouterOutput['updateTrade']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateTrade', input);
-    const updatedTrade = await ctx.app.model.Trade.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedTrade) throw new Error('Trade update failed');
-    return updatedTrade as Trade;
-  }
-  // Universe Methods
-  async getUniverse(input: RouterInput['getUniverse'], ctx: RouterContext): Promise<RouterOutput['getUniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getUniverse', input);
-    const universe = await ctx.app.model.Universe.findOne(getFilter(input)).exec();
-    if (!universe) throw new Error('Universe not found');
-    return universe as Universe;
-  }
-  async createUniverse(
-    input: RouterInput['createUniverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createUniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createUniverse', input);
-    const universe = await ctx.app.model.Universe.create(input);
-    return universe as Universe;
-  }
-  async updateUniverse(
-    input: RouterInput['updateUniverse'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateUniverse']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateUniverse', input);
-    const updatedUniverse = await ctx.app.model.Universe.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedUniverse) throw new Error('Universe update failed');
-    return updatedUniverse as Universe;
-  }
-  // Validator Methods
-  async getValidator(input: RouterInput['getValidator'], ctx: RouterContext): Promise<RouterOutput['getValidator']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getValidator', input);
-    const validator = await ctx.app.model.Validator.findOne(getFilter(input)).exec();
-    if (!validator) throw new Error('Validator not found');
-    return validator as Validator;
-  }
-  async createValidator(
-    input: RouterInput['createValidator'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createValidator']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createValidator', input);
-    const validator = await ctx.app.model.Validator.create(input);
-    return validator as Validator;
-  }
-  async updateValidator(
-    input: RouterInput['updateValidator'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateValidator']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateValidator', input);
-    const updatedValidator = await ctx.app.model.Validator.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedValidator) throw new Error('Validator update failed');
-    return updatedValidator as Validator;
-  }
-  // Vote Methods
-  async getVote(input: RouterInput['getVote'], ctx: RouterContext): Promise<RouterOutput['getVote']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getVote', input);
-    const vote = await ctx.app.model.Vote.findOne(getFilter(input)).exec();
-    if (!vote) throw new Error('Vote not found');
-    return vote as Vote;
-  }
-  async createVote(input: RouterInput['createVote'], ctx: RouterContext): Promise<RouterOutput['createVote']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createVote', input);
-    const vote = await ctx.app.model.Vote.create(input);
-    return vote as Vote;
-  }
-  async updateVote(input: RouterInput['updateVote'], ctx: RouterContext): Promise<RouterOutput['updateVote']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateVote', input);
-    const updatedVote = await ctx.app.model.Vote.findByIdAndUpdate(input.where.id.equals, { new: true }).exec();
-    if (!updatedVote) throw new Error('Vote update failed');
-    return updatedVote as Vote;
-  }
-  // WorldEvent Methods
-  async getWorldEvent(input: RouterInput['getWorldEvent'], ctx: RouterContext): Promise<RouterOutput['getWorldEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getWorldEvent', input);
-    const worldEvent = await ctx.app.model.WorldEvent.findOne(getFilter(input)).exec();
-    if (!worldEvent) throw new Error('WorldEvent not found');
-    return worldEvent as WorldEvent;
-  }
-  async createWorldEvent(
-    input: RouterInput['createWorldEvent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createWorldEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createWorldEvent', input);
-    const worldEvent = await ctx.app.model.WorldEvent.create(input);
-    return worldEvent as WorldEvent;
-  }
-  async updateWorldEvent(
-    input: RouterInput['updateWorldEvent'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateWorldEvent']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateWorldEvent', input);
-    const updatedWorldEvent = await ctx.app.model.WorldEvent.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedWorldEvent) throw new Error('WorldEvent update failed');
-    return updatedWorldEvent as WorldEvent;
-  }
-  // WorldRecord Methods
-  async getWorldRecord(
-    input: RouterInput['getWorldRecord'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['getWorldRecord']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getWorldRecord', input);
-    const worldRecord = await ctx.app.model.WorldRecord.findOne(getFilter(input)).exec();
-    if (!worldRecord) throw new Error('WorldRecord not found');
-    return worldRecord as WorldRecord;
-  }
-  async createWorldRecord(
-    input: RouterInput['createWorldRecord'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['createWorldRecord']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createWorldRecord', input);
-    const worldRecord = await ctx.app.model.WorldRecord.create(input);
-    return worldRecord as WorldRecord;
-  }
-  async updateWorldRecord(
-    input: RouterInput['updateWorldRecord'],
-    ctx: RouterContext
-  ): Promise<RouterOutput['updateWorldRecord']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateWorldRecord', input);
-    const updatedWorldRecord = await ctx.app.model.WorldRecord.findByIdAndUpdate(input.where.id.equals, {
-      new: true,
-    })
-      .lean()
-      .exec();
-    if (!updatedWorldRecord) throw new Error('WorldRecord update failed');
-    return updatedWorldRecord as WorldRecord;
-  }
-  // Get Bounty
-  async getBounty(input: RouterInput['getBounty'], ctx: RouterContext): Promise<RouterOutput['getBounty']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.getBounty', input);
-    const bounty = await ctx.app.model.Bounty.findOne(getFilter(input)).exec();
-    if (!bounty) throw new Error('Bounty not found');
-    return bounty as Bounty;
-  }
-  // Create Bounty
-  async createBounty(input: RouterInput['createBounty'], ctx: RouterContext): Promise<RouterOutput['createBounty']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.createBounty', input);
-    const bounty = await ctx.app.model.Bounty.create(input);
-    return bounty as Bounty;
-  }
-  // Update Bounty
-  async updateBounty(input: RouterInput['updateBounty'], ctx: RouterContext): Promise<RouterOutput['updateBounty']> {
-    if (!input) throw new ARXError('NO_INPUT');
-    log('Core.Service.updateBounty', input);
-    const updatedBounty = await ctx.app.model.Bounty.findByIdAndUpdate(input.where.id.equals, { new: true })
-      .lean()
-      .exec();
-    if (!updatedBounty) throw new Error('Bounty update failed');
-    return updatedBounty as Bounty;
-  }
-}