lexicons, server: make pages have an open union

options are:
- blob: object with blob record which is a blob itself

in future could be used for things like xml-ed xrpc
calls with processors and rss'd xml'd xrpc calls (for
ex: leaflet pubs as an rss feed)

lexicons/dev.atcities.route.json

···
         "type": "object",
         "properties": {
           "page": {
-            "type": "blob",
-            "accept": ["*/*"]
+            "type": "union",
+            "refs": ["#blob"]
           }
         },
         "required": ["page"]
       }
+    },
+
+    "blob": {
+      "type": "object",
+      "properties": {
+        "blob": {
+          "type": "blob",
+          "accept": ["*/*"]
+        }
+      },
+      "required": ["blob"]
     }
   }
 }

server/src/lexicons/types/dev/atcities/route.ts

···
 import * as v from "@atcute/lexicons/validations";
 import type {} from "@atcute/lexicons/ambient";
 
+const _blobSchema = /*#__PURE__*/ v.object({
+  $type: /*#__PURE__*/ v.optional(
+    /*#__PURE__*/ v.literal("dev.atcities.route#blob"),
+  ),
+  blob: /*#__PURE__*/ v.blob(),
+});
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.string(),
   /*#__PURE__*/ v.object({
     $type: /*#__PURE__*/ v.literal("dev.atcities.route"),
-    page: /*#__PURE__*/ v.blob(),
+    get page() {
+      return /*#__PURE__*/ v.variant([blobSchema]);
+    },
   }),
 );
 
+type blob$schematype = typeof _blobSchema;
 type main$schematype = typeof _mainSchema;
 
+export interface blobSchema extends blob$schematype {}
 export interface mainSchema extends main$schematype {}
 
+export const blobSchema = _blobSchema as blobSchema;
 export const mainSchema = _mainSchema as mainSchema;
 
+export interface Blob extends v.InferInput<typeof blobSchema> {}
 export interface Main extends v.InferInput<typeof mainSchema> {}
 
 declare module "@atcute/lexicons/ambient" {

server/src/user.ts

···
         }
         // unless its a 404, internal error
         default:
-          throw "Internal Error";
+          throw (
+            "Internal Error: got error fetching record: " + record_data.error
+          );
       }
     }
 
+    console.log(record_data.value);
     if (is(DevAtcitiesRoute.mainSchema, record_data.value)) {
-      const { ok: blob_ok, data: blob_data } = await client.get(
-        "com.atproto.sync.getBlob",
-        {
-          params: {
-            did,
-            cid:
-              "ref" in record_data.value.page
-                ? record_data.value.page.ref.$link
-                : record_data.value.page.cid,
-          },
-          as: "stream",
-        }
-      );
+      switch (record_data.value.page.$type) {
+        case "dev.atcities.route#blob": {
+          const { ok: blob_ok, data: blob_data } = await client.get(
+            "com.atproto.sync.getBlob",
+            {
+              params: {
+                did,
+                cid:
+                  "ref" in record_data.value.page.blob
+                    ? record_data.value.page.blob.ref.$link
+                    : record_data.value.page.blob.cid,
+              },
+              as: "stream",
+            }
+          );
 
-      // possible errors include:
-      // - request issue
-      // - 404 not found
-      // - account takedown
-      // in all cases thats not recoverable
-      // so throw out and take the happy path
-      if (!blob_ok) {
-        if (blob_data.error === "BlobNotFound") {
-          // 404 error so try load 404 page
-          if (route !== "404") {
-            const r404 = await getRoute(did, pds, "404");
-            return new Response(r404.body, {
-              status: 404,
-              statusText: "Not Found",
-              headers: r404.headers,
-            });
+          // possible errors include:
+          // - request issue
+          // - 404 not found
+          // - account takedown
+          // in all cases thats not recoverable
+          // so throw out and take the happy path
+          if (!blob_ok) {
+            if (blob_data.error === "BlobNotFound") {
+              // 404 error so try load 404 page
+              if (route !== "404") {
+                const r404 = await getRoute(did, pds, "404");
+                return new Response(r404.body, {
+                  status: 404,
+                  statusText: "Not Found",
+                  headers: r404.headers,
+                });
+              }
+              return new Response("Could not load page.", {
+                status: 404,
+                statusText: "Not Found",
+              });
+            } else
+              throw "Internal Error: Error fetching blob: " + blob_data.error;
           }
-          return new Response("Could not load page.", {
-            status: 404,
-            statusText: "Not Found",
+
+          return new Response(blob_data, {
+            headers: {
+              "Content-Type": record_data.value.page.blob.mimeType,
+            },
           });
-        } else throw "Internal Error";
+        }
       }
-
-      return new Response(blob_data, {
-        headers: {
-          "Content-Type": record_data.value.page.mimeType,
-        },
-      });
-
-      // isnt valid data so throw exception
-    } else
-      return new Response(
-        "Malformed record for at://" + did + "/dev.atcities.route/" + targetRkey
-      );
+    }
+    // isnt valid data so throw exception
+    return new Response(
+      "Malformed record for at://" + did + "/dev.atcities.route/" + targetRkey
+    );
   } catch (e) {
     console.error(e);
     return new Response("Something went wrong loading this route", {