refactor!: normalize SQL schema to snake_case

BREAKING CHANGE: Existing Durable Objects need storage reset.

- Rename tables: blob → blobs, record_blob → record_blobs
- Rename columns: mimeType → mime_type, createdAt → created_at,
blobCid → blob_cid, recordUri → record_uri
- Update index: idx_record_blob_uri → idx_record_blobs_record_uri
- Add CHANGELOG.md
- Add .backup/ to .gitignore

🤖 Generated with [Claude Code](https://claude.com/claude-code)

Co-Authored-By: Claude Opus 4.5 <[e-mail]>

.gitignore

···
 credentials-*.json
 .env
 .dev.vars
+.backup/

CHANGELOG.md

···
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
+
+## [Unreleased]
+
+### Changed
+
+- **BREAKING:** Normalized SQL schema to snake_case convention
+  - Tables: `blob` → `blobs`, `record_blob` → `record_blobs`
+  - Columns: `mimeType` → `mime_type`, `createdAt` → `created_at`, `blobCid` → `blob_cid`, `recordUri` → `record_uri`
+  - Existing Durable Objects require storage reset
+
+## [0.1.0] - 2025-01-07
+
+Initial experimental release.
+
+### Added
+
+- **Repo operations:** createRecord, getRecord, putRecord, deleteRecord, applyWrites, listRecords
+- **Sync endpoints:** getRepo (CAR export), subscribeRepos (WebSocket firehose), getLatestCommit
+- **Authentication:** createSession, getSession, refreshSession with JWT tokens
+- **Blob storage:** uploadBlob, getBlob, listBlobs with R2 backend
+  - MIME type sniffing (JPEG, PNG, GIF, WebP, MP4, AVIF, HEIC)
+  - Automatic orphaned blob cleanup via DO alarms
+  - Blob-record association tracking
+- **Identity:** Handle resolution, PLC directory registration
+- **Federation:** Relay notification (requestCrawl), AppView proxy for app.bsky.* endpoints
+- **Infrastructure:**
+  - Merkle Search Tree (MST) for repo structure
+  - DAG-CBOR encoding with CID generation
+  - P-256 ECDSA signing via Web Crypto
+  - TypeScript checking via JSDoc annotations
+  - Setup script for key generation and PLC registration

src/pds.js

···
  */
 
 /**
- * Row from the `blob` table - tracks uploaded blob metadata
+ * Row from the `blobs` table - tracks uploaded blob metadata
  * @typedef {Object} BlobRow
  * @property {string} cid - Content ID of the blob (raw codec)
- * @property {string} mimeType - MIME type (sniffed or from Content-Type header)
+ * @property {string} mime_type - MIME type (sniffed or from Content-Type header)
  * @property {number} size - Size in bytes
- * @property {string} createdAt - ISO timestamp of upload
+ * @property {string} created_at - ISO timestamp of upload
  */
 
 /**
···
         evt BLOB NOT NULL
       );
 
-      CREATE TABLE IF NOT EXISTS blob (
+      CREATE TABLE IF NOT EXISTS blobs (
         cid TEXT PRIMARY KEY,
-        mimeType TEXT NOT NULL,
+        mime_type TEXT NOT NULL,
         size INTEGER NOT NULL,
-        createdAt TEXT NOT NULL
+        created_at TEXT NOT NULL
       );
 
-      CREATE TABLE IF NOT EXISTS record_blob (
-        blobCid TEXT NOT NULL,
-        recordUri TEXT NOT NULL,
-        PRIMARY KEY (blobCid, recordUri)
+      CREATE TABLE IF NOT EXISTS record_blobs (
+        blob_cid TEXT NOT NULL,
+        record_uri TEXT NOT NULL,
+        PRIMARY KEY (blob_cid, record_uri)
       );
 
-      CREATE INDEX IF NOT EXISTS idx_record_blob_uri ON record_blob(recordUri);
+      CREATE INDEX IF NOT EXISTS idx_record_blobs_record_uri ON record_blobs(record_uri);
 
       CREATE INDEX IF NOT EXISTS idx_records_collection ON records(collection, rkey);
     `);
···
     );
 
     // Associate blobs with this record (delete old associations first for updates)
-    this.sql.exec('DELETE FROM record_blob WHERE recordUri = ?', uri);
+    this.sql.exec('DELETE FROM record_blobs WHERE record_uri = ?', uri);
 
     const blobRefs = findBlobRefs(record);
     for (const blobCid of blobRefs) {
       // Verify blob exists
       const blobExists = this.sql
-        .exec('SELECT cid FROM blob WHERE cid = ?', blobCid)
+        .exec('SELECT cid FROM blobs WHERE cid = ?', blobCid)
         .toArray();
 
       if (blobExists.length === 0) {
···
 
       // Create association
       this.sql.exec(
-        'INSERT INTO record_blob (blobCid, recordUri) VALUES (?, ?)',
+        'INSERT INTO record_blobs (blob_cid, record_uri) VALUES (?, ?)',
         blobCid,
         uri,
       );
···
 
     // Get blobs associated with this record
     const associatedBlobs = this.sql
-      .exec('SELECT blobCid FROM record_blob WHERE recordUri = ?', uri)
+      .exec('SELECT blob_cid FROM record_blobs WHERE record_uri = ?', uri)
       .toArray();
 
     // Remove associations for this record
-    this.sql.exec('DELETE FROM record_blob WHERE recordUri = ?', uri);
+    this.sql.exec('DELETE FROM record_blobs WHERE record_uri = ?', uri);
 
     // Check each blob for orphan status and delete if unreferenced
-    for (const { blobCid } of associatedBlobs) {
+    for (const { blob_cid } of associatedBlobs) {
       const stillReferenced = this.sql
-        .exec('SELECT 1 FROM record_blob WHERE blobCid = ? LIMIT 1', blobCid)
+        .exec('SELECT 1 FROM record_blobs WHERE blob_cid = ? LIMIT 1', blob_cid)
         .toArray();
 
       if (stillReferenced.length === 0) {
         // Blob is orphaned, delete from R2 and database
-        await this.env?.BLOBS?.delete(`${did}/${blobCid}`);
-        this.sql.exec('DELETE FROM blob WHERE cid = ?', blobCid);
+        await this.env?.BLOBS?.delete(`${did}/${blob_cid}`);
+        this.sql.exec('DELETE FROM blobs WHERE cid = ?', blob_cid);
       }
     }
 
···
     });
 
     // Insert metadata (INSERT OR IGNORE handles concurrent uploads)
-    const createdAt = new Date().toISOString();
+    const created_at = new Date().toISOString();
     this.sql.exec(
-      'INSERT OR IGNORE INTO blob (cid, mimeType, size, createdAt) VALUES (?, ?, ?, ?)',
+      'INSERT OR IGNORE INTO blobs (cid, mime_type, size, created_at) VALUES (?, ?, ?, ?)',
       cidStr,
       mimeType,
       size,
-      createdAt,
+      created_at,
     );
 
     // Return BlobRef
···
 
     // Look up blob metadata
     const rows = this.sql
-      .exec('SELECT mimeType, size FROM blob WHERE cid = ?', cid)
+      .exec('SELECT mime_type, size FROM blobs WHERE cid = ?', cid)
       .toArray();
 
     if (rows.length === 0) {
       return errorResponse('BlobNotFound', 'blob not found', 404);
     }
 
-    const { mimeType, size } = rows[0];
+    const { mime_type, size } = rows[0];
 
     // Fetch from R2
     const r2Key = `${did}/${cid}`;
···
     // Return blob with security headers
     return new Response(object.body, {
       headers: {
-        'Content-Type': /** @type {string} */ (mimeType),
+        'Content-Type': /** @type {string} */ (mime_type),
         'Content-Length': String(size),
         'X-Content-Type-Options': 'nosniff',
         'Content-Security-Policy': "default-src 'none'; sandbox",
···
       );
     }
 
