chore: Initial profile infrastructure setup

lexicons/defs.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.label.defs",
+  "defs": {
+    "label": {
+      "type": "object",
+      "description": "Metadata tag on an atproto resource (eg, repo or record).",
+      "required": ["src", "uri", "val", "cts"],
+      "properties": {
+        "ver": {
+          "type": "integer",
+          "description": "The AT Protocol version of the label object."
+        },
+        "src": {
+          "type": "string",
+          "format": "did",
+          "description": "DID of the actor who created this label."
+        },
+        "uri": {
+          "type": "string",
+          "format": "uri",
+          "description": "AT URI of the record, repository (account), or other resource that this label applies to."
+        },
+        "cid": {
+          "type": "string",
+          "format": "cid",
+          "description": "Optionally, CID specifying the specific version of 'uri' resource this label applies to."
+        },
+        "val": {
+          "type": "string",
+          "maxLength": 128,
+          "description": "The short string name of the value or type of this label."
+        },
+        "neg": {
+          "type": "boolean",
+          "description": "If true, this is a negation label, overwriting a previous label."
+        },
+        "cts": {
+          "type": "string",
+          "format": "datetime",
+          "description": "Timestamp when this label was created."
+        },
+        "exp": {
+          "type": "string",
+          "format": "datetime",
+          "description": "Timestamp at which this label expires (no longer applies)."
+        },
+        "sig": {
+          "type": "bytes",
+          "description": "Signature of dag-cbor encoded label."
+        }
+      }
+    },
+    "selfLabels": {
+      "type": "object",
+      "description": "Metadata tags on an atproto record, published by the author within the record.",
+      "required": ["values"],
+      "properties": {
+        "values": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#selfLabel" },
+          "maxLength": 10
+        }
+      }
+    },
+    "selfLabel": {
+      "type": "object",
+      "description": "Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.",
+      "required": ["val"],
+      "properties": {
+        "val": {
+          "type": "string",
+          "maxLength": 128,
+          "description": "The short string name of the value or type of this label."
+        }
+      }
+    },
+    "labelValueDefinition": {
+      "type": "object",
+      "description": "Declares a label value and its expected interpretations and behaviors.",
+      "required": ["identifier", "severity", "blurs", "locales"],
+      "properties": {
+        "identifier": {
+          "type": "string",
+          "description": "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",
+          "maxLength": 100,
+          "maxGraphemes": 100
+        },
+        "severity": {
+          "type": "string",
+          "description": "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",
+          "knownValues": ["inform", "alert", "none"]
+        },
+        "blurs": {
+          "type": "string",
+          "description": "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",
+          "knownValues": ["content", "media", "none"]
+        },
+        "defaultSetting": {
+          "type": "string",
+          "description": "The default setting for this label.",
+          "knownValues": ["ignore", "warn", "hide"],
+          "default": "warn"
+        },
+        "adultOnly": {
+          "type": "boolean",
+          "description": "Does the user need to have adult content enabled in order to configure this label?"
+        },
+        "locales": {
+          "type": "array",
+          "items": { "type": "ref", "ref": "#labelValueDefinitionStrings" }
+        }
+      }
+    },
+    "labelValueDefinitionStrings": {
+      "type": "object",
+      "description": "Strings which describe the label in the UI, localized into a specific language.",
+      "required": ["lang", "name", "description"],
+      "properties": {
+        "lang": {
+          "type": "string",
+          "description": "The code of the language these strings are written in.",
+          "format": "language"
+        },
+        "name": {
+          "type": "string",
+          "description": "A short human-readable name for the label.",
+          "maxGraphemes": 64,
+          "maxLength": 640
+        },
+        "description": {
+          "type": "string",
+          "description": "A longer description of what the label means and why it might be applied.",
+          "maxGraphemes": 10000,
+          "maxLength": 100000
+        }
+      }
+    },
+    "labelValue": {
+      "type": "string",
+      "knownValues": [
+        "!hide",
+        "!no-promote",
+        "!warn",
+        "!no-unauthenticated",
+        "dmca-violation",
+        "doxxing",
+        "porn",
+        "sexual",
+        "nudity",
+        "nsfl",
+        "gore"
+      ]
+    }
+  }
+}

lexicons/profile.json

···
+{
+  "lexicon": 1,
+  "id": "org.atmosphereconf.profile",
+  "defs": {
+    "main": {
+      "type": "record",
+      "description": "A conference attendee profile.",
+      "key": "literal:self",
+      "record": {
+        "type": "object",
+        "properties": {
+          "displayName": {
+            "type": "string",
+            "maxGraphemes": 64,
+            "maxLength": 640
+          },
+          "description": {
+            "type": "string",
+            "description": "Free-form profile description text.",
+            "maxGraphemes": 256,
+            "maxLength": 2560
+          },
+          "avatar": {
+            "type": "blob",
+            "description": "Profile picture for conference attendee",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "banner": {
+            "type": "blob",
+            "description": "Larger horizontal image to display behind profile view.",
+            "accept": ["image/png", "image/jpeg"],
+            "maxSize": 1000000
+          },
+          "labels": {
+            "type": "union",
+            "description": "Self-label values for the conference profile.",
+            "refs": ["com.atproto.label.defs#selfLabels"]
+          },
+          "createdAt": { "type": "string", "format": "datetime" }
+        }
+      }
+    }
+  }
+}

lexicons/strongRef.json

···
+{
+  "lexicon": 1,
+  "id": "com.atproto.repo.strongRef",
+  "description": "A URI with a content-hash fingerprint.",
+  "defs": {
+    "main": {
+      "type": "object",
+      "required": ["uri", "cid"],
+      "properties": {
+        "uri": { "type": "string", "format": "at-uri" },
+        "cid": { "type": "string", "format": "cid" }
+      }
+    }
+  }
+}

package-lock.json

···
         "daisyui": "^5.3.9",
         "dotenv": "^17.2.3",
         "tailwindcss": "^4.1.16"
+      },
+      "devDependencies": {
+        "@atproto/lex-cli": "^0.9.6"
       }
     },
     "node_modules/@astrojs/compiler": {
···
         "@atproto/jwk": "0.6.0",
         "@atproto/jwk-jose": "0.1.11",
         "zod": "^3.23.8"
+      }
+    },
+    "node_modules/@atproto/lex-cli": {
+      "version": "0.9.6",
+      "resolved": "https://registry.npmjs.org/@atproto/lex-cli/-/lex-cli-0.9.6.tgz",
+      "integrity": "sha512-EedEKmURoSP735YwSDHsFrLOhZ4P2it8goCHv5ApWi/R9DFpOKOpmYfIXJ9MAprK8cw+yBnjDJbzpLJy7UXlTg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@atproto/lexicon": "^0.5.1",
+        "@atproto/syntax": "^0.4.1",
+        "chalk": "^4.1.2",
+        "commander": "^9.4.0",
+        "prettier": "^3.2.5",
+        "ts-morph": "^24.0.0",
+        "yesno": "^0.4.0",
+        "zod": "^3.23.8"
+      },
+      "bin": {
+        "lex": "dist/index.js"
+      },
+      "engines": {
+        "node": ">=18.7.0"
+      }
+    },
+    "node_modules/@atproto/lex-cli/node_modules/ansi-styles": {
+      "version": "4.3.0",
+      "resolved": "https://registry.npmjs.org/ansi-styles/-/ansi-styles-4.3.0.tgz",
+      "integrity": "sha512-zbB9rCJAT1rbjiVDb2hqKFHNYLxgtk8NURxZ3IZwD3F6NtxbXZQCnnSi1Lkx+IDohdPlFp222wVALIheZJQSEg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-convert": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=8"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/ansi-styles?sponsor=1"
+      }
+    },
+    "node_modules/@atproto/lex-cli/node_modules/chalk": {
+      "version": "4.1.2",
+      "resolved": "https://registry.npmjs.org/chalk/-/chalk-4.1.2.tgz",
+      "integrity": "sha512-oKnbhFyRIXpUuez8iBMmyEa4nbj4IOQyuhc/wy9kY7/WVPcwIO9VA668Pu8RkO7+0G76SLROeyw9CpQ061i4mA==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "ansi-styles": "^4.1.0",
+        "supports-color": "^7.1.0"
+      },
+      "engines": {
+        "node": ">=10"
+      },
+      "funding": {
+        "url": "https://github.com/chalk/chalk?sponsor=1"
       }
     },
     "node_modules/@atproto/lexicon": {
···
         "vite": "^5.2.0 || ^6 || ^7"
       }
     },
