fix express import

deno.json

···
 {
-  "workspace": ["./feeds", "./lexicon", "./scripts"],
+  "workspace": ["./feeds", "./scripts"],
   "tasks": {
     "lex-dl": "deno task --cwd scripts lex-dl",
     "lex-gen": "deno task --cwd scripts lex-gen"
   },
   "imports": {
+    "@std/assert": "jsr:@std/assert@1",
     "@atproto/api": "npm:@atproto/api@^0.14.18",
     "@atproto/identity": "npm:@atproto/identity@^0.4.6",
     "@atproto/lexicon": "npm:@atproto/lexicon@^0.4.9",
···
     "@atproto/syntax": "npm:@atproto/syntax@^0.4.0",
     "@atproto/xrpc": "npm:@atproto/xrpc@^0.6.12",
     "@atproto/xrpc-server": "npm:@atproto/xrpc-server@^0.7.14",
-    "@std/assert": "jsr:@std/assert@1",
+    "@types/node": "npm:@types/node@^22.14.0",
     "multiformats": "npm:multiformats@^13.3.2"
   },
   "nodeModulesDir": "auto",
   "fmt": {
     "lineWidth": 120
+  },
+  "lint": {
+    "exclude": ["lexicon/api/", "lexicon/server"]
   }
 }

deno.lock

···
   "specifiers": {
     "jsr:@std/assert@1": "1.0.12",
     "jsr:@std/internal@^1.0.6": "1.0.6",
-    "npm:@atproto/api@~0.14.18": "0.14.18",
-    "npm:@atproto/identity@~0.4.6": "0.4.6",
-    "npm:@atproto/lex-cli@0.7": "0.7.1",
-    "npm:@atproto/lexicon@~0.4.9": "0.4.9",
+    "npm:@atproto/api@*": "0.14.19",
+    "npm:@atproto/api@~0.14.18": "0.14.19",
+    "npm:@atproto/identity@~0.4.6": "0.4.7",
+    "npm:@atproto/lex-cli@0.7": "0.7.2",
+    "npm:@atproto/lexicon@~0.4.10": "0.4.10",
+    "npm:@atproto/lexicon@~0.4.9": "0.4.10",
     "npm:@atproto/repo@~0.7.3": "0.7.3",
     "npm:@atproto/syntax@0.4": "0.4.0",
-    "npm:@atproto/xrpc-server@~0.7.14": "0.7.14",
+    "npm:@atproto/xrpc-server@~0.7.14": "0.7.15",
     "npm:@atproto/xrpc@~0.6.12": "0.6.12",
     "npm:@types/node@*": "22.12.0",
+    "npm:@types/node@^22.14.0": "22.14.0",
     "npm:adm-zip@*": "0.5.16",
     "npm:adm-zip@~0.5.16": "0.5.16",
+    "npm:express@*": "4.21.2",
     "npm:multiformats@^13.3.2": "13.3.2",
     "npm:ts-morph@*": "25.0.1",
     "npm:ts-morph@^25.0.1": "25.0.1"
···
     }
   },
   "npm": {
-    "@atproto/api@0.14.18": {
-      "integrity": "sha512-BEkM7p51oYslDN9lUNeMtVAQqYWUhinJnFsCdTuSLLCb28LNDErbmt6wiA3mCw68E5E/Sh8DC1+L9UPfCi0Awg==",
+    "@atproto/api@0.14.19": {
+      "integrity": "sha512-YYTqM0K0qk2TP7PguktPzlAQGLTL1bEGz6PgY5kqKJNX4o1318kJYB22DzjJYqV2NUCq0JQ9Lb0oskLvTisEOg==",
       "dependencies": [
-        "@atproto/common-web@0.4.0",
-        "@atproto/lexicon@0.4.9",
+        "@atproto/common-web",
+        "@atproto/lexicon",
         "@atproto/syntax",
-        "@atproto/xrpc@0.6.11",
+        "@atproto/xrpc",
         "await-lock",
         "multiformats@9.9.0",
         "tlds",
-        "zod"
-      ]
-    },
-    "@atproto/common-web@0.4.0": {
-      "integrity": "sha512-ZYL0P9myHybNgwh/hBY0HaBzqiLR1B5/ie5bJpLQAg0whRzNA28t8/nU2vh99tbsWcAF0LOD29M8++LyENJLNQ==",
-      "dependencies": [
-        "graphemer",
-        "multiformats@9.9.0",
-        "uint8arrays",
         "zod"
       ]
     },
···
         "zod"
       ]
     },
