Initial release: self-hosted client photo gallery

Rust (axum + sqlx) API and worker sharing a Postgres-backed job queue
(SKIP LOCKED, heartbeat, reaper, typed statuses), S3 storage with derived
keys and a fully private bucket, OIDC photographer login with per-request
allowlist checks, client share links with argon2 passwords and lockout,
cookie-based image authorization with sliding expiry, hand-rolled
spec-compliant streaming ZIP downloads with exact Content-Length,
React + Vite gallery frontend, single Docker image, Helm chart for
external S3 + Postgres, and Gitea CI.

Co-Authored-By: Claude <noreply@anthropic.com>

.env.example

@@ -16,10 +16,10 @@ S3_FORCE_PATH_STYLE=true
 OIDC_ISSUER=https://auth.example.com
 OIDC_CLIENT_ID=photos
 OIDC_CLIENT_SECRET=change-me
-ALLOWED_EMAILS=u797+claude@posteo.de
+ALLOWED_EMAILS=you@example.com
 
 # DEV ONLY: skip OIDC and sign straight in as this email. Never set in production.
-# DEV_AUTOLOGIN_EMAIL=u797+claude@posteo.de
+# DEV_AUTOLOGIN_EMAIL=you@example.com
 
 WORKER_CONCURRENCY=2
 RUST_LOG=info,sqlx=warn

Cargo.lock