+    "node_modules/@ts-morph/common": {
+      "version": "0.25.0",
+      "resolved": "https://registry.npmjs.org/@ts-morph/common/-/common-0.25.0.tgz",
+      "integrity": "sha512-kMnZz+vGGHi4GoHnLmMhGNjm44kGtKUXGnOvrKmMwAuvNjM/PgKVGfUnL7IDvK7Jb2QQ82jq3Zmp04Gy+r3Dkg==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "minimatch": "^9.0.4",
+        "path-browserify": "^1.0.1",
+        "tinyglobby": "^0.2.9"
+      }
+    },
     "node_modules/@types/debug": {
       "version": "4.1.12",
       "resolved": "https://registry.npmjs.org/@types/debug/-/debug-4.1.12.tgz",
···
         "url": "https://github.com/sponsors/wooorm"
       }
     },
+    "node_modules/balanced-match": {
+      "version": "1.0.2",
+      "resolved": "https://registry.npmjs.org/balanced-match/-/balanced-match-1.0.2.tgz",
+      "integrity": "sha512-3oSeUO0TMV67hN1AmbXsK4yaqU7tjiHlbxRDZOpH0KW9+CeX4bRAaX0Anxt0tx2MrpRpWwQaPwIlISEJhYU5Pw==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/base-64": {
       "version": "1.0.0",
       "resolved": "https://registry.npmjs.org/base-64/-/base-64-1.0.0.tgz",
···
       },
       "funding": {
         "url": "https://github.com/sponsors/sindresorhus"
+      }
+    },
+    "node_modules/brace-expansion": {
+      "version": "2.0.2",
+      "resolved": "https://registry.npmjs.org/brace-expansion/-/brace-expansion-2.0.2.tgz",
+      "integrity": "sha512-Jt0vHyM+jmUBqojB7E1NIYadt0vI0Qxjxd2TErW94wDz+E2LAm5vKMXXwg6ZZBTHPuUlDgQHKXvjGBdfcF1ZDQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "balanced-match": "^1.0.0"
       }
     },
     "node_modules/brotli": {
···
         "node": ">=6"
       }
     },
+    "node_modules/code-block-writer": {
+      "version": "13.0.3",
+      "resolved": "https://registry.npmjs.org/code-block-writer/-/code-block-writer-13.0.3.tgz",
+      "integrity": "sha512-Oofo0pq3IKnsFtuHqSF7TqBfr71aeyZDVJ0HpmqB7FBM2qEigL0iPONSCZSO9pE9dZTAxANe5XHG9Uy0YMv8cg==",
+      "dev": true,
+      "license": "MIT"
+    },
+    "node_modules/color-convert": {
+      "version": "2.0.1",
+      "resolved": "https://registry.npmjs.org/color-convert/-/color-convert-2.0.1.tgz",
+      "integrity": "sha512-RRECPsj7iu/xb5oKYcsFHSppFNnsj/52OVTRKb4zP5onXwVF3zVmmToNcOfGC+CRDpfK/U584fMg38ZHCaElKQ==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "color-name": "~1.1.4"
+      },
+      "engines": {
+        "node": ">=7.0.0"
+      }
+    },
+    "node_modules/color-name": {
+      "version": "1.1.4",
+      "resolved": "https://registry.npmjs.org/color-name/-/color-name-1.1.4.tgz",
+      "integrity": "sha512-dOy+3AuW3a2wNbZHIuMZpTcgjGuLU/uBL/ubcZF9OXbDo8ff4O8yVp5Bf0efS8uEoYo5q4Fx7dY9OgQGXgAsQA==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/comma-separated-tokens": {
       "version": "2.0.3",
       "resolved": "https://registry.npmjs.org/comma-separated-tokens/-/comma-separated-tokens-2.0.3.tgz",
···
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/commander": {
+      "version": "9.5.0",
+      "resolved": "https://registry.npmjs.org/commander/-/commander-9.5.0.tgz",
+      "integrity": "sha512-KRs7WVDKg86PWiuAqhDrAQnTXZKraVcCc6vFdL14qrZ/DcWwuRo7VoiYXalXO7S5GKpqYiVEwCbgFDfxNHKJBQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": "^12.20.0 || >=14"
       }
     },
     "node_modules/common-ancestor-path": {
···
         "radix3": "^1.1.2",
         "ufo": "^1.6.1",
         "uncrypto": "^0.1.3"
+      }
+    },
+    "node_modules/has-flag": {
+      "version": "4.0.0",
+      "resolved": "https://registry.npmjs.org/has-flag/-/has-flag-4.0.0.tgz",
+      "integrity": "sha512-EykJT/Q1KjTWctppgIAgfSO0tKVuZUjhgMr17kqTumMl6Afv3EISleU7qZUzoXDFTAHTDC4NOoG/ZxU3EvlMPQ==",
+      "dev": true,
+      "license": "MIT",
+      "engines": {
+        "node": ">=8"
       }
     },
     "node_modules/hast-util-from-html": {
···
         "node": ">= 0.6"
       }
     },
