v0.5.0

apps/backend/src/runs/dto/update-run.dto.ts

@@ -1,5 +1,5 @@
 // apps/backend/src/runs/dto/update-run.dto.ts
-import { IsString, IsOptional, IsNumber } from 'class-validator';
+import { IsString, IsOptional, IsNumber, IsInt, Min } from 'class-validator';
 
 export class UpdateRunDto {
   @IsOptional()
@@ -13,4 +13,14 @@ export class UpdateRunDto {
   @IsOptional()
   @IsString()
   location?: string;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  lower_bound_idx?: number;
+
+  @IsOptional()
+  @IsInt()
+  @Min(0)
+  upper_bound_idx?: number;
 }

apps/backend/src/runs/runs.service.spec.ts

@@ -1,4 +1,4 @@
-import { BadRequestException } from '@nestjs/common';
+import { BadRequestException, ConflictException } from '@nestjs/common';
 import { RunsService } from './runs.service';
 
 describe('RunsService', () => {
@@ -84,11 +84,11 @@ describe('RunsService', () => {
     expect(res2).toBeNull();
   });
 
-  it('createRun throws when run with srcPath exists', async () => {
+  it('createRun throws ConflictException when run with srcPath exists', async () => {
     const data = { srcPath: 'x', length: 10 } as any;
     jest.spyOn(service, 'findBySrcPath').mockResolvedValue({ id: 1 } as any);
 
-    await expect(service.createRun(data)).rejects.toThrow('Run with this srcPath already exists');
+    await expect(service.createRun(data)).rejects.toBeInstanceOf(ConflictException);
   });
 
   it('createRun inserts and returns created row', async () => {
@@ -104,6 +104,21 @@ describe('RunsService', () => {
     expect(res).toEqual(inserted);
   });
 
+  it('createRun defaults bounds to full run range when omitted', async () => {
+    const data = { srcPath: 'bounds-default', length: 10 } as any;
+    jest.spyOn(service, 'findBySrcPath').mockResolvedValue(null);
+    mockDb.insert().values().returning.mockResolvedValue([{ id: 7, ...data }]);
+
+    await service.createRun(data);
+
+    expect(mockDb.insert().values).toHaveBeenCalledWith(
+      expect.objectContaining({
+        lower_bound_idx: 0,
+        upper_bound_idx: 9,
+      }),
+    );
+  });
+
   it('updateRun throws BadRequestException when updates empty', async () => {
     await expect(service.updateRun(1, {} as any)).rejects.toBeInstanceOf(BadRequestException);
   });
@@ -117,6 +132,38 @@ describe('RunsService', () => {
     expect(res).toEqual(updated);
   });
 
+  it('updateRun rejects invalid trim bounds', async () => {
+    mockDb.query.runs.findFirst.mockResolvedValue({
+      id: 1,
+      length: 10,
+      lower_bound_idx: 0,
+      upper_bound_idx: 9,
+    });
+
+    await expect(
+      service.updateRun(1, { lower_bound_idx: 8, upper_bound_idx: 4 } as any),
+    ).rejects.toBeInstanceOf(BadRequestException);
+  });
+
+  it('updateRun allows valid trim bounds', async () => {
+    mockDb.query.runs.findFirst.mockResolvedValue({
+      id: 1,
+      length: 10,
+      lower_bound_idx: 0,
+      upper_bound_idx: 9,
+    });
+    mockDb.update().set().where().returning.mockResolvedValue([
+      { id: 1, lower_bound_idx: 2, upper_bound_idx: 8 },
+    ]);
+
+    const res = await service.updateRun(1, {
+      lower_bound_idx: 2,
+      upper_bound_idx: 8,
+    } as any);
+
+    expect(res).toEqual({ id: 1, lower_bound_idx: 2, upper_bound_idx: 8 });
+  });
+
   it('updateRun returns null when no rows updated', async () => {
     mockDb.update().set().where().returning.mockResolvedValue([]);
 

apps/backend/src/runs/runs.service.ts

@@ -1,4 +1,4 @@
-import { Injectable, Inject, BadRequestException } from "@nestjs/common";
+import { Injectable, Inject, BadRequestException, ConflictException } from "@nestjs/common";
 import { eq } from "drizzle-orm";
 import { DATABASE_CONNECTION } from "../database/database.module";
 import { runs } from "@repo/database";
@@ -39,19 +39,26 @@ export class RunsService {
     date?: Date;
     location?: string;
     profile?: number;
+    lower_bound_idx?: number;
+    upper_bound_idx?: number;
     front_freq?: number;
     rear_freq?: number;
   }) {
     // enforce uniqueness at service level to avoid duplicate runs
     const existing = await this.findBySrcPath(data.srcPath);
     if (existing) {
-      throw new Error("Run with this srcPath already exists");
+      throw new ConflictException("Run with this srcPath already exists");
     }
 
+    const resolvedLowerBound = data.lower_bound_idx ?? 0;
+    const resolvedUpperBound = data.upper_bound_idx ?? Math.max(data.length - 1, 0);
+
     const inserted = await this.db
       .insert(runs)
       .values({
         ...data,
+        lower_bound_idx: resolvedLowerBound,
+        upper_bound_idx: resolvedUpperBound,
         date: data.date ?? new Date(), // default to now if not provided
       })
       .returning();
@@ -60,11 +67,58 @@ export class RunsService {
   }
 
   // Partial update for a run (e.g., update comments)
-  async updateRun(id: number, updates: Partial<{ comments: string; length: number; location: string }>) {
+  async updateRun(
+    id: number,
+    updates: Partial<{
+      comments: string;
+      length: number;
+      location: string;
+      lower_bound_idx: number;
+      upper_bound_idx: number;
+    }>,
+  ) {
     if (Object.keys(updates).length === 0) {
       throw new BadRequestException("No updates provided for the run.");
     }
 
+    const hasBoundsUpdate =
+      updates.lower_bound_idx !== undefined ||
+      updates.upper_bound_idx !== undefined ||
+      updates.length !== undefined;
+
+    if (hasBoundsUpdate) {
+      const currentRun = await this.getRunById(id);
+      if (!currentRun) {
+        return null;
+      }
+
+      const effectiveLength = updates.length ?? currentRun.length;
+      const effectiveLowerBound =
+        updates.lower_bound_idx ?? currentRun.lower_bound_idx ?? 0;
+      const effectiveUpperBound =
+        updates.upper_bound_idx ?? currentRun.upper_bound_idx ?? Math.max(effectiveLength - 1, 0);
+
+      if (!Number.isInteger(effectiveLowerBound) || !Number.isInteger(effectiveUpperBound)) {
+        throw new BadRequestException("Trim bounds must be integers.");
+      }
+
+      if (effectiveLength <= 0) {
+        throw new BadRequestException("Run length must be greater than zero.");
+      }
+
+      if (effectiveLowerBound < 0) {
+        throw new BadRequestException("lower_bound_idx must be greater than or equal to zero.");
+      }
+
+      if (effectiveUpperBound < effectiveLowerBound) {
+        throw new BadRequestException("upper_bound_idx must be greater than or equal to lower_bound_idx.");
+      }
+
+      if (effectiveUpperBound >= effectiveLength) {
+        throw new BadRequestException("upper_bound_idx must be less than run length.");
+      }
+    }
+
     const updated = await this.db
       .update(runs)
       .set(updates)

apps/frontend/app/api/runs.ts

@@ -1,6 +1,14 @@
 import { apiClient } from "./client";
 import { Run } from "@repo/database";
 
+export interface RunUpdatePayload {
+  comments?: string;
+  length?: number;
+  location?: string;
+  lower_bound_idx?: number;
+  upper_bound_idx?: number;
+}
+
 export function getRuns() {
   return apiClient.get<Run[]>("/runs");
 }
@@ -9,6 +17,6 @@ export function getRunById(id: number) {
   return apiClient.get<Run>(`/runs/${id}`);
 }
 
-export function updateRun(id: number, payload: Partial<Pick<Run, 'comments' | 'length' | 'location'>>) {
+export function updateRun(id: number, payload: RunUpdatePayload) {
     return apiClient.patch(`/runs/${id}`, payload);
 } 

apps/frontend/app/components/graphs/base/Histogram.tsx

@@ -1,6 +1,5 @@
 import React, { useEffect, useMemo, useRef, useState } from 'react';
 import * as d3 from 'd3';
-import { html } from 'd3';
 import { getSeriesColor } from '../../../lib/graphColors';
 
 export interface HistogramBin {
@@ -53,8 +52,8 @@ export const Histogram: React.FC<HistogramProps> = ({
   }, []);
 
   // Main D3 rendering
-  const finalSeries: HistogramSeries[] = useMemo(
-    () =>
+  const finalSeries: HistogramSeries[] = useMemo(() =>
+      // If series prop provided map each series item
       series && series.length > 0
         ? series
             .filter((s) => Array.isArray(s.data))
@@ -68,14 +67,17 @@ export const Histogram: React.FC<HistogramProps> = ({
   );
 
   useEffect(() => {
+    // Missing container guard
     if (!containerRef.current || width === 0) return;
 
+    // Mising data guard
     const hasData = finalSeries.some((s) => s.data.length > 0);
     if (!hasData) {
       d3.select(containerRef.current).selectAll("svg").remove();
       return;
     }
 
+    // Dimensions
     const margin = { top: 20, right: 20, bottom: 40, left: 50 };
     const innerWidth = width - margin.left - margin.right;
     const innerHeight = height - margin.top - margin.bottom;
@@ -89,15 +91,13 @@ export const Histogram: React.FC<HistogramProps> = ({
       .thresholds(binCount);
     const binsBySeries = finalSeries.map((s) => binGenerator(s.data));
 
-    if (binsBySeries.length === 0 || binsBySeries[0]?.length === 0) return;
-
     const firstSeriesBins = binsBySeries[0];
     if (!firstSeriesBins) return;
     const firstBin = firstSeriesBins[0];
     const lastBin = firstSeriesBins[firstSeriesBins.length - 1];
     if (!firstBin || !lastBin || firstBin.x0 == null || lastBin.x1 == null) return;
 
-    // Build scales for bars and axes
+    // Scales
     const x = d3
       .scaleLinear()
       .domain([firstBin.x0, lastBin.x1])
@@ -116,6 +116,7 @@ export const Histogram: React.FC<HistogramProps> = ({
       .domain([0, yMax])
       .range([innerHeight, 0]);
 
+    // SVG setup
     const svg = d3
       .select(containerRef.current)
       .selectAll<SVGSVGElement, null>("svg")
@@ -147,6 +148,7 @@ export const Histogram: React.FC<HistogramProps> = ({
       label: string;
     };
 
+    // Prepare data for rendering
     const seriesCount = Math.max(1, finalSeries.length);
     const bars: RenderBar[] = binsBySeries.flatMap((seriesBins, seriesIndex) => {
       const seriesConfig = finalSeries[seriesIndex];