fix(producer): cache pubkey uri with record value

packages/producer/mod.ts

···
   ProducerOptions,
   ProducerParams,
 } from "./types.ts";
-import { type Did, is } from "@atcute/lexicons";
+import { type Did, parse, type ResourceUri } from "@atcute/lexicons";
 import type { Client, CredentialManager } from "@atcute/client";
-import { AppCisternLexiconPubkey } from "@cistern/lexicon";
+import {
+  AppCisternLexiconPubkey,
+} from "@cistern/lexicon";
 
 import type {} from "@atcute/atproto";
 
 export async function createProducer(
-  { publicKey, ...opts }: ProducerOptions,
+  { publicKey: rkey, ...opts }: ProducerOptions,
 ): Promise<Producer> {
   const reqs = await produceRequirements(opts);
 
-  let record: AppCisternLexiconPubkey.Main | undefined;
-  if (typeof publicKey === "string") {
+  let publicKey: LocalPublicKey | undefined;
+  if (rkey) {
     // Fetch record contents from PDS
     const res = await reqs.rpc.get("com.atproto.repo.getRecord", {
       params: {
         repo: reqs.miniDoc.did,
-        rkey: publicKey,
+        rkey,
         collection: "app.cistern.lexicon.pubkey",
       },
     });
···
       );
     }
 
-    record = res.data.value as AppCisternLexiconPubkey.Main;
-  } else if (is(AppCisternLexiconPubkey.mainSchema, publicKey)) {
-    record = publicKey;
-  } else if (publicKey) {
-    throw new Error(
-      "provided public key does not validate against lexicon schema",
-    );
+    const record = parse(AppCisternLexiconPubkey.mainSchema, res.data.value);
+
+    publicKey = { uri: res.data.uri, record };
   }
 
-  return new Producer({ ...reqs, options: { ...opts, publicKey: record } });
+  return new Producer({
+    ...reqs,
+    publicKey,
+  });
 }
 
 export class Producer {
···
     this.did = params.miniDoc.did;
     this.rpc = params.rpc;
     this.manager = params.manager;
-    this.publicKey = params.options.publicKey;
+    this.publicKey = params.publicKey;
   }
 
   /**

packages/producer/types.ts

···
 import type { BaseClientOptions, ClientRequirements } from "@cistern/shared";
 import type { AppCisternLexiconPubkey } from "@cistern/lexicon";
-import type { RecordKey } from "@atcute/lexicons";
-
-export type LocalPublicKey = AppCisternLexiconPubkey.Main;
+import type { RecordKey, ResourceUri } from "@atcute/lexicons";
 
 export interface ProducerOptions extends BaseClientOptions {
-  publicKey?: RecordKey | LocalPublicKey;
+  publicKey?: RecordKey;
 }
 
 export type ProducerParams = ClientRequirements<ProducerOptions> & {
-  options: {
-    publicKey?: AppCisternLexiconPubkey.Main;
-  };
+  publicKey?: LocalPublicKey;
 };
+
+export interface LocalPublicKey {
+  uri: ResourceUri;
+  record: AppCisternLexiconPubkey.Main;
+}