+    "node_modules/minimatch": {
+      "version": "9.0.5",
+      "resolved": "https://registry.npmjs.org/minimatch/-/minimatch-9.0.5.tgz",
+      "integrity": "sha512-G6T0ZX48xgozx7587koeX9Ys2NYy6Gmv//P89sEte9V9whIapMNF4idKxnW2QtCcLiTWlb/wfCabAtAFWhhBow==",
+      "dev": true,
+      "license": "ISC",
+      "dependencies": {
+        "brace-expansion": "^2.0.1"
+      },
+      "engines": {
+        "node": ">=16 || 14 >=14.17"
+      },
+      "funding": {
+        "url": "https://github.com/sponsors/isaacs"
+      }
+    },
     "node_modules/mrmime": {
       "version": "2.0.1",
       "resolved": "https://registry.npmjs.org/mrmime/-/mrmime-2.0.1.tgz",
···
         "url": "https://github.com/inikulin/parse5?sponsor=1"
       }
     },
+    "node_modules/path-browserify": {
+      "version": "1.0.1",
+      "resolved": "https://registry.npmjs.org/path-browserify/-/path-browserify-1.0.1.tgz",
+      "integrity": "sha512-b7uo2UCUOYZcnF/3ID0lulOJi/bafxa1xPe7ZPsammBSpjSWQkjNxlt635YGS2MiR9GjvuXCtz2emr3jbsz98g==",
+      "dev": true,
+      "license": "MIT"
+    },
     "node_modules/picocolors": {
       "version": "1.1.1",
       "resolved": "https://registry.npmjs.org/picocolors/-/picocolors-1.1.1.tgz",
···
       },
       "engines": {
         "node": "^10 || ^12 || >=14"
+      }
+    },
+    "node_modules/prettier": {
+      "version": "3.6.2",
+      "resolved": "https://registry.npmjs.org/prettier/-/prettier-3.6.2.tgz",
+      "integrity": "sha512-I7AIg5boAr5R0FFtJ6rCfD+LFsWHp81dolrFD8S79U9tb8Az2nGrJncnMSnys+bpQJfRUzqs9hnA81OAA3hCuQ==",
+      "dev": true,
+      "license": "MIT",
+      "bin": {
+        "prettier": "bin/prettier.cjs"
+      },
+      "engines": {
+        "node": ">=14"
+      },
+      "funding": {
+        "url": "https://github.com/prettier/prettier?sponsor=1"
       }
     },
     "node_modules/prismjs": {
···
         "url": "https://github.com/chalk/strip-ansi?sponsor=1"
       }
     },
+    "node_modules/supports-color": {
+      "version": "7.2.0",
+      "resolved": "https://registry.npmjs.org/supports-color/-/supports-color-7.2.0.tgz",
+      "integrity": "sha512-qpCAvRl9stuOHveKsn7HncJRvv501qIacKzQlO/+Lwxc9+0q2wLyv4Dfvt80/DPn2pqOBsJdDiogXGR9+OvwRw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "has-flag": "^4.0.0"
+      },
+      "engines": {
+        "node": ">=8"
+      }
+    },
     "node_modules/tailwindcss": {
       "version": "4.1.16",
       "resolved": "https://registry.npmjs.org/tailwindcss/-/tailwindcss-4.1.16.tgz",
···
       "funding": {
         "type": "github",
         "url": "https://github.com/sponsors/wooorm"
+      }
+    },
+    "node_modules/ts-morph": {
+      "version": "24.0.0",
+      "resolved": "https://registry.npmjs.org/ts-morph/-/ts-morph-24.0.0.tgz",
+      "integrity": "sha512-2OAOg/Ob5yx9Et7ZX4CvTCc0UFoZHwLEJ+dpDPSUi5TgwwlTlX47w+iFRrEwzUZwYACjq83cgjS/Da50Ga37uw==",
+      "dev": true,
+      "license": "MIT",
+      "dependencies": {
+        "@ts-morph/common": "~0.25.0",
+        "code-block-writer": "^13.0.3"
       }
     },
     "node_modules/tsconfck": {
···
       "engines": {
         "node": ">=12"
       }
+    },
+    "node_modules/yesno": {
+      "version": "0.4.0",
+      "resolved": "https://registry.npmjs.org/yesno/-/yesno-0.4.0.tgz",
+      "integrity": "sha512-tdBxmHvbXPBKYIg81bMCB7bVeDmHkRzk5rVJyYYXurwKkHq/MCd8rz4HSJUP7hW0H2NlXiq8IFiWvYKEHhlotA==",
+      "dev": true,
+      "license": "BSD"
     },
     "node_modules/yocto-queue": {
       "version": "1.2.1",

package.json

···
     "dev": "astro dev",
     "build": "astro build",
     "preview": "astro preview",
-    "astro": "astro"
+    "astro": "astro",
+    "lexgen": "lex gen-server ./src/lexicon ./lexicons/*"
   },
   "dependencies": {
     "@astrojs/node": "^9.5.0",
···
     "daisyui": "^5.3.9",
     "dotenv": "^17.2.3",
     "tailwindcss": "^4.1.16"
+  },
+  "devDependencies": {
+    "@atproto/lex-cli": "^0.9.6"
   }
 }

src/components/ProfileForm.astro

···
+---
+interface Props {
+  displayName?: string
+  description?: string
+  avatar?: string
+  banner?: string
+  submitLabel?: string
+  action?: string
+}
+
+const {
+  displayName = '',
+  description = '',
+  avatar = '',
+  banner = '',
+  submitLabel = 'Create Profile',
+  action = '/api/profile/create'
+} = Astro.props
+---
+
+<form
+  method="POST"
+  action={action}
+  enctype="multipart/form-data"
+  class="space-y-4"
+>
+  <div class="form-control">
+    <label class="label">
+      <span class="label-text">Display Name</span>
+      <span class="label-text-alt">Max 64 characters</span>
+    </label>
+    <input
+      type="text"
+      name="displayName"
+      placeholder="Enter your display name"
+      class="input input-bordered w-full"
+      value={displayName}
+      maxlength="64"
+      required
+    />
+  </div>
+
+  <div class="form-control">
+    <label class="label">
+      <span class="label-text">Description</span>
+      <span class="label-text-alt">Max 256 characters</span>
+    </label>
+    <textarea
+      name="description"
+      placeholder="Tell us about yourself"
+      class="textarea textarea-bordered h-24"
+      maxlength="256"
+    >{description}</textarea>
+  </div>
+
+  <div class="form-control">
+    <label class="label">
+      <span class="label-text">Avatar</span>
+      <span class="label-text-alt">PNG or JPEG, max 1MB</span>
+    </label>
+    {avatar && (
+      <div class="avatar mb-2">
+        <div class="w-24 rounded-full">
+          <img src={avatar} alt="Current avatar" />
+        </div>
+      </div>
+    )}
+    <input
+      type="file"
+      name="avatar"
+      accept="image/png,image/jpeg"
+      class="file-input file-input-bordered w-full"
+    />
+  </div>
+
+  <div class="form-control">
+    <label class="label">
+      <span class="label-text">Banner</span>
+      <span class="label-text-alt">PNG or JPEG, max 1MB</span>
+    </label>
+    {banner && (
+      <div class="mb-2">
+        <img src={banner} alt="Current banner" class="w-full h-32 object-cover rounded-lg" />
+      </div>
+    )}
+    <input
+      type="file"
+      name="banner"
+      accept="image/png,image/jpeg"
+      class="file-input file-input-bordered w-full"
+    />
+  </div>
+
+  <div class="form-control mt-6">
+    <button type="submit" class="btn btn-primary w-full">
+      {submitLabel}
+    </button>
+  </div>
+</form>
+
+<script>
+  // Client-side validation for file sizes
+  const form = document.querySelector('form')
+  if (form) {
+    form.addEventListener('submit', (e) => {
+      const avatarInput = form.querySelector('input[name="avatar"]') as HTMLInputElement
+      const bannerInput = form.querySelector('input[name="banner"]') as HTMLInputElement
+
+      const maxSize = 1000000 // 1MB
+
+      if (avatarInput?.files?.[0] && avatarInput.files[0].size > maxSize) {
+        e.preventDefault()
+        alert('Avatar file size must be less than 1MB')
+        return
+      }
+
+      if (bannerInput?.files?.[0] && bannerInput.files[0].size > maxSize) {
+        e.preventDefault()
+        alert('Banner file size must be less than 1MB')
+        return
+      }
+    })
+  }
+</script>