@@ -2562,7 +2562,6 @@ dependencies = [
  "cookie",
  "crc32fast",
  "futures",
- "hex",
  "image",
  "rand 0.8.7",
  "reqwest",

Cargo.toml

@@ -25,7 +25,6 @@ axum = { version = "0.8", features = ["macros"] }
 axum-extra = { version = "0.10", features = ["cookie", "cookie-signed"] }
 chrono = { version = "0.4", features = ["serde"] }
 futures = "0.3"
-hex = "0.4"
 image = "0.25"
 rand = "0.8"
 reqwest = { version = "0.12", default-features = false, features = ["json", "rustls-tls"] }

README.md

@@ -2,25 +2,7 @@
 
 Self-hosted client gallery for photographers. Upload RAWs/JPGs into albums,
 share them with clients via private (optionally password-protected) links,
-collect accept/reject votes, ratings and tags, and let clients download
-originals.
-
-## Screenshots
-
-The album view — drag-and-drop upload, justified gallery, and each client's
-feedback (votes, stars, tags) overlaid on the thumbnails:
-
-![Album view with upload zone and feedback overlays](docs/screenshots/album-admin.jpg)
-
-What clients see on a share link — vote on favorites, filter by verdict,
-download selects or the whole album as a ZIP:
-
-![Client gallery with verdict filters](docs/screenshots/share-client.jpg)
-
-The lightbox — accept/reject, star rating, tags, and keyboard-driven culling
-(`P`/`X`/`U`, `1`–`5`):
-
-![Lightbox with voting and rating controls](docs/screenshots/lightbox.jpg)
+collect ratings and tags, and let clients download originals.
 
 ## Architecture
 
@@ -54,10 +36,8 @@ The lightbox — accept/reject, star rating, tags, and keyboard-driven culling
   revokes access immediately. Clients use unguessable share tokens, optionally
   gated by an argon2-hashed password (10 wrong guesses lock the link for
   15 minutes).
-- **Frontend**: React + Vite SPA — justified gallery, lightbox with
-  accept/reject thumbs, rating stars and tag chips, keyboard-driven culling
-  (`P`/`X`/`U`, `1`–`5`, `?` shows all shortcuts), drag-and-drop multi-file
-  upload with progress.
+- **Frontend**: React + Vite SPA — justified gallery, lightbox with rating
+  stars and tag chips, drag-and-drop multi-file upload with progress.
 
 ## Local development
 
@@ -155,11 +135,9 @@ Notes:
 - Each album can have any number of share links (`/s/<24-char-token>`), each
   with its own label (e.g. the client's name), optional password, optional
   expiry, and a per-link download toggle.
-- Accept/reject votes (👍/👎), ratings (1–5 stars) and free-form tags are
-  stored **per link**, so create one link per client to keep feedback
-  separate. The album view shows all feedback grouped by link label, and
-  clients can filter their gallery by verdict (e.g. review only what's still
-  undecided, or select-all + download the accepted set).
+- Ratings (1–5 stars) and free-form tags are stored **per link**, so create
+  one link per client to keep feedback separate. The album view shows all
+  feedback grouped by link label.
 - Clients (and you) can multi-select photos and download them — or the whole
   album — as a ZIP. Archives are streamed (each file spools briefly through a
   temp file for its checksum, then pipelines while the next one prefetches),
@@ -172,8 +150,8 @@ Notes:
 - 10 wrong passwords lock a link for 15 minutes (fresh attempts after the
   window). A locked link shows in the album's share list with an Unlock
   button.
-- Deleting a link removes its votes/ratings/tags; deleting photos or albums
-  cleans up S3 objects via background jobs.
+- Deleting a link removes its ratings/tags; deleting photos or albums cleans
+  up S3 objects via background jobs.
 
 ## Known limitations / deliberate v1 cuts
 

frontend/src/api.js

@@ -73,13 +73,6 @@ export function postDownload(url, ids = '') {
   form.remove()
 }
 
-// SHA-256 of a File, matching the server's content hash — used to skip
-// uploading bytes the album already has.
-export async function sha256Hex(file) {
-  const digest = await crypto.subtle.digest('SHA-256', await file.arrayBuffer())
-  return [...new Uint8Array(digest)].map((b) => b.toString(16).padStart(2, '0')).join('')
-}
-
 export function uploadFile(url, file, onProgress) {
   return new Promise((resolve, reject) => {
     const xhr = new XMLHttpRequest()

frontend/src/components/Gallery.jsx

@@ -1,85 +1,42 @@
-import { useEffect, useRef, useState } from 'react'
 import { imgUrl } from '../api'
 
-// True justified layout: pack photos greedily into rows at their real aspect
-// ratios, then scale each row's height so it fills the container width
-// exactly. No cropping, no stretch, and the last row simply renders at the
-// target height instead of being padded by a spacer.
-function layoutRows(photos, containerWidth, targetHeight, gap) {
-  const rows = []
-  let row = []
-  let arSum = 0
-  let index = 0
-  for (const photo of photos) {
-    const ar = photo.width && photo.height ? photo.width / photo.height : 1.5
-    row.push({ photo, ar, index: index++ })
-    arSum += ar
-    const gaps = (row.length - 1) * gap
-    if (arSum * targetHeight + gaps >= containerWidth) {
-      rows.push({ items: row, height: (containerWidth - gaps) / arSum })
-      row = []
-      arSum = 0
-    }
-  }
-  if (row.length > 0) {
-    const gaps = (row.length - 1) * gap
-    rows.push({
-      items: row,
-      height: Math.min(targetHeight, (containerWidth - gaps) / arSum),
-    })
-  }
-  return rows
-}
-
+// Justified gallery: rows are built with flexbox, each tile's flex-grow is
+// proportional to its aspect ratio so rows fill the container edge to edge.
+// When `selected`/`onToggleSelect` are provided, tiles get a select checkmark;
+// selection state lives in the parent so it survives lightbox open/close.
 export default function Gallery({ photos, onOpen, overlay, selected, onToggleSelect }) {
-  const containerRef = useRef(null)
-  const [width, setWidth] = useState(0)
-
-  useEffect(() => {
-    const observer = new ResizeObserver((entries) => setWidth(entries[0].contentRect.width))
-    observer.observe(containerRef.current)
-    return () => observer.disconnect()
-  }, [])
-
-  // The container renders even with zero photos — unmounting it would detach
-  // the observer and leave a later non-empty render stuck at width 0.
-  const gap = 6
-  const targetHeight = width < 700 ? 170 : 240
-  const rows = width > 0 ? layoutRows(photos, width, targetHeight, gap) : []
+  if (photos.length === 0) return null
   const selecting = selected && selected.size > 0
-
   return (
-    <div ref={containerRef} className={`gallery${selecting ? ' selecting' : ''}`}>
-      {rows.map((row) => (
-        <div key={row.items[0].photo.id} className="g-row" style={{ height: row.height }}>
-          {row.items.map(({ photo: p, ar, index }) => {
-            const isSelected = selected ? selected.has(p.id) : false
-            return (
-              <div
-                key={p.id}
-                className={`g-item${isSelected ? ' selected' : ''}`}
-                style={{ width: ar * row.height }}
-                onClick={() => onOpen && onOpen(index)}
+    <div className={`gallery${selecting ? ' selecting' : ''}`}>
+      {photos.map((p, i) => {
+        const ar = p.width && p.height ? p.width / p.height : 1.5
+        const isSelected = selected ? selected.has(p.id) : false
+        return (
+          <div
+            key={p.id}
+            className={`g-item${isSelected ? ' selected' : ''}`}
+            style={{ '--ar': ar }}
+            onClick={() => onOpen && onOpen(i)}
+          >
+            <img src={imgUrl(p, 'thumb')} loading="lazy" alt={p.filename} />
+            {onToggleSelect && (
+              <button
+                className="g-check"
+                title={isSelected ? 'Deselect' : 'Select'}
+                onClick={(e) => {
+                  e.stopPropagation()
+                  onToggleSelect(p.id)
+                }}
               >
-                <img src={imgUrl(p, 'thumb')} loading="lazy" alt={p.filename} />
-                {onToggleSelect && (
-                  <button
-                    className="g-check"
-                    title={isSelected ? 'Deselect' : 'Select'}
-                    onClick={(e) => {
-                      e.stopPropagation()
-                      onToggleSelect(p.id, e.shiftKey)
-                    }}
-                  >
-                    ✓
-                  </button>
-                )}
-                {overlay && overlay(p)}
-              </div>
-            )
-          })}
-        </div>
-      ))}
+                ✓
+              </button>
+            )}
+            {overlay && overlay(p)}
+          </div>
+        )
+      })}
+      <div className="g-spacer" />
     </div>
   )
 }

frontend/src/components/Lightbox.jsx

@@ -1,71 +1,18 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect } from 'react'
 import { imgUrl } from '../api'
 
-const BASE_SHORTCUTS = [
-  ['← / →', 'previous / next photo'],
-  ['Space', 'next photo (Shift+Space back)'],
-  ['?', 'show / hide shortcuts'],
-  ['Esc', 'close'],
-]
-
-// `actions` defines the page's shortcuts as one table — display and dispatch
-// come from the same entry, so the help overlay can't drift from behavior:
-// { keys: ['p'], help: ['P', 'accept…'], run: (photo, key) => … }.
-// Keys fire only outside text inputs and while the help overlay is closed.
-export default function Lightbox({ photos, index, onClose, onNav, footer, actions }) {
+export default function Lightbox({ photos, index, onClose, onNav, footer }) {
   const photo = photos[index]
-  const [showHelp, setShowHelp] = useState(false)
-
-  // Handlers and view state live in a ref, updated every render, so the
-  // window listener is attached once yet always dispatches against current
-  // values — re-subscribing per render leaves a gap until effects re-run in
-  // which a fast second keystroke hits a stale closure (and e.g. re-votes
-  // the previous photo).
-  const live = useRef({})
-  live.current = { index, count: photos.length, photo, onClose, onNav, actions, showHelp }
 
   useEffect(() => {
-    // Only text entry captures keys (Escape leaves the field); focus on a
-    // checkbox or button must not disable lightbox navigation.
-    const isTyping = (el) =>
-      el.tagName === 'TEXTAREA' ||
-      el.isContentEditable ||
-      (el.tagName === 'INPUT' && !['checkbox', 'radio', 'button'].includes(el.type))
-    const handler = (e) => {
-      const s = live.current
-      if (isTyping(e.target)) {
-        if (e.key === 'Escape') e.target.blur()
-        return
-      }
-      if (e.metaKey || e.ctrlKey || e.altKey) return
-      if (e.key === 'Escape') {
-        if (s.showHelp) setShowHelp(false)
-        else s.onClose()
-        return
-      }
-      if (e.key === '?') {
-        setShowHelp((h) => !h)
-        return
-      }
-      // With the help overlay up, keys must not act on the photo behind it.
-      if (s.showHelp) return
-      if (e.key === 'ArrowRight' || (e.key === ' ' && !e.shiftKey)) {
-        e.preventDefault()
-        if (s.index < s.count - 1) s.onNav(s.index + 1)
-        return
-      }
-      if (e.key === 'ArrowLeft' || (e.key === ' ' && e.shiftKey)) {
-        e.preventDefault()
-        if (s.index > 0) s.onNav(s.index - 1)
-        return
-      }
-      const key = e.key.toLowerCase()
-      const action = s.actions?.find((a) => a.keys.includes(key))
-      if (action && s.photo) action.run(s.photo, key)
+    const onKey = (e) => {
+      if (e.key === 'Escape') onClose()
+      if (e.key === 'ArrowRight' && index < photos.length - 1) onNav(index + 1)
+      if (e.key === 'ArrowLeft' && index > 0) onNav(index - 1)
     }
-    window.addEventListener('keydown', handler)
-    return () => window.removeEventListener('keydown', handler)
-  }, [])
+    window.addEventListener('keydown', onKey)
+    return () => window.removeEventListener('keydown', onKey)
+  }, [index, photos.length, onClose, onNav])
 
   useEffect(() => {
     document.body.style.overflow = 'hidden'
@@ -83,13 +30,6 @@ export default function Lightbox({ photos, index, onClose, onNav, footer, action
         <span className="lb-count">
           {index + 1} / {photos.length}
         </span>
-        <button
-          className="lb-btn"
-          onClick={() => setShowHelp((h) => !h)}
-          title="Keyboard shortcuts (?)"
-        >
-          ?
-        </button>
         <button className="lb-btn" onClick={onClose} title="Close (Esc)">
           ✕
         </button>
@@ -127,25 +67,6 @@ export default function Lightbox({ photos, index, onClose, onNav, footer, action
           {footer(photo)}
         </div>
       )}
-      {showHelp && (
-        <div
-          className="lb-help"
-          onClick={(e) => {
-            e.stopPropagation()
-            setShowHelp(false)
-          }}
-        >
-          <div className="lb-help-card">
-            <h3>Keyboard shortcuts</h3>
-            {[...(actions?.map((a) => a.help) || []), ...BASE_SHORTCUTS].map(([keys, label]) => (
-              <div key={keys} className="lb-help-row">
-                <kbd>{keys}</kbd>
-                <span className="muted">{label}</span>
-              </div>
-            ))}
-          </div>
-        </div>
-      )}
     </div>
   )
 }

frontend/src/components/SelectionBar.jsx

@@ -15,7 +15,6 @@ export default function SelectionBar({
   onClear,
   onDownload,
   onDownloadAll,
-  onDelete,
 }) {
   if (total === 0) return null
 
@@ -48,11 +47,6 @@ export default function SelectionBar({
       <button className="btn btn-primary" onClick={onDownload}>
         Download {count} as ZIP ({fmtBytes(selectedBytes)})
       </button>
-      {onDelete && (
-        <button className="btn btn-danger" onClick={onDelete}>
-          Delete {count}
-        </button>
-      )}
     </div>
   )
 }

frontend/src/components/Thumbs.jsx

@@ -1,24 +0,0 @@
-// Accept/reject vote. `value` is 'accept', 'reject' or null; clicking the
-// active thumb clears it. Without onChange it renders read-only.
-export default function Thumbs({ value, onChange, small }) {
-  const thumb = (verdict, glyph, label) => (
-    <button
-      type="button"
-      className={`thumb${value === verdict ? ' active' : ''}`}
-      disabled={!onChange}
-      onClick={(e) => {
-        e.stopPropagation()
-        onChange(value === verdict ? null : verdict)
-      }}
-      title={onChange ? label : undefined}
-    >
-      {glyph}
-    </button>
-  )
-  return (
-    <span className={`thumbs${small ? ' thumbs-small' : ''}`}>
-      {thumb('accept', '👍', 'Accept (P)')}
-      {thumb('reject', '👎', 'Reject (X)')}
-    </span>
-  )
-}

frontend/src/pages/AlbumPage.jsx

@@ -1,120 +1,21 @@
 import { useCallback, useEffect, useRef, useState } from 'react'
 import { Link, useNavigate, useParams } from 'react-router-dom'
-import { api, postDownload, sha256Hex, uploadFile } from '../api'
+import { api, postDownload, uploadFile } from '../api'
 import Gallery from '../components/Gallery'
 import Lightbox from '../components/Lightbox'
-import SelectionBar, { fmtBytes } from '../components/SelectionBar'
+import SelectionBar from '../components/SelectionBar'
 import Stars from '../components/Stars'
-import Thumbs from '../components/Thumbs'
-import useLightbox from '../useLightbox'
 import useSelection from '../useSelection'
 
-function fmtEta(seconds) {
-  if (!isFinite(seconds) || seconds < 0) return ''
-  if (seconds < 60) return `${Math.ceil(seconds)}s`
-  if (seconds < 3600) return `${Math.ceil(seconds / 60)} min`
-  return `${Math.floor(seconds / 3600)}h ${Math.ceil((seconds % 3600) / 60)} min`
-}
-
 const UPLOAD_CONCURRENCY = 3
 
-// Expiry convention, in one place for the create form and the row editor:
-// end of the chosen day in the photographer's local timezone — date-only
-// strings would parse as UTC midnight and expire a day early.
-const endOfDayIso = (day) => (day ? new Date(`${day}T23:59:59`).toISOString() : null)
-
-// ISO timestamp -> local yyyy-mm-dd for date inputs.
-const localDate = (iso) => {
-  const d = new Date(iso)
-  return `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}-${String(d.getDate()).padStart(2, '0')}`
-}
-
-// Staged expiry editor: commits on blur/Enter, never per keystroke — typing
-// a year fires change events with bogus intermediate dates (year 0002) that
-// must not hit the live link. The ✕ clears explicitly; Safari's date input
-// has no native clear control.
-function ExpiryDate({ value, onCommit }) {
-  const current = value ? localDate(value) : ''
-  const [draft, setDraft] = useState(current)
-  useEffect(() => setDraft(current), [current])
-
-  const commit = () => {
-    if (draft === current) return
-    // A half-typed year (e.g. 0002) can survive until blur; don't persist it.
-    if (draft && draft.slice(0, 4) < '2000') {
-      setDraft(current)
-      return
-    }
-    onCommit(endOfDayIso(draft))
-  }
-
-  return (
-    <label className="row field-label" title="Expiry date — empty means the link never expires">
-      <span className="muted">expires</span>
-      <input
-        type="date"
-        value={draft}
-        onChange={(e) => setDraft(e.target.value)}
-        onBlur={commit}
-        onKeyDown={(e) => {
-          if (e.key === 'Enter') e.target.blur()
-        }}
-      />
-      {draft ? (
-        <button
-          type="button"
-          className="btn btn-ghost"
-          title="Remove expiry — link never expires"
-          onClick={() => {
-            setDraft('')
-            onCommit(null)
-          }}
-        >
-          ✕
-        </button>
-      ) : (
-        <span className="muted">never</span>
-      )}
-    </label>
-  )
-}
-
 function UploadZone({ albumId, onUploaded }) {
   const [queue, setQueue] = useState([])
   const [dragging, setDragging] = useState(false)
-  const [speed, setSpeed] = useState(0)
   const inputRef = useRef(null)
   const running = useRef(0)
   const pending = useRef([])
   const lastRefresh = useRef(0)
-  const loadedRef = useRef(0)
-
-  const totalBytes = queue.reduce((sum, item) => sum + item.file.size, 0)
-  const loadedBytes = queue.reduce(
-    (sum, item) =>
-      sum + (item.status === 'done' ? item.file.size : (item.progress || 0) * item.file.size),
-    0,
-  )
-  loadedRef.current = loadedBytes
-  const active = queue.some((item) =>
-    ['uploading', 'queued', 'checking'].includes(item.status),
-  )
-
-  // Sample throughput once a second (EMA-smoothed) while uploads run.
-  useEffect(() => {
-    if (!active) {
-      setSpeed(0)
-      return
-    }
-    let last = { loaded: loadedRef.current, time: Date.now() }
-    const timer = setInterval(() => {
-      const now = Date.now()
-      const instant = (loadedRef.current - last.loaded) / ((now - last.time) / 1000)
-      last = { loaded: loadedRef.current, time: now }
-      setSpeed((prev) => (prev > 0 ? prev * 0.7 + instant * 0.3 : instant))
-    }, 1000)
-    return () => clearInterval(timer)
-  }, [active])
 
   // Refresh the album at most every 5s during a bulk upload (the processing
   // poll keeps it fresh anyway), plus once when the queue drains.
@@ -130,27 +31,23 @@ function UploadZone({ albumId, onUploaded }) {
     while (running.current < UPLOAD_CONCURRENCY && pending.current.length > 0) {
       const item = pending.current.shift()
       running.current += 1
-      const update = (patch) =>
-        setQueue((q) => q.map((x) => (x.key === item.key ? { ...x, ...patch } : x)))
-      const transfer = async () => {
-        // Hash locally first: content the album already has is skipped
-        // without transferring a single byte.
-        update({ status: 'checking' })
-        try {
-          const hash = await sha256Hex(item.file)
-          await api(`/api/albums/${albumId}/photos/by-hash/${hash}`)
-          update({ status: 'skipped', progress: 1 })
-          return
-        } catch {
-          // 404 (not there yet) or hashing unavailable — upload normally.
-        }
-        update({ status: 'uploading' })
-        const url = `/api/albums/${albumId}/photos?filename=${encodeURIComponent(item.file.name)}`
-        await uploadFile(url, item.file, (p) => update({ progress: p }))
-        update({ status: 'done', progress: 1 })
-      }
-      transfer()
-        .catch((e) => update({ status: 'error', error: e.message }))
+      setQueue((q) =>
+        q.map((x) => (x.key === item.key ? { ...x, status: 'uploading' } : x)),
+      )
+      const url = `/api/albums/${albumId}/photos?filename=${encodeURIComponent(item.file.name)}`
+      uploadFile(url, item.file, (p) =>
+        setQueue((q) => q.map((x) => (x.key === item.key ? { ...x, progress: p } : x))),
+      )
+        .then(() =>
+          setQueue((q) =>
+            q.map((x) => (x.key === item.key ? { ...x, status: 'done', progress: 1 } : x)),
+          ),
+        )
+        .catch((e) =>
+          setQueue((q) =>
+            q.map((x) => (x.key === item.key ? { ...x, status: 'error', error: e.message } : x)),
+          ),
+        )
         .finally(() => {
           running.current -= 1
           refresh()
@@ -198,22 +95,6 @@ function UploadZone({ albumId, onUploaded }) {
         }}
       />
       <p>Drop RAWs or JPGs here, or click to select</p>
-      {queue.length > 0 && (
-        <div className="upload-summary" onClick={(e) => e.stopPropagation()}>
-          <progress className="upload-total" value={loadedBytes} max={totalBytes || 1} />
-          <span className="muted">
-            {queue.filter((i) => i.status === 'done' || i.status === 'skipped').length} /{' '}
-            {queue.length} files ·{' '}
-            {fmtBytes(loadedBytes)} of {fmtBytes(totalBytes)}
-            {active && speed > 0 && (
-              <>
-                {' · '}
-                {fmtBytes(speed)}/s · ~{fmtEta((totalBytes - loadedBytes) / speed)} left
-              </>
-            )}
-          </span>
-        </div>
-      )}
       {queue.length > 0 && (
         <ul className="upload-list" onClick={(e) => e.stopPropagation()}>
           {queue.map((item) => (
@@ -221,10 +102,6 @@ function UploadZone({ albumId, onUploaded }) {
               <span className="upload-name">{item.file.name}</span>
               {item.status === 'error' ? (
                 <span className="error">{item.error}</span>
-              ) : item.status === 'skipped' ? (
-                <span className="muted">already uploaded</span>
-              ) : item.status === 'checking' ? (
-                <span className="muted">checking…</span>
               ) : (
                 <progress value={item.progress} max="1" />
               )}
@@ -259,7 +136,11 @@ function SharesPanel({ albumId }) {
           label: form.label,
           password: form.password || null,
           allow_download: form.allow_download,
-          expires_at: endOfDayIso(form.expires_at),
+          // End of the chosen day in the photographer's local timezone —
+          // date-only strings would parse as UTC midnight and expire a day early.
+          expires_at: form.expires_at
+            ? new Date(`${form.expires_at}T23:59:59`).toISOString()
+            : null,
         },
       })
       setForm({ label: '', password: '', allow_download: true, expires_at: '' })
@@ -276,18 +157,6 @@ function SharesPanel({ albumId }) {
     setTimeout(() => setCopied(null), 1500)
   }
 
-  const update = async (shareId, patch) => {
-    try {
-      const updated = await api(`/api/shares/${shareId}`, { method: 'PATCH', body: patch })
-      setShares((list) => list.map((s) => (s.id === shareId ? updated : s)))
-      setError(null)
-    } catch (e) {
-      setError(e.message)
-      // Re-sync the controlled inputs with what the server actually has.
-      load()
-    }
-  }
-
   return (
     <section className="panel">
       <h2>Client links</h2>
@@ -302,20 +171,15 @@ function SharesPanel({ albumId }) {
             <span className="muted">
               {s.has_password ? '🔒 password' : 'no password'}
               {' · '}
-              {s.rating_count} ratings, {s.tag_count} tags, 👍 {s.accept_count} 👎{' '}
-              {s.reject_count}
+              {s.allow_download ? 'downloads on' : 'downloads off'}
+              {s.expires_at
+                ? ` · expires ${new Date(s.expires_at).toLocaleDateString()}`
+                : ' · never expires'}
+              {' · '}
+              {s.rating_count} ratings, {s.tag_count} tags
             </span>
           </div>
           <div className="row">
-            <label className="select-toggle" title="Allow this link to download originals/ZIPs">
-              <input
-                type="checkbox"
-                checked={s.allow_download}
-                onChange={(e) => update(s.id, { allow_download: e.target.checked })}
-              />
-              downloads
-            </label>
-            <ExpiryDate value={s.expires_at} onCommit={(iso) => update(s.id, { expires_at: iso })} />
             {s.locked && (
               <button
                 className="btn"
@@ -396,6 +260,9 @@ export default function AlbumPage() {
   const navigate = useNavigate()
   const [detail, setDetail] = useState(null)
   const [error, setError] = useState(null)
+  // Track the open photo by id, not index — the polling refetch can reorder
+  // the array underneath an open lightbox.
+  const [lightboxId, setLightboxId] = useState(null)
 
   const load = useCallback(
     () => api(`/api/albums/${id}`).then(setDetail).catch((e) => setError(e.message)),
@@ -415,7 +282,14 @@ export default function AlbumPage() {
 
   const ready = (detail?.photos ?? []).filter((p) => p.status === 'ready')
   const { selected, toggle, selectAll, clear, selectedBytes, totalBytes } = useSelection(ready)
-  const lightbox = useLightbox(ready)
+  const lightboxIndex = ready.findIndex((p) => p.id === lightboxId)
+
+  // If the open photo leaves the ready list (deleted elsewhere, reprocess),
+  // close for good — otherwise the lightbox would pop back open when the
+  // photo returns to ready.
+  useEffect(() => {
+    if (lightboxId && lightboxIndex < 0) setLightboxId(null)
+  }, [lightboxId, lightboxIndex])
 
   if (error) return <p className="error">{error}</p>
   if (!detail) return <p className="muted">Loading…</p>
@@ -445,23 +319,11 @@ export default function AlbumPage() {
 
   const removePhoto = async (photoId) => {
     if (!confirm('Delete this photo?')) return
-    lightbox.close()
+    setLightboxId(null)
     await api(`/api/photos/${photoId}`, { method: 'DELETE' })
     load()
   }
 
-  const removeSelected = async () => {
-    if (!confirm(`Delete ${selected.size} selected photo${selected.size === 1 ? '' : 's'}? This cannot be undone.`))
-      return
-    try {
-      await api('/api/photos/delete', { method: 'POST', body: { ids: [...selected] } })
-      clear()
-    } catch (e) {
-      alert(`Delete failed: ${e.message}`)
-    }
-    load()
-  }
-
   return (
     <>
       <div className="page-head">
@@ -514,20 +376,15 @@ export default function AlbumPage() {
 
       <Gallery
         photos={ready}
-        onOpen={lightbox.openAt}
+        onOpen={(i) => setLightboxId(ready[i].id)}
         selected={selected}
         onToggleSelect={toggle}
         overlay={(p) => {
           const avg = avgRating(p.id)
           const tagCount = feedback[p.id]?.tags.length || 0
-          const verdicts = feedback[p.id]?.verdicts || []
-          const accepts = verdicts.filter((v) => v.verdict === 'accept').length
-          const rejects = verdicts.length - accepts
-          if (avg === null && tagCount === 0 && accepts === 0 && rejects === 0) return null
+          if (avg === null && tagCount === 0) return null
           return (
             <div className="g-overlay">
-              {accepts > 0 && <span>👍 {accepts}</span>}
-              {rejects > 0 && <span>👎 {rejects}</span>}
               {avg !== null && <span>★ {avg.toFixed(1)}</span>}
               {tagCount > 0 && <span># {tagCount}</span>}
             </div>
@@ -543,35 +400,26 @@ export default function AlbumPage() {
         total={ready.length}
         selectedBytes={selectedBytes}
         totalBytes={totalBytes}
-        onSelectAll={() => selectAll(ready)}
+        onSelectAll={selectAll}
         onClear={clear}
         onDownload={() => postDownload(`/api/albums/${id}/zip`, [...selected].join(','))}
         onDownloadAll={() => postDownload(`/api/albums/${id}/zip`)}
-        onDelete={removeSelected}
       />
 
-      {lightbox.index >= 0 && (
+      {lightboxIndex >= 0 && (
         <Lightbox
           photos={ready}
-          index={lightbox.index}
-          onClose={lightbox.close}
-          onNav={lightbox.openAt}
-          actions={[
-            { keys: ['s'], help: ['S', 'select for download'], run: (p) => toggle(p.id) },
-          ]}
+          index={lightboxIndex}
+          onClose={() => setLightboxId(null)}
+          onNav={(i) => setLightboxId(ready[i].id)}
           footer={(p) => {
-            const fb = feedback[p.id] || { ratings: [], verdicts: [], tags: [] }
+            const fb = feedback[p.id] || { ratings: [], tags: [] }
             return (
               <div className="admin-footer">
                 <div className="feedback">
-                  {fb.ratings.length === 0 && fb.verdicts.length === 0 && fb.tags.length === 0 && (
+                  {fb.ratings.length === 0 && fb.tags.length === 0 && (
                     <span className="muted">No client feedback yet</span>
                   )}
-                  {fb.verdicts.map((v, i) => (
-                    <span key={`v${i}`} className="feedback-item">
-                      {v.share_label || 'client'}: <Thumbs value={v.verdict} small />
-                    </span>
-                  ))}
                   {fb.ratings.map((r, i) => (
                     <span key={`r${i}`} className="feedback-item">
                       {r.share_label || 'client'}: <Stars value={r.rating} small />

frontend/src/pages/SharePage.jsx

@@ -1,4 +1,4 @@
-import { useCallback, useEffect, useMemo, useRef, useState } from 'react'
+import { useCallback, useEffect, useState } from 'react'
 import { useParams } from 'react-router-dom'
 import { api, postDownload } from '../api'
 import Gallery from '../components/Gallery'
@@ -6,43 +6,18 @@ import Lightbox from '../components/Lightbox'
 import SelectionBar from '../components/SelectionBar'
 import Stars from '../components/Stars'
 import TagEditor from '../components/TagEditor'
-import Thumbs from '../components/Thumbs'
-import useLightbox from '../useLightbox'
 import useSelection from '../useSelection'
 
-const FILTERS = [
-  { key: 'all', label: 'All' },
-  { key: 'accept', label: '👍' },
-  { key: 'reject', label: '👎' },
-  { key: 'undecided', label: 'Undecided' },
-]
-
-const matchesFilter = (photo, key) =>
-  key === 'all' || (key === 'undecided' ? !photo.my_verdict : photo.my_verdict === key)
-
 export default function SharePage() {
   const { token } = useParams()
   const [view, setView] = useState(null)
   const [error, setError] = useState(null)
   const [password, setPassword] = useState('')
   const [unlockError, setUnlockError] = useState(null)
-  const [filter, setFilter] = useState('all')
-
-  const photos = view?.photos ?? []
-  const visible = useMemo(() => photos.filter((p) => matchesFilter(p, filter)), [photos, filter])
-  const filterCounts = useMemo(() => {
-    const counts = { all: photos.length, accept: 0, reject: 0, undecided: 0 }
-    for (const p of photos) counts[p.my_verdict ?? 'undecided'] += 1
-    return counts
-  }, [photos])
-
-  // Selection spans the whole album (so switching filters keeps it), while
-  // the selection bar describes only the current view: its counts, bytes and
-  // downloads cover the visible photos, and "select all" adds them.
-  const { selected, toggle, selectAll, clear } = useSelection(photos)
-  const visibleSelected = visible.filter((p) => selected.has(p.id))
-  const sumBytes = (list) => list.reduce((sum, p) => sum + p.size_bytes, 0)
-  const lightbox = useLightbox(visible)
+  const [lightbox, setLightbox] = useState(-1)
+  const { selected, toggle, selectAll, clear, selectedBytes, totalBytes } = useSelection(
+    view?.photos ?? [],
+  )
 
   const load = useCallback(
     () => api(`/api/share/${token}`).then(setView).catch((e) => setError(e.message)),
@@ -70,75 +45,29 @@ export default function SharePage() {
     }))
   }
 
-  // Optimistic write: patch local state, PUT, reload from the server on
-  // failure to undo the patch.
-  const saveFeedback = async (photo, patch, endpoint, body) => {
-    patchPhoto(photo.id, patch)
+  const setRating = async (photo, rating) => {
+    patchPhoto(photo.id, { my_rating: rating || null })
     try {
-      await api(`/api/share/${token}/photos/${photo.id}/${endpoint}`, { method: 'PUT', body })
+      await api(`/api/share/${token}/photos/${photo.id}/rating`, {
+        method: 'PUT',
+        body: { rating },
+      })
     } catch {
       load()
     }
   }
-  const setRating = (photo, rating) =>
-    saveFeedback(photo, { my_rating: rating || null }, 'rating', { rating })
-  const setVerdict = (photo, verdict) =>
-    saveFeedback(photo, { my_verdict: verdict }, 'verdict', { verdict })
-  const setTags = (photo, tags) => saveFeedback(photo, { my_tags: tags }, 'tags', { tags })
 
-  // Keyboard votes navigate away from the photo they change, so a transient
-  // toast names what just happened to it — without it the jump reads as
-  // "did that register?".
-  const [flash, setFlash] = useState(null)
-  const flashSeq = useRef(0)
-  const flashTimer = useRef()
-  const showFlash = (text) => {
-    flashSeq.current += 1
-    setFlash({ text, key: flashSeq.current })
-    clearTimeout(flashTimer.current)
-    flashTimer.current = setTimeout(() => setFlash(null), 1400)
+  const setTags = async (photo, tags) => {
+    patchPhoto(photo.id, { my_tags: tags })
+    try {
+      await api(`/api/share/${token}/photos/${photo.id}/tags`, {
+        method: 'PUT',
+        body: { tags },
+      })
+    } catch {
+      load()
+    }
   }
-  useEffect(() => () => clearTimeout(flashTimer.current), [])
-
-  // Culling flow: vote, then advance to the photo that was next in the
-  // current view. Under a filter that hides the voted photo, the advance
-  // target stays visible, so the run continues seamlessly.
-  const voteAndAdvance = (photo, verdict) => {
-    const next = visible[lightbox.index + 1]
-    setVerdict(photo, verdict)
-    showFlash(
-      verdict === 'accept'
-        ? `👍 ${photo.filename}`
-        : verdict === 'reject'
-          ? `👎 ${photo.filename}`
-          : `↺ ${photo.filename} cleared`,
-    )
-    if (next) lightbox.show(next.id)
-  }
-
-  const keyActions = [
-    { keys: ['p'], help: ['P', 'accept and go to next'], run: (p) => voteAndAdvance(p, 'accept') },
-    { keys: ['x'], help: ['X', 'reject and go to next'], run: (p) => voteAndAdvance(p, 'reject') },
-    {
-      keys: ['u'],
-      help: ['U', 'clear accept / reject'],
-      // When clearing hides the photo from the current filter, advance like
-      // a vote so the lightbox doesn't just close.
-      run: (p) =>
-        matchesFilter({ my_verdict: null }, filter)
-          ? setVerdict(p, null)
-          : voteAndAdvance(p, null),
-    },
-    {
-      keys: ['1', '2', '3', '4', '5'],
-      help: ['1–5', 'star rating'],
-      run: (p, key) => setRating(p, Number(key)),
-    },
-    { keys: ['0'], help: ['0', 'clear star rating'], run: (p) => setRating(p, 0) },
-    ...(view?.allow_download
-      ? [{ keys: ['s'], help: ['S', 'select for download'], run: (p) => toggle(p.id) }]
-      : []),
-  ]
 
   if (error) return <div className="center-page">{error}</div>
   if (!view) return <div className="center-page">Loading…</div>
@@ -171,80 +100,49 @@ export default function SharePage() {
         <h1>{view.album_name}</h1>
         {view.album_description && <p className="muted">{view.album_description}</p>}
         <p className="muted">
-          {photos.length} photo{photos.length === 1 ? '' : 's'} · click a photo to view, rate and
-          tag · press <kbd>?</kbd> in the viewer for shortcuts
+          {view.photos.length} photo{view.photos.length === 1 ? '' : 's'} · click a photo to view,
+          rate and tag
         </p>
-        {photos.length > 0 && (
-          <div className="filter-bar">
-            {FILTERS.map((f) => (
-              <button
-                key={f.key}
-                className={`filter-chip${filter === f.key ? ' active' : ''}`}
-                onClick={() => setFilter(f.key)}
-              >
-                {f.label} {filterCounts[f.key]}
-              </button>
-            ))}
-          </div>
-        )}
       </header>
       <main className="page">
         <Gallery
-          photos={visible}
-          onOpen={lightbox.openAt}
+          photos={view.photos}
+          onOpen={setLightbox}
           selected={view.allow_download ? selected : undefined}
-          // Shift-ranges must walk the filtered view, not the full album —
-          // otherwise hidden photos get swept into the selection.
-          onToggleSelect={
-            view.allow_download ? (id, shift) => toggle(id, shift, visible) : undefined
-          }
+          onToggleSelect={view.allow_download ? toggle : undefined}
           overlay={(p) =>
-            p.my_verdict || p.my_rating || p.my_tags.length > 0 ? (
+            p.my_rating || p.my_tags.length > 0 ? (
               <div className="g-overlay">
-                {p.my_verdict && <span>{p.my_verdict === 'accept' ? '👍' : '👎'}</span>}
                 {p.my_rating && <span>★ {p.my_rating}</span>}
                 {p.my_tags.length > 0 && <span># {p.my_tags.length}</span>}
               </div>
             ) : null
           }
         />
-        {photos.length === 0 && (
+        {view.photos.length === 0 && (
           <p className="center-page muted">Nothing here yet — check back soon.</p>
         )}
-        {photos.length > 0 && visible.length === 0 && (
-          <p className="center-page muted">No photos match this filter.</p>
-        )}
       </main>
       {view.allow_download && (
         <SelectionBar
-          count={visibleSelected.length}
-          total={visible.length}
-          selectedBytes={sumBytes(visibleSelected)}
-          totalBytes={sumBytes(visible)}
-          onSelectAll={() => selectAll(visible)}
+          count={selected.size}
+          total={view.photos.length}
+          selectedBytes={selectedBytes}
+          totalBytes={totalBytes}
+          onSelectAll={selectAll}
           onClear={clear}
-          onDownload={() =>
-            postDownload(`/api/share/${token}/zip`, visibleSelected.map((p) => p.id).join(','))
-          }
-          onDownloadAll={() =>
-            // Under a filter, "download all" means all photos shown.
-            postDownload(
-              `/api/share/${token}/zip`,
-              filter === 'all' ? '' : visible.map((p) => p.id).join(','),
-            )
-          }
+          onDownload={() => postDownload(`/api/share/${token}/zip`, [...selected].join(','))}
+          onDownloadAll={() => postDownload(`/api/share/${token}/zip`)}
         />
       )}
-      {lightbox.index >= 0 && (
+      {lightbox >= 0 && (
         <Lightbox
-          photos={visible}
-          index={lightbox.index}
-          onClose={lightbox.close}
-          onNav={lightbox.openAt}
-          actions={keyActions}
+          photos={view.photos}
+          index={lightbox}
+          onClose={() => setLightbox(-1)}
+          onNav={setLightbox}
           footer={(p) => (
             <div className="client-footer">
-              <Thumbs value={p.my_verdict} onChange={(v) => setVerdict(p, v)} />
               <Stars value={p.my_rating || 0} onChange={(r) => setRating(p, r)} />
               <TagEditor tags={p.my_tags} onChange={(tags) => setTags(p, tags)} />
               {view.allow_download && (
@@ -266,11 +164,6 @@ export default function SharePage() {
           )}
         />
       )}
-      {flash && (
-        <div key={flash.key} className="action-flash">
-          {flash.text}
-        </div>
-      )}
     </>
   )
 }

frontend/src/styles.css

@@ -191,17 +191,15 @@ input:focus {
 /* justified gallery */
 .gallery {
   display: flex;
-  flex-direction: column;
+  flex-wrap: wrap;
   gap: 6px;
   margin: 1rem 0;
 }
-.g-row {
-  display: flex;
-  gap: 6px;
-}
 .g-item {
   position: relative;
-  flex: none;
+  height: 240px;
+  flex-grow: calc(var(--ar) * 100);
+  flex-basis: calc(var(--ar) * 240px);
   border-radius: 4px;
   overflow: hidden;
   cursor: pointer;
@@ -213,6 +211,11 @@ input:focus {
   object-fit: cover;
   display: block;
 }
+.g-spacer {
+  flex-grow: 1000000;
+  flex-basis: 0;
+  height: 0;
+}
 .g-overlay {
   position: absolute;
   bottom: 0;
@@ -307,18 +310,6 @@ input:focus {
 .upload-zone p {
   margin: 0;
 }
-.upload-summary {
-  display: flex;
-  flex-direction: column;
-  gap: 0.3rem;
-  margin-top: 1rem;
-  cursor: default;
-  font-size: 0.9rem;
-}
-.upload-total {
-  width: 100%;
-  accent-color: var(--accent);
-}
 .upload-list {
   list-style: none;
   margin: 1rem 0 0;
@@ -534,130 +525,6 @@ progress {
   cursor: default;
 }
 
-/* thumbs (accept / reject) */
-.thumbs {
-  display: inline-flex;
-  gap: 0.15rem;
-}
-.thumb {
-  background: none;
-  border: none;
-  font-size: 1.35rem;
-  line-height: 1;
-  padding: 0 0.15rem;
-  cursor: pointer;
-  filter: grayscale(1);
-  opacity: 0.4;
-  transition: opacity 0.12s;
-}
-.thumb:hover:enabled {
-  opacity: 0.8;
-}
-.thumb.active {
-  filter: none;
-  opacity: 1;
-}
-.thumb:disabled {
-  cursor: default;
-}
-.thumbs-small .thumb {
-  font-size: 0.95rem;
-}
-
-/* verdict filter */
-.filter-bar {
-  display: flex;
-  justify-content: center;
-  flex-wrap: wrap;
-  gap: 0.5rem;
-  margin-top: 0.9rem;
-}
-.filter-chip {
-  background: var(--panel);
-  border: 1px solid var(--panel-2);
-  border-radius: 999px;
-  color: var(--muted);
-  padding: 0.25rem 0.8rem;
-  font-size: 0.85rem;
-  cursor: pointer;
-}
-.filter-chip.active {
-  background: var(--panel-2);
-  color: var(--text);
-  border-color: var(--accent);
-}
-
-/* transient action feedback (keyboard votes that navigate away) */
-.action-flash {
-  position: fixed;
-  top: 3rem;
-  left: 50%;
-  transform: translateX(-50%);
-  z-index: 110;
-  background: var(--panel);
-  border: 1px solid var(--panel-2);
-  border-radius: 999px;
-  padding: 0.35rem 1rem;
-  font-size: 0.9rem;
-  white-space: nowrap;
-  pointer-events: none;
-  animation: flash-fade 1.4s ease forwards;
-}
-@keyframes flash-fade {
-  0% {
-    opacity: 0;
-    transform: translate(-50%, -6px);
-  }
-  8%,
-  70% {
-    opacity: 1;
-    transform: translate(-50%, 0);
-  }
-  100% {
-    opacity: 0;
-    transform: translate(-50%, 0);
-  }
-}
-
-/* lightbox shortcut help */
-.lb-help {
-  position: absolute;
-  inset: 0;
-  display: flex;
-  align-items: center;
-  justify-content: center;
-  background: rgba(8, 9, 11, 0.6);
-  z-index: 102;
-}
-.lb-help-card {
-  background: var(--panel);
-  border: 1px solid var(--panel-2);
-  border-radius: 12px;
-  padding: 1.1rem 1.5rem 1.25rem;
-  min-width: 280px;
-  cursor: default;
-}
-.lb-help-card h3 {
-  font-size: 0.95rem;
-  margin: 0 0 0.6rem;
-}
-.lb-help-row {
-  display: flex;
-  align-items: baseline;
-  justify-content: space-between;
-  gap: 1.5rem;
-  padding: 0.18rem 0;
-  font-size: 0.88rem;
-}
-kbd {
-  background: var(--panel-2);
-  border-radius: 4px;
-  padding: 0.08rem 0.45rem;
-  font-family: ui-monospace, SFMono-Regular, Menlo, monospace;
-  font-size: 0.8rem;
-  white-space: nowrap;
-}
-
 /* tags */
 .tag-editor {
   display: inline-flex;
@@ -689,6 +556,10 @@ kbd {
 }
 
 @media (max-width: 700px) {
+  .g-item {
+    height: 160px;
+    flex-basis: calc(var(--ar) * 160px);
+  }
   .lb-stage {
     padding: 0 0.5rem;
   }

frontend/src/useLightbox.js

@@ -1,21 +0,0 @@
-import { useEffect, useState } from 'react'
-
-// Lightbox state tracked by photo id, not index — the list can reorder
-// (polling refetch) or shrink (filter change, delete) underneath an open
-// lightbox. When the open photo leaves the list, close for good — otherwise
-// the lightbox would pop back open when the photo returns to the list.
-export default function useLightbox(photos) {
-  const [openId, setOpenId] = useState(null)
-  const index = openId ? photos.findIndex((p) => p.id === openId) : -1
-
-  useEffect(() => {
-    if (openId && index < 0) setOpenId(null)
-  }, [openId, index])
-
-  return {
-    index,
-    openAt: (i) => setOpenId(photos[i].id),
-    show: (id) => setOpenId(id),
-    close: () => setOpenId(null),
-  }
-}

frontend/src/useSelection.js

@@ -1,12 +1,10 @@
-import { useEffect, useRef, useState } from 'react'
+import { useEffect, useState } from 'react'
 
 // Multi-select over a photo list. Selection lives here (not in the gallery)
 // so it survives lightbox open/close, and is pruned automatically when
 // photos disappear from the list (deletes, polling refreshes).
 export default function useSelection(photos) {
   const [selected, setSelected] = useState(() => new Set())
-  // Anchor for shift-click range selection: the photo last toggled.
-  const lastToggled = useRef(null)
 
   useEffect(() => {
     setSelected((prev) => {
@@ -17,43 +15,16 @@ export default function useSelection(photos) {
     })
   }, [photos])
 
-  // Shift-toggle selects the whole range from the previously toggled photo
-  // (both directions), so contiguous runs don't need per-photo clicks. The
-  // range walks `list` — the photo order the user is actually looking at —
-  // which callers with a filtered view must pass explicitly, so hidden
-  // photos are never swept into the selection. Anchor updates and range
-  // computation stay out of the setSelected updater: React may re-invoke
-  // updaters (StrictMode does), so they must be pure.
-  const toggle = (photoId, shift = false, list = photos) => {
-    const anchor = lastToggled.current
-    lastToggled.current = photoId
-    if (shift && anchor) {
-      const a = list.findIndex((p) => p.id === anchor)
-      const b = list.findIndex((p) => p.id === photoId)
-      if (a >= 0 && b >= 0) {
-        const range = list.slice(Math.min(a, b), Math.max(a, b) + 1).map((p) => p.id)
-        setSelected((prev) => new Set([...prev, ...range]))
-        return
-      }
-    }
+  const toggle = (photoId) =>
     setSelected((prev) => {
       const next = new Set(prev)
       if (next.has(photoId)) next.delete(photoId)
       else next.add(photoId)
       return next
     })
-  }
 
-  // Adds `list` (the caller's currently visible photos) to the selection —
-  // additive, so selecting all of one filtered view keeps picks from another.
-  const selectAll = (list) =>
-    setSelected((prev) => new Set([...prev, ...list.map((p) => p.id)]))
-  const clear = () => {
-    // Reset the anchor too — a shift-click after Clear must start fresh, not
-    // extend a range from a photo selected before the wipe.
-    lastToggled.current = null
-    setSelected(new Set())
-  }
+  const selectAll = () => setSelected(new Set(photos.map((p) => p.id)))
+  const clear = () => setSelected(new Set())
   const selectedBytes = photos.reduce((sum, p) => sum + (selected.has(p.id) ? p.size_bytes : 0), 0)
   const totalBytes = photos.reduce((sum, p) => sum + p.size_bytes, 0)
 

migrations/0002_content_hash.sql

@@ -1,10 +0,0 @@
--- Content hashes: sha256 powers duplicate-upload detection (same content in
--- the same album is returned instead of copied); crc32 lets zip downloads
--- stream originals straight from S3 without a local spool pass.
--- Both are null for photos uploaded before this migration; they self-heal on
--- reprocess (sha256 + crc32) and on zip download (crc32).
-alter table photos add column sha256 text;
-alter table photos add column crc32 bigint;
-
-create unique index photos_album_sha_uidx on photos (album_id, sha256)
-    where sha256 is not null;

migrations/0004_verdicts.sql

@@ -1,13 +0,0 @@
--- Client accept/reject votes, one per (link, photo) — a separate axis from
--- the 1-5 star rating so a photo can be e.g. accepted but unrated.
-create table verdicts (
-    share_id uuid not null references shares(id) on delete cascade,
-    photo_id uuid not null references photos(id) on delete cascade,
-    verdict text not null check (verdict in ('accept', 'reject')),
-    updated_at timestamptz not null default now(),
-    primary key (share_id, photo_id)
-);
-
--- Cascaded photo deletes fire per-row FK triggers; without this each one
--- sequential-scans the table.
-create index verdicts_photo_idx on verdicts (photo_id);

src/imaging.rs

@@ -62,24 +62,7 @@ pub async fn process_photo(state: &AppState, photo_id: Uuid) -> anyhow::Result<(
         .unwrap_or("bin")
         .to_lowercase();
     let src_path = dir.path().join(format!("original.{extension}"));
-    let (sha256, crc32) =
-        download(state, &s3::original_key(photo_id, &photo.filename), &src_path).await?;
-    if photo.sha256.is_none() || photo.crc32.is_none() {
-        // Best-effort backfill for pre-hash photos; a duplicate in the same
-        // album trips the unique index, which is fine — skip silently.
-        if let Err(e) = sqlx::query(
-            "update photos set sha256 = coalesce(sha256, $2), crc32 = coalesce(crc32, $3)
-             where id = $1",
-        )
-        .bind(photo_id)
-        .bind(&sha256)
-        .bind(crc32)
-        .execute(&state.db)
-        .await
-        {
-            tracing::debug!("hash backfill skipped for {photo_id}: {e}");
-        }
-    }
+    download(state, &s3::original_key(photo_id, &photo.filename), &src_path).await?;
 
     let meta = exif_metadata(&src_path).await?;
 
@@ -120,11 +103,7 @@ pub async fn process_photo(state: &AppState, photo_id: Uuid) -> anyhow::Result<(
     Ok(())
 }
 
-/// Download the original, hashing along the way so legacy photos (uploaded
-/// before hashes existed) can be backfilled.
-async fn download(state: &AppState, key: &str, path: &Path) -> anyhow::Result<(String, i64)> {
-    use sha2::Digest;
-    use tokio::io::{AsyncReadExt, AsyncWriteExt};
+async fn download(state: &AppState, key: &str, path: &Path) -> anyhow::Result<()> {
     let object = state
         .s3
         .get_object()
@@ -135,20 +114,8 @@ async fn download(state: &AppState, key: &str, path: &Path) -> anyhow::Result<(S
         .with_context(|| format!("fetching s3://{}/{key}", state.config.s3_bucket))?;
     let mut reader = object.body.into_async_read();
     let mut file = tokio::fs::File::create(path).await?;
-    let mut sha = sha2::Sha256::new();
-    let mut crc = crc32fast::Hasher::new();
-    let mut buf = vec![0u8; 128 * 1024];
-    loop {
-        let n = reader.read(&mut buf).await?;
-        if n == 0 {
-            break;
-        }
-        sha.update(&buf[..n]);
-        crc.update(&buf[..n]);
-        file.write_all(&buf[..n]).await?;
-    }
-    file.flush().await?;
-    Ok((hex::encode(sha.finalize()), i64::from(crc.finalize())))
+    tokio::io::copy(&mut reader, &mut file).await?;
+    Ok(())
 }
 
 #[derive(Default)]

src/models.rs

@@ -1,5 +1,5 @@
 use chrono::{DateTime, Utc};
-use serde::{Deserialize, Serialize};
+use serde::Serialize;
 use uuid::Uuid;
 
 /// Stored as text in Postgres; decoded via TryFrom so an unknown value is a
@@ -47,25 +47,6 @@ impl TryFrom<String> for PhotoStatus {
     }
 }
 
-/// Client accept/reject vote. Same convention as PhotoStatus: text in
-/// Postgres (check-constrained), this enum everywhere Rust touches the value
-/// — serde rejects anything but "accept"/"reject" at the API boundary.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, Serialize, Deserialize)]
-#[serde(rename_all = "lowercase")]
-pub enum Verdict {
-    Accept,
-    Reject,
-}
-
-impl Verdict {
-    pub fn as_str(self) -> &'static str {
-        match self {
-            Self::Accept => "accept",
-            Self::Reject => "reject",
-        }
-    }
-}
-
 #[derive(Debug, Clone, Copy, PartialEq, Eq)]
 pub enum JobKind {
     ProcessPhoto,
@@ -134,10 +115,6 @@ pub struct Photo {
     pub height: Option<i32>,
     pub taken_at: Option<DateTime<Utc>>,
     pub processed_at: Option<DateTime<Utc>>,
-    #[serde(skip_serializing)]
-    pub sha256: Option<String>,
-    #[serde(skip_serializing)]
-    pub crc32: Option<i64>,
     pub created_at: DateTime<Utc>,
 }
 

src/routes/albums.rs

@@ -7,7 +7,7 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::error::{ApiError, ApiResult};
-use crate::models::{Album, Photo, PhotoStatus};
+use crate::models::{Album, JobKind, Photo, PhotoStatus};
 use crate::state::AppState;
 
 #[derive(Serialize, sqlx::FromRow)]
@@ -79,40 +79,12 @@ pub struct ShareTag {
     pub tag: String,
 }
 
-#[derive(Serialize)]
-pub struct ShareVerdict {
-    pub share_label: String,
-    pub verdict: String,
-}
-
 #[derive(Serialize, Default)]
 pub struct PhotoFeedback {
     pub ratings: Vec<ShareRating>,
-    pub verdicts: Vec<ShareVerdict>,
     pub tags: Vec<ShareTag>,
 }
 
-async fn feedback_rows<T>(
-    db: &sqlx::PgPool,
-    sql: &str,
-    album_id: Uuid,
-) -> Result<Vec<(Uuid, String, T)>, sqlx::Error>
-where
-    (Uuid, String, T): for<'r> sqlx::FromRow<'r, sqlx::postgres::PgRow> + Send + Unpin,
-{
-    sqlx::query_as(sql).bind(album_id).fetch_all(db).await
-}
-
-fn fold_feedback<T>(
-    feedback: &mut HashMap<Uuid, PhotoFeedback>,
-    rows: Vec<(Uuid, String, T)>,
-    push: impl Fn(&mut PhotoFeedback, String, T),
-) {
-    for (photo_id, share_label, value) in rows {
-        push(feedback.entry(photo_id).or_default(), share_label, value);
-    }
-}
-
 #[derive(Serialize)]
 pub struct AlbumDetail {
     pub album: Album,
@@ -136,49 +108,41 @@ pub async fn get_one(
     .fetch_all(&state.db)
     .await?;
 
-    // The three feedback kinds are independent (photo_id, share label, value)
-    // queries — run them concurrently and fold with one shared shape.
-    let (ratings, verdicts, tags) = tokio::try_join!(
-        feedback_rows::<i32>(
-            &state.db,
-            "select r.photo_id, s.label, r.rating
-             from ratings r join shares s on s.id = r.share_id
-             where s.album_id = $1",
-            album_id,
-        ),
-        feedback_rows::<String>(
-            &state.db,
-            "select v.photo_id, s.label, v.verdict
-             from verdicts v join shares s on s.id = v.share_id
-             where s.album_id = $1",
-            album_id,
-        ),
-        feedback_rows::<String>(
-            &state.db,
-            "select t.photo_id, s.label, t.tag
-             from tags t join shares s on s.id = t.share_id
-             where s.album_id = $1
-             order by t.created_at",
-            album_id,
-        ),
-    )?;
-
     let mut feedback: HashMap<Uuid, PhotoFeedback> = HashMap::new();
-    fold_feedback(&mut feedback, ratings, |f, share_label, rating| {
-        f.ratings.push(ShareRating {
-            share_label,
-            rating,
-        })
-    });
-    fold_feedback(&mut feedback, verdicts, |f, share_label, verdict| {
-        f.verdicts.push(ShareVerdict {
-            share_label,
-            verdict,
-        })
-    });
-    fold_feedback(&mut feedback, tags, |f, share_label, tag| {
-        f.tags.push(ShareTag { share_label, tag })
-    });
+    let ratings: Vec<(Uuid, String, i32)> = sqlx::query_as(
+        "select r.photo_id, s.label, r.rating
+         from ratings r join shares s on s.id = r.share_id
+         where s.album_id = $1",
+    )
+    .bind(album_id)
+    .fetch_all(&state.db)
+    .await?;
+    for (photo_id, share_label, rating) in ratings {
+        feedback
+            .entry(photo_id)
+            .or_default()
+            .ratings
+            .push(ShareRating {
+                share_label,
+                rating,
+            });
+    }
+    let tags: Vec<(Uuid, String, String)> = sqlx::query_as(
+        "select t.photo_id, s.label, t.tag
+         from tags t join shares s on s.id = t.share_id
+         where s.album_id = $1
+         order by t.created_at",
+    )
+    .bind(album_id)
+    .fetch_all(&state.db)
+    .await?;
+    for (photo_id, share_label, tag) in tags {
+        feedback
+            .entry(photo_id)
+            .or_default()
+            .tags
+            .push(ShareTag { share_label, tag });
+    }
 
     Ok(Json(AlbumDetail {
         album,
@@ -232,13 +196,17 @@ pub async fn delete(
     if locked.is_none() {
         return Err(ApiError::not_found());
     }
-    // Delete photos through the shared path so the S3 cleanup convention
-    // lives in one place; the album lock above keeps this set complete.
-    let photo_ids: Vec<Uuid> = sqlx::query_scalar("select id from photos where album_id = $1")
-        .bind(album_id)
-        .fetch_all(&mut *tx)
-        .await?;
-    super::photos::delete_with_cleanup(&mut tx, &photo_ids).await?;
+    // Delete photos and enqueue their S3 cleanup atomically, in one statement.
+    sqlx::query(
+        "with deleted as (delete from photos where album_id = $1 returning id)
+         insert into jobs (kind, payload)
+         select $2, jsonb_build_object('prefix', 'photos/' || id || '/')
+         from deleted",
+    )
+    .bind(album_id)
+    .bind(JobKind::DeleteS3Prefix.as_str())
+    .execute(&mut *tx)
+    .await?;
     sqlx::query("delete from albums where id = $1")
         .bind(album_id)
         .execute(&mut *tx)

src/routes/client.rs

@@ -10,7 +10,7 @@ use serde::{Deserialize, Serialize};
 use uuid::Uuid;
 
 use crate::error::{ApiError, ApiResult};
-use crate::models::{PhotoStatus, Share, Verdict};
+use crate::models::{PhotoStatus, Share};
 use crate::state::AppState;
 
 pub async fn load_share(state: &AppState, token: &str) -> Result<Share, ApiError> {
@@ -137,7 +137,6 @@ struct ClientPhotoRow {
     taken_at: Option<DateTime<Utc>>,
     processed_at: Option<DateTime<Utc>>,
     my_rating: Option<i32>,
-    my_verdict: Option<String>,
 }
 
 #[derive(Serialize)]
@@ -186,10 +185,9 @@ pub async fn get_share(
     let jar = grant_access(&state, jar, share.id);
 
     let rows: Vec<ClientPhotoRow> = sqlx::query_as(
-        "select p.id, p.filename, p.size_bytes, p.width, p.height, p.taken_at, p.processed_at, r.rating as my_rating, v.verdict as my_verdict
+        "select p.id, p.filename, p.size_bytes, p.width, p.height, p.taken_at, p.processed_at, r.rating as my_rating
          from photos p
          left join ratings r on r.photo_id = p.id and r.share_id = $2
-         left join verdicts v on v.photo_id = p.id and v.share_id = $2
          where p.album_id = $1 and p.status = $3
          order by coalesce(p.taken_at, p.created_at), p.filename",
     )
@@ -354,42 +352,6 @@ pub async fn set_rating(
     Ok(Json(serde_json::json!({ "ok": true })))
 }
 
-#[derive(Deserialize)]
-pub struct VerdictBody {
-    verdict: Option<Verdict>,
-}
-
-pub async fn set_verdict(
-    State(state): State<AppState>,
-    Path((token, photo_id)): Path<(String, Uuid)>,
-    jar: SignedCookieJar,
-    Json(body): Json<VerdictBody>,
-) -> ApiResult<Json<serde_json::Value>> {
-    let share = share_photo(&state, &jar, &token, photo_id).await?;
-    match body.verdict {
-        None => {
-            sqlx::query("delete from verdicts where share_id = $1 and photo_id = $2")
-                .bind(share.id)
-                .bind(photo_id)
-                .execute(&state.db)
-                .await?;
-        }
-        Some(verdict) => {
-            sqlx::query(
-                "insert into verdicts (share_id, photo_id, verdict) values ($1, $2, $3)
-                 on conflict (share_id, photo_id)
-                 do update set verdict = excluded.verdict, updated_at = now()",
-            )
-            .bind(share.id)
-            .bind(photo_id)
-            .bind(verdict.as_str())
-            .execute(&state.db)
-            .await?;
-        }
-    }
-    Ok(Json(serde_json::json!({ "ok": true })))
-}
-
 #[derive(Deserialize)]
 pub struct TagsBody {
     tags: Vec<String>,

src/routes/mod.rs

@@ -77,14 +77,9 @@ pub fn router(state: &AppState) -> Router<AppState> {
             get(shares::list).post(shares::create),
         )
         .route("/api/albums/{id}/zip", post(zip::album_zip))
-        .route("/api/albums/{id}/photos/by-hash/{sha256}", get(photos::by_hash))
-        .route("/api/photos/delete", post(photos::delete_many))
         .route("/api/photos/{id}", delete(photos::delete))
         .route("/api/photos/{id}/reprocess", post(photos::reprocess))
-        .route(
-            "/api/shares/{id}",
-            delete(shares::delete).patch(shares::update),
-        )
+        .route("/api/shares/{id}", delete(shares::delete))
         .route("/api/shares/{id}/reset-lock", post(shares::reset_lock))
         .route_layer(middleware::from_fn_with_state(
             state.clone(),
@@ -104,10 +99,6 @@ pub fn router(state: &AppState) -> Router<AppState> {
             "/api/share/{token}/photos/{photo_id}/rating",
             put(client::set_rating),
         )
-        .route(
-            "/api/share/{token}/photos/{photo_id}/verdict",
-            put(client::set_verdict),
-        )
         .route(
             "/api/share/{token}/photos/{photo_id}/tags",
             put(client::set_tags),

src/routes/photos.rs

@@ -5,7 +5,6 @@ use axum::http::HeaderMap;
 use axum::Json;
 use futures::StreamExt;
 use serde::Deserialize;
-use sha2::Digest;
 use tokio::io::AsyncWriteExt;
 use uuid::Uuid;
 
@@ -61,23 +60,17 @@ pub async fn upload(
         .unwrap_or("application/octet-stream")
         .to_string();
 
-    // Stream the request body to a temp file so large raws never sit in
-    // memory, hashing as it flows: sha256 for duplicate detection, crc32 for
-    // spool-free zip downloads.
+    // Stream the request body to a temp file so large raws never sit in memory.
     let dir = tempfile::tempdir().map_err(anyhow::Error::from)?;
     let path = dir.path().join("upload.bin");
     let mut file = tokio::fs::File::create(&path)
         .await
         .map_err(anyhow::Error::from)?;
     let mut stream = body.into_data_stream();
-    let mut sha = sha2::Sha256::new();
-    let mut crc = crc32fast::Hasher::new();
     let mut size: i64 = 0;
     while let Some(chunk) = stream.next().await {
         let chunk = chunk.map_err(|e| ApiError::bad_request(format!("upload aborted: {e}")))?;
         size += chunk.len() as i64;
-        sha.update(&chunk);
-        crc.update(&chunk);
         file.write_all(&chunk).await.map_err(anyhow::Error::from)?;
     }
     file.flush().await.map_err(anyhow::Error::from)?;
@@ -85,20 +78,6 @@ pub async fn upload(
     if size == 0 {
         return Err(ApiError::bad_request("empty upload"));
     }
-    let sha256 = hex::encode(sha.finalize());
-    let crc32 = i64::from(crc.finalize());
-
-    // Same content already in this album? Return it — re-dragging a folder
-    // after a partial upload just fills the gaps instead of duplicating.
-    let existing: Option<Photo> =
-        sqlx::query_as("select * from photos where album_id = $1 and sha256 = $2")
-            .bind(album_id)
-            .bind(&sha256)
-            .fetch_optional(&state.db)
-            .await?;
-    if let Some(existing) = existing {
-        return Ok(Json(existing));
-    }
 
     // Upload to S3 first, then create the row and enqueue processing in one
     // transaction — a photo row can never exist without its job, and a failed
@@ -107,33 +86,30 @@ pub async fn upload(
     let key = s3::original_key(photo_id, &filename);
     s3::put_file(&state, &key, &path, &content_type).await?;
 
-    let result: Result<(sqlx::Transaction<'static, sqlx::Postgres>, Photo), sqlx::Error> =
-        async {
-            let mut tx = state.db.begin().await?;
-            let photo: Photo = sqlx::query_as(
-                "insert into photos (id, album_id, filename, content_type, size_bytes, status, sha256, crc32)
-                 values ($1, $2, $3, $4, $5, $6, $7, $8)
-                 returning *",
-            )
-            .bind(photo_id)
-            .bind(album_id)
-            .bind(&filename)
-            .bind(&content_type)
-            .bind(size)
-            .bind(PhotoStatus::Uploaded.as_str())
-            .bind(&sha256)
-            .bind(crc32)
-            .fetch_one(&mut *tx)
-            .await?;
-            jobs::enqueue(
-                &mut *tx,
-                JobKind::ProcessPhoto,
-                serde_json::json!({ "photo_id": photo_id }),
-            )
-            .await?;
-            Ok((tx, photo))
-        }
-        .await;
+    let result: ApiResult<(sqlx::Transaction<'static, sqlx::Postgres>, Photo)> = async {
+        let mut tx = state.db.begin().await?;
+        let photo: Photo = sqlx::query_as(
+            "insert into photos (id, album_id, filename, content_type, size_bytes, status)
+             values ($1, $2, $3, $4, $5, $6)
+             returning *",
+        )
+        .bind(photo_id)
+        .bind(album_id)
+        .bind(&filename)
+        .bind(&content_type)
+        .bind(size)
+        .bind(PhotoStatus::Uploaded.as_str())
+        .fetch_one(&mut *tx)
+        .await?;
+        jobs::enqueue(
+            &mut *tx,
+            JobKind::ProcessPhoto,
+            serde_json::json!({ "photo_id": photo_id }),
+        )
+        .await?;
+        Ok((tx, photo))
+    }
+    .await;
 
     let (tx, photo) = match result {
         Ok(pair) => pair,
@@ -142,24 +118,7 @@ pub async fn upload(
             if let Err(cleanup) = s3::delete_prefix(&state, &s3::photo_prefix(photo_id)).await {
                 tracing::error!("failed to clean up s3 after aborted upload: {cleanup:#}");
             }
-            // Concurrent identical upload beat us to the unique index — hand
-            // back the winner instead of an error.
-            let unique_violation = matches!(
-                &e,
-                sqlx::Error::Database(db) if db.code().as_deref() == Some("23505")
-            );
-            if unique_violation {
-                let winner: Option<Photo> =
-                    sqlx::query_as("select * from photos where album_id = $1 and sha256 = $2")
-                        .bind(album_id)
-                        .bind(&sha256)
-                        .fetch_optional(&state.db)
-                        .await?;
-                if let Some(winner) = winner {
-                    return Ok(Json(winner));
-                }
-            }
-            return Err(e.into());
+            return Err(e);
         }
     };
     if let Err(e) = tx.commit().await {
@@ -174,84 +133,28 @@ pub async fn upload(
     Ok(Json(photo))
 }
 
-/// Client-side dedup support: lets the uploader skip transferring files whose
-/// content already exists in the album.
-pub async fn by_hash(
-    State(state): State<AppState>,
-    Path((album_id, sha256)): Path<(Uuid, String)>,
-) -> ApiResult<Json<Photo>> {
-    let photo: Option<Photo> =
-        sqlx::query_as("select * from photos where album_id = $1 and sha256 = $2")
-            .bind(album_id)
-            .bind(&sha256)
-            .fetch_optional(&state.db)
-            .await?;
-    photo.map(Json).ok_or_else(ApiError::not_found)
-}
-
-/// The one deletion path: delete the given photos and enqueue their S3
-/// cleanup jobs in the same transaction. Prefixes come from s3::photo_prefix
-/// so the key layout has a single source of truth. Returns how many photos
-/// were actually deleted.
-pub(super) async fn delete_with_cleanup(
-    tx: &mut sqlx::PgConnection,
-    ids: &[Uuid],
-) -> Result<u64, sqlx::Error> {
-    let deleted: Vec<Uuid> = sqlx::query_scalar("delete from photos where id = any($1) returning id")
-        .bind(ids)
-        .fetch_all(&mut *tx)
-        .await?;
-    if deleted.is_empty() {
-        return Ok(0);
-    }
-    let prefixes: Vec<String> = deleted.iter().map(|id| s3::photo_prefix(*id)).collect();
-    sqlx::query(
-        "insert into jobs (kind, payload)
-         select $1, jsonb_build_object('prefix', p)
-         from unnest($2::text[]) as p",
-    )
-    .bind(JobKind::DeleteS3Prefix.as_str())
-    .bind(&prefixes)
-    .execute(&mut *tx)
-    .await?;
-    Ok(deleted.len() as u64)
-}
-
 pub async fn delete(
     State(state): State<AppState>,
     Path(photo_id): Path<Uuid>,
 ) -> ApiResult<Json<serde_json::Value>> {
     let mut tx = state.db.begin().await?;
-    if delete_with_cleanup(&mut tx, &[photo_id]).await? == 0 {
+    let deleted = sqlx::query("delete from photos where id = $1")
+        .bind(photo_id)
+        .execute(&mut *tx)
+        .await?;
+    if deleted.rows_affected() == 0 {
         return Err(ApiError::not_found());
     }
+    jobs::enqueue(
+        &mut *tx,
+        JobKind::DeleteS3Prefix,
+        serde_json::json!({ "prefix": s3::photo_prefix(photo_id) }),
+    )
+    .await?;
     tx.commit().await?;
     Ok(Json(serde_json::json!({ "ok": true })))
 }
 
-#[derive(Deserialize)]
-pub struct DeleteManyBody {
-    ids: Vec<Uuid>,
-}
-
-pub async fn delete_many(
-    State(state): State<AppState>,
-    Json(body): Json<DeleteManyBody>,
-) -> ApiResult<Json<serde_json::Value>> {
-    if body.ids.is_empty() {
-        return Err(ApiError::bad_request("ids must not be empty"));
-    }
-    let mut tx = state.db.begin().await?;
-    let deleted = delete_with_cleanup(&mut tx, &body.ids).await?;
-    // Consistent with the single-photo route: deleting nothing is an error,
-    // not a silent success (e.g. a stale tab re-deleting already-gone photos).
-    if deleted == 0 {
-        return Err(ApiError::not_found());
-    }
-    tx.commit().await?;
-    Ok(Json(serde_json::json!({ "ok": true, "deleted": deleted })))
-}
-
 pub async fn reprocess(
     State(state): State<AppState>,
     Path(photo_id): Path<Uuid>,

src/routes/shares.rs

@@ -23,8 +23,6 @@ struct ShareAdminRow {
     created_at: DateTime<Utc>,
     rating_count: i64,
     tag_count: i64,
-    accept_count: i64,
-    reject_count: i64,
 }
 
 fn share_json(state: &AppState, row: &ShareAdminRow) -> serde_json::Value {
@@ -40,30 +38,20 @@ fn share_json(state: &AppState, row: &ShareAdminRow) -> serde_json::Value {
         "created_at": row.created_at,
         "rating_count": row.rating_count,
         "tag_count": row.tag_count,
-        "accept_count": row.accept_count,
-        "reject_count": row.reject_count,
     })
 }
 
-// Aggregates run as laterals so each feedback table is scanned once per
-// share (the verdict lateral yields both counts from a single pass).
-const SHARE_SELECT: &str = "select s.id, s.token, s.label, s.password_hash, s.allow_download,
+const SHARE_COLUMNS: &str = "s.id, s.token, s.label, s.password_hash, s.allow_download,
     s.expires_at, s.locked_until, s.created_at,
-    rc.rating_count, tc.tag_count, vc.accept_count, vc.reject_count
-    from shares s
-    cross join lateral (select count(*) as rating_count from ratings r where r.share_id = s.id) rc
-    cross join lateral (select count(*) as tag_count from tags t where t.share_id = s.id) tc
-    cross join lateral (
-        select count(*) filter (where v.verdict = 'accept') as accept_count,
-               count(*) filter (where v.verdict = 'reject') as reject_count
-        from verdicts v where v.share_id = s.id) vc";
+    (select count(*) from ratings r where r.share_id = s.id) as rating_count,
+    (select count(*) from tags t where t.share_id = s.id) as tag_count";
 
 pub async fn list(
     State(state): State<AppState>,
     Path(album_id): Path<Uuid>,
 ) -> ApiResult<Json<Vec<serde_json::Value>>> {
     let rows: Vec<ShareAdminRow> = sqlx::query_as(&format!(
-        "{SHARE_SELECT} where s.album_id = $1 order by s.created_at desc"
+        "select {SHARE_COLUMNS} from shares s where s.album_id = $1 order by s.created_at desc"
     ))
     .bind(album_id)
     .fetch_all(&state.db)
@@ -131,53 +119,11 @@ pub async fn create(
     .fetch_one(&state.db)
     .await?;
 
-    let row: ShareAdminRow = sqlx::query_as(&format!("{SHARE_SELECT} where s.id = $1"))
-        .bind(share_id)
-        .fetch_one(&state.db)
-        .await?;
-    Ok(Json(share_json(&state, &row)))
-}
-
-/// Distinguishes an absent JSON field (keep current value) from an explicit
-/// null (clear the expiry): absent → None, present → Some(inner).
-fn double_option<'de, D>(de: D) -> Result<Option<Option<DateTime<Utc>>>, D::Error>
-where
-    D: serde::Deserializer<'de>,
-{
-    serde::Deserialize::deserialize(de).map(Some)
-}
-
-#[derive(Deserialize)]
-pub struct UpdateShare {
-    allow_download: Option<bool>,
-    #[serde(default, deserialize_with = "double_option")]
-    expires_at: Option<Option<DateTime<Utc>>>,
-}
-
-pub async fn update(
-    State(state): State<AppState>,
-    Path(share_id): Path<Uuid>,
-    Json(body): Json<UpdateShare>,
-) -> ApiResult<Json<serde_json::Value>> {
-    let updated = sqlx::query(
-        "update shares set
-             allow_download = coalesce($2, allow_download),
-             expires_at = case when $3 then $4 else expires_at end
-         where id = $1",
-    )
-    .bind(share_id)
-    .bind(body.allow_download)
-    .bind(body.expires_at.is_some())
-    .bind(body.expires_at.flatten())
-    .execute(&state.db)
-    .await?;
-    if updated.rows_affected() == 0 {
-        return Err(ApiError::not_found());
-    }
-    let row: ShareAdminRow = sqlx::query_as(&format!("{SHARE_SELECT} where s.id = $1"))
-        .bind(share_id)
-        .fetch_one(&state.db)
-        .await?;
+    let row: ShareAdminRow =
+        sqlx::query_as(&format!("select {SHARE_COLUMNS} from shares s where s.id = $1"))
+            .bind(share_id)
+            .fetch_one(&state.db)
+            .await?;
     Ok(Json(share_json(&state, &row)))
 }
 

src/routes/zip.rs

@@ -136,9 +136,6 @@ struct Entry {
     offset: u64,
     dos_time: u16,
     dos_date: u16,
-    /// Stored at upload/processing time; photos from before hashes existed
-    /// have None and take the slower spool path (which backfills it).
-    crc: Option<u32>,
 }
 
 struct ZipPlan {
@@ -179,7 +176,6 @@ fn plan_zip(photos: &[Photo]) -> Result<ZipPlan, ApiError> {
             offset: entry_offset,
             dos_time,
             dos_date,
-            crc: photo.crc32.map(|v| v as u32),
         });
     }
     let cd_offset = offset;
@@ -281,23 +277,9 @@ fn stream_zip(state: AppState, photos: Vec<Photo>, album_name: &str) -> ApiResul
         .map_err(|e| anyhow::anyhow!("building response: {e}").into())
 }
 
-enum Fetched {
-    /// CRC already known — the body streams straight into the response.
-    Direct(Box<aws_sdk_s3::operation::get_object::GetObjectOutput>),
-    /// Pre-hash photo: spooled to a temp file to compute the CRC first.
-    Spooled(tokio::fs::File, u32),
-}
-
-/// Start fetching an original. With a known CRC this only opens the S3
-/// response (the body is consumed later, straight into the zip stream);
-/// otherwise the object is spooled to an anonymous temp file to compute the
-/// CRC, verifying the byte count the zip plan promised.
-fn fetch_entry(
-    state: &AppState,
-    key: String,
-    expected_size: u64,
-    crc_known: bool,
-) -> JoinHandle<anyhow::Result<Fetched>> {
+/// Download an original into an anonymous temp file, computing its CRC-32 and
+/// verifying the byte count matches what the zip plan promised.
+fn spool(state: &AppState, key: String, expected_size: u64) -> JoinHandle<anyhow::Result<(tokio::fs::File, u32)>> {
     let state = state.clone();
     tokio::spawn(async move {
         let object = state
@@ -308,9 +290,6 @@ fn fetch_entry(
             .send()
             .await
             .map_err(|e| anyhow::anyhow!("fetching {key}: {e}"))?;
-        if crc_known {
-            return Ok(Fetched::Direct(Box::new(object)));
-        }
         let mut file = tokio::fs::File::from_std(tempfile::tempfile()?);
         let mut reader = object.body.into_async_read();
         let mut hasher = crc32fast::Hasher::new();
@@ -331,7 +310,7 @@ fn fetch_entry(
         );
         file.flush().await?;
         file.seek(std::io::SeekFrom::Start(0)).await?;
-        Ok(Fetched::Spooled(file, hasher.finalize()))
+        Ok((file, hasher.finalize()))
     })
 }
 
@@ -344,29 +323,20 @@ async fn write_zip(
     const FLAGS: u16 = 0x0800;
     let mut crcs = Vec::with_capacity(plan.entries.len());
 
-    // Prefetch: start fetching the next object while streaming the current one.
-    let mut pending: Option<JoinHandle<anyhow::Result<Fetched>>> = None;
+    // Prefetch: spool the next object from S3 while streaming the current one.
+    let mut pending: Option<JoinHandle<anyhow::Result<(tokio::fs::File, u32)>>> = None;
     for (i, entry) in plan.entries.iter().enumerate() {
         let current = match pending.take() {
             Some(handle) => handle,
-            None => fetch_entry(state, entry.s3_key.clone(), entry.size, entry.crc.is_some()),
+            None => spool(state, entry.s3_key.clone(), entry.size),
         };
         if let Some(next) = plan.entries.get(i + 1) {
-            pending = Some(fetch_entry(
-                state,
-                next.s3_key.clone(),
-                next.size,
-                next.crc.is_some(),
-            ));
+            pending = Some(spool(state, next.s3_key.clone(), next.size));
         }
-        let fetched = current
+        let (mut file, crc) = current
             .await
-            .map_err(|e| anyhow::anyhow!("fetch task failed: {e}"))?
+            .map_err(|e| anyhow::anyhow!("spool task failed: {e}"))?
             .map_err(|e| anyhow::anyhow!("photo {}: {e:#}", entry.photo_id))?;
-        let crc = match &fetched {
-            Fetched::Direct(_) => entry.crc.expect("direct fetch implies known crc"),
-            Fetched::Spooled(_, crc) => *crc,
-        };
         crcs.push(crc);
 
         let mut lfh = Vec::with_capacity(30 + entry.name.len());
@@ -383,28 +353,7 @@ async fn write_zip(
         lfh.extend_from_slice(&0u16.to_le_bytes()); // extra len
         lfh.extend_from_slice(&entry.name);
         out.write_all(&lfh).await?;
-        match fetched {
-            Fetched::Direct(object) => {
-                let mut reader = object.body.into_async_read();
-                let copied = tokio::io::copy(&mut reader, &mut out).await?;
-                anyhow::ensure!(
-                    copied == entry.size,
-                    "{} is {copied} bytes in s3 but {} in the database",
-                    entry.s3_key,
-                    entry.size
-                );
-            }
-            Fetched::Spooled(mut file, crc) => {
-                tokio::io::copy(&mut file, &mut out).await?;
-                // Self-heal: store the freshly computed crc so the next
-                // download of this photo streams directly.
-                let _ = sqlx::query("update photos set crc32 = coalesce(crc32, $2) where id = $1")
-                    .bind(entry.photo_id)
-                    .bind(i64::from(crc))
-                    .execute(&state.db)
-                    .await;
-            }
-        }
+        tokio::io::copy(&mut file, &mut out).await?;
     }
 
     // Central directory.