debugging

lexicons/ch/indiemusi/alpha/actor/artist.json

···
   "id": "ch.indiemusi.alpha.actor.artist",
   "defs": {
     "main": {
-      "key": "tid",
-      "type": "record",
       "description": "An artist or band who performs music",
+      "key": "literal:self",
       "record": {
-        "type": "object",
-        "required": ["name"],
         "properties": {
           "name": {
             "type": "string",
             "maxLength": 255
           }
-        }
-      }
+        },
+        "type": "object"
+      },
+      "type": "record"
     }
   }
 }

lexicons/org/atmosphereconf/profile.json

···
+{
+  "lexicon": 1,
+  "id": "org.atmosphereconf.profile",
+  "defs": {
+    "main": {
+      "description": "A declaration of a basic account profile.",
+      "key": "literal:self",
+      "record": {
+        "properties": {
+          "avatar": {
+            "accept": [
+              "image/png",
+              "image/jpeg"
+            ],
+            "description": "Small image to be displayed next to posts from account. AKA, 'profile picture'",
+            "maxSize": 1000000,
+            "type": "blob"
+          },
+          "createdAt": {
+            "format": "datetime",
+            "type": "string"
+          },
+          "description": {
+            "description": "Free-form profile description text.",
+            "maxGraphemes": 256,
+            "maxLength": 2560,
+            "type": "string"
+          },
+          "displayName": {
+            "maxGraphemes": 64,
+            "maxLength": 640,
+            "type": "string"
+          },
+          "interests": {
+            "type": "array",
+            "items": {
+              "type": "string"
+            }
+          }
+        },
+        "type": "object"
+      },
+      "type": "record"
+    }
+  }
+}

src/features/actors/handlers.tsx

···
 
     // TODO: Implement actual publishing owner creation logic here
     // For now, we'll just simulate success