src/lexicon/index.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  type Auth,
+  type Options as XrpcOptions,
+  Server as XrpcServer,
+  type StreamConfigOrHandler,
+  type MethodConfigOrHandler,
+  createServer as createXrpcServer,
+} from '@atproto/xrpc-server'
+import { schemas } from './lexicons.js'
+
+export function createServer(options?: XrpcOptions): Server {
+  return new Server(options)
+}
+
+export class Server {
+  xrpc: XrpcServer
+  org: OrgNS
+  com: ComNS
+
+  constructor(options?: XrpcOptions) {
+    this.xrpc = createXrpcServer(schemas, options)
+    this.org = new OrgNS(this)
+    this.com = new ComNS(this)
+  }
+}
+
+export class OrgNS {
+  _server: Server
+  atmosphereconf: OrgAtmosphereconfNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.atmosphereconf = new OrgAtmosphereconfNS(server)
+  }
+}
+
+export class OrgAtmosphereconfNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}
+
+export class ComNS {
+  _server: Server
+  atproto: ComAtprotoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.atproto = new ComAtprotoNS(server)
+  }
+}
+
+export class ComAtprotoNS {
+  _server: Server
+  repo: ComAtprotoRepoNS
+
+  constructor(server: Server) {
+    this._server = server
+    this.repo = new ComAtprotoRepoNS(server)
+  }
+}
+
+export class ComAtprotoRepoNS {
+  _server: Server
+
+  constructor(server: Server) {
+    this._server = server
+  }
+}

src/lexicon/lexicons.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import {
+  type LexiconDoc,
+  Lexicons,
+  ValidationError,
+  type ValidationResult,
+} from '@atproto/lexicon'
+import { type $Typed, is$typed, maybe$typed } from './util.js'
+
+export const schemaDict = {
+  ComAtprotoLabelDefs: {
+    lexicon: 1,
+    id: 'com.atproto.label.defs',
+    defs: {
+      label: {
+        type: 'object',
+        description:
+          'Metadata tag on an atproto resource (eg, repo or record).',
+        required: ['src', 'uri', 'val', 'cts'],
+        properties: {
+          ver: {
+            type: 'integer',
+            description: 'The AT Protocol version of the label object.',
+          },
+          src: {
+            type: 'string',
+            format: 'did',
+            description: 'DID of the actor who created this label.',
+          },
+          uri: {
+            type: 'string',
+            format: 'uri',
+            description:
+              'AT URI of the record, repository (account), or other resource that this label applies to.',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+            description:
+              "Optionally, CID specifying the specific version of 'uri' resource this label applies to.",
+          },
+          val: {
+            type: 'string',
+            maxLength: 128,
+            description:
+              'The short string name of the value or type of this label.',
+          },
+          neg: {
+            type: 'boolean',
+            description:
+              'If true, this is a negation label, overwriting a previous label.',
+          },
+          cts: {
+            type: 'string',
+            format: 'datetime',
+            description: 'Timestamp when this label was created.',
+          },
+          exp: {
+            type: 'string',
+            format: 'datetime',
+            description:
+              'Timestamp at which this label expires (no longer applies).',
+          },
+          sig: {
+            type: 'bytes',
+            description: 'Signature of dag-cbor encoded label.',
+          },
+        },
+      },
+      selfLabels: {
+        type: 'object',
+        description:
+          'Metadata tags on an atproto record, published by the author within the record.',
+        required: ['values'],
+        properties: {
+          values: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#selfLabel',
+            },
+            maxLength: 10,
+          },
+        },
+      },
+      selfLabel: {
+        type: 'object',
+        description:
+          'Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel.',
+        required: ['val'],
+        properties: {
+          val: {
+            type: 'string',
+            maxLength: 128,
+            description:
+              'The short string name of the value or type of this label.',
+          },
+        },
+      },
+      labelValueDefinition: {
+        type: 'object',
+        description:
+          'Declares a label value and its expected interpretations and behaviors.',
+        required: ['identifier', 'severity', 'blurs', 'locales'],
+        properties: {
+          identifier: {
+            type: 'string',
+            description:
+              "The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+).",
+            maxLength: 100,
+            maxGraphemes: 100,
+          },
+          severity: {
+            type: 'string',
+            description:
+              "How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing.",
+            knownValues: ['inform', 'alert', 'none'],
+          },
+          blurs: {
+            type: 'string',
+            description:
+              "What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing.",
+            knownValues: ['content', 'media', 'none'],
+          },
+          defaultSetting: {
+            type: 'string',
+            description: 'The default setting for this label.',
+            knownValues: ['ignore', 'warn', 'hide'],
+            default: 'warn',
+          },
+          adultOnly: {
+            type: 'boolean',
+            description:
+              'Does the user need to have adult content enabled in order to configure this label?',
+          },
+          locales: {
+            type: 'array',
+            items: {
+              type: 'ref',
+              ref: 'lex:com.atproto.label.defs#labelValueDefinitionStrings',
+            },
+          },
+        },
+      },
+      labelValueDefinitionStrings: {
+        type: 'object',
+        description:
+          'Strings which describe the label in the UI, localized into a specific language.',
+        required: ['lang', 'name', 'description'],
+        properties: {
+          lang: {
+            type: 'string',
+            description:
+              'The code of the language these strings are written in.',
+            format: 'language',
+          },
+          name: {
+            type: 'string',
+            description: 'A short human-readable name for the label.',
+            maxGraphemes: 64,
+            maxLength: 640,
+          },
+          description: {
+            type: 'string',
+            description:
+              'A longer description of what the label means and why it might be applied.',
+            maxGraphemes: 10000,
+            maxLength: 100000,
+          },
+        },
+      },
+      labelValue: {
+        type: 'string',
+        knownValues: [
+          '!hide',
+          '!no-promote',
+          '!warn',
+          '!no-unauthenticated',
+          'dmca-violation',
+          'doxxing',
+          'porn',
+          'sexual',
+          'nudity',
+          'nsfl',
+          'gore',
+        ],
+      },
+    },
+  },
+  OrgAtmosphereconfProfile: {
+    lexicon: 1,
+    id: 'org.atmosphereconf.profile',
+    defs: {
+      main: {
+        type: 'record',
+        description: 'A conference attendee profile.',
+        key: 'literal:self',
+        record: {
+          type: 'object',
+          properties: {
+            displayName: {
+              type: 'string',
+              maxGraphemes: 64,
+              maxLength: 640,
+            },
+            description: {
+              type: 'string',
+              description: 'Free-form profile description text.',
+              maxGraphemes: 256,
+              maxLength: 2560,
+            },
+            avatar: {
+              type: 'blob',
+              description: 'Profile picture for conference attendee',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            banner: {
+              type: 'blob',
+              description:
+                'Larger horizontal image to display behind profile view.',
+              accept: ['image/png', 'image/jpeg'],
+              maxSize: 1000000,
+            },
+            labels: {
+              type: 'union',
+              description: 'Self-label values for the conference profile.',
+              refs: ['lex:com.atproto.label.defs#selfLabels'],
+            },
+            createdAt: {
+              type: 'string',
+              format: 'datetime',
+            },
+          },
+        },
+      },
+    },
+  },
+  ComAtprotoRepoStrongRef: {
+    lexicon: 1,
+    id: 'com.atproto.repo.strongRef',
+    description: 'A URI with a content-hash fingerprint.',
+    defs: {
+      main: {
+        type: 'object',
+        required: ['uri', 'cid'],
+        properties: {
+          uri: {
+            type: 'string',
+            format: 'at-uri',
+          },
+          cid: {
+            type: 'string',
+            format: 'cid',
+          },
+        },
+      },
+    },
+  },
+} as const satisfies Record<string, LexiconDoc>
+export const schemas = Object.values(schemaDict) satisfies LexiconDoc[]
+export const lexicons: Lexicons = new Lexicons(schemas)
+
+export function validate<T extends { $type: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType: true,
+): ValidationResult<T>
+export function validate<T extends { $type?: string }>(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: false,
+): ValidationResult<T>
+export function validate(
+  v: unknown,
+  id: string,
+  hash: string,
+  requiredType?: boolean,
+): ValidationResult {
+  return (requiredType ? is$typed : maybe$typed)(v, id, hash)
+    ? lexicons.validate(`${id}#${hash}`, v)
+    : {
+        success: false,
+        error: new ValidationError(
+          `Must be an object with "${hash === 'main' ? id : `${id}#${hash}`}" $type property`,
+        ),
+      }
+}
+
+export const ids = {
+  ComAtprotoLabelDefs: 'com.atproto.label.defs',
+  OrgAtmosphereconfProfile: 'org.atmosphereconf.profile',
+  ComAtprotoRepoStrongRef: 'com.atproto.repo.strongRef',
+} as const