-    "@atproto/common@0.4.9": {
-      "integrity": "sha512-5xIMkBpTMEjgat0GUu6ZnbTUq2ZvY4ddwMMPcznXoYzpigl3yt5OnHed4JQlzOVRTBSiJ2hNu+yiAS6D9L9NAg==",
+    "@atproto/common@0.4.10": {
+      "integrity": "sha512-/Yxnax3XOhf46jYpe8/6O3ORjTNMB4YCaxx3V1f+FKy6meTm3GNrJwo8d1CBs0UiTiheRiNATOV3u0s3C7Ydaw==",
       "dependencies": [
-        "@atproto/common-web@0.4.0",
+        "@atproto/common-web",
         "@ipld/dag-cbor",
         "cbor-x",
         "iso-datestring-validator",
···
         "uint8arrays"
       ]
     },
-    "@atproto/identity@0.4.6": {
-      "integrity": "sha512-fJq/cIp9MOgHxZfxuyki6mobk0QxRnbts53DstRixlvb5mOoxwttb9Gp6A8u9q49zBsfOmXNTHmP97I9iMHmTQ==",
+    "@atproto/identity@0.4.7": {
+      "integrity": "sha512-A61OT9yc74dEFi1elODt/tzQNSwV3ZGZCY5cRl6NYO9t/0AVdaD+fyt81yh3mRxyI8HeVOecvXl3cPX5knz9rQ==",
       "dependencies": [
-        "@atproto/common-web@0.4.0",
+        "@atproto/common-web",
         "@atproto/crypto"
       ]
     },
-    "@atproto/lex-cli@0.7.1": {
-      "integrity": "sha512-lgEMwDsUo1rUdbsTyHC2XUyGevcMpOc0xYa+5YOIqQp00DR8ENmt9pyg3aFO0bFf9qVY3IkCQXQ3NXuZawD7yg==",
+    "@atproto/lex-cli@0.7.2": {
+      "integrity": "sha512-GdAH5Y3mEZGqASxyhRPZ8iLEOByJb+/T206AuwPAoIzLuqvSK2E4H0G61J2KdvEa1X78jroJ3/iotppD5vsmlg==",
       "dependencies": [
-        "@atproto/lexicon@0.4.9",
+        "@atproto/lexicon",
         "@atproto/syntax",
         "chalk",
         "commander",
···
     "@atproto/lexicon@0.4.10": {
       "integrity": "sha512-uDbP20vetBgtXPuxoyRcvOGBt2gNe1dFc9yYKcb6jWmXfseHiGTnIlORJOLBXIT2Pz15Eap4fLxAu6zFAykD5A==",
       "dependencies": [
-        "@atproto/common-web@0.4.1",
-        "@atproto/syntax",
-        "iso-datestring-validator",
-        "multiformats@9.9.0",
-        "zod"
-      ]
-    },
-    "@atproto/lexicon@0.4.9": {
-      "integrity": "sha512-/tmEuHQFr51V2V7EAVJzaA40sqJ7ylAZpR962VbOsPtmcdOHvezbjVHYEMXgfb927hS+xqbVyzBTbu5w9v8prA==",
-      "dependencies": [
-        "@atproto/common-web@0.4.0",
+        "@atproto/common-web",
         "@atproto/syntax",
         "iso-datestring-validator",
         "multiformats@9.9.0",
···
       "integrity": "sha512-1CVQnkTZpQLYvZiglcgGGetnwRRfPXP05GiHwruLK7ER6yO6vKNtSCWvkUxgKacMY+h/wE0B9XidzbL52DyInA==",
       "dependencies": [
         "@atproto/common",
-        "@atproto/common-web@0.4.0",
+        "@atproto/common-web",
         "@atproto/crypto",
-        "@atproto/lexicon@0.4.9",
+        "@atproto/lexicon",
         "@ipld/car",
         "@ipld/dag-cbor",
         "multiformats@9.9.0",
···
     "@atproto/syntax@0.4.0": {
       "integrity": "sha512-b9y5ceHS8YKOfP3mdKmwAx5yVj9294UN7FG2XzP6V5aKUdFazEYRnR9m5n5ZQFKa3GNvz7de9guZCJ/sUTcOAA=="
     },
-    "@atproto/xrpc-server@0.7.14": {
-      "integrity": "sha512-6Jr7S2h5skvw8M5OdsRuX8O81oDonOSWA1vlc48CG52D+UgxXEwMerDVOvlpBQcDuSanOosDagKaeiFCzcKWgA==",
+    "@atproto/xrpc-server@0.7.15": {
+      "integrity": "sha512-9MjhQk3iaIL391j5dD2/lS908yCCwvbGken2wtZoLubSluCKTli2G53NXlfmGcPLEC5IN5iM1+BaUUzfV3Wt5g==",
       "dependencies": [
         "@atproto/common",
         "@atproto/crypto",
-        "@atproto/lexicon@0.4.9",
-        "@atproto/xrpc@0.6.11",
+        "@atproto/lexicon",
+        "@atproto/xrpc",
         "cbor-x",
         "express",
         "http-errors",
···
         "zod"
       ]
     },
-    "@atproto/xrpc@0.6.11": {
-      "integrity": "sha512-J2cZP8FjoDN0UkyTYBlCvKvxwBbDm4dld47u6FQK30RJy9YpSiUkdxJJ10NYqpi7JVny3M0qWQgpWJDV94+PdA==",
-      "dependencies": [
-        "@atproto/lexicon@0.4.9",
-        "zod"
-      ]
-    },
     "@atproto/xrpc@0.6.12": {
       "integrity": "sha512-Ut3iISNLujlmY9Gu8sNU+SPDJDvqlVzWddU8qUr0Yae5oD4SguaUFjjhireMGhQ3M5E0KljQgDbTmnBo1kIZ3w==",
       "dependencies": [
-        "@atproto/lexicon@0.4.10",
+        "@atproto/lexicon",
         "zod"
       ]
     },
···
     "@types/node@22.12.0": {
       "integrity": "sha512-Fll2FZ1riMjNmlmJOdAyY5pUbkftXslB5DgEzlIuNaiWhXd00FhWxVC/r4yV/4wBb9JfImTu+jiSvXTkJ7F/gA==",
       "dependencies": [
-        "undici-types"
+        "undici-types@6.20.0"
+      ]
+    },
+    "@types/node@22.14.0": {
+      "integrity": "sha512-Kmpl+z84ILoG+3T/zQFyAJsU6EPTmOCj8/2+83fSN6djd6I4o7uOuGIH6vq3PrjY5BGitSbFuMN18j3iknubbA==",
+      "dependencies": [
+        "undici-types@6.21.0"
       ]
     },
     "abort-controller@3.0.0": {
···
     "undici-types@6.20.0": {
       "integrity": "sha512-Ny6QZ2Nju20vw1SRHe3d9jVu6gJ+4e3+MMpqu7pqE5HT6WsTSlce++GQmK5UXS8mzV8DSYHrQH+Xrf2jVcuKNg=="
     },
+    "undici-types@6.21.0": {
+      "integrity": "sha512-iwDZqg0QAGrg9Rav5H4n0M64c3mkR59cJ6wQp+7C4nI0gsmExaedaYLNO44eT4AtBBwjbTiGPMlt2Md0T9H9JQ=="
+    },
     "unpipe@1.0.0": {
       "integrity": "sha512-pjy2bYhSsufwWlKwPc+l3cN7+wuJlK6uz0YdJEOlQDbl6jo/YlPi4mb8agUkVC8BF7V8NuzeyPNqRksA3hztKQ=="
     },
···
       "npm:@atproto/syntax@0.4",
       "npm:@atproto/xrpc-server@~0.7.14",
       "npm:@atproto/xrpc@~0.6.12",
+      "npm:@types/node@^22.14.0",
       "npm:multiformats@^13.3.2"
     ],
     "members": {
       "scripts": {
         "dependencies": [
+          "npm:@types/node@^22.14.0",
           "npm:adm-zip@~0.5.16",
           "npm:ts-morph@^25.0.1"
         ]

feeds/deno.json

···
   "imports": {
     "@/": "./",
     "@@/": "../"
+    // "@types/node": "npm:@types/node@^22.14.0",
+    // "@atproto/api": "npm:@atproto/api@^0.14.18",
+    // "@atproto/identity": "npm:@atproto/identity@^0.4.6",
+    // "@atproto/lexicon": "npm:@atproto/lexicon@^0.4.9",
+    // "@atproto/repo": "npm:@atproto/repo@^0.7.3",
+    // "@atproto/syntax": "npm:@atproto/syntax@^0.4.0",
+    // "@atproto/xrpc": "npm:@atproto/xrpc@^0.6.12",
+    // "@atproto/xrpc-server": "npm:@atproto/xrpc-server@^0.7.14",
+    // "multiformats": "npm:multiformats@^13.3.2"
   }
 }

feeds/server.ts

···
 import {} from "@@/lexicon/api.ts";
+import {} from "npm:@atproto/api";
 
 export type Config = {
   subscriptionEndpoint: string;

lexicon/deno.json

···
-{
-  "lint": {
-    "exclude": ["api/", "server/"]
-  }
-}

lexicon/server.ts

···
-export * from "./server.ts";
+export * from "./server/index.ts";

lexicon/server/types/app/bsky/actor/getPreferences.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/getProfile.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/getProfiles.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/getSuggestions.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/putPreferences.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/searchActors.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/actor/searchActorsTypeahead.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/describeFeedGenerator.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getActorFeeds.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getActorLikes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getAuthorFeed.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getFeed.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getFeedGenerator.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getFeedGenerators.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getFeedSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getLikes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getListFeed.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getPostThread.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getPosts.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getQuotes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getRepostedBy.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getSuggestedFeeds.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/getTimeline.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/searchPosts.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/feed/sendInteractions.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getActorStarterPacks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getBlocks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getFollowers.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getFollows.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getKnownFollowers.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getList.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getListBlocks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getListMutes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getLists.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getMutes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getRelationships.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getStarterPack.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getStarterPacks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/getSuggestedFollowsByActor.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/muteActor.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/muteActorList.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/muteThread.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/searchStarterPacks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/unmuteActor.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/unmuteActorList.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/graph/unmuteThread.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/labeler/getServices.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/notification/getUnreadCount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/notification/listNotifications.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/notification/putPreferences.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/notification/registerPush.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/notification/updateSeen.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getConfig.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getPopularFeedGenerators.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getSuggestedFeeds.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getSuggestedFeedsSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getSuggestedStarterPacks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getSuggestedStarterPacksSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getSuggestionsSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getTaggedSuggestions.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getTrendingTopics.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getTrends.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/getTrendsSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/searchActorsSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/searchPostsSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/unspecced/searchStarterPacksSkeleton.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/video/getJobStatus.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/video/getUploadLimits.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/app/bsky/video/uploadVideo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/chat/bsky/actor/deleteAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/actor/exportAccountData.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/chat/bsky/convo/acceptConvo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/addReaction.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/deleteMessageForSelf.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/getConvo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/getConvoAvailability.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/getConvoForMembers.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/getLog.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/getMessages.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/leaveConvo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/listConvos.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/muteConvo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/removeReaction.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/sendMessage.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/sendMessageBatch.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/unmuteConvo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/updateAllRead.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/convo/updateRead.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/moderation/getActorMetadata.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/moderation/getMessageContext.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/chat/bsky/moderation/updateActorAccess.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/deleteAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/disableAccountInvites.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/disableInviteCodes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/enableAccountInvites.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/getAccountInfo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/getAccountInfos.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/getInviteCodes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/getSubjectStatus.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/searchAccounts.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/sendEmail.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/updateAccountEmail.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/updateAccountHandle.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/updateAccountPassword.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/updateAccountSigningKey.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/admin/updateSubjectStatus.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/getRecommendedDidCredentials.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/refreshIdentity.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/requestPlcOperationSignature.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/resolveDid.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/resolveHandle.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/resolveIdentity.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/signPlcOperation.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/submitPlcOperation.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/identity/updateHandle.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/label/queryLabels.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/moderation/createReport.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/applyWrites.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/createRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/deleteRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/describeRepo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/getRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/importRepo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/repo/listMissingBlobs.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/listRecords.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/putRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/repo/uploadBlob.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/server/activateAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/checkAccountStatus.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/confirmEmail.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/createAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/createAppPassword.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/createInviteCode.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/createInviteCodes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/createSession.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/deactivateAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/deleteAccount.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/deleteSession.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/describeServer.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/getAccountInviteCodes.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/getServiceAuth.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/getSession.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/listAppPasswords.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/refreshSession.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/requestAccountDelete.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/requestEmailConfirmation.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/requestEmailUpdate.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/requestPasswordReset.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/reserveSigningKey.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/resetPassword.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/revokeAppPassword.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/server/updateEmail.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/getBlob.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/sync/getBlocks.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/sync/getCheckout.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/sync/getHead.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/getLatestCommit.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/getRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/sync/getRepo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import stream from "node:stream";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";

lexicon/server/types/com/atproto/sync/getRepoStatus.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/listBlobs.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/listRepos.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/listReposByCollection.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/notifyOfUpdate.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/sync/requestCrawl.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/temp/addReservedHandle.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/temp/checkSignupQueue.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/temp/fetchLabels.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/com/atproto/temp/requestPhoneVerification.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/communication/createTemplate.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/communication/deleteTemplate.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/communication/listTemplates.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/communication/updateTemplate.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/emitEvent.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getEvent.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getRecord.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getRecords.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getRepo.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getReporterStats.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getRepos.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/getSubjects.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/queryEvents.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/queryStatuses.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/moderation/searchRepos.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/server/getConfig.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/addValues.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/deleteSet.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/deleteValues.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/getValues.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/querySets.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/set/upsertSet.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/setting/listOptions.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/setting/removeOptions.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/setting/upsertOption.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/signature/findCorrelation.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/signature/findRelatedAccounts.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/signature/searchAccounts.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/team/addMember.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/team/deleteMember.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/team/listMembers.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

lexicon/server/types/tools/ozone/team/updateMember.ts

···
 /**
  * GENERATED CODE - DO NOT MODIFY
  */
-import express from "express";
+import express from "npm:express";
 import { BlobRef, type ValidationResult } from "@atproto/lexicon";
 import { CID } from "multiformats/cid";
 import { validate as _validate } from "../../../../lexicons.ts";

scripts/deno.json

···
   },
   "imports": {
     "adm-zip": "npm:adm-zip@^0.5.16",
-    "ts-morph": "npm:ts-morph@^25.0.1"
+    "ts-morph": "npm:ts-morph@^25.0.1",
+    "@types/node": "npm:@types/node@^22.14.0"
   }
 }

scripts/lexicon/generate.ts

···
 
   src.getImportDeclarations().forEach((imp) => {
     if (!imp.isModuleSpecifierRelative()) {
+      const current = imp.getModuleSpecifierValue();
+      if (current == "express") {
+        imp.setModuleSpecifier("npm:" + current);
+      }
       return;
     }
     const current = imp.getModuleSpecifierValue();