-    console.log("Creating publishing owner:", {
-      firstName: firstName?.trim(),
-      lastName: lastName?.trim(),
-      companyName: companyName?.trim(),
-      ipi: ipi?.trim(),
-      collectingSociety: collectingSociety?.trim(),
-      userId: context.currentUser!.sub, // Safe to use ! because requireAuth ensures currentUser exists
-    });
+    // console.log("Creating publishing owner:", {
+    //   firstName: firstName?.trim(),
+    //   lastName: lastName?.trim(),
+    //   companyName: companyName?.trim(),
+    //   ipi: ipi?.trim(),
+    //   collectingSociety: collectingSociety?.trim(),
+    //   userId: context.currentUser!.sub, // Safe to use ! because requireAuth ensures currentUser exists
+    // });
 
     const oauthClient = new OAuthClient(
       oauthConfig,
···
     //     collecting_society: collectingSociety?.trim(),
     //   });
 
-    const newArtist = await client.ch.indiemusi.alpha.actor.artist.createRecord({
-      name: "Hilke"
-    })
+    // const newArtist = await client.ch.indiemusi.alpha.actor.artist.createRecord({
+    //   name: "Hilke"
+    // })
 
+    console.log("CLIENT", client);
+    const newProfile = await client.org.atmosphereconf.profile.createRecord({ displayName: "Hilke" });
+    console.log("NEW PROFILE", newProfile);
     return Response.redirect(
       new URL(
         "/actors/?success=Publishing owner created successfully",

src/generated_client.ts

···
 // Generated TypeScript client for AT Protocol records
-// Generated at: 2025-10-12 08:29:02 UTC
-// Lexicons: 23
+// Generated at: 2025-10-24 13:07:19 UTC
+// Lexicons: 24
 
 /**
  * @example Usage
···
   likeCount?: number;
 }
 
+export interface OrgAtmosphereconfProfile {
+  /** Small image to be displayed next to posts from account. AKA, 'profile picture' */
+  avatar?: BlobRef;
+  createdAt?: string;
+  /** Free-form profile description text. */
+  description?: string;
+  displayName?: string;
+  interests?: string[];
+}
+
+export type OrgAtmosphereconfProfileSortFields =
+  | "createdAt"
+  | "description"
+  | "displayName";
+
 export interface ChIndiemusiAlphaRecording {
   title: string;
   song?: ChIndiemusiAlphaSong;
···
 export type ChIndiemusiAlphaSongSortFields = "title" | "iswc";
 
 export interface ChIndiemusiAlphaActorArtist {
-  name: string;
+  name?: string;
 }
 
 export type ChIndiemusiAlphaActorArtistSortFields = "name";
···
   }
 }
 
+class ProfileAtmosphereconfOrgClient {
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+  }
+
+  async getRecords(
+    params?: {
+      limit?: number;
+      cursor?: string;
+      where?: {
+        [K in OrgAtmosphereconfProfileSortFields | IndexedRecordFields]?:
+          WhereCondition;
+      };
+      orWhere?: {
+        [K in OrgAtmosphereconfProfileSortFields | IndexedRecordFields]?:
+          WhereCondition;
+      };
+      sortBy?: SortField<OrgAtmosphereconfProfileSortFields>[];
+    },
+  ): Promise<GetRecordsResponse<OrgAtmosphereconfProfile>> {
+    return await this.client.getRecords("org.atmosphereconf.profile", params);
+  }
+
+  async getRecord(
+    params: GetRecordParams,
+  ): Promise<RecordResponse<OrgAtmosphereconfProfile>> {
+    return await this.client.getRecord("org.atmosphereconf.profile", params);
+  }
+
+  async countRecords(
+    params?: {
+      limit?: number;
+      cursor?: string;
+      where?: {
+        [K in OrgAtmosphereconfProfileSortFields | IndexedRecordFields]?:
+          WhereCondition;
+      };
+      orWhere?: {
+        [K in OrgAtmosphereconfProfileSortFields | IndexedRecordFields]?:
+          WhereCondition;
+      };
+      sortBy?: SortField<OrgAtmosphereconfProfileSortFields>[];
+    },
+  ): Promise<CountRecordsResponse> {
+    return await this.client.countRecords("org.atmosphereconf.profile", params);
+  }
+
+  async createRecord(
+    record: OrgAtmosphereconfProfile,
+    useSelfRkey?: boolean,
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.createRecord(
+      "org.atmosphereconf.profile",
+      record,
+      useSelfRkey,
+    );
+  }
+
+  async updateRecord(
+    rkey: string,
+    record: OrgAtmosphereconfProfile,
+  ): Promise<{ uri: string; cid: string }> {
+    return await this.client.updateRecord(
+      "org.atmosphereconf.profile",
+      rkey,
+      record,
+    );
+  }
+
+  async deleteRecord(rkey: string): Promise<void> {
+    return await this.client.deleteRecord("org.atmosphereconf.profile", rkey);
+  }
+}
+
+class AtmosphereconfOrgClient {
+  readonly profile: ProfileAtmosphereconfOrgClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.profile = new ProfileAtmosphereconfOrgClient(client);
+  }
+}
+
+class OrgClient {
+  readonly atmosphereconf: AtmosphereconfOrgClient;
+  private readonly client: SlicesClient;
+
+  constructor(client: SlicesClient) {
+    this.client = client;
+    this.atmosphereconf = new AtmosphereconfOrgClient(client);
+  }
+}
+
 class RecordingAlphaIndiemusiChClient {
   private readonly client: SlicesClient;
 
···
 
 export class AtProtoClient extends SlicesClient {
   readonly app: AppClient;
+  readonly org: OrgClient;
   readonly ch: ChClient;
   readonly oauth?: OAuthClient | AuthProvider;
 
···
   ) {
     super(baseUrl, sliceUri, oauthClient);
     this.app = new AppClient(this);
+    this.org = new OrgClient(this);
     this.ch = new ChClient(this);
     this.oauth = oauthClient;
   }