src/lexicon/types/com/atproto/label/defs.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.label.defs'
+
+/** Metadata tag on an atproto resource (eg, repo or record). */
+export interface Label {
+  $type?: 'com.atproto.label.defs#label'
+  /** The AT Protocol version of the label object. */
+  ver?: number
+  /** DID of the actor who created this label. */
+  src: string
+  /** AT URI of the record, repository (account), or other resource that this label applies to. */
+  uri: string
+  /** Optionally, CID specifying the specific version of 'uri' resource this label applies to. */
+  cid?: string
+  /** The short string name of the value or type of this label. */
+  val: string
+  /** If true, this is a negation label, overwriting a previous label. */
+  neg?: boolean
+  /** Timestamp when this label was created. */
+  cts: string
+  /** Timestamp at which this label expires (no longer applies). */
+  exp?: string
+  /** Signature of dag-cbor encoded label. */
+  sig?: Uint8Array
+}
+
+const hashLabel = 'label'
+
+export function isLabel<V>(v: V) {
+  return is$typed(v, id, hashLabel)
+}
+
+export function validateLabel<V>(v: V) {
+  return validate<Label & V>(v, id, hashLabel)
+}
+
+/** Metadata tags on an atproto record, published by the author within the record. */
+export interface SelfLabels {
+  $type?: 'com.atproto.label.defs#selfLabels'
+  values: SelfLabel[]
+}
+
+const hashSelfLabels = 'selfLabels'
+
+export function isSelfLabels<V>(v: V) {
+  return is$typed(v, id, hashSelfLabels)
+}
+
+export function validateSelfLabels<V>(v: V) {
+  return validate<SelfLabels & V>(v, id, hashSelfLabels)
+}
+
+/** Metadata tag on an atproto record, published by the author within the record. Note that schemas should use #selfLabels, not #selfLabel. */
+export interface SelfLabel {
+  $type?: 'com.atproto.label.defs#selfLabel'
+  /** The short string name of the value or type of this label. */
+  val: string
+}
+
+const hashSelfLabel = 'selfLabel'
+
+export function isSelfLabel<V>(v: V) {
+  return is$typed(v, id, hashSelfLabel)
+}
+
+export function validateSelfLabel<V>(v: V) {
+  return validate<SelfLabel & V>(v, id, hashSelfLabel)
+}
+
+/** Declares a label value and its expected interpretations and behaviors. */
+export interface LabelValueDefinition {
+  $type?: 'com.atproto.label.defs#labelValueDefinition'
+  /** The value of the label being defined. Must only include lowercase ascii and the '-' character ([a-z-]+). */
+  identifier: string
+  /** How should a client visually convey this label? 'inform' means neutral and informational; 'alert' means negative and warning; 'none' means show nothing. */
+  severity: 'inform' | 'alert' | 'none' | (string & {})
+  /** What should this label hide in the UI, if applied? 'content' hides all of the target; 'media' hides the images/video/audio; 'none' hides nothing. */
+  blurs: 'content' | 'media' | 'none' | (string & {})
+  /** The default setting for this label. */
+  defaultSetting: 'ignore' | 'warn' | 'hide' | (string & {})
+  /** Does the user need to have adult content enabled in order to configure this label? */
+  adultOnly?: boolean
+  locales: LabelValueDefinitionStrings[]
+}
+
+const hashLabelValueDefinition = 'labelValueDefinition'
+
+export function isLabelValueDefinition<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinition)
+}
+
+export function validateLabelValueDefinition<V>(v: V) {
+  return validate<LabelValueDefinition & V>(v, id, hashLabelValueDefinition)
+}
+
+/** Strings which describe the label in the UI, localized into a specific language. */
+export interface LabelValueDefinitionStrings {
+  $type?: 'com.atproto.label.defs#labelValueDefinitionStrings'
+  /** The code of the language these strings are written in. */
+  lang: string
+  /** A short human-readable name for the label. */
+  name: string
+  /** A longer description of what the label means and why it might be applied. */
+  description: string
+}
+
+const hashLabelValueDefinitionStrings = 'labelValueDefinitionStrings'
+
+export function isLabelValueDefinitionStrings<V>(v: V) {
+  return is$typed(v, id, hashLabelValueDefinitionStrings)
+}
+
+export function validateLabelValueDefinitionStrings<V>(v: V) {
+  return validate<LabelValueDefinitionStrings & V>(
+    v,
+    id,
+    hashLabelValueDefinitionStrings,
+  )
+}
+
+export type LabelValue =
+  | '!hide'
+  | '!no-promote'
+  | '!warn'
+  | '!no-unauthenticated'
+  | 'dmca-violation'
+  | 'doxxing'
+  | 'porn'
+  | 'sexual'
+  | 'nudity'
+  | 'nsfl'
+  | 'gore'
+  | (string & {})

