@anvil-js/client 0.0.1 → 0.0.2

package/dist/server.cjs

@@ -0,0 +1,1038 @@
+'use strict';
+
+var server = require('@trpc/server');
+var zod = require('zod');
+
+// src/router.ts
+var UUIDSchema = zod.z.string().uuid();
+var ISODateSchema = zod.z.string().datetime({ offset: true });
+var ArchSchema = zod.z.enum(["x64", "arm64", "x86"]);
+zod.z.enum(["windows", "macos", "linux"]);
+var LoaderTypeSchema = zod.z.enum(["vanilla", "fabric", "forge", "neoforge", "quilt"]);
+var LocalizedStringSchema = zod.z.record(zod.z.string(), zod.z.string());
+zod.z.object({
+  code: zod.z.enum([
+    "BAD_REQUEST",
+    "UNAUTHORIZED",
+    "FORBIDDEN",
+    "NOT_FOUND",
+    "CONFLICT",
+    "TOO_MANY_REQUESTS",
+    "INTERNAL_SERVER_ERROR"
+  ]),
+  message: zod.z.string()
+});
+zod.z.object({
+  page: zod.z.number().int().min(1).default(1),
+  pageSize: zod.z.number().int().min(1).max(200).default(50)
+});
+var UserSummarySchema = zod.z.object({
+  uuid: UUIDSchema,
+  email: zod.z.string().email(),
+  username: zod.z.string().min(1).max(64),
+  displayName: zod.z.string().min(1).max(128),
+  avatarUrl: zod.z.string().url().nullable(),
+  role: zod.z.enum(["USER", "MODERATOR", "ADMIN"]).default("USER")
+});
+var SessionSchema = zod.z.object({
+  anvil: zod.z.object({
+    user: UserSummarySchema,
+    accessToken: zod.z.string(),
+    refreshToken: zod.z.string(),
+    expiresAt: ISODateSchema
+  }),
+  mojang: zod.z.object({
+    uuid: UUIDSchema,
+    username: zod.z.string(),
+    accessToken: zod.z.string(),
+    expiresAt: ISODateSchema
+  }).nullable()
+});
+var LoginInputSchema = zod.z.object({
+  email: zod.z.string().email(),
+  password: zod.z.string().min(8).max(128)
+});
+var RegisterInputSchema = zod.z.object({
+  email: zod.z.string().email(),
+  username: zod.z.string().min(3).max(64).regex(/^[a-zA-Z0-9_]+$/),
+  password: zod.z.string().min(8).max(128)
+});
+var RefreshInputSchema = zod.z.object({
+  refreshToken: zod.z.string().min(1)
+});
+var ForgotPasswordInputSchema = zod.z.object({
+  email: zod.z.string().email()
+});
+var ResetPasswordInputSchema = zod.z.object({
+  token: zod.z.string().min(1),
+  newPassword: zod.z.string().min(8).max(128)
+});
+var ValidateInputSchema = zod.z.object({
+  token: zod.z.string().min(1)
+});
+var BuildSummarySchema = zod.z.object({
+  id: UUIDSchema,
+  slug: zod.z.string(),
+  name: zod.z.string(),
+  shortDescription: zod.z.string(),
+  iconUrl: zod.z.string().url().nullable(),
+  mcVersions: zod.z.array(zod.z.string()),
+  loaders: zod.z.array(LoaderTypeSchema),
+  visibility: zod.z.enum(["public", "private", "unlisted"]),
+  pricing: zod.z.discriminatedUnion("model", [
+    zod.z.object({ model: zod.z.literal("free") }),
+    zod.z.object({
+      model: zod.z.literal("paid"),
+      priceCents: zod.z.number().int().nonnegative(),
+      currency: zod.z.string()
+    }),
+    zod.z.object({
+      model: zod.z.literal("subscription"),
+      tiers: zod.z.array(
+        zod.z.object({
+          id: zod.z.string(),
+          name: zod.z.string(),
+          priceCents: zod.z.number().int().nonnegative(),
+          interval: zod.z.enum(["month", "year"])
+        })
+      )
+    })
+  ]),
+  stats: zod.z.object({
+    downloads: zod.z.number().int().nonnegative(),
+    favorites: zod.z.number().int().nonnegative(),
+    updatedAt: ISODateSchema
+  }),
+  // Provider source  --  UI uses this to badge cards (Modrinth / Anvil).
+  source: zod.z.enum(["modrinth", "anvil"]).default("anvil")
+});
+var BuildFileSchema = zod.z.object({
+  url: zod.z.string().url(),
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: zod.z.number().int().nonnegative(),
+  primary: zod.z.boolean()
+});
+var BuildVersionSchema = zod.z.object({
+  id: UUIDSchema,
+  buildId: UUIDSchema,
+  name: zod.z.string(),
+  mcVersion: zod.z.string(),
+  loader: LoaderTypeSchema,
+  loaderVersion: zod.z.string(),
+  files: zod.z.array(BuildFileSchema),
+  dependencies: zod.z.array(
+    zod.z.object({
+      kind: zod.z.enum(["required", "optional", "incompatible", "embedded"]),
+      projectId: zod.z.string(),
+      versionId: zod.z.string().optional()
+    })
+  ),
+  changelog: zod.z.string().optional(),
+  publishedAt: ISODateSchema
+});
+var BuildSchema = BuildSummarySchema.extend({
+  versions: zod.z.array(BuildVersionSchema),
+  description: zod.z.string().optional(),
+  longDescription: LocalizedStringSchema.optional()
+});
+var ListBuildsInputSchema = zod.z.object({
+  search: zod.z.string().optional(),
+  tags: zod.z.array(zod.z.string()).optional(),
+  mcVersions: zod.z.array(zod.z.string()).optional(),
+  loaders: zod.z.array(LoaderTypeSchema).optional(),
+  visibility: zod.z.array(zod.z.enum(["public", "private", "unlisted"])).optional(),
+  source: zod.z.array(zod.z.enum(["modrinth", "anvil"])).optional(),
+  page: zod.z.number().int().min(1).default(1),
+  pageSize: zod.z.number().int().min(1).max(100).default(24),
+  sort: zod.z.enum(["popular", "recent", "name"]).default("popular")
+});
+var GetBuildInputSchema = zod.z.object({
+  idOrSlug: zod.z.string().min(1)
+});
+var RequestDownloadInputSchema = zod.z.object({
+  versionId: UUIDSchema,
+  clientArch: ArchSchema.optional()
+});
+var RequestDownloadOutputSchema = zod.z.object({
+  installId: UUIDSchema,
+  downloadUrl: zod.z.string().url(),
+  expiresAt: ISODateSchema,
+  sha256: zod.z.string(),
+  sizeBytes: zod.z.number().int().nonnegative()
+});
+var LicenseSchema = zod.z.object({
+  id: UUIDSchema,
+  buildId: UUIDSchema,
+  buildName: zod.z.string(),
+  status: zod.z.enum(["active", "expired", "revoked"]),
+  source: zod.z.enum(["purchase", "subscription", "gift", "promo", "dev_grant"]),
+  grantedAt: ISODateSchema,
+  expiresAt: ISODateSchema.nullable()
+});
+var ListLicensesInputSchema = zod.z.object({
+  buildId: UUIDSchema.optional(),
+  status: zod.z.enum(["active", "expired", "revoked"]).optional()
+});
+var CheckLicenseInputSchema = zod.z.object({
+  buildId: UUIDSchema
+});
+var CheckLicenseOutputSchema = zod.z.object({
+  hasAccess: zod.z.boolean(),
+  license: LicenseSchema.optional(),
+  reason: zod.z.enum(["no_license", "expired", "revoked", "region_locked"]).optional()
+});
+var RelationshipTypeSchema = zod.z.enum(["FRIENDS", "BLOCKED", "NEUTRAL"]);
+var RelationshipStatusSchema = zod.z.enum(["PENDING", "VERIFIED"]);
+var RelationshipDirectionSchema = zod.z.enum(["INCOMING", "OUTGOING", "MUTUAL"]);
+var RelationshipsListKindSchema = zod.z.enum([
+  "FRIENDS",
+  "INCOMING_PENDING",
+  "OUTGOING_PENDING",
+  "BLOCKED"
+]);
+var PresenceStatusSchema = zod.z.enum(["ONLINE", "OFFLINE", "AWAY", "BUSY"]);
+var RelationshipSchema = zod.z.object({
+  id: UUIDSchema,
+  type: RelationshipTypeSchema,
+  status: RelationshipStatusSchema,
+  // 'MUTUAL' for verified friends, 'INCOMING' for pending requests
+  // sent to the current user, 'OUTGOING' for pending requests the
+  // current user sent.
+  direction: RelationshipDirectionSchema,
+  // The other side of the relationship.
+  otherUser: UserSummarySchema,
+  since: ISODateSchema,
+  // uuid of the user who sent the original request (FRIENDS only;
+  // for BLOCKED this is the user who created the block, which may
+  // be either side).
+  initiatorUuid: UUIDSchema
+});
+var TrustedHostSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string().min(1).max(64),
+  domains: zod.z.array(zod.z.string().min(1).max(255)).min(1).max(32),
+  addedAt: ISODateSchema
+});
+var UserActivitySchema = zod.z.object({
+  // 'playing <buildId>' / 'building' / 'browsing' / 'afk'
+  type: zod.z.string(),
+  metadata: zod.z.record(zod.z.string(), zod.z.string())
+});
+var PresenceSchema = zod.z.object({
+  uuid: UUIDSchema,
+  status: PresenceStatusSchema,
+  lastOnline: ISODateSchema,
+  currentActivity: UserActivitySchema.optional()
+});
+var LocalizedRuleSchema = zod.z.object({
+  locale: zod.z.string(),
+  title: zod.z.string(),
+  body: zod.z.string()
+});
+var CommunityRulesStatusSchema = zod.z.object({
+  accepted: zod.z.boolean(),
+  version: zod.z.string(),
+  rules: zod.z.array(LocalizedRuleSchema),
+  updatedAt: ISODateSchema
+});
+var SuspensionStatusSchema = zod.z.object({
+  suspended: zod.z.boolean(),
+  reason: zod.z.string().optional(),
+  expiresAt: ISODateSchema.optional()
+});
+var CreateRelationshipInputSchema = zod.z.object({
+  targetUuid: UUIDSchema,
+  type: zod.z.enum(["FRIENDS", "BLOCKED", "NEUTRAL"])
+});
+var DeleteRelationshipInputSchema = zod.z.object({
+  targetUuid: UUIDSchema,
+  type: zod.z.enum(["FRIENDS", "BLOCKED", "NEUTRAL"])
+});
+var ListRelationshipsInputSchema = zod.z.object({
+  type: RelationshipsListKindSchema.optional()
+});
+var AcceptRequestInputSchema = zod.z.object({
+  fromUuid: UUIDSchema
+});
+var CancelRequestInputSchema = zod.z.object({
+  toUuid: UUIDSchema
+});
+var LookupByNameInputSchema = zod.z.object({
+  username: zod.z.string().min(3).max(64).regex(/^[a-zA-Z0-9_]+$/)
+});
+var ReportActivityInputSchema = zod.z.object({
+  type: zod.z.string().min(1).max(64),
+  metadata: zod.z.record(zod.z.string(), zod.z.string())
+});
+var InviteToServerInputSchema = zod.z.object({
+  targetUuid: UUIDSchema,
+  address: zod.z.string().min(1).max(512)
+});
+var CreateTrustedHostInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(64),
+  domains: zod.z.array(zod.z.string().min(1).max(255)).min(1).max(32)
+});
+var DeleteTrustedHostInputSchema = zod.z.object({
+  id: UUIDSchema
+});
+var LookupByNameOutputSchema = zod.z.object({
+  user: zod.z.object({
+    uuid: UUIDSchema,
+    username: zod.z.string(),
+    displayName: zod.z.string()
+  }).nullable(),
+  nameMap: zod.z.record(UUIDSchema, zod.z.string())
+});
+var CosmeticTypeSchema = zod.z.enum([
+  "hat",
+  "body",
+  "back",
+  "face",
+  "hand",
+  "feet",
+  "particle",
+  "emote"
+]);
+var CosmeticRaritySchema = zod.z.enum(["common", "uncommon", "rare", "epic", "legendary"]);
+var CosmeticSchema = zod.z.object({
+  id: UUIDSchema,
+  type: CosmeticTypeSchema,
+  rarity: CosmeticRaritySchema,
+  name: LocalizedStringSchema,
+  description: LocalizedStringSchema.optional(),
+  iconUrl: zod.z.string().url().nullable(),
+  modelUrl: zod.z.string().url().nullable(),
+  owned: zod.z.boolean().default(false),
+  equipped: zod.z.boolean().default(false)
+});
+var OutfitSlotSchema = zod.z.object({
+  type: CosmeticTypeSchema,
+  cosmeticId: UUIDSchema.nullable()
+});
+var OutfitSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string().min(1).max(64),
+  slots: zod.z.array(OutfitSlotSchema).max(8),
+  createdAt: ISODateSchema,
+  updatedAt: ISODateSchema
+});
+var EmoteWheelSlotSchema = zod.z.object({
+  position: zod.z.number().int().min(0).max(7),
+  emoteId: UUIDSchema.nullable()
+});
+var EmoteWheelSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string().min(1).max(64),
+  slots: zod.z.array(EmoteWheelSlotSchema).length(8),
+  createdAt: ISODateSchema
+});
+var SkinVariantSchema = zod.z.enum(["classic", "slim"]);
+var SkinSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string().min(1).max(64),
+  variant: SkinVariantSchema,
+  textureUrl: zod.z.string().url(),
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: zod.z.number().int().nonnegative(),
+  source: zod.z.enum(["uploaded", "mojang"]),
+  active: zod.z.boolean().default(false),
+  createdAt: ISODateSchema
+});
+var EquipCosmeticInputSchema = zod.z.object({
+  cosmeticId: UUIDSchema,
+  equipped: zod.z.boolean()
+});
+var CreateOutfitInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(64),
+  slots: zod.z.array(OutfitSlotSchema).max(8)
+});
+var UpdateOutfitInputSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string().min(1).max(64).optional(),
+  slots: zod.z.array(OutfitSlotSchema).max(8).optional()
+});
+var DeleteOutfitInputSchema = zod.z.object({ id: UUIDSchema });
+var SaveEmoteWheelInputSchema = zod.z.object({
+  id: UUIDSchema.nullable(),
+  name: zod.z.string().min(1).max(64),
+  slots: zod.z.array(EmoteWheelSlotSchema).length(8)
+});
+var UploadSkinInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(64),
+  variant: SkinVariantSchema,
+  // base64 of the PNG bytes
+  data: zod.z.string().min(1)
+});
+var SetActiveSkinInputSchema = zod.z.object({ id: UUIDSchema });
+var ChannelKindSchema = zod.z.enum(["DM", "GROUP", "ANNOUNCEMENT"]);
+var ChatMemberSchema = zod.z.object({
+  user: UserSummarySchema,
+  role: zod.z.enum(["owner", "admin", "member"]),
+  joinedAt: ISODateSchema,
+  lastReadAt: ISODateSchema.nullable(),
+  muted: zod.z.boolean().default(false)
+});
+var ChannelSchema = zod.z.object({
+  id: UUIDSchema,
+  kind: ChannelKindSchema,
+  name: zod.z.string().nullable(),
+  // null for DMs
+  members: zod.z.array(ChatMemberSchema),
+  createdAt: ISODateSchema,
+  lastMessageAt: ISODateSchema.nullable(),
+  unreadCount: zod.z.number().int().nonnegative().default(0)
+});
+var MessageSchema = zod.z.object({
+  id: UUIDSchema,
+  channelId: UUIDSchema,
+  authorUuid: UUIDSchema,
+  authorDisplayName: zod.z.string(),
+  body: zod.z.string(),
+  // Markdown can be client-rendered; for the scaffold we ship it raw.
+  bodyMarkdown: zod.z.string().optional(),
+  createdAt: ISODateSchema,
+  editedAt: ISODateSchema.nullable(),
+  deletedAt: ISODateSchema.nullable(),
+  // Optional references
+  replyTo: UUIDSchema.nullable().optional()
+});
+var ListChannelsInputSchema = zod.z.object({
+  kind: ChannelKindSchema.optional()
+});
+var CreateDMInputSchema = zod.z.object({
+  otherUserUuid: UUIDSchema
+});
+var CreateGroupInputSchema = zod.z.object({
+  name: zod.z.string().min(1).max(64),
+  memberUuids: zod.z.array(UUIDSchema).min(1).max(64)
+});
+var ListMessagesInputSchema = zod.z.object({
+  channelId: UUIDSchema,
+  before: ISODateSchema.optional(),
+  limit: zod.z.number().int().min(1).max(200).default(50)
+});
+var SendMessageInputSchema = zod.z.object({
+  channelId: UUIDSchema,
+  body: zod.z.string().min(1).max(4e3),
+  replyTo: UUIDSchema.optional()
+});
+var EditMessageInputSchema = zod.z.object({
+  id: UUIDSchema,
+  body: zod.z.string().min(1).max(4e3)
+});
+var DeleteMessageInputSchema = zod.z.object({
+  id: UUIDSchema
+});
+var MarkReadInputSchema = zod.z.object({
+  channelId: UUIDSchema,
+  messageId: UUIDSchema
+});
+var ReportMessageInputSchema = zod.z.object({
+  messageId: UUIDSchema,
+  reason: zod.z.enum(["spam", "harassment", "illegal", "other"]),
+  note: zod.z.string().max(500).optional()
+});
+var ChannelReportsInputSchema = zod.z.object({
+  channelId: UUIDSchema,
+  start: ISODateSchema.optional(),
+  end: ISODateSchema.optional()
+});
+var MediaKindSchema = zod.z.enum(["screenshot", "video", "world", "skin"]);
+var MediaItemSchema = zod.z.object({
+  id: UUIDSchema,
+  kind: MediaKindSchema,
+  url: zod.z.string().url(),
+  thumbnailUrl: zod.z.string().url().nullable(),
+  sha256: zod.z.string().regex(/^[a-f0-9]{64}$/),
+  sizeBytes: zod.z.number().int().nonnegative(),
+  width: zod.z.number().int().positive().optional(),
+  height: zod.z.number().int().positive().optional(),
+  durationSec: zod.z.number().int().nonnegative().optional(),
+  createdAt: ISODateSchema
+});
+var ListMediaInputSchema = zod.z.object({
+  kind: MediaKindSchema.optional(),
+  limit: zod.z.number().int().min(1).max(200).default(50),
+  offset: zod.z.number().int().min(0).default(0)
+});
+var UploadMediaInputSchema = zod.z.object({
+  kind: MediaKindSchema,
+  // base64 of the file bytes
+  data: zod.z.string().min(1),
+  filename: zod.z.string().min(1).max(255),
+  width: zod.z.number().int().positive().optional(),
+  height: zod.z.number().int().positive().optional()
+});
+var DeleteMediaInputSchema = zod.z.object({ id: UUIDSchema });
+var SignalingKindSchema = zod.z.enum(["offer", "answer", "candidate"]);
+var SignalingMessageSchema = zod.z.object({
+  id: UUIDSchema,
+  kind: SignalingKindSchema,
+  fromUuid: UUIDSchema,
+  toUuid: UUIDSchema,
+  payload: zod.z.string(),
+  // JSON-encoded SDP / ICE
+  createdAt: ISODateSchema
+});
+var SendSignalingInputSchema = zod.z.object({
+  toUuid: UUIDSchema,
+  kind: SignalingKindSchema,
+  payload: zod.z.string()
+});
+zod.z.object({
+  fromUuid: UUIDSchema.optional(),
+  since: ISODateSchema.optional()
+});
+var UpnpSessionStatusSchema = zod.z.enum(["pending", "active", "closed", "error"]);
+var UpnpSessionSchema = zod.z.object({
+  id: UUIDSchema,
+  ownerUuid: UUIDSchema,
+  ownerDisplayName: zod.z.string(),
+  publicAddress: zod.z.string(),
+  publicPort: zod.z.number().int().min(1).max(65535),
+  localAddress: zod.z.string(),
+  localPort: zod.z.number().int().min(1).max(65535),
+  status: UpnpSessionStatusSchema,
+  createdAt: ISODateSchema,
+  closedAt: ISODateSchema.nullable(),
+  invitedUuids: zod.z.array(UUIDSchema)
+});
+var CreateUpnpInputSchema = zod.z.object({
+  localAddress: zod.z.string(),
+  localPort: zod.z.number().int().min(1).max(65535),
+  invitedUuids: zod.z.array(UUIDSchema).default([])
+});
+var CloseUpnpInputSchema = zod.z.object({ id: UUIDSchema });
+var KnownServerSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string(),
+  address: zod.z.string(),
+  description: zod.z.string().optional(),
+  iconUrl: zod.z.string().url().nullable(),
+  playerCount: zod.z.number().int().nonnegative().nullable(),
+  maxPlayers: zod.z.number().int().positive().nullable(),
+  version: zod.z.string().nullable(),
+  pingMs: zod.z.number().int().nonnegative().nullable(),
+  source: zod.z.enum(["anvil", "community"])
+});
+var SystemStatusSchema = zod.z.object({
+  status: zod.z.enum(["operational", "degraded", "outage"]),
+  maintenanceUntil: ISODateSchema.nullable(),
+  message: zod.z.string().nullable()
+});
+var InstalledInstanceSchema = zod.z.object({
+  id: UUIDSchema,
+  name: zod.z.string(),
+  mcVersion: zod.z.string(),
+  loader: LoaderTypeSchema,
+  loaderVersion: zod.z.string(),
+  path: zod.z.string(),
+  sizeBytes: zod.z.number().int().nonnegative(),
+  lastPlayedAt: ISODateSchema.nullable(),
+  installedAt: ISODateSchema
+});
+var ReportTelemetryInputSchema = zod.z.object({
+  event: zod.z.enum(["launch", "playtime", "crash"]),
+  metadata: zod.z.record(zod.z.string(), zod.z.string()).default({})
+});
+var LauncherUpdateInfoSchema = zod.z.object({
+  currentVersion: zod.z.string(),
+  latestVersion: zod.z.string(),
+  updateAvailable: zod.z.boolean(),
+  changelog: zod.z.string().nullable(),
+  downloadUrl: zod.z.string().url().nullable()
+});
+
+// src/router.ts
+var createContext = async (opts) => {
+  return {
+    userUuid: opts.userUuid,
+    token: opts.token,
+    requestId: opts.requestId ?? (typeof crypto !== "undefined" ? crypto.randomUUID() : Math.random().toString())
+  };
+};
+var t = server.initTRPC.context().create({
+  // No superjson transformer in the scaffold. The MSW dev layer
+  // returns plain `{ result: { data } }` envelopes; using
+  // superjson here requires the server to wrap responses in
+  // `{ result: { data, meta: { values } } }`, which the MSW
+  // handlers don't (and shouldn't) emit. All our data is
+  // JSON-serializable so the default transformer is correct.
+  // When `apps/api` is wired, either re-introduce superjson
+  // here AND update the MSW handlers to match, or leave the
+  // default transformer in place (the prod NestJS handler can
+  // also omit the transformer).
+  errorFormatter: ({ shape }) => ({
+    ...shape,
+    data: {
+      code: shape.data.code,
+      httpStatus: shape.data.httpStatus
+    }
+  })
+});
+var router = t.router;
+var publicProcedure = t.procedure;
+var middleware = t.middleware;
+var isAuthed = middleware(({ ctx, next }) => {
+  if (!ctx.userUuid) {
+    throw new server.TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Authentication required"
+    });
+  }
+  const parsed = UUIDSchema.safeParse(ctx.userUuid);
+  if (!parsed.success) {
+    throw new server.TRPCError({
+      code: "UNAUTHORIZED",
+      message: "Invalid user identifier"
+    });
+  }
+  return next({ ctx: { ...ctx, userUuid: ctx.userUuid } });
+});
+var protectedProcedure = t.procedure.use(isAuthed);
+var authRouter = router({
+  // --- Anvil auth (email + password) ---
+  signIn: publicProcedure.input(LoginInputSchema).output(
+    zod.z.object({
+      accessToken: zod.z.string(),
+      refreshToken: zod.z.string(),
+      expiresAt: zod.z.string().datetime(),
+      user: UserSummarySchema
+    })
+  ).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  signUp: publicProcedure.input(RegisterInputSchema).output(
+    zod.z.object({
+      accessToken: zod.z.string(),
+      refreshToken: zod.z.string(),
+      expiresAt: zod.z.string().datetime(),
+      user: UserSummarySchema
+    })
+  ).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  refresh: publicProcedure.input(RefreshInputSchema).output(
+    zod.z.object({
+      accessToken: zod.z.string(),
+      refreshToken: zod.z.string(),
+      expiresAt: zod.z.string().datetime()
+    })
+  ).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  validate: publicProcedure.input(ValidateInputSchema).output(
+    zod.z.object({
+      valid: zod.z.boolean(),
+      user: UserSummarySchema.optional(),
+      expiresAt: zod.z.string().datetime().optional()
+    })
+  ).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  forgotPassword: publicProcedure.input(ForgotPasswordInputSchema).output(zod.z.void()).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  resetPassword: publicProcedure.input(ResetPasswordInputSchema).output(zod.z.void()).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  signOut: protectedProcedure.output(zod.z.void()).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  // --- Session (current authenticated user) ---
+  session: router({
+    current: protectedProcedure.output(SessionSchema).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  // --- Mojang auth (Microsoft OAuth)  --  spec §5.1 ---
+  mojang: router({
+    startDeviceCode: publicProcedure.output(
+      zod.z.object({
+        deviceCode: zod.z.string(),
+        userCode: zod.z.string(),
+        verificationUri: zod.z.string().url(),
+        expiresIn: zod.z.number().int(),
+        interval: zod.z.number().int()
+      })
+    ).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    pollDeviceCode: publicProcedure.input(zod.z.object({ deviceCode: zod.z.string() })).output(
+      zod.z.discriminatedUnion("kind", [
+        zod.z.object({
+          kind: zod.z.literal("success"),
+          mcAccessToken: zod.z.string(),
+          mcRefreshToken: zod.z.string(),
+          mcExpiresAt: zod.z.string().datetime(),
+          profile: zod.z.object({ uuid: UUIDSchema, username: zod.z.string() })
+        }),
+        zod.z.object({ kind: zod.z.literal("pending") }),
+        zod.z.object({
+          kind: zod.z.literal("error"),
+          code: zod.z.enum(["authorization_declined", "expired", "slow_down"])
+        })
+      ])
+    ).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  })
+});
+var buildsRouter = router({
+  list: publicProcedure.input(ListBuildsInputSchema).output(
+    zod.z.object({
+      items: zod.z.array(BuildSummarySchema),
+      total: zod.z.number().int().nonnegative(),
+      page: zod.z.number().int().min(1),
+      pageSize: zod.z.number().int().min(1)
+    })
+  ).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  get: publicProcedure.input(GetBuildInputSchema).output(BuildSchema).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  getVersions: publicProcedure.input(zod.z.object({ buildId: UUIDSchema })).output(zod.z.array(zod.z.any())).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  requestDownload: protectedProcedure.input(RequestDownloadInputSchema).output(RequestDownloadOutputSchema).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var licensesRouter = router({
+  list: protectedProcedure.input(ListLicensesInputSchema).output(zod.z.array(LicenseSchema)).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  check: protectedProcedure.input(CheckLicenseInputSchema).output(CheckLicenseOutputSchema).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var healthRouter = router({
+  ping: publicProcedure.output(zod.z.object({ status: zod.z.string(), version: zod.z.string(), timestamp: zod.z.string().datetime() })).query(() => ({
+    status: "ok",
+    version: "0.0.0",
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  })),
+  version: publicProcedure.output(
+    zod.z.object({
+      api: zod.z.string(),
+      minLauncher: zod.z.string(),
+      recommendedLauncher: zod.z.string(),
+      deprecations: zod.z.array(zod.z.string())
+    })
+  ).query(() => ({
+    api: "0.0.0",
+    minLauncher: "0.0.0",
+    recommendedLauncher: "0.0.0",
+    deprecations: []
+  }))
+});
+var socialRouter = router({
+  relationships: router({
+    create: protectedProcedure.input(CreateRelationshipInputSchema).output(zod.z.object({ relationship: RelationshipSchema, created: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    delete: protectedProcedure.input(DeleteRelationshipInputSchema).output(zod.z.object({ deleted: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    list: protectedProcedure.input(ListRelationshipsInputSchema).output(zod.z.object({ items: zod.z.array(RelationshipSchema) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    acceptRequest: protectedProcedure.input(AcceptRequestInputSchema).output(zod.z.object({ relationship: RelationshipSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    cancelRequest: protectedProcedure.input(CancelRequestInputSchema).output(zod.z.object({ cancelled: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  users: router({
+    lookupByName: protectedProcedure.input(LookupByNameInputSchema).output(LookupByNameOutputSchema).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  presence: router({
+    /**
+     * Query (not subscription) in this scaffold. Prod presence streaming
+     * will land as a separate /v1/ws subscription multiplexed over the
+     * WebSocket gateway. For now the MSW layer returns a snapshot of the
+     * current presence map; the client polls every 5s.
+     */
+    get: protectedProcedure.input(zod.z.object({ uuids: zod.z.array(UUIDSchema) })).output(zod.z.object({ items: zod.z.array(PresenceSchema) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  activity: router({
+    report: protectedProcedure.input(ReportActivityInputSchema).output(zod.z.void()).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  invites: router({
+    toServer: protectedProcedure.input(InviteToServerInputSchema).output(zod.z.object({ delivered: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  trustedHosts: router({
+    list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(TrustedHostSchema) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    create: protectedProcedure.input(CreateTrustedHostInputSchema).output(zod.z.object({ host: TrustedHostSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    delete: protectedProcedure.input(DeleteTrustedHostInputSchema).output(zod.z.object({ deleted: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  communityRules: router({
+    get: protectedProcedure.input(zod.z.void()).output(CommunityRulesStatusSchema).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    agree: protectedProcedure.input(zod.z.void()).output(zod.z.object({ accepted: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  suspension: router({
+    get: protectedProcedure.input(zod.z.void()).output(SuspensionStatusSchema).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  })
+});
+var cosmeticsRouter = router({
+  list: protectedProcedure.input(
+    zod.z.object({
+      type: zod.z.enum(["hat", "body", "back", "face", "hand", "feet", "particle", "emote"]).optional(),
+      owned: zod.z.boolean().optional(),
+      limit: zod.z.number().int().min(1).max(200).default(60),
+      offset: zod.z.number().int().min(0).default(0)
+    })
+  ).output(zod.z.object({ items: zod.z.array(CosmeticSchema), total: zod.z.number().int().nonnegative() })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  equip: protectedProcedure.input(EquipCosmeticInputSchema).output(zod.z.object({ ok: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var outfitsRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(OutfitSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  create: protectedProcedure.input(CreateOutfitInputSchema).output(zod.z.object({ outfit: OutfitSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  update: protectedProcedure.input(UpdateOutfitInputSchema).output(zod.z.object({ outfit: OutfitSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  delete: protectedProcedure.input(DeleteOutfitInputSchema).output(zod.z.object({ deleted: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var emoteWheelsRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(EmoteWheelSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  save: protectedProcedure.input(SaveEmoteWheelInputSchema).output(zod.z.object({ wheel: EmoteWheelSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var skinsRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(SkinSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  upload: protectedProcedure.input(UploadSkinInputSchema).output(zod.z.object({ skin: SkinSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  setActive: protectedProcedure.input(SetActiveSkinInputSchema).output(zod.z.object({ ok: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var chatRouter = router({
+  channels: router({
+    list: protectedProcedure.input(ListChannelsInputSchema).output(zod.z.object({ items: zod.z.array(ChannelSchema) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    createDM: protectedProcedure.input(CreateDMInputSchema).output(zod.z.object({ channel: ChannelSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    createGroup: protectedProcedure.input(CreateGroupInputSchema).output(zod.z.object({ channel: ChannelSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  messages: router({
+    list: protectedProcedure.input(ListMessagesInputSchema).output(zod.z.object({ items: zod.z.array(MessageSchema) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    send: protectedProcedure.input(SendMessageInputSchema).output(zod.z.object({ message: MessageSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    edit: protectedProcedure.input(EditMessageInputSchema).output(zod.z.object({ message: MessageSchema })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    delete: protectedProcedure.input(DeleteMessageInputSchema).output(zod.z.object({ deleted: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    markRead: protectedProcedure.input(MarkReadInputSchema).output(zod.z.object({ ok: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    report: protectedProcedure.input(ReportMessageInputSchema).output(zod.z.object({ reported: zod.z.boolean() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    reports: protectedProcedure.input(ChannelReportsInputSchema).output(zod.z.object({ items: zod.z.array(zod.z.any()) })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  })
+});
+var mediaRouter = router({
+  list: protectedProcedure.input(ListMediaInputSchema).output(zod.z.object({ items: zod.z.array(MediaItemSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  upload: protectedProcedure.input(UploadMediaInputSchema).output(zod.z.object({ item: MediaItemSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  delete: protectedProcedure.input(DeleteMediaInputSchema).output(zod.z.object({ deleted: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var multiplayerRouter = router({
+  sendSignaling: protectedProcedure.input(SendSignalingInputSchema).output(zod.z.object({ message: SignalingMessageSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  listSignaling: protectedProcedure.input(zod.z.object({ fromUuid: UUIDSchema.optional(), since: ISODateSchema.optional() })).output(zod.z.object({ items: zod.z.array(SignalingMessageSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var upnpRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(UpnpSessionSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  create: protectedProcedure.input(CreateUpnpInputSchema).output(zod.z.object({ session: UpnpSessionSchema })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  close: protectedProcedure.input(CloseUpnpInputSchema).output(zod.z.object({ closed: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var discoveryRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(KnownServerSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var systemRouter = router({
+  status: protectedProcedure.input(zod.z.void()).output(SystemStatusSchema).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var instancesRouter = router({
+  list: protectedProcedure.input(zod.z.void()).output(zod.z.object({ items: zod.z.array(InstalledInstanceSchema) })).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var telemetryRouter = router({
+  report: protectedProcedure.input(ReportTelemetryInputSchema).output(zod.z.object({ ok: zod.z.boolean() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var launcherRouter = router({
+  updateCheck: protectedProcedure.input(zod.z.void()).output(LauncherUpdateInfoSchema).query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var adminRouter = router({
+  users: router({
+    list: protectedProcedure.input(zod.z.object({ limit: zod.z.number().optional(), offset: zod.z.number().optional(), search: zod.z.string().optional() }).optional()).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    get: protectedProcedure.input(zod.z.object({ uuid: zod.z.string() })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    updateRole: protectedProcedure.input(zod.z.object({ uuid: zod.z.string(), role: zod.z.enum(["USER", "MODERATOR", "ADMIN"]) })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    ban: protectedProcedure.input(zod.z.object({ uuid: zod.z.string() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  builds: router({
+    list: protectedProcedure.query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    create: protectedProcedure.input(zod.z.object({ slug: zod.z.string(), name: zod.z.string(), shortDescription: zod.z.string().optional(), iconUrl: zod.z.string().optional(), visibility: zod.z.enum(["PUBLIC", "PRIVATE", "UNLISTED"]).optional() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    update: protectedProcedure.input(zod.z.object({ id: zod.z.string(), name: zod.z.string().optional(), shortDescription: zod.z.string().optional(), iconUrl: zod.z.string().optional().nullable(), visibility: zod.z.enum(["PUBLIC", "PRIVATE", "UNLISTED"]).optional() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    delete: protectedProcedure.input(zod.z.object({ id: zod.z.string() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    listVersions: protectedProcedure.input(zod.z.object({ buildId: zod.z.string() })).query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    createVersion: protectedProcedure.input(zod.z.object({
+      buildId: zod.z.string(),
+      name: zod.z.string(),
+      mcVersion: zod.z.string(),
+      loader: zod.z.enum(["VANILLA", "FABRIC", "FORGE", "NEOFORGE", "QUILT"]),
+      loaderVersion: zod.z.string().optional(),
+      changelog: zod.z.string().optional(),
+      downloadUrl: zod.z.string().optional(),
+      sha256: zod.z.string().optional(),
+      bytes: zod.z.number().optional()
+    })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    }),
+    deleteVersion: protectedProcedure.input(zod.z.object({ id: zod.z.string() })).mutation(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  telemetry: router({
+    recent: protectedProcedure.query(() => {
+      throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+    })
+  }),
+  stats: protectedProcedure.query(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var profileRouter = router({
+  update: protectedProcedure.input(zod.z.object({ displayName: zod.z.string().optional(), bio: zod.z.string().optional().nullable(), avatarUrl: zod.z.string().url().optional().nullable() })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  }),
+  changePassword: protectedProcedure.input(zod.z.object({ currentPassword: zod.z.string(), newPassword: zod.z.string().min(8) })).mutation(() => {
+    throw new server.TRPCError({ code: "INTERNAL_SERVER_ERROR", message: "not implemented" });
+  })
+});
+var appRouter = router({
+  v1: router({
+    health: healthRouter,
+    auth: authRouter,
+    profile: profileRouter,
+    builds: buildsRouter,
+    licenses: licensesRouter,
+    social: socialRouter,
+    cosmetics: cosmeticsRouter,
+    admin: adminRouter,
+    outfits: outfitsRouter,
+    emoteWheels: emoteWheelsRouter,
+    skins: skinsRouter,
+    chat: chatRouter,
+    media: mediaRouter,
+    multiplayer: multiplayerRouter,
+    upnp: upnpRouter,
+    discovery: discoveryRouter,
+    system: systemRouter,
+    instances: instancesRouter,
+    telemetry: telemetryRouter,
+    launcher: launcherRouter
+  })
+});
+var createCaller = async (ctx) => {
+  const context = await createContext(ctx);
+  return appRouter.createCaller(context);
+};
+
+exports.appRouter = appRouter;
+exports.createCaller = createCaller;
+exports.createContext = createContext;
+exports.protectedProcedure = protectedProcedure;
+exports.publicProcedure = publicProcedure;
+//# sourceMappingURL=server.cjs.map
+//# sourceMappingURL=server.cjs.map