-    // Query blobs with pagination (cursor is createdAt::cid for uniqueness)
-    let query = 'SELECT cid, createdAt FROM blob';
+    // Query blobs with pagination (cursor is created_at::cid for uniqueness)
+    let query = 'SELECT cid, created_at FROM blobs';
     const params = [];
 
     if (cursor) {
       const [cursorTime, cursorCid] = cursor.split('::');
-      query += ' WHERE (createdAt > ? OR (createdAt = ? AND cid > ?))';
+      query += ' WHERE (created_at > ? OR (created_at = ? AND cid > ?))';
       params.push(cursorTime, cursorTime, cursorCid);
     }
 
-    query += ' ORDER BY createdAt ASC, cid ASC LIMIT ?';
+    query += ' ORDER BY created_at ASC, cid ASC LIMIT ?';
     params.push(limit + 1); // Fetch one extra to detect if there's more
 
     const rows = this.sql.exec(query, ...params).toArray();
···
     if (rows.length > limit) {
       rows.pop(); // Remove the extra row
       const last = rows[rows.length - 1];
-      nextCursor = `${last.createdAt}::${last.cid}`;
+      nextCursor = `${last.created_at}::${last.cid}`;
     }
 
     return Response.json({
···
     const did = await this.getDid();
     if (!did) return;
 
-    // Find orphans: blobs not in record_blob, older than 24h
+    // Find orphans: blobs not in record_blobs, older than 24h
     const cutoff = new Date(Date.now() - 24 * 60 * 60 * 1000).toISOString();
 
     const orphans = this.sql
       .exec(
-        `SELECT b.cid FROM blob b
-         LEFT JOIN record_blob rb ON b.cid = rb.blobCid
-         WHERE rb.blobCid IS NULL AND b.createdAt < ?`,
+        `SELECT b.cid FROM blobs b
+         LEFT JOIN record_blobs rb ON b.cid = rb.blob_cid
+         WHERE rb.blob_cid IS NULL AND b.created_at < ?`,
         cutoff,
       )
       .toArray();
 
     for (const { cid } of orphans) {
       await this.env?.BLOBS?.delete(`${did}/${cid}`);
-      this.sql.exec('DELETE FROM blob WHERE cid = ?', cid);
+      this.sql.exec('DELETE FROM blobs WHERE cid = ?', cid);
     }
   }
 }