fix(lexicon): remove reliance on ambient types

deno.lock

···
         "dependencies": [
           "jsr:@puregarlic/randimal@^1.1.1",
           "jsr:@std/expect@^1.0.17",
-          "npm:@atcute/atproto@^3.1.9",
           "npm:@atcute/client@^4.0.5",
           "npm:@atcute/jetstream@^1.1.2",
           "npm:@atcute/lexicons@^1.2.2",
···
       "packages/producer": {
         "dependencies": [
           "jsr:@std/expect@^1.0.17",
-          "npm:@atcute/atproto@^3.1.9",
           "npm:@atcute/client@^4.0.5",
           "npm:@atcute/lexicons@^1.2.2",
           "npm:@atcute/tid@^1.0.3"
···
       },
       "packages/shared": {
         "dependencies": [
+          "npm:@atcute/atproto@^3.1.9",
           "npm:@atcute/client@^4.0.5",
           "npm:@atcute/lexicons@^1.2.2"
         ]

packages/consumer/deno.jsonc

···
     "exclude": ["*.test.ts"]
   },
   "imports": {
-    "@atcute/atproto": "npm:@atcute/atproto@^3.1.9",
     "@atcute/client": "npm:@atcute/client@^4.0.5",
     "@atcute/jetstream": "npm:@atcute/jetstream@^1.1.2",
     "@atcute/lexicons": "npm:@atcute/lexicons@^1.2.2",

packages/consumer/mod.test.ts

···
 import type { Did, Handle, ResourceUri } from "@atcute/lexicons";
 import { now } from "@atcute/tid";
 import type { AppCisternMemo } from "@cistern/lexicon";
+import type { XRPCProcedures, XRPCQueries } from "@cistern/shared";
 
 // Helper to create a mock Consumer instance
 function createMockConsumer(
···
 }
 
 // Helper to create a mock RPC client
-function createMockRpcClient(): Client {
+function createMockRpcClient(): Client<XRPCQueries, XRPCProcedures> {
   return {
     get: () => {
       throw new Error("Mock RPC get not implemented");
···
     post: () => {
       throw new Error("Mock RPC post not implemented");
     },
-  } as unknown as Client;
+  } as unknown as Client<XRPCQueries, XRPCProcedures>;
 }
 
 Deno.test({
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({ rpc: mockRpc });
     const keypair = await consumer.generateKeyPair();
···
           status: 500,
           data: { error: "Internal Server Error" },
         }),
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({ rpc: mockRpc });
 
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({
       rpc: mockRpc,
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({
       rpc: mockRpc,
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({
       rpc: mockRpc,
···
           status: 401,
           data: { error: "Unauthorized" },
         }),
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({
       rpc: mockRpc,
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({ rpc: mockRpc });
 
···
           status: 404,
           data: { error: "Not Found" },
         }),
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const consumer = createMockConsumer({ rpc: mockRpc });
 

packages/consumer/mod.ts

···
-import { produceRequirements } from "@cistern/shared";
+import {
+  produceRequirements,
+  type XRPCProcedures,
+  type XRPCQueries,
+} from "@cistern/shared";
 import { decryptText, generateKeys } from "@cistern/crypto";
 import { generateRandomName } from "@puregarlic/randimal";
 import { is, parse, type RecordKey } from "@atcute/lexicons";
···
   DecryptedMemo,
   LocalKeyPair,
 } from "./types.ts";
-
-import type {} from "@atcute/atproto";
 
 export async function createConsumer(
   options: ConsumerOptions,
···
 export class Consumer {
   did: Did;
   keypair?: LocalKeyPair;
-  rpc: Client;
+  rpc: Client<XRPCQueries, XRPCProcedures>;
   manager: CredentialManager;
 
   constructor(params: ConsumerParams) {

packages/lexicon/src/types/app/cistern/memo.ts

···
 import type {} from "@atcute/lexicons";
 import * as v from "@atcute/lexicons/validations";
-import type {} from "@atcute/lexicons/ambient";
 
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.string(),
···
 export const mainSchema = _mainSchema as mainSchema;
 
 export interface Main extends v.InferInput<typeof mainSchema> {}
-
-declare module "@atcute/lexicons/ambient" {
-  interface Records {
-    "app.cistern.memo": mainSchema;
-  }
-}

packages/lexicon/src/types/app/cistern/pubkey.ts

···
 import type {} from "@atcute/lexicons";
 import * as v from "@atcute/lexicons/validations";
-import type {} from "@atcute/lexicons/ambient";
 
 const _mainSchema = /*#__PURE__*/ v.record(
   /*#__PURE__*/ v.string(),
···
 export const mainSchema = _mainSchema as mainSchema;
 
 export interface Main extends v.InferInput<typeof mainSchema> {}
-
-declare module "@atcute/lexicons/ambient" {
-  interface Records {
-    "app.cistern.pubkey": mainSchema;
-  }
-}

packages/producer/deno.jsonc

···
     "exclude": ["*.test.ts"]
   },
   "imports": {
-    "@atcute/atproto": "npm:@atcute/atproto@^3.1.9",
     "@atcute/client": "npm:@atcute/client@^4.0.5",
     "@atcute/lexicons": "npm:@atcute/lexicons@^1.2.2",
     "@atcute/tid": "npm:@atcute/tid@^1.0.3",

packages/producer/mod.test.ts

···
 import type { Client, CredentialManager } from "@atcute/client";
 import type { Did, Handle, ResourceUri } from "@atcute/lexicons";
 import type { AppCisternPubkey } from "@cistern/lexicon";
+import type { XRPCProcedures, XRPCQueries } from "@cistern/shared";
 
 // Helper to create a mock Producer instance
 function createMockProducer(
···
 }
 
 // Helper to create a mock RPC client
-function createMockRpcClient(): Client {
+function createMockRpcClient(): Client<XRPCQueries, XRPCProcedures> {
   return {
     get: () => {
       throw new Error("Mock RPC get not implemented");
···
     post: () => {
       throw new Error("Mock RPC post not implemented");
     },
-  } as unknown as Client;
+  } as unknown as Client<XRPCQueries, XRPCProcedures>;
 }
 
 Deno.test({
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const producer = createMockProducer({
       rpc: mockRpc,
···
           status: 500,
           data: { error: "Internal Server Error" },
         }),
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const producer = createMockProducer({
       rpc: mockRpc,
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const producer = createMockProducer({ rpc: mockRpc });
 
···
         }
         return Promise.resolve({ ok: false, status: 500, data: {} });
       },
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const producer = createMockProducer({ rpc: mockRpc });
 
···
           status: 401,
           data: { error: "Unauthorized" },
         }),
-    } as unknown as Client;
+    } as unknown as Client<XRPCQueries, XRPCProcedures>;
 
     const producer = createMockProducer({ rpc: mockRpc });
 

packages/producer/mod.ts

···
 import { now } from "@atcute/tid";
 import { type AppCisternMemo, AppCisternPubkey } from "@cistern/lexicon";
 
-import type {} from "@atcute/atproto";
-
 export async function createProducer(
   { publicKey: rkey, ...opts }: ProducerOptions,
 ): Promise<Producer> {

packages/shared/deno.jsonc

···
     "exclude": ["*.test.ts"]
   },
   "imports": {
+    "@atcute/atproto": "npm:@atcute/atproto@^3.1.9",
     "@atcute/client": "npm:@atcute/client@^4.0.5",
     "@atcute/lexicons": "npm:@atcute/lexicons@^1.2.2"
   }

packages/shared/types.ts

···
 import type { Did, Handle } from "@atcute/lexicons";
 import type { Client, CredentialManager } from "@atcute/client";
+import type {
+  ComAtprotoRepoCreateRecord,
+  ComAtprotoRepoDeleteRecord,
+  ComAtprotoRepoGetRecord,
+  ComAtprotoRepoListRecords,
+} from "@atcute/atproto";
 
 export interface MiniDoc {
   did: Did;
···
   appPassword: string;
 }
 
+export interface XRPCQueries {
+  "com.atproto.repo.getRecord": ComAtprotoRepoGetRecord.mainSchema;
+  "com.atproto.repo.listRecords": ComAtprotoRepoListRecords.mainSchema;
+}
+
+export interface XRPCProcedures {
+  "com.atproto.repo.createRecord": ComAtprotoRepoCreateRecord.mainSchema;
+  "com.atproto.repo.deleteRecord": ComAtprotoRepoDeleteRecord.mainSchema;
+}
+
 export interface ClientRequirements<Options extends BaseClientOptions> {
   miniDoc: MiniDoc;
   manager: CredentialManager;
-  rpc: Client;
+  rpc: Client<XRPCQueries, XRPCProcedures>;
   options: Options;
 }