we can actually reduce even more because the atcute package is this great

bun.lock

···
         "@react-router/fs-routes": "^7.9.4",
         "@react-router/node": "^7.9.2",
         "@react-router/serve": "^7.9.2",
+        "@watproto/lexicon": "workspace:*",
         "clsx": "^2.1.1",
         "daisyui": "^5.3.10",
         "isbot": "^5.1.31",
···
         "vite-tsconfig-paths": "^5.1.4",
       },
     },
+    "packages/lexicon": {
+      "name": "@watproto/lexicon",
+      "version": "0.0.1",
+      "dependencies": {
+        "@atcute/atproto": "^3.1.8",
+        "@atcute/bluesky": "^3.2.9",
+        "@atcute/lexicons": "^1.2.2",
+      },
+    },
     "packages/server": {
       "name": "@watproto/server",
       "version": "0.0.1",
···
         "@atcute/xrpc-server": "^0.1.3",
         "@elysiajs/cors": "1.4.0",
         "@elysiajs/openapi": "1.4.11",
+        "@watproto/lexicon": "workspace:*",
         "elysia": "1.4.13",
         "kysely": "^0.28.8",
         "kysely-bun-worker": "^1.2.1",
···
     "@typescript-eslint/visitor-keys": ["@typescript-eslint/visitor-keys@8.46.2", "", { "dependencies": { "@typescript-eslint/types": "8.46.2", "eslint-visitor-keys": "^4.2.1" } }, "sha512-tUFMXI4gxzzMXt4xpGJEsBsTox0XbNQ1y94EwlD/CuZwFcQP79xfQqMhau9HsRc/J0cAPA/HZt1dZPtGn9V/7w=="],
 
     "@watproto/client": ["@watproto/client@workspace:packages/client"],
+
+    "@watproto/lexicon": ["@watproto/lexicon@workspace:packages/lexicon"],
 
     "@watproto/server": ["@watproto/server@workspace:packages/server"],
 

lex.config.js

···
 import { defineLexiconConfig } from '@atcute/lex-cli'
 
-const LEX_ENV = process.env.LEX_ENV
-
 export default defineLexiconConfig({
   files: ['lexicons/**/*.json'],
-  outdir:
-    LEX_ENV === 'server'
-      ? 'packages/server/src/xrpc/'
-      : 'packages/client/app/xrpc/',
+  outdir: 'packages/lexicon',
   imports: ['@atcute/atproto', '@atcute/bluesky']
 })

package.json

···
     "typecheck": "bun run --workspaces typecheck",
     "typecheck:server": "bun run --filter @watproto/server typecheck",
     "typecheck:client": "bun run --filter @watproto/client typecheck",
-    "lex": "bun run lex:client && bun run lex:server",
-    "lex:client": "LEX_ENV=client bunx --bun lex-cli generate -c lex.config.js",
-    "lex:server": "LEX_ENV=server bunx --bun lex-cli generate -c lex.config.js"
+    "lex": "bunx --bun lex-cli generate -c lex.config.js"
   },
   "devDependencies": {
     "@atcute/atproto": "^3.1.8",

packages/client/app/lib/user.ts

···
 import { idResolver } from './idResolver.server'
 import { StatusError } from './https'
-import { getSessionAgent, type XRPCLient } from '@www/lib/xprcClient'
+import { getSessionAgent, type XRPCLient } from '@www/lib/xrpcClient'
 import type { Did } from '@atcute/lexicons'
 
 export async function getCurrentUser(request: Request) {

packages/client/app/lib/xprcClient.ts packages/client/app/lib/xrpcClient.ts

···
 
 // magic import: this loads bluesky calls into the current atcute client
 import type {} from '@atcute/bluesky'
+import type {} from '@watproto/lexicon'
 
 export type XRPCLient = Awaited<ReturnType<typeof getSessionAgent>>['client']
 

packages/client/package.json

···
     "typecheck": "bunx --bun react-router typegen && tsc"
   },
   "dependencies": {
+    "@watproto/lexicon": "workspace:*",
     "@atcute/client": "^4.0.5",
     "@atproto/identity": "^0.4.9",
     "@atproto/oauth-client-node": "^0.3.10",

packages/lexicon/package.json

···
+{
+  "name": "@watproto/lexicon",
+  "version": "0.0.1",
+  "license": "MIT",
+  "main": "./index.ts",
+  "types": "./index.ts",
+  "dependencies": {
+    "@atcute/atproto": "^3.1.8",
+    "@atcute/bluesky": "^3.2.9",
+    "@atcute/lexicons": "^1.2.2"
+  }
+}

packages/server/package.json

···
     "typecheck": "bunx --bun tsc --noEmit"
   },
   "dependencies": {
+    "@watproto/lexicon": "workspace:*",
     "@atcute/xrpc-server": "^0.1.3",
     "@elysiajs/cors": "1.4.0",
     "@elysiajs/openapi": "1.4.11",

packages/server/src/lib/xrpcServer.ts

···
 import { XRPCRouter, json } from '@atcute/xrpc-server'
 import { cors } from '@atcute/xrpc-server/middlewares/cors'
-import { AppWafrnContentCreatePost } from '../xrpc/index.js'
+import { AppWafrnContentCreatePost } from '@watproto/lexicon'
 
 const xrpcServer = new XRPCRouter({ middlewares: [cors()] })
 

packages/server/src/xrpc/index.ts

···
-export * as AppWafrnContentCreatePost from "./types/app/wafrn/content/createPost.js";
-export * as AppWafrnContentPost from "./types/app/wafrn/content/post.js";

packages/server/src/xrpc/types/app/wafrn/content/createPost.ts

···
-import type {} from "@atcute/lexicons";
-import * as v from "@atcute/lexicons/validations";
-import type {} from "@atcute/lexicons/ambient";
-import * as AppWafrnContentPost from "./post.js";
-import * as ComAtprotoLabelDefs from "@atcute/atproto/types/label/defs";
-
-const _mainSchema = /*#__PURE__*/ v.procedure("app.wafrn.content.createPost", {
-  params: null,
-  input: {
-    type: "lex",
-    schema: /*#__PURE__*/ v.object({
-      contentMarkdown: /*#__PURE__*/ v.string(),
-      contentWarning: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
-      get labels() {
-        return /*#__PURE__*/ v.optional(
-          /*#__PURE__*/ v.variant([ComAtprotoLabelDefs.selfLabelsSchema]),
-        );
-      },
-      tags: /*#__PURE__*/ v.optional(
-        /*#__PURE__*/ v.array(/*#__PURE__*/ v.string()),
-      ),
-      /**
-       * @default "public"
-       */
-      visibility: /*#__PURE__*/ v.optional(
-        /*#__PURE__*/ v.string<
-          "followers" | "mentioned" | "public" | (string & {})
-        >(),
-        "public",
-      ),
-    }),
-  },
-  output: {
-    type: "lex",
-    schema: /*#__PURE__*/ v.object({
-      get post() {
-        return AppWafrnContentPost.mainSchema;
-      },
-    }),
-  },
-});
-
-type main$schematype = typeof _mainSchema;
-
-export interface mainSchema extends main$schematype {}
-
-export const mainSchema = _mainSchema as mainSchema;
-
-export interface $params {}
-export interface $input extends v.InferXRPCBodyInput<mainSchema["input"]> {}
-export interface $output extends v.InferXRPCBodyInput<mainSchema["output"]> {}
-
-declare module "@atcute/lexicons/ambient" {
-  interface XRPCProcedures {
-    "app.wafrn.content.createPost": mainSchema;
-  }
-}

packages/server/src/xrpc/types/app/wafrn/content/post.ts

···
-import type {} from "@atcute/lexicons";
-import * as v from "@atcute/lexicons/validations";
-import type {} from "@atcute/lexicons/ambient";
-import * as ComAtprotoLabelDefs from "@atcute/atproto/types/label/defs";
-
-const _mainSchema = /*#__PURE__*/ v.record(
-  /*#__PURE__*/ v.tidString(),
-  /*#__PURE__*/ v.object({
-    $type: /*#__PURE__*/ v.literal("app.wafrn.content.post"),
-    get content() {
-      return /*#__PURE__*/ v.variant([
-        postContentSchema,
-        postEncryptedContentSchema,
-      ]);
-    },
-    /**
-     * @default "public"
-     */
-    visibility: /*#__PURE__*/ v.optional(
-      /*#__PURE__*/ v.string<
-        "followers" | "mentioned" | "public" | (string & {})
-      >(),
-      "public",
-    ),
-  }),
-);
-const _postContentSchema = /*#__PURE__*/ v.object({
-  $type: /*#__PURE__*/ v.optional(
-    /*#__PURE__*/ v.literal("app.wafrn.content.post#postContent"),
-  ),
-  contentHTML: /*#__PURE__*/ v.string(),
-  contentMarkdown: /*#__PURE__*/ v.string(),
-  contentWarning: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.string()),
-  createdAt: /*#__PURE__*/ v.datetimeString(),
-  get labels() {
-    return /*#__PURE__*/ v.optional(
-      /*#__PURE__*/ v.variant([ComAtprotoLabelDefs.selfLabelsSchema]),
-    );
-  },
-  tags: /*#__PURE__*/ v.optional(
-    /*#__PURE__*/ v.array(/*#__PURE__*/ v.string()),
-  ),
-  updatedAt: /*#__PURE__*/ v.optional(/*#__PURE__*/ v.datetimeString()),
-});
-const _postEncryptedContentSchema = /*#__PURE__*/ v.object({
-  $type: /*#__PURE__*/ v.optional(
-    /*#__PURE__*/ v.literal("app.wafrn.content.post#postEncryptedContent"),
-  ),
-  encryptedContent: /*#__PURE__*/ v.string(),
-  /**
-   * @minimum 0
-   */
-  keyVersion: /*#__PURE__*/ v.integer(),
-});
-
-type main$schematype = typeof _mainSchema;
-type postContent$schematype = typeof _postContentSchema;
-type postEncryptedContent$schematype = typeof _postEncryptedContentSchema;
-
-export interface mainSchema extends main$schematype {}
-export interface postContentSchema extends postContent$schematype {}
-export interface postEncryptedContentSchema
-  extends postEncryptedContent$schematype {}
-
-export const mainSchema = _mainSchema as mainSchema;
-export const postContentSchema = _postContentSchema as postContentSchema;
-export const postEncryptedContentSchema =
-  _postEncryptedContentSchema as postEncryptedContentSchema;
-
-export interface Main extends v.InferInput<typeof mainSchema> {}
-export interface PostContent extends v.InferInput<typeof postContentSchema> {}
-export interface PostEncryptedContent
-  extends v.InferInput<typeof postEncryptedContentSchema> {}
-
-declare module "@atcute/lexicons/ambient" {
-  interface Records {
-    "app.wafrn.content.post": mainSchema;
-  }
-}