diff --git a/packages/child-lab-cli/hello.py b/packages/child-lab-cli/hello.py
deleted file mode 100644
index 8b137891..00000000
--- a/packages/child-lab-cli/hello.py
+++ /dev/null
@@ -1 +0,0 @@
-
diff --git a/packages/child-lab-cli/pyproject.toml b/packages/child-lab-cli/pyproject.toml
index 4c545b82..1508742d 100644
--- a/packages/child-lab-cli/pyproject.toml
+++ b/packages/child-lab-cli/pyproject.toml
@@ -4,4 +4,31 @@ version = "0.1.0"
 description = "Add your description here"
 readme = "README.md"
 requires-python = ">=3.12.7"
-dependencies = []
+dependencies = [
+    "click>=8.1.8",
+    "pyserde>=0.23.0",
+    "torch>=2.6.0",
+    "tqdm>=4.67.1",
+    "viser>=0.2.23",
+    "child-lab-visualization",
+    "child-lab-procedures",
+    "depth-estimation",
+    "marker-detection",
+    "transformation-buffer",
+    "video-io",
+]
+
+[tool.uv.sources]
+child-lab-procedures = { workspace = true }
+child-lab-visualization = { workspace = true }
+depth-estimation = { workspace = true }
+marker-detection = { workspace = true }
+transformation-buffer = { workspace = true }
+video-io = { workspace = true }
+
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project.scripts]
+child-lab = "child_lab_cli:child_lab"
diff --git a/packages/child-lab-cli/src/child_lab_cli/__init__.py b/packages/child-lab-cli/src/child_lab_cli/__init__.py
new file mode 100644
index 00000000..8e4b122a
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/__init__.py
@@ -0,0 +1,28 @@
+import click
+
+from .commands import (
+    calibrate_camera,
+    estimate_transformations,
+    generate_pointcloud,
+    process,
+    video,
+    visualize,
+    workspace,
+)
+
+
+@click.group('child-lab')
+def cli() -> None: ...
+
+
+cli.add_command(calibrate_camera)
+cli.add_command(estimate_transformations)
+cli.add_command(generate_pointcloud)
+cli.add_command(process)
+cli.add_command(video)
+cli.add_command(visualize)
+cli.add_command(workspace)
+
+
+def child_lab() -> None:
+    cli(max_content_width=120)
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/__init__.py b/packages/child-lab-cli/src/child_lab_cli/commands/__init__.py
new file mode 100644
index 00000000..33f10391
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/__init__.py
@@ -0,0 +1,17 @@
+from .calibrate_camera import calibrate_camera
+from .estimate_transformations import estimate_transformations
+from .generate_pointcloud import generate_pointcloud
+from .process import process
+from .video import video
+from .visualize import visualize
+from .workspace import workspace
+
+__all__ = [
+    'calibrate_camera',
+    'estimate_transformations',
+    'generate_pointcloud',
+    'process',
+    'video',
+    'visualize',
+    'workspace',
+]
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/calibrate_camera.py b/packages/child-lab-cli/src/child_lab_cli/commands/calibrate_camera.py
new file mode 100644
index 00000000..8ae551c4
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/calibrate_camera.py
@@ -0,0 +1,110 @@
+from pathlib import Path
+
+import click
+from child_lab_procedures.calibrate_camera import Configuration, Procedure, VideoIoContext
+from marker_detection.chessboard import BoardProperties, VisualizationContext
+from serde.yaml import to_yaml
+from tqdm import trange
+from video_io import Reader, Visualizer, Writer
+
+from child_lab_cli.workspace.model import Workspace
+
+
+@click.command('calibrate-camera', options_metavar='<options>')
+@click.argument('workspace-root', type=Path, metavar='<workspace>')
+@click.argument('video-name', type=str, metavar='<video>')
+@click.option(
+    '--square-size',
+    type=float,
+    required=True,
+    help='Board square size in centimeters',
+    metavar='<square-size>',
+)
+@click.option(
+    '--inner-board-corners',
+    nargs=2,
+    type=int,
+    required=True,
+    help="Number of chessboard's inner corners in rows and columns",
+    metavar='<inner-shape>',
+)
+@click.option(
+    '--max-samples',
+    type=int,
+    required=False,
+    help='Maximal number of board samples to collect',
+)
+@click.option(
+    '--max-speed',
+    type=float,
+    default=float('inf'),
+    required=False,
+    help='Maximal speed the board can move with to be captured, in pixels per second',
+)
+@click.option(
+    '--min-distance',
+    type=float,
+    default=0.3,
+    required=False,
+    help='Minimal distance between new observation and the previous observations to be captured',
+)
+def calibrate_camera(
+    workspace_root: Path,
+    video_name: str,
+    square_size: float,
+    inner_board_corners: tuple[int, int],
+    max_samples: int | None,
+    max_speed: float,
+    min_distance: float,
+) -> None:
+    """
+    Calibrate the camera using <video> from <workspace> by detecting
+    inner corners of a chessboard of <inner-shape> with <square-size>.
+    """
+
+    workspace = Workspace.in_directory(workspace_root)
+
+    video_output = workspace.output / 'calibration'
+    video_output.mkdir(exist_ok=True)
+    video_destination = (video_output / video_name).with_suffix('.mp4')
+
+    calibration_destination = (workspace.calibration / video_name).with_suffix('.yml')
+
+    video = next((v for v in workspace.videos() if v.name == video_name), None)
+    if video is None:
+        raise click.ClickException(
+            f'Input video {video_name} not found in {workspace.input}'
+        )
+
+    reader = Reader(video.location)
+    writer = Writer(
+        video_destination,
+        reader.metadata,
+        Visualizer[VisualizationContext]({'chessboard_draw_corners': True}),
+    )
+    video_io_context = VideoIoContext(video_name, reader, writer)
+
+    configuration = Configuration(
+        BoardProperties(square_size, *inner_board_corners),
+        max_samples,
+        max_speed,
+        min_distance,
+    )
+
+    procedure = Procedure(configuration, video_io_context)
+
+    progress_bar = trange(
+        procedure.length_estimate(),
+        desc='Gathering samples for calibration...',
+    )
+
+    samples = procedure.run(lambda: progress_bar.update())
+    match samples:
+        case None:
+            raise click.ClickException('Procedure has diverged')
+
+        case samples:
+            click.echo('Computing calibration...')
+            result = samples.calibrate()
+            calibration_destination.touch()
+            calibration_destination.write_text(to_yaml(result.calibration))
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/estimate_transformations.py b/packages/child-lab-cli/src/child_lab_cli/commands/estimate_transformations.py
new file mode 100644
index 00000000..4ea6f208
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/estimate_transformations.py
@@ -0,0 +1,167 @@
+from pathlib import Path
+
+import click
+from child_lab_procedures.estimate_transformations import (
+    Configuration,
+    Procedure,
+    VideoIoContext,
+)
+from marker_detection.aruco import (
+    Dictionary,
+    RigidModel,
+    VisualizationContext,
+)
+from serde.json import to_json
+from serde.yaml import from_yaml
+from tqdm import trange
+from transformation_buffer.rigid_model import Cube
+from video_io.calibration import Calibration
+from video_io.reader import Reader
+from video_io.visualizer import Visualizer
+from video_io.writer import Writer
+
+from child_lab_cli.workspace.model import Workspace
+
+
+@click.command('estimate-transformations')
+@click.argument('workspace-root', type=Path, metavar='<workspace>')
+@click.argument('video-names', type=str, nargs=-1, metavar='<videos>')
+@click.option(
+    '--marker-dictionary',
+    type=str,
+    help='Dictionary to detect markers from',
+    metavar='<dictionary>',
+)
+@click.option(
+    '--marker-size',
+    type=float,
+    help='Marker size in centimeters',
+    metavar='<size>',
+)
+@click.option(
+    '--visualize',
+    type=bool,
+    is_flag=True,
+    default=False,
+    help='Produce videos with visualizations',
+)
+@click.option(
+    '--device',
+    type=str,
+    required=False,
+    help='Torch device to use for tensor computations',
+)
+@click.option(
+    '--checkpoint',
+    type=Path,
+    required=False,
+    help='File containing a serialized transformation buffer to load and place new transformations in',
+)
+@click.option(
+    '--skip',
+    type=int,
+    required=False,
+    help='Seconds of videos to skip at the beginning',
+)
+def estimate_transformations(
+    workspace_root: Path,
+    video_names: list[str],
+    marker_dictionary: str,
+    marker_size: float,
+    visualize: bool,
+    device: str | None,
+    checkpoint: Path | None,
+    skip: int | None,
+) -> None:
+    """
+    Estimate mutual poses of cameras using <videos> from <workspace>
+    by detecting ArUco markers of <size>, from <dictionary>
+    and save them as a JSON-serialized transformation buffer.
+    """
+
+    workspace = Workspace.in_directory(workspace_root)
+
+    buffer_destination = workspace.transformation / 'buffer.json'
+
+    video_output = workspace.output / 'transformation'
+    video_output.mkdir(exist_ok=True)
+
+    video_io_contexts: list[VideoIoContext] = []
+    calibrated_videos = workspace.calibrated_videos()
+
+    for video_name in video_names:
+        video = next((v for v in calibrated_videos if v.name == video_name), None)
+
+        if video is None:
+            raise click.ClickException(
+                f'Input video {video_name} not found in {workspace.input}'
+            )
+
+        assert video.calibration.is_file()
+
+        calibration = from_yaml(Calibration, video.calibration.read_text())
+
+        reader = Reader(video.location)
+
+        writer = (
+            Writer(
+                (video_output / video.name).with_suffix('.mp4'),
+                reader.metadata,
+                Visualizer[VisualizationContext](
+                    {
+                        'intrinsics': calibration.intrinsics_matrix().numpy(),
+                        'marker_draw_masks': True,
+                        'marker_draw_ids': True,
+                        'marker_draw_axes': True,
+                        'marker_draw_angles': True,
+                        'marker_mask_color': (0.0, 1.0, 0.0, 1.0),
+                        'marker_axis_length': 100,
+                        'marker_axis_thickness': 1,
+                    }
+                ),
+            )
+            if visualize
+            else None
+        )
+
+        context = VideoIoContext(
+            video.name,
+            calibration,
+            reader,
+            writer,
+        )
+        video_io_contexts.append(context)
+
+    dictionary = Dictionary.parse(marker_dictionary)
+    assert dictionary is not None
+
+    configuration = Configuration(
+        RigidModel(marker_size, 1.0),
+        dictionary,
+        arudice=DEFAULT_ARUDICE,
+    )
+
+    procedure = Procedure(configuration, video_io_contexts)
+    progress_bar = trange(
+        procedure.length_estimate(),
+        desc='Estimating transformations...',
+    )
+
+    result = procedure.run(lambda: progress_bar.update())
+
+    match result:
+        case None:
+            raise click.ClickException('Procedure has diverged')
+
+        case buffer:
+            buffer_destination.touch()
+            buffer_destination.write_text(to_json(buffer))
+            click.echo('Done!')
+
+
+DEFAULT_ARUDICE = [
+    Cube[str](
+        50.0,
+        ('marker_42', 'marker_43', 'marker_44', 'marker_45', 'marker_46', 'marker_47'),
+    )
+]
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/generate_pointcloud.py b/packages/child-lab-cli/src/child_lab_cli/commands/generate_pointcloud.py
new file mode 100644
index 00000000..69106740
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/generate_pointcloud.py
@@ -0,0 +1,151 @@
+from collections.abc import Generator
+from pathlib import Path
+
+import click
+import torch
+import tqdm
+from depth_estimation import depth_pro
+from jaxtyping import UInt8
+from serde.yaml import from_yaml
+from torchvision.transforms import Compose, ConvertImageDtype, Normalize, Resize
+from video_io.calibration import Calibration
+from video_io.reader import Reader
+
+from ..workspace import Workspace
+
+
+@click.command('generate-pointcloud')
+@click.argument('workspace_root', type=Path, metavar='<workspace>')
+@click.argument('video_name', type=str, metavar='<video>')
+@click.option(
+    '--checkpoint',
+    type=Path,
+    required=True,
+    help='DepthPro checkpoint to build the depth estimator from',
+)
+@click.option(
+    '--batch-size',
+    type=int,
+    default=16,
+    required=False,
+    help='Number of frames to process as a single batch',
+)
+@click.option(
+    '--device',
+    type=str,
+    default='cpu',
+    required=False,
+    help='Torch device to use for tensor computations',
+)
+def generate_pointcloud(
+    workspace_root: Path,
+    video_name: str,
+    checkpoint: Path,
+    batch_size: int,
+    device: str,
+) -> None:
+    """
+    Generate a point cloud for <video> from <workspace> by estimating the depth.
+    """
+
+    workspace = Workspace.in_directory(workspace_root)
+
+    for video in workspace.calibrated_videos():
+        if video.name == video_name:
+            break
+    else:
+        raise FileNotFoundError(f'Video {video_name} not found in {workspace.input}.')
+
+    output = workspace.output / 'points' / video_name
+
+    if not output.is_dir():
+        output.mkdir()
+
+    calibration = from_yaml(Calibration, video.calibration.read_text())
+    fx = calibration.focal_length[0]
+
+    main_device = torch.device(device)
+
+    reader = Reader(video.location, torch.device('cpu'))
+
+    depth_estimator = depth_pro.DepthPro(
+        depth_pro.Configuration(checkpoint=checkpoint),
+        main_device,
+        torch.half,
+    )
+
+    fx = calibration.focal_length[0]
+    fx = fx * reader.metadata.width / depth_estimator.input_image_size
+
+    click.echo('Depth estimator created!')
+
+    def batched_frames(
+        reader: Reader,
+        batch_size: int,
+    ) -> Generator[torch.Tensor, None, None]:
+        while (frames := reader.read_batch(batch_size)) is not None:
+            yield frames
+
+    progress_bar = tqdm.tqdm(
+        range(0, reader.metadata.frames, batch_size),
+        desc='Processing batches of frames',
+    )
+
+    for i, frames in enumerate(batched_frames(reader, batch_size)):
+        depths = [
+            depth_estimator.predict(frame.to(main_device), fx).depth.cpu()
+            for frame in frames.unbind()
+        ]
+
+        perspective_points = torch.stack(
+            [calibration.unproject_depth(depth) for depth in depths]
+        )
+
+        torch.save(perspective_points, output / f'points_{i}.pt')
+
+        progress_bar.update()
+
+    click.echo('Done!')
+
+
+# TODO: Delete this from here
+class DepthEstimator:
+    device: torch.device
+    model: depth_pro.DepthPro
+    model_config: depth_pro.Configuration
+    to_model: Compose
+
+    def __init__(self, checkpoint: Path, device: torch.device) -> None:
+        self.device = device
+
+        config = depth_pro.Configuration(checkpoint=checkpoint)
+        self.model_config = config
+        self.model = depth_pro.DepthPro(config, device, torch.half)
+
+        self.to_model = Compose(  # type: ignore[no-untyped-call]
+            [
+                ConvertImageDtype(torch.half),
+                Normalize([0.5, 0.5, 0.5], [0.5, 0.5, 0.5]),  # type: ignore[no-untyped-call]
+            ]
+        )
+
+    def predict(
+        self,
+        frame_batch: UInt8[torch.Tensor, 'batch 3 height width'],
+        focal_length_x: float | None = None,
+    ) -> torch.Tensor:
+        *_, height, width = frame_batch.shape
+
+        scaled_focal_length = (
+            (focal_length_x * self.model.input_image_size / width)
+            if focal_length_x is not None
+            else None
+        )
+
+        result = self.model.predict(self.to_model(frame_batch), scaled_focal_length)
+
+        return (  # type: ignore[no-any-return] # mypy infers Any here for some reason.
+            Resize((height, width))  # type: ignore[no-untyped-call]
+            .forward(result.depth)
+            .to(torch.float32)
+        )
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/process.py b/packages/child-lab-cli/src/child_lab_cli/commands/process.py
new file mode 100644
index 00000000..ef7120a3
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/process.py
@@ -0,0 +1,36 @@
+from pathlib import Path
+
+import click
+
+
+@click.command('process')
+@click.argument('workspace', type=Path)
+@click.argument('videos', type=Path, nargs=-1)
+@click.option(
+    '--device',
+    type=str,
+    required=False,
+    help='Torch device to use for tensor computations',
+)
+@click.option(
+    '--skip',
+    type=int,
+    required=False,
+    help='Seconds of videos to skip at the beginning',
+)
+@click.option(
+    '--dynamic-transformations',
+    type=bool,
+    is_flag=True,
+    default=False,
+    help='Compute camera transformations on the fly, using heuristic algorithms',
+)
+# @click_trap()
+def process(
+    workspace: Path,
+    videos: list[Path],
+    device: str | None,
+    skip: int | None,
+    dynamic_transformations: bool,
+) -> None:
+    pass
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/video.py b/packages/child-lab-cli/src/child_lab_cli/commands/video.py
new file mode 100644
index 00000000..801c264c
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/video.py
@@ -0,0 +1,132 @@
+import shutil
+from collections.abc import Generator
+from pathlib import Path
+from time import strptime
+
+import click
+import torch
+from tqdm import trange
+from video_io.reader import Reader
+from video_io.writer import Writer
+
+from child_lab_cli.workspace.model import Video, Workspace
+
+
+@click.group('video')
+def video() -> None: ...
+
+
+@video.command('cut')
+@click.argument('workspace-root', type=Path, metavar='<workspace>')
+@click.argument('video-names', type=str, nargs=-1, metavar='<videos>')
+@click.option(
+    '--time',
+    type=str,
+    nargs=2,
+    required=True,
+    help='Start and end of the cut video in format <minutes:seconds>',
+)
+@click.option(
+    '--shape',
+    nargs=2,
+    type=int,
+    required=False,
+    default=(1080, 1920),
+    help='Common height and width of the result videos',
+)
+@click.option(
+    '--fps',
+    type=int,
+    required=False,
+    default=50,
+    help='Common FPS of the result videos',
+)
+@click.option(
+    '--batch-size',
+    type=int,
+    required=False,
+    default=64,
+    help='Number of frames to load and save in one step',
+)
+@click.option(
+    '--device',
+    type=str,
+    required=False,
+    default='cpu',
+    help='Torch device used for video decoding',
+)
+def cut(
+    workspace_root: Path,
+    video_names: list[str],
+    time: tuple[str, str],
+    shape: tuple[int, int],
+    fps: int,
+    batch_size: int,
+    device: str,
+) -> None:
+    workspace = Workspace.in_directory(workspace_root)
+
+    available_videos = workspace.videos()
+    input_videos: list[Video] = []
+
+    for video_name in video_names:
+        video = next((v for v in available_videos if v.name == video_name), None)
+        if video is None:
+            raise FileNotFoundError(f'Video {video_name} not found in {workspace.input}.')
+
+        input_videos.append(video)
+
+    temporary_output = workspace.root / '.cut_tmp'
+    if temporary_output.is_dir():
+        shutil.rmtree(temporary_output)
+    temporary_output.mkdir(exist_ok=True)
+
+    start_second = __parse_seconds(time[0])
+    end_second = __parse_seconds(time[1])
+    frames_to_read = end_second * fps - start_second * fps
+    n_batches = frames_to_read // batch_size
+    last_batch_size = frames_to_read % batch_size
+
+    video_progress_bar = trange(len(input_videos), desc='Processing videos')
+    frame_progress_bar = trange(
+        0,
+        frames_to_read,
+        batch_size,
+        desc='Processing',
+    )
+
+    for video in input_videos:
+        temporary_destination = (temporary_output / video.name).with_suffix(
+            video.location.suffix
+        )
+        destination = (workspace.input / video.name).with_suffix(video.location.suffix)
+
+        reader = Reader(video.location, torch.device(device), fps, shape[1], shape[0])
+        writer = Writer(temporary_destination, reader.metadata)
+
+        frame_progress_bar.reset()
+        frame_progress_bar.set_description(f'Processing "{video.name}" (batched)')
+
+        def sizes() -> Generator[int, None, None]:
+            for _ in range(n_batches):
+                yield batch_size
+            yield last_batch_size
+
+        for size in sizes():
+            batch = reader.read_batch(size)
+            assert batch is not None
+            writer.write_batch(batch)
+
+            frame_progress_bar.update()
+
+        temporary_destination.rename(destination)
+
+        video_progress_bar.update()
+
+    shutil.rmtree(temporary_output)
+    click.echo('Done!')
+
+
+def __parse_seconds(encoded_time: str) -> int:
+    parsed = strptime(encoded_time, '%M:%S')
+    return parsed.tm_sec + 60 * parsed.tm_min
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/visualize.py b/packages/child-lab-cli/src/child_lab_cli/commands/visualize.py
new file mode 100644
index 00000000..3c1d3abb
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/visualize.py
@@ -0,0 +1,62 @@
+from pathlib import Path
+
+import click
+import torch
+import viser
+from child_lab_visualization.server import show_pointcloud_and_camera_poses
+from serde.json import from_json
+from serde.yaml import from_yaml
+from transformation_buffer.buffer import Buffer
+from video_io.calibration import Calibration
+from video_io.reader import Reader
+
+from ..workspace import Workspace, WorkspaceModelError
+
+
+@click.command('visualize')
+@click.argument('workspace_root', type=Path, metavar='<workspace>')
+@click.argument('video_name', type=str, metavar='<video>')
+def visualize(
+    workspace_root: Path,
+    video_name: str,
+) -> None:
+    """
+    Display a point cloud for <video> from <workspace> in a local Viser server.
+    """
+
+    workspace = Workspace.in_directory(workspace_root)
+    points = workspace.output / 'points' / video_name
+    buffer_location = workspace.transformation / 'buffer.json'
+
+    if not points.is_dir():
+        raise WorkspaceModelError(
+            f'{points} should contain serialized point clouds for video {video_name}'
+        )
+
+    if not buffer_location.is_file():
+        raise WorkspaceModelError(
+            f'{buffer_location} should contain the serialized transformation buffer'
+        )
+
+    for video in workspace.calibrated_videos():
+        if video.name == video_name:
+            break
+    else:
+        raise FileNotFoundError(f'Video {video_name} not found in {workspace.input}.')
+
+    reader = Reader(video.location, torch.device('cpu'))
+    calibration = from_yaml(Calibration, video.calibration.read_text())
+    buffer = from_json(Buffer[str], buffer_location.read_text())
+
+    points_files = sorted(points.glob('*'), key=lambda path: path.stem)
+
+    server = viser.ViserServer()
+    show_pointcloud_and_camera_poses(
+        server,
+        video_name,
+        reader,
+        points_files,
+        calibration,
+        buffer,
+    )
+    server.sleep_forever()
diff --git a/packages/child-lab-cli/src/child_lab_cli/commands/workspace.py b/packages/child-lab-cli/src/child_lab_cli/commands/workspace.py
new file mode 100644
index 00000000..628ed88e
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/commands/workspace.py
@@ -0,0 +1,114 @@
+import shutil
+from datetime import datetime
+from pathlib import Path
+
+import click
+
+from child_lab_cli.workspace.model import Workspace
+
+
+@click.group('workspace')
+def workspace() -> None: ...
+
+
+@workspace.command('new')
+@click.argument('name', type=str)
+@click.argument('location', type=Path)
+@click.option(
+    '--data',
+    '-d',
+    required=False,
+    type=Path,
+    help='Path to a directory containing .avi or .mp4 movies to copy as a workspace input data',
+)
+@click.option(
+    '--calibration',
+    '-c',
+    required=False,
+    type=Path,
+    help='Path to a directory containing serialized camera intrinsics to use in the workspace',
+)
+@click.option(
+    '--transformation',
+    '-t',
+    required=False,
+    type=Path,
+    help='Path to a directory containing transformation data to use in the workspacee',
+)
+def new(
+    name: str,
+    location: Path,
+    data: Path | None,
+    calibration: Path | None,
+    transformation: Path | None,
+) -> None:
+    """
+    Create a new workspace
+    """
+
+    if not location.is_dir():
+        raise click.ClickException(
+            f'Cannot create workspace at {location} - the directory does not exist'
+        )
+
+    if data is not None and not data.is_dir():
+        raise click.ClickException(f'Cannot find data at {data}')
+
+    if calibration is not None and not calibration.is_dir():
+        raise click.ClickException(f'Cannot find calibration at {calibration}')
+
+    if transformation is not None and not transformation.is_dir():
+        raise click.ClickException(f'Cannot find transformation at {transformation}')
+
+    workspace = Workspace.in_directory(location / name)
+
+    if data is not None:
+        shutil.copytree(data, workspace.input)
+
+    if calibration is not None:
+        shutil.copytree(calibration, workspace.calibration)
+
+    if transformation is not None:
+        shutil.copytree(transformation, workspace.transformation)
+
+    click.echo(f'Successfully initialized workspace "{name}" at {workspace.root}')
+
+
+@workspace.command('archive')
+@click.argument('workspace_root', type=Path)
+@click.option(
+    '--name',
+    '-n',
+    required=False,
+    type=str,
+    help='A custom name of the archived directory',
+)
+def archive(
+    workspace_root: Path,
+    name: str | None,
+) -> None:
+    """
+    Archive the whole content of the workspace
+    """
+
+    workspace = Workspace.in_directory(workspace_root)
+
+    archive_entry = workspace.archive / (
+        name
+        if name is not None
+        else ('archive_' + datetime.now().isoformat('_', timespec='seconds'))
+    )
+    archive_entry.mkdir(exist_ok=False)
+
+    for item in workspace_root.iterdir():
+        if item.name == 'archive':
+            continue
+
+        if item.is_file():
+            shutil.copy(item, archive_entry)
+
+        elif item.is_dir():
+            destination = archive_entry / item.name
+            shutil.copytree(item, destination)
+
+    click.echo(f'Successfully archived workspace "{workspace.name}"')
diff --git a/packages/child-lab-cli/src/child_lab_cli/workspace/__init__.py b/packages/child-lab-cli/src/child_lab_cli/workspace/__init__.py
new file mode 100644
index 00000000..abded480
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/workspace/__init__.py
@@ -0,0 +1,3 @@
+from .model import CalibratedVideo, NonCalibratedVideo, Workspace, WorkspaceModelError
+
+__all__ = ['CalibratedVideo', 'NonCalibratedVideo', 'Workspace', 'WorkspaceModelError']
diff --git a/packages/child-lab-cli/src/child_lab_cli/workspace/model.py b/packages/child-lab-cli/src/child_lab_cli/workspace/model.py
new file mode 100644
index 00000000..6a53df0a
--- /dev/null
+++ b/packages/child-lab-cli/src/child_lab_cli/workspace/model.py
@@ -0,0 +1,143 @@
+from dataclasses import dataclass
+from pathlib import Path
+from typing import Self
+
+from serde.json import from_json
+from transformation_buffer.buffer import Buffer
+
+
+@dataclass(slots=True)
+class Video:
+    name: str
+    location: Path
+
+
+@dataclass(frozen=True, slots=True)
+class NonCalibratedVideo:
+    name: str
+    location: Path
+
+
+@dataclass(frozen=True, slots=True)
+class CalibratedVideo:
+    name: str
+    location: Path
+    calibration: Path
+
+
+class WorkspaceModelError(Exception): ...
+
+
+@dataclass(frozen=True, slots=True)
+class Workspace:
+    """
+    Describes locations of the workspace components.
+
+    Attributes
+    ---
+    name: str
+        Name of the workspace.
+
+    root: Path
+        Path to the root directory of the workspace.
+
+    input: list[Input]
+        Directory with input videos to be processed.
+
+    output: Path | None
+        Directory for storing the resulsts of the analysis.
+
+    archive: Path | None
+        Directory for storing the results of the analysis and the input data
+        from all the other workspace directories.
+
+    calibration: Path | None
+        Directory containing the serialized camera intrinsics for each camera.
+
+    transformation: Path | None
+        Directory containing the serialized transformation models.
+    """
+
+    name: str
+    root: Path
+    input: Path
+    output: Path
+    archive: Path
+    calibration: Path
+    transformation: Path
+
+    def videos(self) -> list[Video]:
+        return [Video(path.stem, path) for path in self.input.glob('*')]
+
+    def calibrated_videos(self) -> list[CalibratedVideo]:
+        return [
+            CalibratedVideo(path.stem, path, calibration)
+            for path in self.input.glob('*')
+            if (calibration := self.calibration / f'{path.stem}.yml').is_file()
+        ]
+
+    def non_calibrated_videos(self) -> list[NonCalibratedVideo]:
+        return [
+            NonCalibratedVideo(path.stem, path)
+            for path in self.input.glob('*')
+            if not (self.calibration / path.name).is_file()
+        ]
+
+    def transformation_buffer(self) -> Buffer[object] | None:
+        location = self.transformation / 'buffer.json'
+
+        try:
+            return from_json(Buffer, location.read_text())
+        except Exception:
+            return None
+
+    @classmethod
+    def in_directory(cls, root: Path) -> Self:
+        """
+        Constructs a new workspace with `root` root directory.
+
+        Parameters
+        ---
+        root: Path
+            Root directory of the workspace.
+
+        Raises
+        ---
+        WorkspaceModelError
+            If `root` is not an existing directory.
+        """
+
+        created_directories: list[Path] = []
+
+        def maybe_create(path: Path) -> Path:
+            if path.is_dir():
+                return path
+
+            if path.exists():
+                raise WorkspaceModelError(f'{path} should be a directory.')
+
+            path.mkdir()
+
+            nonlocal created_directories
+            created_directories.append(path)
+
+            return path
+
+        try:
+            maybe_create(root)
+
+            return cls(
+                root.stem,
+                root,
+                maybe_create(root / 'input'),
+                maybe_create(root / 'output'),
+                maybe_create(root / 'archive'),
+                maybe_create(root / 'calibration'),
+                maybe_create(root / 'transformation'),
+            )
+
+        except Exception as exception:
+            for path in reversed(created_directories):
+                path.rmdir()
+
+            raise exception
diff --git a/pyproject.toml b/pyproject.toml
index a5cfe01a..b3d5d92e 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -32,7 +32,6 @@ dev = [
     "icecream>=2.1.3",
     "ruff>=0.6.8",
     "mypy>=1.11.2",
-    "spin>=0.13",
     "pytest>=8.3.4",
     "syrupy>=4.8.1",
     "pytest-benchmark>=5.1.0",
@@ -105,7 +104,7 @@ allow_untyped_globals = false
 disallow_any_expr = false
 disallow_any_explicit = false
 disallow_any_decorated = false
-disallow_any_generics = false  # This option makes using jaxtyping with numpy problematic
+disallow_any_generics = false   # This option makes using jaxtyping with numpy problematic
 disallow_any_unimported = true
 disallow_subclassing_any = true
 disallow_untyped_defs = true
@@ -120,6 +119,3 @@ follow_untyped_imports = true
 
 [tool.mypy-networkx]
 ignore_missing_imports = true
-
-[tool.spin.commands]
-"Development" = ["spin/development.py:workspace", "spin/development.py:video"]
diff --git a/spin/development.py b/spin/development.py
deleted file mode 100644
index 21365967..00000000
--- a/spin/development.py
+++ /dev/null
@@ -1,356 +0,0 @@
-import shutil
-from datetime import datetime
-from pathlib import Path
-from time import strptime
-
-import click
-
-from child_lab_framework.core.video import (
-    SUPPORTED_SUFFIXES,
-    Format,
-    Input,
-    Reader,
-    Writer,
-)
-from child_lab_framework.core.workspace import Workspace
-
-DEVELOPMENT_DIRECTORY = Path(__file__).parent.parent / 'dev'
-DATA_LOCATION = DEVELOPMENT_DIRECTORY / 'data'
-CALIBRATION_PRESETS_LOCATION = DEVELOPMENT_DIRECTORY / 'calibration'
-TRANSFORMATION_PRESETS_LOCATION = DEVELOPMENT_DIRECTORY / 'transformation'
-WORKSPACES_LOCATION = DEVELOPMENT_DIRECTORY / 'result'
-
-
-@click.group
-def workspace() -> None:
-    """
-    Manage workspaces
-    """
-
-
-@click.group
-def video() -> None:
-    """
-    Modify input videos
-    """
-
-
-@workspace.command
-@click.argument('name', type=str)
-@click.option(
-    '--data',
-    '-d',
-    required=False,
-    type=Path,
-    help='Path to a directory containing .avi or .mp4 movies to copy as a workspace input data, relative to the development directory',
-)
-@click.option(
-    '--calibration',
-    '-c',
-    required=False,
-    type=str,
-    help='Name of the calibration preset to use in the workspace',
-)
-@click.option(
-    '--transformation',
-    '-t',
-    required=False,
-    type=str,
-    help='Name of the transformation preset to use in the workspace',
-)
-def new(
-    name: str,
-    data: Path | None,
-    calibration: str | None,
-    transformation: str | None,
-) -> None:
-    """
-    Create a new workspace
-    """
-
-    workspace_root = WORKSPACES_LOCATION / name
-
-    if workspace_root.exists():
-        raise click.ClickException(
-            f'Cannot create workspace "{name}" - file with this name already exists in {WORKSPACES_LOCATION}'
-        )
-
-    if data is not None and not data.is_dir():
-        raise click.ClickException(f'Cannot find data location "{data}"')
-
-    if calibration is not None:
-        calibration_preset_location = CALIBRATION_PRESETS_LOCATION / calibration
-
-        if not calibration_preset_location.is_dir():
-            raise click.ClickException(
-                f'Cannot find calibration preset "{calibration_preset_location}"'
-            )
-    else:
-        calibration_preset_location = None
-
-    if transformation is not None:
-        transformation_preset_location = CALIBRATION_PRESETS_LOCATION / transformation
-
-        if not transformation_preset_location.is_dir():
-            raise click.ClickException(
-                f'Cannot find transformation preset "{transformation_preset_location}"'
-            )
-    else:
-        transformation_preset_location = None
-
-    input = workspace_root / 'input'
-    output = workspace_root / 'output'
-    archive = workspace_root / 'archive'
-    workspace_calibration = workspace_root / 'calibration'
-    workspace_transformation = workspace_root / 'transformation'
-
-    for directory in (
-        workspace_root,
-        input,
-        output,
-        archive,
-    ):
-        directory.mkdir()
-
-    if data is not None:
-        for file in data.iterdir():
-            if file.suffix in SUPPORTED_SUFFIXES:
-                shutil.copy(file, input)
-
-    if calibration_preset_location is not None:
-        shutil.copytree(calibration_preset_location, workspace_calibration)
-    else:
-        workspace_calibration.mkdir()
-
-    if transformation_preset_location is not None:
-        shutil.copytree(transformation_preset_location, workspace_transformation)
-    else:
-        workspace_transformation.mkdir()
-
-    click.echo(f'Successfully initialized workspace "{name}" in {WORKSPACES_LOCATION}')
-
-
-@workspace.command
-@click.argument('workspace', type=str)
-@click.option(
-    '--name',
-    '-n',
-    required=False,
-    type=str,
-    help='A custom name of the archived directory',
-)
-def archive(
-    workspace: str,
-    name: str | None,
-) -> None:
-    """
-    Archive the whole content of the workspace
-    """
-
-    workspace_root = WORKSPACES_LOCATION / workspace
-
-    if not workspace_root.exists():
-        raise click.ClickException(
-            f'Cannot find workspace "{workspace}" in {WORKSPACES_LOCATION}'
-        )
-
-    archive = workspace_root / 'archive'
-
-    if not archive.is_dir():
-        raise click.ClickException(
-            f'Workspace "{workspace}" doesn\'t contain the archive directory'
-        )
-
-    __archive_workspace_unchecked(workspace_root, archive, name)
-
-    click.echo(f'Successfully archived workspace "{workspace}"')
-
-
-@workspace.command
-@click.argument('name', type=str)
-def show(name: str) -> None:
-    """
-    Displays info about the workspace
-    """
-
-    root = WORKSPACES_LOCATION / name
-
-    if not root.is_dir():
-        raise click.ClickException(
-            f'Cannot find workspace "{name}" in {WORKSPACES_LOCATION}'
-        )
-
-    print(Workspace.load(root))
-
-
-@video.command
-@click.argument('workspace_name', type=str)
-@click.option(
-    '--name',
-    type=str,
-    required=False,
-    help='Name of the video to process. Cuts all available videos if not provided',
-)
-@click.option(
-    '--time',
-    type=str,
-    nargs=2,
-    required=True,
-    help='Start and end of the cut video in format <minutes:seconds>',
-)
-@click.option(
-    '--shape',
-    nargs=2,
-    type=int,
-    required=False,
-    default=(1080, 1920),
-    help='Common height and width of the result videos',
-)
-@click.option(
-    '--fps',
-    type=int,
-    required=False,
-    default=50,
-    help='Common FPS of the result videos',
-)
-@click.option(
-    '--no-archive',
-    type=bool,
-    is_flag=True,
-    default=False,
-    help='Do not archive the workspace before modifying the videos',
-)
-def cut(
-    workspace_name: str,
-    name: str | None,
-    time: tuple[str, str],
-    shape: tuple[int, int],
-    fps: int,
-    no_archive: bool,
-) -> None:
-    """
-    Cut all the input videos in the workspace to a common time and shape
-    """
-
-    workspace = Workspace.load(WORKSPACES_LOCATION / workspace_name)
-    workspace_root = workspace.root
-
-    if not no_archive:
-        archive = workspace_root / 'archive'
-
-        if not archive.is_dir():
-            raise click.ClickException(
-                f'Workspace "{workspace}" doesn\'t contain the archive directory'
-            )
-
-        __archive_workspace_unchecked(workspace_root, archive, None)
-
-    input_directory = workspace_root / 'input'
-
-    processed_input_directory = workspace_root / '__tmp_processed_input'
-    processed_input_directory.mkdir()
-
-    height, width = shape
-    start = __parse_seconds(time[0])
-    end = __parse_seconds(time[1])
-
-    if start >= end:
-        raise click.ClickException(
-            f'Expected start time < end time, got {start = } and {end = }'
-        )
-
-    if name is not None:
-        input_candidates = [input for input in workspace.inputs if input.name == name]
-
-        if len(input_candidates) == 0:
-            raise click.ClickException(f'Cannot find video "{name}" in {input_directory}')
-
-        input = input_candidates[0]
-
-        __cut_video_unchecked(
-            input,
-            processed_input_directory,
-            height,
-            width,
-            fps,
-            start,
-            end,
-        )
-
-        input.source.unlink()
-
-    else:
-        for input in workspace.inputs:
-            __cut_video_unchecked(
-                input,
-                processed_input_directory,
-                height,
-                width,
-                fps,
-                start,
-                end,
-            )
-
-            input.source.unlink()
-
-    for file in processed_input_directory.iterdir():
-        shutil.copy(file, input_directory)
-
-    shutil.rmtree(processed_input_directory)
-
-    click.echo(f'Successfully cut input videos in workspace "{workspace_name}"')
-
-
-def __parse_seconds(encoded_time: str) -> int:
-    parsed = strptime(encoded_time, '%M:%S')
-    return parsed.tm_sec + 60 * parsed.tm_min
-
-
-def __cut_video_unchecked(
-    input: Input,
-    destination_directory: Path,
-    height: int,
-    width: int,
-    fps: int,
-    start: int,
-    end: int,
-) -> None:
-    reader = Reader(input, height=height, width=width, fps=fps, batch_size=1)
-    reader.read_skipping(start * fps)
-
-    writer = Writer(
-        destination_directory / (input.source.stem + '.mp4'),
-        reader.properties,
-        output_format=Format.MP4,
-    )
-
-    for _ in range((end - start) * fps):
-        frame = reader.read()
-        assert frame is not None
-        writer.write(frame)
-
-
-def __archive_workspace_unchecked(
-    workspace_root: Path,
-    archive: Path,
-    entry_name: str | None,
-) -> None:
-    entry_name = (
-        entry_name
-        if entry_name is not None
-        else ('archive_' + datetime.now().isoformat('_', timespec='seconds'))
-    )
-
-    archive_entry = archive / entry_name
-    archive_entry.mkdir()  # safe to assume that such entry does not exist
-
-    for item in workspace_root.iterdir():
-        if item.name == 'archive':
-            continue
-
-        if item.is_file():
-            shutil.copy(item, archive_entry)
-
-        elif item.is_dir():
-            destination = archive_entry / item.name
-            shutil.copytree(item, destination)
diff --git a/uv.lock b/uv.lock
index f0bfd8bb..03ff8aac 100644
--- a/uv.lock
+++ b/uv.lock
@@ -133,7 +133,35 @@ source = { editable = "packages/child-lab-annotation" }
 [[package]]
 name = "child-lab-cli"
 version = "0.1.0"
-source = { virtual = "packages/child-lab-cli" }
+source = { editable = "packages/child-lab-cli" }
+dependencies = [
+    { name = "child-lab-procedures" },
+    { name = "child-lab-visualization" },
+    { name = "click" },
+    { name = "depth-estimation" },
+    { name = "marker-detection" },
+    { name = "pyserde" },
+    { name = "torch" },
+    { name = "tqdm" },
+    { name = "transformation-buffer" },
+    { name = "video-io" },
+    { name = "viser" },
+]
+
+[package.metadata]
+requires-dist = [
+    { name = "child-lab-procedures", editable = "packages/child-lab-procedures" },
+    { name = "child-lab-visualization", editable = "packages/child-lab-visualization" },
+    { name = "click", specifier = ">=8.1.8" },
+    { name = "depth-estimation", editable = "packages/depth-estimation" },
+    { name = "marker-detection", editable = "packages/marker-detection" },
+    { name = "pyserde", specifier = ">=0.23.0" },
+    { name = "torch", specifier = ">=2.6.0" },
+    { name = "tqdm", specifier = ">=4.67.1" },
+    { name = "transformation-buffer", editable = "packages/transformation-buffer" },
+    { name = "video-io", editable = "packages/video-io" },
+    { name = "viser", specifier = ">=0.2.23" },
+]
 
 [[package]]
 name = "child-lab-data"
@@ -169,7 +197,6 @@ dev = [
     { name = "pytest" },
     { name = "pytest-benchmark" },
     { name = "ruff" },
-    { name = "spin" },
     { name = "syrupy" },
 ]
 workspace = [
@@ -212,12 +239,11 @@ dev = [
     { name = "pytest", specifier = ">=8.3.4" },
     { name = "pytest-benchmark", specifier = ">=5.1.0" },
     { name = "ruff", specifier = ">=0.6.8" },
-    { name = "spin", specifier = ">=0.13" },
     { name = "syrupy", specifier = ">=4.8.1" },
 ]
 workspace = [
     { name = "child-lab-annotation", editable = "packages/child-lab-annotation" },
-    { name = "child-lab-cli", virtual = "packages/child-lab-cli" },
+    { name = "child-lab-cli", editable = "packages/child-lab-cli" },
     { name = "child-lab-data", editable = "packages/child-lab-data" },
     { name = "child-lab-framework", editable = "." },
     { name = "child-lab-procedures", editable = "packages/child-lab-procedures" },
@@ -993,7 +1019,7 @@ name = "nvidia-cudnn-cu12"
 version = "9.5.1.17"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas-cu12" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/2a/78/4535c9c7f859a64781e43c969a3a7e84c54634e319a996d43ef32ce46f83/nvidia_cudnn_cu12-9.5.1.17-py3-none-manylinux_2_28_x86_64.whl", hash = "sha256:30ac3869f6db17d170e0e556dd6cc5eee02647abc31ca856634d5a40f82c15b2", size = 570988386 },
@@ -1004,7 +1030,7 @@ name = "nvidia-cufft-cu12"
 version = "11.3.0.4"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink-cu12" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/8f/16/73727675941ab8e6ffd86ca3a4b7b47065edcca7a997920b831f8147c99d/nvidia_cufft_cu12-11.3.0.4-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:ccba62eb9cef5559abd5e0d54ceed2d9934030f51163df018532142a8ec533e5", size = 200221632 },
@@ -1033,9 +1059,9 @@ name = "nvidia-cusolver-cu12"
 version = "11.7.1.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-cublas-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
-    { name = "nvidia-cusparse-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-cublas-cu12" },
+    { name = "nvidia-cusparse-cu12" },
+    { name = "nvidia-nvjitlink-cu12" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/f0/6e/c2cf12c9ff8b872e92b4a5740701e51ff17689c4d726fca91875b07f655d/nvidia_cusolver_cu12-11.7.1.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:e9e49843a7707e42022babb9bcfa33c29857a93b88020c4e4434656a655b698c", size = 158229790 },
@@ -1047,7 +1073,7 @@ name = "nvidia-cusparse-cu12"
 version = "12.5.4.2"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "nvidia-nvjitlink-cu12", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "nvidia-nvjitlink-cu12" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/06/1e/b8b7c2f4099a37b96af5c9bb158632ea9e5d9d27d7391d7eb8fc45236674/nvidia_cusparse_cu12-12.5.4.2-py3-none-manylinux2014_x86_64.manylinux_2_17_x86_64.whl", hash = "sha256:7556d9eca156e18184b94947ade0fba5bb47d69cec46bf8660fd2c71a4b48b73", size = 216561367 },
@@ -1625,20 +1651,6 @@ wheels = [
     { url = "https://files.pythonhosted.org/packages/32/46/9cb0e58b2deb7f82b84065f37f3bffeb12413f947f9388e4cac22c4621ce/sortedcontainers-2.4.0-py2.py3-none-any.whl", hash = "sha256:a163dcaede0f1c021485e957a39245190e74249897e2ae4b2aa38595db237ee0", size = 29575 },
 ]
 
-[[package]]
-name = "spin"
-version = "0.14"
-source = { registry = "https://pypi.org/simple" }
-dependencies = [
-    { name = "click" },
-    { name = "colorama", marker = "sys_platform == 'win32'" },
-    { name = "importlib-metadata" },
-]
-sdist = { url = "https://files.pythonhosted.org/packages/40/d8/b38fcbfa77de8bbed51c532b515d2aed5843a883ab0ee7ef75bc437f5a71/spin-0.14.tar.gz", hash = "sha256:1a5f6ce53699ef58bf893970ecb9d7f8814a8ca08da5d26e1391fe2a9fa04bcc", size = 30004 }
-wheels = [
-    { url = "https://files.pythonhosted.org/packages/eb/49/eced0f0f6d4ad2311061e73564d427ec4b67d9b6abc37903b7ce1aa650cc/spin-0.14-py3-none-any.whl", hash = "sha256:cc56f0593e7697a7e04dc621ebd4da765b49a46f5ef7cab22ea5cb3a0743321a", size = 31053 },
-]
-
 [[package]]
 name = "svg-path"
 version = "6.3"
@@ -1847,7 +1859,7 @@ name = "triton"
 version = "3.3.0"
 source = { registry = "https://pypi.org/simple" }
 dependencies = [
-    { name = "setuptools", marker = "(platform_machine != 'aarch64' and sys_platform == 'linux') or (sys_platform != 'darwin' and sys_platform != 'linux' and sys_platform != 'win32')" },
+    { name = "setuptools" },
 ]
 wheels = [
     { url = "https://files.pythonhosted.org/packages/11/53/ce18470914ab6cfbec9384ee565d23c4d1c55f0548160b1c7b33000b11fd/triton-3.3.0-cp312-cp312-manylinux_2_27_x86_64.manylinux_2_28_x86_64.whl", hash = "sha256:b68c778f6c4218403a6bd01be7484f6dc9e20fe2083d22dd8aef33e3b87a10a3", size = 156504509 },