src/lexicon/types/com/atproto/repo/strongRef.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../../lexicons'
+import {
+  type $Typed,
+  is$typed as _is$typed,
+  type OmitKey,
+} from '../../../../util'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'com.atproto.repo.strongRef'
+
+export interface Main {
+  $type?: 'com.atproto.repo.strongRef'
+  uri: string
+  cid: string
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain)
+}

src/lexicon/types/org/atmosphereconf/profile.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+import { type ValidationResult, BlobRef } from '@atproto/lexicon'
+import { CID } from 'multiformats/cid'
+import { validate as _validate } from '../../../lexicons'
+import { type $Typed, is$typed as _is$typed, type OmitKey } from '../../../util'
+import type * as ComAtprotoLabelDefs from '../../com/atproto/label/defs.js'
+
+const is$typed = _is$typed,
+  validate = _validate
+const id = 'org.atmosphereconf.profile'
+
+export interface Main {
+  $type: 'org.atmosphereconf.profile'
+  displayName?: string
+  /** Free-form profile description text. */
+  description?: string
+  /** Profile picture for conference attendee */
+  avatar?: BlobRef
+  /** Larger horizontal image to display behind profile view. */
+  banner?: BlobRef
+  labels?: $Typed<ComAtprotoLabelDefs.SelfLabels> | { $type: string }
+  createdAt?: string
+  [k: string]: unknown
+}
+
+const hashMain = 'main'
+
+export function isMain<V>(v: V) {
+  return is$typed(v, id, hashMain)
+}
+
+export function validateMain<V>(v: V) {
+  return validate<Main & V>(v, id, hashMain, true)
+}
+
+export {
+  type Main as Record,
+  isMain as isRecord,
+  validateMain as validateRecord,
+}

src/lexicon/util.ts

···
+/**
+ * GENERATED CODE - DO NOT MODIFY
+ */
+
+import { type ValidationResult } from '@atproto/lexicon'
+
+export type OmitKey<T, K extends keyof T> = {
+  [K2 in keyof T as K2 extends K ? never : K2]: T[K2]
+}
+
+export type $Typed<V, T extends string = string> = V & { $type: T }
+export type Un$Typed<V extends { $type?: string }> = OmitKey<V, '$type'>
+
+export type $Type<Id extends string, Hash extends string> = Hash extends 'main'
+  ? Id
+  : `${Id}#${Hash}`
+
+function isObject<V>(v: V): v is V & object {
+  return v != null && typeof v === 'object'
+}
+
+function is$type<Id extends string, Hash extends string>(
+  $type: unknown,
+  id: Id,
+  hash: Hash,
+): $type is $Type<Id, Hash> {
+  return hash === 'main'
+    ? $type === id
+    : // $type === `${id}#${hash}`
+      typeof $type === 'string' &&
+        $type.length === id.length + 1 + hash.length &&
+        $type.charCodeAt(id.length) === 35 /* '#' */ &&
+        $type.startsWith(id) &&
+        $type.endsWith(hash)
+}
+
+export type $TypedObject<
+  V,
+  Id extends string,
+  Hash extends string,
+> = V extends {
+  $type: $Type<Id, Hash>
+}
+  ? V
+  : V extends { $type?: string }
+    ? V extends { $type?: infer T extends $Type<Id, Hash> }
+      ? V & { $type: T }
+      : never
+    : V & { $type: $Type<Id, Hash> }
+
+export function is$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is $TypedObject<V, Id, Hash> {
+  return isObject(v) && '$type' in v && is$type(v.$type, id, hash)
+}
+
+export function maybe$typed<V, Id extends string, Hash extends string>(
+  v: V,
+  id: Id,
+  hash: Hash,
+): v is V & object & { $type?: $Type<Id, Hash> } {
+  return (
+    isObject(v) &&
+    ('$type' in v ? v.$type === undefined || is$type(v.$type, id, hash) : true)
+  )
+}
+
+export type Validator<R = unknown> = (v: unknown) => ValidationResult<R>
+export type ValidatorParam<V extends Validator> =
+  V extends Validator<infer R> ? R : never
+
+/**
+ * Utility function that allows to convert a "validate*" utility function into a
+ * type predicate.
+ */
+export function asPredicate<V extends Validator>(validate: V) {
+  return function <T>(v: T): v is T & ValidatorParam<V> {
+    return validate(v).success
+  }
+}

src/pages/api/profile/create.ts

