Pure functional file validation logic.

This namespace contains no side effects - only pure functions for validating
files based on size, type, extension, etc.

Port definitions for file storage functionality.

This namespace defines the contracts that storage adapters must implement.
Follows the Functional Core / Imperative Shell pattern where ports define
the boundaries between pure logic and side effects.

Malli schemas for file storage validation.

Google Cloud Storage adapter.

Implements IFileStorage for storing files in Google Cloud Storage (GCS).
Suitable for production deployments on Google Cloud requiring scalable
object storage.

Java AWT-based image processing implementation.

Implements IImageProcessor using Java's built-in image processing capabilities.
No external dependencies required.

Local filesystem storage adapter.

Implements IFileStorage for storing files on the local filesystem.
Suitable for development and single-server deployments.

Amazon S3 storage adapter.

Implements IFileStorage for storing files in AWS S3 or S3-compatible services.
Suitable for production deployments requiring scalable object storage.

HTTP handlers for file upload and download operations.

Provides Ring-compatible handlers for file operations.

Integrant lifecycle for the storage module.

Config key:

:boundary/storage
  {:provider :local :root "uploads"}                ; local filesystem
  {:provider :s3  :bucket "b" :region "eu-west-1"}  ; AWS S3 / compatible
  {:provider :gcs :bucket "b" :project-id "p"}      ; Google Cloud Storage

  Returns {:provider <kw> :storage <IFileStorage> :service <IStorageService>}.
  Consumers (e.g. :boundary/storage-routes) use :service.

The `:local` provider accepts the catalogue's `:root` as an alias for the
local adapter's `:base-path`.

Storage service orchestrating file operations.

This service coordinates file validation, storage, and image processing.
Follows the Functional Core / Imperative Shell pattern where this service
represents the imperative shell that coordinates pure validation logic
with side-effectful storage operations.