style: fix fmt, lint, and types

README.md

···
 # Cistern
 
 Cistern is an attempt at implementing a private, personal quick-capture system
-on AT Protocol. Cistern "items" are encrypted, so that they are only readable
-by the holder of the correct secret key—stored off-protocol. These items are
+on AT Protocol. Cistern "items" are encrypted, so that they are only readable by
+the holder of the correct secret key—stored off-protocol. These items are
 intended to be ephemeral, and to be deleted after they've been read.
 
 The intention is for Cistern to bridge the gap between where ideas are had and
 where they can be stored long-term. For example, let's say you have an idea
-while at a restaurant. You create an item using your phone, and once you're
-back at your desk and you open Obsidian, that item is automatically pulled from
-your PDS, decrypted, and deleted from your PDS. If your notebook was open at
-the time you created your item, the Cistern Obsidian plugin would have been
-notified of the new item via the Jetstream, and so you would find your memo
-waiting for you once you got home.
+while at a restaurant. You create an item using your phone, and once you're back
+at your desk and you open Obsidian, that item is automatically pulled from your
+PDS, decrypted, and deleted from your PDS. If your notebook was open at the time
+you created your item, the Cistern Obsidian plugin would have been notified of
+the new item via the Jetstream, and so you would find your memo waiting for you
+once you got home.

packages/crypto/deno.jsonc

···
 {
   "name": "@cistern/crypto",
   "exports": {
-    ".": "mod.ts"
+    ".": "./mod.ts"
   },
   "imports": {
     "@noble/ciphers": "jsr:@noble/ciphers@^2.0.1",

packages/crypto/src/keys.ts

···
 import { XWing } from "@noble/post-quantum/hybrid.js";
+import type { KeyPair } from "./types.ts";
 
-export function generateKeys() {
+export function generateKeys(): KeyPair {
   return XWing.keygen();
 }
 
-export function serializeKey(key: Uint8Array) {
+export function serializeKey(key: Uint8Array): string {
   return key.toBase64();
 }
 
-export function deserializeKey(key: string) {
+export function deserializeKey(key: string): Uint8Array {
   return Uint8Array.fromBase64(key);
 }

packages/crypto/src/types.ts

···
+export type KeyPair = {
+  secretKey: Uint8Array;
+  publicKey: Uint8Array;
+};
+
 export interface EncryptedPayload {
   cipherText: string;
   content: string;

packages/lexicon/deno.jsonc

···
 {
   "name": "@cistern/lexicon",
   "exports": {
-    ".": "mod.ts"
+    ".": "./mod.ts"
   },
   "imports": {
     "@atproto/lexicon": "npm:@atproto/lexicon@^0.5.1"

packages/lexicon/mod.ts

···
 import item from "./schemas/item.json" with { type: "json" };
 import pubkey from "./schemas/pubkey.json" with { type: "json" };
 
-import { Lexicons } from "@atproto/lexicon";
+import { type LexiconDoc, Lexicons } from "@atproto/lexicon";
 
-const lexicons = new Lexicons();
+const lexicons: Lexicons = new Lexicons();
 
-lexicons.add(item);
-lexicons.add(pubkey);
+lexicons.add(item as LexiconDoc);
+lexicons.add(pubkey as LexiconDoc);
 
 export { item, lexicons, pubkey };

packages/lexicon/schemas/item.json

···
 {
-  "version": 1,
+  "lexicon": 1,
   "id": "app.cistern.lexicon.item",
   "description": "An encrypted memo intended to be accessed and deleted later.",
   "defs": {
···
             "type": "string",
             "description": "TID representing when this item was created",
             "format": "tid"
-          }
+          },
           "ciphertext": {
             "type": "string",
             "description": "Encapsulated shared ciphertext",
···
           "nonce": {
             "type": "string",
             "description": "Base64-encoded nonce used for content encryption",
-            "maxLength": 32,
+            "maxLength": 32
           },
           "algorithm": {
             "type": "string",
···
           },
           "contentLength": {
             "type": "integer",
-            "description": "Original content length in bytes",
+            "description": "Original content length in bytes"
           },
           "contentHash": {
             "type": "string",

packages/lexicon/schemas/pubkey.json

···
 {
-  "version": 1,
+  "lexicon": 1,
   "id": "app.cistern.lexicon.pubkey",
   "description": "A public key used to encrypt Cistern items",
   "defs": {