Remove recordings feature, replay sessions directly, bump to 0.6.0

Recordings were just a thin named pointer over an already-captured
session's events, so the whole separate feature (recordings table, API
routes, pages, UI) is gone: any completed session can now be named and
replayed directly. Replaying no longer creates a session or duplicates
events of its own - it just bumps the source session's playCount/lastPlayedAt.

Also renames play_sessions/playSession(s) to sessions/session(s) throughout
the schema, queries, API routes, and UI for consistency, and updates the
README to match the new flow.

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

app/(app)/page.tsx

@@ -2,8 +2,7 @@ import Link from "next/link";
 import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { BrandMark } from "@/components/layout/BrandMark";
-import { listRecordings } from "@/lib/db/queries/recordings";
-import { listPlaySessions } from "@/lib/db/queries/play-sessions";
+import { listSessions } from "@/lib/db/queries/sessions";
 import { getSessionsSummary } from "@/lib/db/queries/stats";
 
 // Always reflects live DB state for an authenticated, single-tenant app -
@@ -11,13 +10,8 @@ import { getSessionsSummary } from "@/lib/db/queries/stats";
 export const dynamic = "force-dynamic";
 
 export default async function DashboardPage() {
-  const [recordings, sessions, summary] = await Promise.all([
-    listRecordings(),
-    listPlaySessions(),
-    getSessionsSummary(),
-  ]);
+  const [sessions, summary] = await Promise.all([listSessions(), getSessionsSummary()]);
 
-  const recentRecordings = recordings.slice(0, 5);
   const recentSessions = [...sessions].reverse().slice(0, 5);
 
   return (
@@ -27,7 +21,7 @@ export default async function DashboardPage() {
           <BrandMark size={48} animated className="rounded-[9px]" />
           <h1 className="font-heading text-3xl font-semibold">Welcome back</h1>
           <p className="max-w-xl text-sm text-muted-foreground">
-            Scan for nearby devices, take control, and record sessions to replay later - all running
+            Scan for nearby devices, take control, and replay completed sessions later - all running
             directly from your browser over Web Bluetooth.
           </p>
           <Button asChild size="lg">
@@ -53,53 +47,31 @@ export default async function DashboardPage() {
         </Card>
         <Card className="bp-glass">
           <CardHeader>
-            <CardTitle className="text-sm text-muted-foreground">Saved recordings</CardTitle>
+            <CardTitle className="text-sm text-muted-foreground">Replays</CardTitle>
           </CardHeader>
-          <CardContent className="bp-readout text-3xl">{recordings.length}</CardContent>
+          <CardContent className="bp-readout text-3xl">{summary.totalReplays}</CardContent>
         </Card>
       </div>
 
-      <div className="grid gap-6 lg:grid-cols-2">
-        <Card className="bp-glass">
-          <CardHeader>
-            <CardTitle>Recent recordings</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col">
-            {recentRecordings.length === 0 && (
-              <p className="text-sm text-muted-foreground">Nothing saved yet.</p>
-            )}
-            {recentRecordings.map((r, i) => (
-              <Link key={r.id} href={`/recordings/${r.id}`} className="group">
-                {i > 0 && <div className="bp-hairline" />}
-                <div className="flex items-center justify-between px-1 py-2 text-sm">
-                  <span className="group-hover:text-primary">{r.name}</span>
-                  <span className="bp-readout text-xs text-muted-foreground">{r.playCount} plays</span>
-                </div>
-              </Link>
-            ))}
-          </CardContent>
-        </Card>
-
-        <Card className="bp-glass">
-          <CardHeader>
-            <CardTitle>Recent sessions</CardTitle>
-          </CardHeader>
-          <CardContent className="flex flex-col">
-            {recentSessions.length === 0 && <p className="text-sm text-muted-foreground">No sessions yet.</p>}
-            {recentSessions.map((s, i) => (
-              <Link key={s.id} href={`/sessions/${s.id}`} className="group">
-                {i > 0 && <div className="bp-hairline" />}
-                <div className="flex items-center justify-between px-1 py-2 text-sm">
-                  <span className="group-hover:text-primary">{s.name ?? `Session #${s.id}`}</span>
-                  <span className="bp-readout text-xs text-muted-foreground">
-                    {new Date(s.startedAt).toLocaleDateString()}
-                  </span>
-                </div>
-              </Link>
-            ))}
-          </CardContent>
-        </Card>
-      </div>
+      <Card className="bp-glass">
+        <CardHeader>
+          <CardTitle>Recent sessions</CardTitle>
+        </CardHeader>
+        <CardContent className="flex flex-col">
+          {recentSessions.length === 0 && <p className="text-sm text-muted-foreground">No sessions yet.</p>}
+          {recentSessions.map((s, i) => (
+            <Link key={s.id} href={`/sessions/${s.id}`} className="group">
+              {i > 0 && <div className="bp-hairline" />}
+              <div className="flex items-center justify-between px-1 py-2 text-sm">
+                <span className="group-hover:text-primary">{s.name ?? `Session #${s.id}`}</span>
+                <span className="bp-readout text-xs text-muted-foreground">
+                  {new Date(s.startedAt).toLocaleDateString()}
+                </span>
+              </div>
+            </Link>
+          ))}
+        </CardContent>
+      </Card>
     </div>
   );
 }

app/(app)/recordings/[id]/page.tsx

@@ -1,81 +0,0 @@
-import Link from "next/link";
-import { notFound } from "next/navigation";
-import type { Metadata } from "next";
-import { Button } from "@/components/ui/button";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { getRecording, getRecordingName } from "@/lib/db/queries/recordings";
-import { Play } from "lucide-react";
-
-export const dynamic = "force-dynamic";
-
-export async function generateMetadata({ params }: { params: Promise<{ id: string }> }): Promise<Metadata> {
-  const { id } = await params;
-  const name = await getRecordingName(Number(id));
-  return { title: name ?? "Recording" };
-}
-
-function formatDuration(ms: number): string {
-  const totalSeconds = Math.round(ms / 1000);
-  return `${Math.floor(totalSeconds / 60)}:${(totalSeconds % 60).toString().padStart(2, "0")}`;
-}
-
-export default async function RecordingDetailPage({ params }: { params: Promise<{ id: string }> }) {
-  const { id } = await params;
-  const result = await getRecording(Number(id));
-  if (!result) notFound();
-
-  const { recording } = result;
-
-  return (
-    <div className="flex flex-col gap-6">
-      <div className="flex items-center justify-between">
-        <div>
-          <h1 className="font-heading text-2xl font-semibold">{recording.name}</h1>
-          {recording.description && <p className="text-sm text-muted-foreground">{recording.description}</p>}
-        </div>
-        <Button asChild>
-          <Link href={`/recordings/${recording.id}/replay`}>
-            <Play className="size-4" /> Replay
-          </Link>
-        </Button>
-      </div>
-
-      <Card className="bp-glass">
-        <CardHeader>
-          <CardTitle className="text-base">Details</CardTitle>
-        </CardHeader>
-        <CardContent className="grid gap-2 text-sm sm:grid-cols-2">
-          <div>
-            <span className="text-muted-foreground">Duration: </span>
-            {formatDuration(recording.durationMs)}
-          </div>
-          <div>
-            <span className="text-muted-foreground">Plays: </span>
-            {recording.playCount}
-          </div>
-          <div>
-            <span className="text-muted-foreground">Created: </span>
-            {new Date(recording.createdAt).toLocaleString()}
-          </div>
-          <div>
-            <span className="text-muted-foreground">Last played: </span>
-            {recording.lastPlayedAt ? new Date(recording.lastPlayedAt).toLocaleString() : "Never"}
-          </div>
-        </CardContent>
-      </Card>
-
-      <Card className="bp-glass">
-        <CardHeader>
-          <CardTitle className="text-base">Devices in this recording</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-1">
-          {recording.deviceSlots.map((slot) => (
-            <div key={slot.sourceSessionDeviceId} className="text-sm">
-              {slot.slotLabel} <span className="text-muted-foreground">({slot.recordedBleName})</span>
-            </div>
-          ))}
-        </CardContent>
-      </Card>
-    </div>
-  );
-}

app/(app)/recordings/page.tsx

@@ -1,36 +0,0 @@
-import type { Metadata } from "next";
-import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
-import { RecordingsTable } from "@/components/recordings/RecordingsTable";
-import { PageNav } from "@/components/shared/PageNav";
-import { listRecordingsPage } from "@/lib/db/queries/recordings";
-import { parsePage } from "@/lib/pagination";
-
-export const dynamic = "force-dynamic";
-export const metadata: Metadata = { title: "Recordings" };
-
-export default async function RecordingsPage({
-  searchParams,
-}: {
-  searchParams: Promise<{ page?: string }>;
-}) {
-  const page = parsePage((await searchParams).page);
-  const { items: recordings, pageSize, total } = await listRecordingsPage(page);
-
-  return (
-    <div className="flex flex-col gap-6">
-      <div>
-        <h1 className="font-heading text-2xl font-semibold">Recordings</h1>
-        <p className="text-sm text-muted-foreground">Saved sessions you can replay against connected devices.</p>
-      </div>
-      <Card className="bp-glass">
-        <CardHeader>
-          <CardTitle className="text-base">Library</CardTitle>
-        </CardHeader>
-        <CardContent className="flex flex-col gap-3">
-          <RecordingsTable recordings={recordings} />
-          <PageNav basePath="/recordings" page={page} pageSize={pageSize} total={total} />
-        </CardContent>
-      </Card>
-    </div>
-  );
-}

app/(app)/sessions/[id]/page.tsx

@@ -1,15 +1,18 @@
+import Link from "next/link";
 import { notFound } from "next/navigation";
 import type { Metadata } from "next";
+import { Button } from "@/components/ui/button";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { SessionTimelineChart } from "@/components/sessions/SessionTimelineChart";
-import { getPlaySessionDetail, getPlaySessionName } from "@/lib/db/queries/play-sessions";
+import { getSessionDetail, getSessionName } from "@/lib/db/queries/sessions";
 import { getSessionTimeline } from "@/lib/db/queries/stats";
+import { Play } from "lucide-react";
 
 export const dynamic = "force-dynamic";
 
 export async function generateMetadata({ params }: { params: Promise<{ id: string }> }): Promise<Metadata> {
   const { id } = await params;
-  const name = await getPlaySessionName(Number(id));
+  const name = await getSessionName(Number(id));
   return { title: name ?? `Session #${id}` };
 }
 
@@ -22,16 +25,40 @@ function formatDuration(ms: number | null): string {
 export default async function SessionDetailPage({ params }: { params: Promise<{ id: string }> }) {
   const { id } = await params;
   const sessionId = Number(id);
-  const [detail, timeline] = await Promise.all([getPlaySessionDetail(sessionId), getSessionTimeline(sessionId)]);
+  const [detail, timeline] = await Promise.all([getSessionDetail(sessionId), getSessionTimeline(sessionId)]);
   if (!detail) notFound();
 
+  const canReplay = detail.session.status === "completed" && detail.session.durationMs !== null;
+
   return (
     <div className="flex flex-col gap-6">
-      <div>
-        <h1 className="font-heading text-2xl font-semibold">{detail.session.name ?? `Session #${detail.session.id}`}</h1>
-        <p className="text-sm text-muted-foreground">
-          {detail.session.kind} · {detail.session.status} · {formatDuration(detail.session.durationMs)}
-        </p>
+      <div className="flex items-center justify-between gap-4">
+        <div>
+          <h1 className="font-heading text-2xl font-semibold">{detail.session.name ?? `Session #${detail.session.id}`}</h1>
+          <p className="text-sm text-muted-foreground">
+            {detail.session.status} · {formatDuration(detail.session.durationMs)}
+            {detail.session.kind === "replay" && detail.replayedFromName !== undefined && (
+              <> · replayed from {detail.replayedFromName ?? `session #${detail.session.replayedSessionId}`}</>
+            )}
+            {detail.session.playCount > 0 && (
+              <>
+                {" "}
+                · replayed {detail.session.playCount}×
+                {detail.session.lastPlayedAt && ` (last ${new Date(detail.session.lastPlayedAt).toLocaleString()})`}
+              </>
+            )}
+          </p>
+          {detail.session.description && (
+            <p className="mt-1 text-sm text-muted-foreground">{detail.session.description}</p>
+          )}
+        </div>
+        {canReplay && (
+          <Button asChild>
+            <Link href={`/sessions/${detail.session.id}/replay`}>
+              <Play className="size-4" /> Replay
+            </Link>
+          </Button>
+        )}
       </div>
 
       <Card className="bp-glass">

app/(app)/sessions/[id]/replay/page.tsx

@@ -1,10 +1,10 @@
 import type { Metadata } from "next";
-import { ReplayPlayerLoader } from "@/components/recordings/ReplayPlayerLoader";
-import { getRecordingName } from "@/lib/db/queries/recordings";
+import { ReplayPlayerLoader } from "@/components/sessions/ReplayPlayerLoader";
+import { getSessionName } from "@/lib/db/queries/sessions";
 
 export async function generateMetadata({ params }: { params: Promise<{ id: string }> }): Promise<Metadata> {
   const { id } = await params;
-  const name = await getRecordingName(Number(id));
+  const name = await getSessionName(Number(id));
   return { title: name ? `Replay ${name}` : "Replay" };
 }
 
@@ -13,7 +13,7 @@ export default async function ReplayPage({ params }: { params: Promise<{ id: str
   return (
     <div className="flex flex-col gap-6">
       <h1 className="font-heading text-2xl font-semibold">Replay</h1>
-      <ReplayPlayerLoader recordingId={Number(id)} />
+      <ReplayPlayerLoader sessionId={Number(id)} />
     </div>
   );
 }

app/(app)/sessions/page.tsx

@@ -2,7 +2,7 @@ import type { Metadata } from "next";
 import { Card, CardContent, CardHeader, CardTitle } from "@/components/ui/card";
 import { SessionsTable } from "@/components/sessions/SessionsTable";
 import { PageNav } from "@/components/shared/PageNav";
-import { listPlaySessionsPage } from "@/lib/db/queries/play-sessions";
+import { listSessionsPage } from "@/lib/db/queries/sessions";
 import { parsePage } from "@/lib/pagination";
 
 export const dynamic = "force-dynamic";
@@ -14,7 +14,7 @@ export default async function SessionsPage({
   searchParams: Promise<{ page?: string }>;
 }) {
   const page = parsePage((await searchParams).page);
-  const { items: sessions, pageSize, total } = await listPlaySessionsPage(page);
+  const { items: sessions, pageSize, total } = await listSessionsPage(page);
 
   return (
     <div className="flex flex-col gap-6">

app/(app)/stats/page.tsx

@@ -2,18 +2,16 @@ import type { Metadata } from "next";
 import { Tabs, TabsContent, TabsList, TabsTrigger } from "@/components/ui/tabs";
 import { SessionsSummaryCards } from "@/components/stats/SessionsSummaryCards";
 import { DeviceUsageTable } from "@/components/stats/DeviceUsageTable";
-import { RecordingLibraryStats } from "@/components/stats/RecordingLibraryStats";
-import { getDeviceCommandCounts, getDeviceUsageStats, getRecordingLibraryStats, getSessionsSummary } from "@/lib/db/queries/stats";
+import { getDeviceCommandCounts, getDeviceUsageStats, getSessionsSummary } from "@/lib/db/queries/stats";
 
 export const dynamic = "force-dynamic";
 export const metadata: Metadata = { title: "Stats" };
 
 export default async function StatsPage() {
-  const [sessionsSummary, deviceUsage, commandCounts, recordingStats] = await Promise.all([
+  const [sessionsSummary, deviceUsage, commandCounts] = await Promise.all([
     getSessionsSummary(),
     getDeviceUsageStats(),
     getDeviceCommandCounts(),
-    getRecordingLibraryStats(),
   ]);
 
   const commandCountByDevice = new Map(commandCounts.map((c) => [c.deviceId, c.commandCount]));
@@ -23,14 +21,13 @@ export default async function StatsPage() {
     <div className="flex flex-col gap-6">
       <div>
         <h1 className="font-heading text-2xl font-semibold">Stats</h1>
-        <p className="text-sm text-muted-foreground">Usage across sessions, devices, and your recording library.</p>
+        <p className="text-sm text-muted-foreground">Usage across sessions and devices.</p>
       </div>
 
       <Tabs defaultValue="sessions">
         <TabsList className="bp-glass">
           <TabsTrigger value="sessions">Sessions</TabsTrigger>
           <TabsTrigger value="devices">Devices</TabsTrigger>
-          <TabsTrigger value="recordings">Recordings</TabsTrigger>
         </TabsList>
         <TabsContent value="sessions" className="pt-4">
           <SessionsSummaryCards summary={sessionsSummary} />
@@ -38,9 +35,6 @@ export default async function StatsPage() {
         <TabsContent value="devices" className="pt-4">
           <DeviceUsageTable devices={devices} />
         </TabsContent>
-        <TabsContent value="recordings" className="pt-4">
-          <RecordingLibraryStats stats={recordingStats} />
-        </TabsContent>
       </Tabs>
     </div>
   );

app/api/play-sessions/[id]/route.ts

@@ -1,56 +0,0 @@
-import { NextResponse } from "next/server";
-import { z } from "zod";
-import { deletePlaySession, endPlaySession, getPlaySessionDetail } from "@/lib/db/queries/play-sessions";
-import { getRecordingsForSession } from "@/lib/db/queries/recordings";
-import { withRouteLogging } from "@/lib/api/with-route-logging";
-import { createLogger } from "@/lib/logger";
-
-const log = createLogger("play-sessions");
-const patchSchema = z.object({ status: z.enum(["completed", "aborted"]) });
-
-export const GET = withRouteLogging(
-  "play-sessions.get",
-  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    const detail = await getPlaySessionDetail(Number(id));
-    if (!detail) return NextResponse.json({ error: "not found" }, { status: 404 });
-    return NextResponse.json(detail);
-  },
-);
-
-export const PATCH = withRouteLogging(
-  "play-sessions.end",
-  async (req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    const parsed = patchSchema.safeParse(await req.json().catch(() => null));
-    if (!parsed.success) {
-      return NextResponse.json({ error: "status must be completed or aborted" }, { status: 400 });
-    }
-    const updated = await endPlaySession(Number(id), parsed.data);
-    if (!updated) return NextResponse.json({ error: "not found" }, { status: 404 });
-    return NextResponse.json({ playSession: updated });
-  },
-);
-
-export const DELETE = withRouteLogging(
-  "play-sessions.delete",
-  async (req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    const cascade = new URL(req.url).searchParams.get("cascade") === "true";
-    try {
-      await deletePlaySession(Number(id), { cascade });
-      return NextResponse.json({ ok: true });
-    } catch (err) {
-      const message = err instanceof Error ? err.message : String(err);
-      if (message.includes("FOREIGN KEY") || message.includes("SQLITE_CONSTRAINT")) {
-        log.warn("blocked session delete due to referencing recording", { sessionId: id, cascade });
-        const blockingRecordings = await getRecordingsForSession(Number(id));
-        return NextResponse.json(
-          { error: "cannot delete a session that a saved recording still references", recordings: blockingRecordings },
-          { status: 409 },
-        );
-      }
-      throw err;
-    }
-  },
-);

app/api/recordings/[id]/route.ts

@@ -1,42 +0,0 @@
-import { NextResponse } from "next/server";
-import { z } from "zod";
-import { deleteRecording, getRecording, renameRecording } from "@/lib/db/queries/recordings";
-import { withRouteLogging } from "@/lib/api/with-route-logging";
-
-const patchSchema = z.object({
-  name: z.string().min(1).max(160).optional(),
-  description: z.string().max(2000).optional(),
-});
-
-export const GET = withRouteLogging(
-  "recordings.get",
-  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    const result = await getRecording(Number(id));
-    if (!result) return NextResponse.json({ error: "not found" }, { status: 404 });
-    return NextResponse.json(result);
-  },
-);
-
-export const PATCH = withRouteLogging(
-  "recordings.update",
-  async (req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    const parsed = patchSchema.safeParse(await req.json().catch(() => null));
-    if (!parsed.success) {
-      return NextResponse.json({ error: "invalid body" }, { status: 400 });
-    }
-    const updated = await renameRecording(Number(id), parsed.data);
-    if (!updated) return NextResponse.json({ error: "not found" }, { status: 404 });
-    return NextResponse.json({ recording: updated });
-  },
-);
-
-export const DELETE = withRouteLogging(
-  "recordings.delete",
-  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
-    const { id } = await params;
-    await deleteRecording(Number(id));
-    return NextResponse.json({ ok: true });
-  },
-);

app/api/recordings/route.ts

@@ -1,24 +0,0 @@
-import { NextResponse } from "next/server";
-import { z } from "zod";
-import { createRecording, listRecordings } from "@/lib/db/queries/recordings";
-import { withRouteLogging } from "@/lib/api/with-route-logging";
-
-const bodySchema = z.object({
-  sourcePlaySessionId: z.number().int().positive(),
-  name: z.string().min(1).max(160),
-  description: z.string().max(2000).optional(),
-});
-
-export const GET = withRouteLogging("recordings.list", async () => {
-  const rows = await listRecordings();
-  return NextResponse.json({ recordings: rows });
-});
-
-export const POST = withRouteLogging("recordings.create", async (req: Request) => {
-  const parsed = bodySchema.safeParse(await req.json().catch(() => null));
-  if (!parsed.success) {
-    return NextResponse.json({ error: parsed.error.message }, { status: 400 });
-  }
-  const recording = await createRecording(parsed.data);
-  return NextResponse.json({ recording }, { status: 201 });
-});

app/api/sessions/[id]/events/route.ts

@@ -15,7 +15,7 @@ const eventSchema = z.object({
 const bodySchema = z.object({ events: z.array(eventSchema).max(2000) });
 
 export const POST = withRouteLogging(
-  "play-sessions.events.append",
+  "sessions.events.append",
   async (req: Request, { params }: { params: Promise<{ id: string }> }) => {
     const { id } = await params;
     const parsed = bodySchema.safeParse(await req.json().catch(() => null));

app/api/sessions/[id]/replay/route.ts

@@ -0,0 +1,31 @@
+import { NextResponse } from "next/server";
+import { getSessionForReplay, incrementSessionPlayCount } from "@/lib/db/queries/sessions";
+import { withRouteLogging } from "@/lib/api/with-route-logging";
+
+export const GET = withRouteLogging(
+  "sessions.replay-data",
+  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
+    const { id } = await params;
+    const result = await getSessionForReplay(Number(id));
+    if (!result) return NextResponse.json({ error: "not found" }, { status: 404 });
+    if (result.session.durationMs === null) {
+      return NextResponse.json({ error: "session has no recorded duration yet" }, { status: 409 });
+    }
+    return NextResponse.json(result);
+  },
+);
+
+/**
+ * Marks the session as replayed (bumps playCount/lastPlayedAt). Replaying
+ * itself creates no session row or events of its own - the client just
+ * plays this session's already-recorded events back against newly-mapped
+ * devices, so this is the only DB write a replay run causes.
+ */
+export const POST = withRouteLogging(
+  "sessions.replay-start",
+  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
+    const { id } = await params;
+    await incrementSessionPlayCount(Number(id), Date.now());
+    return NextResponse.json({ ok: true });
+  },
+);

app/api/sessions/[id]/route.ts

@@ -0,0 +1,56 @@
+import { NextResponse } from "next/server";
+import { z } from "zod";
+import { deleteSession, endSession, getSessionDetail, renameSession } from "@/lib/db/queries/sessions";
+import { withRouteLogging } from "@/lib/api/with-route-logging";
+
+const patchSchema = z
+  .object({
+    status: z.enum(["completed", "aborted"]).optional(),
+    name: z.string().min(1).max(160).optional(),
+    description: z.string().max(2000).optional(),
+  })
+  .refine((v) => v.status !== undefined || v.name !== undefined || v.description !== undefined, {
+    message: "at least one of status, name, description is required",
+  });
+
+export const GET = withRouteLogging(
+  "sessions.get",
+  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
+    const { id } = await params;
+    const detail = await getSessionDetail(Number(id));
+    if (!detail) return NextResponse.json({ error: "not found" }, { status: 404 });
+    return NextResponse.json(detail);
+  },
+);
+
+export const PATCH = withRouteLogging(
+  "sessions.update",
+  async (req: Request, { params }: { params: Promise<{ id: string }> }) => {
+    const { id } = await params;
+    const parsed = patchSchema.safeParse(await req.json().catch(() => null));
+    if (!parsed.success) {
+      return NextResponse.json({ error: parsed.error.message }, { status: 400 });
+    }
+    const { status, name, description } = parsed.data;
+
+    let updated;
+    if (status !== undefined) {
+      updated = await endSession(Number(id), { status });
+    }
+    if (name !== undefined || description !== undefined) {
+      updated = await renameSession(Number(id), { name, description });
+    }
+
+    if (!updated) return NextResponse.json({ error: "not found" }, { status: 404 });
+    return NextResponse.json({ session: updated });
+  },
+);
+
+export const DELETE = withRouteLogging(
+  "sessions.delete",
+  async (_req: Request, { params }: { params: Promise<{ id: string }> }) => {
+    const { id } = await params;
+    await deleteSession(Number(id));
+    return NextResponse.json({ ok: true });
+  },
+);

app/api/sessions/route.ts

@@ -1,6 +1,6 @@
 import { NextResponse } from "next/server";
 import { z } from "zod";
-import { listPlaySessions, startPlaySession } from "@/lib/db/queries/play-sessions";
+import { listSessions, startSession } from "@/lib/db/queries/sessions";
 import { withRouteLogging } from "@/lib/api/with-route-logging";
 
 const deviceInputSchema = z.object({
@@ -11,22 +11,20 @@ const deviceInputSchema = z.object({
 });
 
 const bodySchema = z.object({
-  kind: z.enum(["live", "replay"]),
-  replayedRecordingId: z.number().int().positive().optional(),
   name: z.string().min(1).optional(),
   devices: z.array(deviceInputSchema).min(1),
 });
 
-export const GET = withRouteLogging("play-sessions.list", async () => {
-  const rows = await listPlaySessions();
-  return NextResponse.json({ playSessions: rows });
+export const GET = withRouteLogging("sessions.list", async () => {
+  const rows = await listSessions();
+  return NextResponse.json({ sessions: rows });
 });
 
-export const POST = withRouteLogging("play-sessions.start", async (req: Request) => {
+export const POST = withRouteLogging("sessions.start", async (req: Request) => {
   const parsed = bodySchema.safeParse(await req.json().catch(() => null));
   if (!parsed.success) {
     return NextResponse.json({ error: parsed.error.message }, { status: 400 });
   }
-  const result = await startPlaySession(parsed.data);
+  const result = await startSession(parsed.data);
   return NextResponse.json(result, { status: 201 });
 });

app/api/stats/recordings/route.ts

@@ -1,8 +0,0 @@
-import { NextResponse } from "next/server";
-import { getRecordingLibraryStats } from "@/lib/db/queries/stats";
-import { withRouteLogging } from "@/lib/api/with-route-logging";
-
-export const GET = withRouteLogging("stats.recordings", async () => {
-  const stats = await getRecordingLibraryStats();
-  return NextResponse.json(stats);
-});