···
+import type { APIRoute } from 'astro'
+import { getOAuthClient } from '../../../lib/context'
+import { getSession } from '../../../lib/session'
+import { Agent, BlobRef } from '@atproto/api'
+import type { Main as ProfileRecord } from '../../../lexicon/types/org/atmosphereconf/profile'
+
+async function fileToBlob(agent: Agent, file: File): Promise<BlobRef> {
+  const arrayBuffer = await file.arrayBuffer()
+  const uint8Array = new Uint8Array(arrayBuffer)
+
+  const response = await agent.com.atproto.repo.uploadBlob(uint8Array, {
+    encoding: file.type,
+  })
+
+  return response.data.blob
+}
+
+export const POST: APIRoute = async ({ request, cookies, redirect }) => {
+  try {
+    const session = getSession(cookies)
+    const oauthClient = getOAuthClient(cookies)
+
+    if (!session.did) {
+      return new Response('Unauthorized', { status: 401 })
+    }
+
+    const oauthSession = await oauthClient.restore(session.did)
+    if (!oauthSession) {
+      return new Response('Session expired', { status: 401 })
+    }
+
+    const agent = new Agent(oauthSession)
+    const formData = await request.formData()
+
+    // Extract form data
+    const displayName = formData.get('displayName')
+    const description = formData.get('description')
+    const avatarFile = formData.get('avatar')
+    const bannerFile = formData.get('banner')
+
+    if (!displayName || typeof displayName !== 'string') {
+      return new Response('Display name is required', { status: 400 })
+    }
+
+    // Validate file sizes
+    if (avatarFile instanceof File && avatarFile.size > 0 && avatarFile.size > 1000000) {
+      return new Response('Avatar file size must be less than 1MB', { status: 400 })
+    }
+
+    if (bannerFile instanceof File && bannerFile.size > 0 && bannerFile.size > 1000000) {
+      return new Response('Banner file size must be less than 1MB', { status: 400 })
+    }
+
+    // Build the profile record
+    const record: Omit<ProfileRecord, '$type'> = {
+      displayName: displayName.slice(0, 64),
+      description: typeof description === 'string' ? description.slice(0, 256) : undefined,
+      createdAt: new Date().toISOString(),
+    }
+
+    // Upload avatar if provided
+    if (avatarFile instanceof File && avatarFile.size > 0) {
+      try {
+        record.avatar = await fileToBlob(agent, avatarFile)
+      } catch (err) {
+        console.error('Failed to upload avatar:', err)
+        return new Response('Failed to upload avatar', { status: 500 })
+      }
+    }
+
+    // Upload banner if provided
+    if (bannerFile instanceof File && bannerFile.size > 0) {
+      try {
+        record.banner = await fileToBlob(agent, bannerFile)
+      } catch (err) {
+        console.error('Failed to upload banner:', err)
+        return new Response('Failed to upload banner', { status: 500 })
+      }
+    }
+
+    // Create or update the profile record
+    try {
+      await agent.com.atproto.repo.putRecord({
+        repo: agent.assertDid,
+        collection: 'org.atmosphereconf.profile',
+        rkey: 'self',
+        record: {
+          $type: 'org.atmosphereconf.profile',
+          ...record,
+        },
+      })
+
+      return redirect('/')
+    } catch (err) {
+      console.error('Failed to create profile:', err)
+      const error = err instanceof Error ? err.message : 'unexpected error'
+      return new Response(`Failed to create profile: ${error}`, { status: 500 })
+    }
+  } catch (err) {
+    console.error('Profile creation failed:', err)
+    const error = err instanceof Error ? err.message : 'unexpected error'
+    return new Response(`Profile creation failed: ${error}`, { status: 500 })
+  }
+}

src/pages/index.astro

···
     <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
     <meta name="viewport" content="width=device-width" />
     <meta name="generator" content={Astro.generator} />
-    <title>ATProto Login</title>
+    <title>ATmosphere Login</title>
   </head>
   <body>
     <div class="min-h-screen flex items-center justify-center">
···
                     )}
                     <p class="text-lg font-semibold">{displayName}</p>
                     <p class="text-sm opacity-70">{handle}</p>
-                    {description && (
-                      <p class="text-sm mt-2 opacity-80">{description}</p>
-                    )}
+                    {description && <p class="text-sm mt-2 opacity-80">{description}</p>}
+                  </div>
+                  <div class="space-y-2 w-full">
+                    <a href={`/profile/${handle}`} class="btn btn-primary w-full">
+                      View Profile
+                    </a>
+                    <form method="POST" action="/api/logout" class="w-full">
+                      <button type="submit" class="btn btn-error w-full">
+                        Logout
+                      </button>
+                    </form>
                   </div>
-                  <form method="POST" action="/api/logout" class="w-full">
-                    <button type="submit" class="btn btn-error w-full">
-                      Logout
-                    </button>
-                  </form>
                 </div>
               </>
             ) : (
               <>
-                <h2 class="card-title justify-center mb-6">ATProto Login</h2>
+                <h2 class="card-title justify-center mb-6">ATmosphere Login</h2>
                 <form method="POST" action="/api/login">
                   <div class="join join-vertical w-full">
                     <input

src/pages/profile/[handle].astro

···
+---
+import '../../styles.css'
+import { getSession } from '../../lib/session'
+import { getOAuthClient } from '../../lib/context'
+import { Agent } from '@atproto/api'
+
+const { handle } = Astro.params
+
+if (!handle) {
+  return Astro.redirect('/')
+}
+
+const session = getSession(Astro.cookies)
+const oauthClient = getOAuthClient(Astro.cookies)
+
+let agent: Agent | null = null
+let profile: any = null
+let conferenceProfile: any = null
+let did: string | null = null
+let isOwnProfile = false
+
+// Get agent if authenticated
+if (session.did) {
+  try {
+    const oauthSession = await oauthClient.restore(session.did)
+    if (oauthSession) {
+      agent = new Agent(oauthSession)
+      isOwnProfile = agent.assertDid === session.did
+    }
+  } catch (err) {
+    console.warn('OAuth restore failed:', err)
+  }
+}
+
+// Create a public agent to resolve the profile if we don't have an authenticated one
+const publicAgent = agent || new Agent({ service: 'https://public.api.bsky.app' })
+
+// Resolve handle to DID and get profile
+try {
+  const resolveResponse = await publicAgent.resolveHandle({ handle })
+  did = resolveResponse.data.did
+
+  // Get Bluesky profile for basic info
+  try {
+    const profileResponse = await publicAgent.app.bsky.actor.getProfile({
+      actor: did,
+    })
+    profile = profileResponse.data
+  } catch (err) {
+    console.warn('Failed to fetch Bluesky profile:', err)
+  }
+
+  // Get conference profile
+  try {
+    const response = await publicAgent.com.atproto.repo.getRecord({
+      repo: did,
+      collection: 'org.atmosphereconf.profile',
+      rkey: 'self'
+    })
+    conferenceProfile = response.data.value
+  } catch (err) {
+    console.log('No conference profile found for this user')
+  }
+} catch (err) {
+  console.error('Failed to resolve handle:', err)
+  return new Response('Profile not found', { status: 404 })
+}
+
+// Helper function to convert blob refs to URLs
+function blobRefToUrl(blobRef: any, did: string): string {
+  if (!blobRef || typeof blobRef !== 'object') return ''
+
+  // Handle BlobRef object with CID
+  if (blobRef.ref) {
+    const cid = blobRef.ref.toString()
+    return `https://cdn.bsky.app/img/avatar/plain/${did}/${cid}@jpeg`
+  }
+
+  return ''
+}
+
+const displayName = conferenceProfile?.displayName || profile?.displayName || handle
+const description = conferenceProfile?.description || profile?.description || ''
+
+// Handle both blob refs and direct URLs
+let avatar = ''
+if (conferenceProfile?.avatar) {
+  avatar = blobRefToUrl(conferenceProfile.avatar, did)
+} else if (profile?.avatar) {
+  avatar = profile.avatar
+}
+
+let banner = ''
+if (conferenceProfile?.banner) {
+  banner = blobRefToUrl(conferenceProfile.banner, did)
+} else if (profile?.banner) {
+  banner = profile.banner
+}
+
+const hasConferenceProfile = !!conferenceProfile
+---
+
+<html lang="en" data-theme="dracula">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width" />
+    <meta name="generator" content={Astro.generator} />
+    <title>{displayName} - ATmosphere</title>
+  </head>
+  <body>
+    <div class="min-h-screen bg-base-300">
+      {banner && (
+        <div class="w-full h-48 md:h-64 bg-base-200">
+          <img
+            src={banner}
+            alt="Profile banner"
+            class="w-full h-full object-cover"
+          />
+        </div>
+      )}
+
+      <div class="container mx-auto px-4 -mt-16 relative z-10 max-w-4xl">
+        <div class="card bg-base-200 shadow-xl">
+          <div class="card-body">
+            <div class="flex flex-col md:flex-row gap-6">
+              <div class="flex-shrink-0">
+                {avatar ? (
+                  <div class="avatar">
+                    <div class="w-32 rounded-full ring ring-primary ring-offset-base-100 ring-offset-2">
+                      <img src={avatar} alt={displayName} />
+                    </div>
+                  </div>
+                ) : (
+                  <div class="avatar placeholder">
+                    <div class="bg-neutral text-neutral-content rounded-full w-32">
+                      <span class="text-3xl">{displayName[0]?.toUpperCase()}</span>
+                    </div>
+                  </div>
+                )}
+              </div>
+
+              <div class="flex-grow">
+                <div class="flex flex-col md:flex-row md:items-start md:justify-between gap-4">
+                  <div>
+                    <h1 class="text-3xl font-bold">{displayName}</h1>
+                    <p class="text-sm opacity-70">@{handle}</p>
+                    {did && (
+                      <p class="text-xs opacity-50 mt-1 font-mono break-all">
+                        {did}
+                      </p>
+                    )}
+                  </div>
+
+                  {isOwnProfile && (
+                    <a href="/profile/create" class="btn btn-primary btn-sm">
+                      Edit Profile
+                    </a>
+                  )}
+                </div>
+
+                {description && (
+                  <p class="mt-4 text-base whitespace-pre-wrap">{description}</p>
+                )}
+
+                <div class="mt-4">
+                  {hasConferenceProfile ? (
+                    <div class="badge badge-success gap-2">
+                      <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" class="inline-block w-4 h-4 stroke-current">
+                        <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M9 12l2 2 4-4m6 2a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+                      </svg>
+                      Conference Attendee
+                    </div>
+                  ) : (
+                    <div class="badge badge-ghost gap-2">
+                      No Conference Profile
+                    </div>
+                  )}
+                </div>
+              </div>
+            </div>
+
+            {!hasConferenceProfile && isOwnProfile && (
+              <div class="alert alert-warning mt-6">
+                <svg xmlns="http://www.w3.org/2000/svg" class="stroke-current shrink-0 h-6 w-6" fill="none" viewBox="0 0 24 24">
+                  <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M12 9v2m0 4h.01m-6.938 4h13.856c1.54 0 2.502-1.667 1.732-3L13.732 4c-.77-1.333-2.694-1.333-3.464 0L3.34 16c-.77 1.333.192 3 1.732 3z" />
+                </svg>
+                <span>You haven't set up your conference profile yet.</span>
+                <div>
+                  <a href="/profile/create" class="btn btn-sm btn-primary">Create Now</a>
+                </div>
+              </div>
+            )}
+          </div>
+        </div>
+
+        <div class="mt-6 mb-12">
+          <a href="/" class="btn btn-ghost">
+            <svg xmlns="http://www.w3.org/2000/svg" class="h-5 w-5 mr-2" fill="none" viewBox="0 0 24 24" stroke="currentColor">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M10 19l-7-7m0 0l7-7m-7 7h18" />
+            </svg>
+            Back to Home
+          </a>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>

src/pages/profile/create.astro

···
+---
+import '../../styles.css'
+import ProfileForm from '../../components/ProfileForm.astro'
+import { getSession } from '../../lib/session'
+import { getOAuthClient } from '../../lib/context'
+import { Agent } from '@atproto/api'
+
+const session = getSession(Astro.cookies)
+const oauthClient = getOAuthClient(Astro.cookies)
+
+// Redirect to login if not authenticated
+if (!session.did) {
+  return Astro.redirect('/')
+}
+
+let agent: Agent | null = null
+let existingProfile: any = null
+
+try {
+  const oauthSession = await oauthClient.restore(session.did)
+  if (oauthSession) {
+    agent = new Agent(oauthSession)
+
+    // Check if profile already exists
+    try {
+      // Try to get the profile record from the repo
+      const did = agent.assertDid
+      const response = await agent.com.atproto.repo.getRecord({
+        repo: did,
+        collection: 'org.atmosphereconf.profile',
+        rkey: 'self'
+      })
+      existingProfile = response.data.value
+    } catch (err) {
+      // Profile doesn't exist yet, which is fine
+      console.log('No existing profile found')
+    }
+  }
+} catch (err) {
+  console.warn('OAuth restore failed:', err)
+  session.destroy()
+  return Astro.redirect('/')
+}
+
+const displayName = existingProfile?.displayName || ''
+const description = existingProfile?.description || ''
+---
+
+<html lang="en" data-theme="dracula">
+  <head>
+    <meta charset="utf-8" />
+    <link rel="icon" type="image/svg+xml" href="/favicon.svg" />
+    <meta name="viewport" content="width=device-width" />
+    <meta name="generator" content={Astro.generator} />
+    <title>Create Profile - ATmosphere</title>
+  </head>
+  <body>
+    <div class="min-h-screen flex items-center justify-center p-4">
+      <div class="card w-full max-w-2xl bg-base-200 shadow-xl">
+        <div class="card-body">
+          <h2 class="card-title justify-center text-2xl mb-6">
+            {existingProfile ? 'Update Your Profile' : 'Create Your Profile'}
+          </h2>
+
+          <div class="alert alert-info mb-4">
+            <svg xmlns="http://www.w3.org/2000/svg" fill="none" viewBox="0 0 24 24" class="stroke-current shrink-0 w-6 h-6">
+              <path stroke-linecap="round" stroke-linejoin="round" stroke-width="2" d="M13 16h-1v-4h-1m1-4h.01M21 12a9 9 0 11-18 0 9 9 0 0118 0z"></path>
+            </svg>
+            <span>Set up your conference attendee profile</span>
+          </div>
+
+          <ProfileForm
+            displayName={displayName}
+            description={description}
+            submitLabel={existingProfile ? 'Update Profile' : 'Create Profile'}
+          />
+
+          <div class="divider">OR</div>
+
+          <a href="/" class="btn btn-ghost w-full">
+            Back to Home
+          </a>
+        </div>
+      </div>
+    </div>
+  </body>
+</html>