tweaks

.env.production.example

@@ -22,7 +22,7 @@ PUBLIC_API_BASE_URL=https://clients.example.com
 INTERNAL_API_BASE_URL=http://backend:8000
 CORS_ALLOW_ORIGINS=https://clients.example.com
 CORS_ALLOW_ORIGIN_REGEX=
-TRUSTED_HOSTS=clients.example.com
+TRUSTED_HOSTS=clients.example.com,127.0.0.1,localhost
 CLIENTS_APP_PORT=8081
 SESSION_COOKIE_SECURE=true
 SESSION_COOKIE_SAMESITE=lax

DATABASE-DESIGN.MD

@@ -0,0 +1,373 @@
+# Database Design
+
+## Purpose
+
+This app uses a relational database to support five main concerns:
+
+1. Raw material pricing and unit conversion.
+2. Mix definitions and mix costing.
+3. Product-level formulas and product costing.
+4. Mix calculator session history.
+5. Access control for both internal users and client users.
+
+The backend is written with SQLAlchemy models in `backend/app/models`. The schema is created automatically at startup, and lightweight migration/patch logic lives in `backend/app/db/migrations.py`.
+
+## Design Principles
+
+- `tenant_id` is the tenancy boundary for most business tables.
+- Reference/master data is stored separately from transactional/session data.
+- Product costing is built from raw materials -> formulas -> products -> outputs.
+- The mix calculator now prefers product-specific ingredient formulas over the shared mix master.
+- The database is designed to run on both SQLite locally and Postgres in production.
+
+## High-Level Domains
+
+### 1. Raw Materials
+
+These tables store ingredients and their price history.
+
+- `raw_materials`
+  - One row per ingredient/raw material.
+  - Stores name, supplier, unit of measure, `kg_per_unit`, status, and notes.
+  - Example: `Hulled Oats`, `White French Millet`, `Pano`.
+
+- `raw_material_price_versions`
+  - One-to-many from `raw_materials`.
+  - Stores `market_value`, `waste_percentage`, `effective_date`, and status.
+  - Lets the system keep historical prices instead of overwriting one current value.
+
+Relationship:
+
+- `raw_materials.id` -> `raw_material_price_versions.raw_material_id`
+
+### 2. Mix Master
+
+These tables store shared mix definitions.
+
+- `mixes`
+  - One row per named mix.
+  - Stores client name, mix name, version, status, and notes.
+  - This is the shared mix/master-recipe layer.
+
+- `mix_ingredients`
+  - One-to-many from `mixes`.
+  - One row per raw material inside a mix.
+  - Stores `quantity_kg` for that mix.
+
+Relationships:
+
+- `mixes.id` -> `mix_ingredients.mix_id`
+- `raw_materials.id` -> `mix_ingredients.raw_material_id`
+
+Important note:
+
+- This table is still used by mix master pages and as a fallback.
+- It is no longer the primary source for mix calculator formulas when product-specific formulas exist.
+
+### 3. Products
+
+These tables describe saleable products and their formula rows.
+
+- `products`
+  - One row per sellable product/SKU.
+  - Stores client name, product name, optional `item_id`, packaging/unit info, margins, and linked mix.
+  - `mix_id` links the product to the shared mix master entry.
+
+- `product_ingredients`
+  - One-to-many from `products`.
+  - One row per raw material required for that product’s formula.
+  - Stores `quantity_kg`, `sort_order`, and optional notes.
+  - This is now the key table for the mix calculator.
+
+Relationships:
+
+- `products.mix_id` -> `mixes.id`
+- `products.id` -> `product_ingredients.product_id`
+- `raw_materials.id` -> `product_ingredients.raw_material_id`
+
+Why both `mix_ingredients` and `product_ingredients` exist:
+
+- `mix_ingredients` represents a shared recipe.
+- `product_ingredients` represents the actual formula used for a specific product.
+- Multiple products can point at the same mix name but still require product-specific formula rows.
+- This solves the workbook case where product labels like `Budgie Mix 20kg` map to a formula/mix name like `Hunter - Budgie Mix`.
+
+### 4. Costing Assumptions
+
+These tables hold non-ingredient costs used in product costing.
+
+- `process_cost_rules`
+  - Holds grading, bagging, and cracking costs by `process_name`.
+
+- `packaging_cost_rules`
+  - Holds bag cost by `sale_type`, `unit_of_measure`, and `own_bag`.
+
+- `freight_cost_rules`
+  - Holds freight cost by `sale_type` and `unit_of_measure`.
+
+These tables are read during product cost calculation after ingredient cost has been resolved.
+
+### 5. Scenarios and Stored Outputs
+
+- `scenarios`
+  - Named pricing/costing scenarios.
+  - Stores `overrides` as JSON.
+
+- `costing_results`
+  - One-to-many from `scenarios`.
+  - Stores calculated output per product for a scenario.
+  - Includes prices, warnings, and calculation details as JSON.
+
+Relationships:
+
+- `scenarios.id` -> `costing_results.scenario_id`
+- `products.id` -> `costing_results.product_id`
+
+### 6. Mix Calculator Sessions
+
+These tables store saved calculator runs.
+
+- `mix_calculator_sessions`
+  - Header row for a calculator run.
+  - Stores product, mix, batch size, total bags, total kg, prepared by, and timestamps.
+
+- `mix_calculator_session_lines`
+  - One-to-many from `mix_calculator_sessions`.
+  - Snapshot of the scaled ingredient rows shown to the user at save time.
+  - Stores `required_kg`, `mix_percentage`, unit, and display name.
+
+Relationships:
+
+- `mix_calculator_sessions.id` -> `mix_calculator_session_lines.session_id`
+- `products.id` -> `mix_calculator_sessions.product_id`
+- `mixes.id` -> `mix_calculator_sessions.mix_id`
+
+Important note:
+
+- Session lines are denormalized snapshots.
+- They are intentionally stored separately so historical saved runs do not change if product formulas are updated later.
+
+### 7. Client Access / Tenant Administration
+
+These tables manage customer-facing users and feature/module access.
+
+- `client_accounts`
+  - One row per client/tenant account.
+
+- `client_users`
+  - One-to-many from `client_accounts`.
+  - Customer-side users tied to a client account.
+
+- `client_feature_access`
+  - One-to-many from `client_accounts`.
+  - Feature flags per client account.
+
+- `client_user_module_permissions`
+  - One-to-many from `client_users`.
+  - Module-level access levels per client user.
+
+- `client_access_audit_events`
+  - One-to-many from `client_accounts`.
+  - Audit log for client-access changes.
+
+Relationships:
+
+- `client_accounts.id` -> `client_users.client_account_id`
+- `client_accounts.id` -> `client_feature_access.client_account_id`
+- `client_accounts.id` -> `client_access_audit_events.client_account_id`
+- `client_users.id` -> `client_user_module_permissions.client_user_id`
+
+### 8. Internal Access Control
+
+These tables are for internal staff login and permissions.
+
+- `users`
+  - Internal users.
+  - Stores per-user `password_hash`, role link, and active flag.
+
+- `roles`
+  - Named roles like `Admin`, `Operations`, `Full Access`.
+
+- `permissions`
+  - Atomic permission keys like `view_mix_calculator`.
+
+- `role_permissions`
+  - Many-to-many join table between roles and permissions.
+
+Relationships:
+
+- `roles.id` -> `users.role_id`
+- `roles.id` <-> `permissions.id` through `role_permissions`
+
+## Core Costing Flow
+
+### Raw Material Cost
+
+The system calculates ingredient cost from:
+
+- `market_value`
+- `waste_percentage`
+- `kg_per_unit`
+
+This produces:
+
+- loss cost
+- adjusted cost per unit
+- cost per kg
+
+### Mix Cost
+
+There are now two formula sources:
+
+1. Preferred: `product_ingredients`
+2. Fallback: `mix_ingredients`
+
+For mix calculator and product costing:
+
+- if a product has rows in `product_ingredients`, use them
+- otherwise use the linked shared mix from `mix_ingredients`
+
+### Product Cost
+
+Product cost is built from:
+
+1. ingredient formula cost
+2. process costs
+3. packaging cost
+4. freight cost
+5. optional distributor / wholesale margin
+
+## Workbook Import Design
+
+The seed/import logic is in `backend/app/seed.py`.
+
+There are now two workbook roles:
+
+- Legacy costing workbook:
+  - `C- Raw Products Costs`
+  - `M - All`
+  - `Product Cost - Price`
+- Product-formula workbook:
+  - `input_data/1.xlsx`
+  - sheet `mix_quantites_per_client_per_pr`
+
+### Current Import Behaviour
+
+- Raw materials are seeded from the legacy costing workbook.
+- Shared mixes are seeded from the legacy costing workbook.
+- Products are seeded from the legacy costing workbook.
+- Product-specific formulas are seeded from `mix_quantites_per_client_per_pr`.
+
+### Formula Matching Rule
+
+Workbook formula rows are attached to products using:
+
+1. `(client_name, product.name)` if it matches directly.
+2. `(client_name, product.mix.name)` if the workbook row uses the mix/formula name instead of the sellable product label.
+
+This is important for cases like:
+
+- workbook formula: `HunterBird / Hunter - Budgie Mix`
+- product row: `HunterBird / Budgie Mix 20kg`
+
+Both product SKUs can inherit the same formula through the linked mix name.
+
+## Tenancy
+
+Most business tables include `tenant_id`.
+
+This includes:
+
+- raw materials
+- price versions
+- mixes
+- mix ingredients
+- product ingredients
+- products
+- scenarios
+- costing results
+- mix calculator sessions and lines
+- client-access tables
+- assumption tables
+
+Startup migration logic backfills `tenant_id` where possible by deriving it from related parent tables.
+
+## Visibility Rules
+
+The `products.visible` flag is used to hide client/product rows from normal UI paths.
+
+Startup migration logic also auto-hides products for a configured list of client names in `backend/app/db/migrations.py`.
+
+This means:
+
+- rows can exist in the database
+- but not be offered in normal mix calculator/product selection flows
+
+## Transaction vs Reference Data
+
+Reference/master data:
+
+- `raw_materials`
+- `raw_material_price_versions`
+- `mixes`
+- `mix_ingredients`
+- `products`
+- `product_ingredients`
+- `process_cost_rules`
+- `packaging_cost_rules`
+- `freight_cost_rules`
+- access-control tables
+
+Transactional/snapshot data:
+
+- `mix_calculator_sessions`
+- `mix_calculator_session_lines`
+- `scenarios`
+- `costing_results`
+- `client_access_audit_events`
+
+## Important Constraints
+
+- `mix_ingredients` is unique on `(mix_id, raw_material_id)`.
+- `product_ingredients` is unique on `(product_id, raw_material_id)`.
+- `client_users` is unique on `(client_account_id, email)`.
+- `client_feature_access` is unique on `(client_account_id, feature_key)`.
+- `client_user_module_permissions` is unique on `(client_user_id, module_key)`.
+- `mix_calculator_sessions` is unique on `(tenant_id, session_number)`.
+
+These constraints prevent duplicate ingredient or access rows within the same parent scope.
+
+## Known Tradeoffs
+
+- `RawMaterial.name` is globally unique, not tenant-scoped. That is simple for now, but stricter than a multi-tenant design usually wants.
+- `Product.mix_id` is still required even though product-specific formulas now exist. That is useful for compatibility and navigation, but it means a product currently has both a shared mix link and potentially its own formula rows.
+- Some calculation outputs are denormalized into session/result tables for stability and history.
+- Migration logic is startup-driven and pragmatic rather than using a full migration framework like Alembic.
+
+## Recommended Mental Model
+
+Use this as the working model of the schema:
+
+- `raw_materials` = ingredients
+- `raw_material_price_versions` = ingredient pricing history
+- `mixes` = shared recipe labels
+- `mix_ingredients` = shared recipe lines
+- `products` = saleable SKUs
+- `product_ingredients` = actual formula for a SKU
+- `mix_calculator_sessions` + `lines` = saved production calculations
+- `scenarios` + `costing_results` = stored what-if pricing outputs
+- `client_*` tables = client account access
+- `users / roles / permissions` = internal staff access
+
+## Files To Read Alongside This Document
+
+- [backend/app/models/raw_material.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/raw_material.py:1)
+- [backend/app/models/mix.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/mix.py:1)
+- [backend/app/models/product.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/product.py:1)
+- [backend/app/models/mix_calculator.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/mix_calculator.py:1)
+- [backend/app/models/scenario.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/scenario.py:1)
+- [backend/app/models/assumption.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/assumption.py:1)
+- [backend/app/models/client_access.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/client_access.py:1)
+- [backend/app/models/access.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/models/access.py:1)
+- [backend/app/db/migrations.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/db/migrations.py:1)
+- [backend/app/seed.py](/abs/path/C:/Users/mattc/data-entry-app/data-entry-app/backend/app/seed.py:1)

README.md

@@ -90,10 +90,17 @@ If your server already has a host-level nginx handling domains and TLS, use `dep
 
    Useful flags: `-Branch <name>` to deploy a feature branch, `-SkipBuild` for env-only changes, `-Seed` to re-run reference data seeding, `-Logs` to tail logs after the deploy, `-SshKey` to point at a specific private key.
 
+   If a release adds or changes database-backed workbook formula structures, deploy with `-Seed` so the server refreshes seeded reference/formula data after the backend starts. For the product-formula change, this is required so Postgres receives the new `product_ingredients` rows sourced from `input_data/1.xlsx`.
+
 5. **Database**: the backend reads `DATABASE_URL`. The production compose file synthesises it as `postgresql+psycopg://${POSTGRES_USER}:${POSTGRES_PASSWORD}@db:5432/${POSTGRES_DB}` so you only need to set the three `POSTGRES_*` vars. Override `DATABASE_URL` directly if you point at a managed Postgres (e.g. DigitalOcean managed databases).
 
 The schema is auto-managed — `app/db/migrations.py` runs at backend startup and is idempotent across SQLite and Postgres. To migrate alpha SQLite data into the new Postgres instance, dump tables to CSV from the alpha container and import via `\copy` in `psql`; there is no automatic SQLite → Postgres path.
 
+For this repo’s current schema, new tables such as `product_ingredients` are created automatically on backend startup in both SQLite and Postgres. Existing data refreshes still depend on seeding, so schema deployment and data deployment are separate concerns:
+
+- backend startup creates missing tables/columns
+- `-Seed` repopulates workbook-driven rows inside those tables
+
 ## Backend
 
 Create a virtual environment, install dependencies, then run:
@@ -116,6 +123,20 @@ pytest
 The backend defaults to SQLite for the prototype and can be switched with the
 `DATABASE_URL` environment variable.
 
+For local non-Docker runs, the default SQLite database is
+`backend/data_entry_app.db` regardless of which directory you launch the
+backend from. This avoids accidentally creating multiple local SQLite files
+with different login data.
+
+The internal login screen at `/` uses the seeded Hunter Stock Feeds users:
+
+- `admin@hunterstockfeeds.com`
+- `ops@hunterstockfeeds.com`
+- `craig@hunterstockfeeds.com`
+
+Unless you override `ADMIN_PASSWORD` before the first seed, those local
+internal users are seeded with the default password `lean101-admin`.
+
 ### Backend logging
 
 The backend now uses a shared console logger with a styled startup banner, concise request logs, and clean shutdown summaries.

backend/Dockerfile

@@ -8,6 +8,8 @@ WORKDIR /app
 RUN addgroup --system app && adduser --system --ingroup app app
 
 COPY backend /app
+COPY ["input_data/1.xlsx", "/app/input_data/1.xlsx"]
+COPY ["Input Cost Spreadsheet(1).xlsx", "/app/Input Cost Spreadsheet(1).xlsx"]
 
 RUN pip install --no-cache-dir --upgrade pip && \
     pip install --no-cache-dir . && \

backend/app/api/access.py

@@ -109,15 +109,11 @@ def _serialize_session(user: User, *, include_token: bool = False) -> UserSessio
 def login(payload: LoginRequest, response: Response, request: Request, db: Session = Depends(get_db)):
     """Internal-user login.
 
-    Authenticates against a shared internal password (``ADMIN_PASSWORD``) and
-    looks up the user by email. Inactive or unknown users are rejected with
-    a generic 401 to avoid leaking which emails are valid.
+    Authenticates against the per-user password hash stored on ``users``.
+    Inactive or unknown users are rejected with a generic 401 to avoid
+    leaking which emails are valid.
     """
     login_rate_limiter.hit(request_client_key(request, suffix="internal-login"))
-    if payload.password != settings.admin_password:
-        log_security_event("auth.login_failed", audience="internal", ip=request_client_key(request))
-        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid email or password")
-
     email = payload.email.strip().lower()
     user = db.scalar(
         select(User)
@@ -127,6 +123,12 @@ def login(payload: LoginRequest, response: Response, request: Request, db: Sessi
     if user is None or not user.is_active:
         log_security_event("auth.login_failed", audience="internal", ip=request_client_key(request))
         raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid email or password")
+    if not (
+        verify_password(payload.password, user.password_hash)
+        or (user.password_hash is None and payload.password == settings.admin_password)
+    ):
+        log_security_event("auth.login_failed", audience="internal", ip=request_client_key(request))
+        raise HTTPException(status_code=status.HTTP_401_UNAUTHORIZED, detail="Invalid email or password")
 
     session = _serialize_session(user, include_token=True)
     if session.token:
@@ -161,13 +163,11 @@ def update_me(
 ):
     """Allow an internal user to update their own name, email, or password."""
     if payload.new_password:
-        # Require current password verification before allowing a password change.
-        # Users who have never set a personal password must supply the shared
-        # admin password as the current credential.
-        current_ok = (
-            verify_password(payload.current_password or "", user.password_hash)
-            if user.password_hash
-            else (payload.current_password or "") == settings.admin_password
+        # Require current password verification before allowing a password
+        # change. Keep a narrow fallback for legacy rows that still have no
+        # password hash yet.
+        current_ok = verify_password(payload.current_password or "", user.password_hash) or (
+            user.password_hash is None and (payload.current_password or "") == settings.admin_password
         )
         if not current_ok:
             raise HTTPException(

backend/app/api/mix_calculator.py

@@ -22,7 +22,7 @@ from app.services.mix_calculator_service import (
     update_mix_calculator_session,
 )
 from app.services.mix_calculator_pdf import MixCalculatorPdfUnavailableError, build_mix_calculator_pdf
-from app.services.mix_calculator_filenames import mix_calculator_pdf_filename
+from app.services.mix_calculator_filenames import mix_calculator_pdf_filename, mix_calculator_preview_pdf_filename
 
 router = APIRouter(prefix="/api/mix-calculator", tags=["mix-calculator"])
 
@@ -56,6 +56,28 @@ def preview_mix_calculator_session(
         raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
 
 
+@router.post("/preview/pdf")
+def preview_mix_calculator_session_pdf(
+    payload: MixCalculatorSessionCreate,
+    session: AuthSession = Depends(require_client_module_access("mix_calculator", "edit")),
+    db: Session = Depends(get_db),
+):
+    try:
+        preview = calculate_mix_calculator_preview(db, tenant_id=session.tenant_id or "", payload=payload)
+        pdf_bytes = build_mix_calculator_pdf(preview)
+    except ValueError as exc:
+        raise HTTPException(status_code=status.HTTP_400_BAD_REQUEST, detail=str(exc)) from exc
+    except MixCalculatorPdfUnavailableError as exc:
+        raise HTTPException(status_code=status.HTTP_503_SERVICE_UNAVAILABLE, detail=str(exc)) from exc
+
+    filename = mix_calculator_preview_pdf_filename(MixCalculatorPreviewRead.model_validate(preview))
+    return Response(
+        content=pdf_bytes,
+        media_type="application/pdf",
+        headers={"Content-Disposition": f'attachment; filename="{filename}"'},
+    )
+
+
 @router.post("", response_model=MixCalculatorSessionRead, status_code=status.HTTP_201_CREATED)
 def create_saved_mix_calculator_session(
     payload: MixCalculatorSessionCreate,

backend/app/api/throughput.py

@@ -0,0 +1,245 @@
+from __future__ import annotations
+
+from datetime import date
+
+from fastapi import APIRouter, Depends, HTTPException, Query, status
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.api.deps import AuthSession, require_client_module_access
+from app.db.session import get_db
+from app.models.throughput import ProductionThroughput, ThroughputProduct
+from app.schemas.throughput import (
+    ThroughputEntryCreate,
+    ThroughputEntryRead,
+    ThroughputEntryUpdate,
+    ThroughputProductCreate,
+    ThroughputProductRead,
+    ThroughputProductUpdate,
+)
+from app.services.throughput_service import (
+    calculate_kg,
+    normalise_staff_name,
+    serialize_entry,
+)
+
+router = APIRouter(prefix="/api/throughput", tags=["operations-throughput"])
+
+MODULE_KEY = "operations_throughput"
+
+
+@router.get("/products", response_model=list[ThroughputProductRead])
+def list_products(
+    include_inactive: bool = Query(default=False),
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY)),
+    db: Session = Depends(get_db),
+):
+    stmt = select(ThroughputProduct).where(ThroughputProduct.tenant_id == session.tenant_id)
+    if not include_inactive:
+        stmt = stmt.where(ThroughputProduct.active.is_(True))
+    stmt = stmt.order_by(ThroughputProduct.name)
+    return db.scalars(stmt).all()
+
+
+@router.post("/products", response_model=ThroughputProductRead, status_code=status.HTTP_201_CREATED)
+def create_product(
+    payload: ThroughputProductCreate,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY, "edit")),
+    db: Session = Depends(get_db),
+):
+    if payload.item_id:
+        existing = db.scalar(
+            select(ThroughputProduct).where(
+                ThroughputProduct.tenant_id == session.tenant_id,
+                ThroughputProduct.item_id == payload.item_id,
+            )
+        )
+        if existing is not None:
+            raise HTTPException(status_code=409, detail="A product with this item_id already exists")
+
+    product = ThroughputProduct(
+        tenant_id=session.tenant_id,
+        item_id=payload.item_id,
+        name=payload.name,
+        default_bag_size=payload.default_bag_size,
+        is_bulka_default=payload.is_bulka_default,
+        active=payload.active,
+        is_stock_item=payload.is_stock_item,
+        notes=payload.notes,
+    )
+    db.add(product)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+@router.patch("/products/{product_id}", response_model=ThroughputProductRead)
+def update_product(
+    product_id: int,
+    payload: ThroughputProductUpdate,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY, "edit")),
+    db: Session = Depends(get_db),
+):
+    product = db.scalar(
+        select(ThroughputProduct).where(
+            ThroughputProduct.id == product_id,
+            ThroughputProduct.tenant_id == session.tenant_id,
+        )
+    )
+    if product is None:
+        raise HTTPException(status_code=404, detail="Product not found")
+    for field, value in payload.model_dump(exclude_unset=True).items():
+        setattr(product, field, value)
+    db.commit()
+    db.refresh(product)
+    return product
+
+
+@router.get("/entries", response_model=list[ThroughputEntryRead])
+def list_entries(
+    date_from: date | None = Query(default=None),
+    date_to: date | None = Query(default=None),
+    product_id: int | None = Query(default=None),
+    staff_name: str | None = Query(default=None),
+    quantity_type: str | None = Query(default=None),
+    limit: int = Query(default=200, ge=1, le=1000),
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY)),
+    db: Session = Depends(get_db),
+):
+    stmt = select(ProductionThroughput).where(ProductionThroughput.tenant_id == session.tenant_id)
+    if date_from is not None:
+        stmt = stmt.where(ProductionThroughput.production_date >= date_from)
+    if date_to is not None:
+        stmt = stmt.where(ProductionThroughput.production_date <= date_to)
+    if product_id is not None:
+        stmt = stmt.where(ProductionThroughput.product_id == product_id)
+    if staff_name:
+        stmt = stmt.where(ProductionThroughput.staff_name == staff_name.strip())
+    if quantity_type in {"bags", "kg"}:
+        stmt = stmt.where(ProductionThroughput.quantity_type == quantity_type)
+    stmt = stmt.order_by(ProductionThroughput.production_date.desc(), ProductionThroughput.id.desc()).limit(limit)
+    return [serialize_entry(entry) for entry in db.scalars(stmt).all()]
+
+
+@router.post("/entries", response_model=ThroughputEntryRead, status_code=status.HTTP_201_CREATED)
+def create_entry(
+    payload: ThroughputEntryCreate,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY, "edit")),
+    db: Session = Depends(get_db),
+):
+    product = None
+    if payload.product_id is not None:
+        product = db.scalar(
+            select(ThroughputProduct).where(
+                ThroughputProduct.id == payload.product_id,
+                ThroughputProduct.tenant_id == session.tenant_id,
+            )
+        )
+        if product is None:
+            raise HTTPException(status_code=400, detail="product_id does not match an existing product")
+
+    snapshot = payload.product_name_snapshot or (product.name if product else None)
+    if not snapshot:
+        raise HTTPException(status_code=400, detail="product_name_snapshot or product_id is required")
+
+    bag_size = payload.bag_size
+    if bag_size is None and product is not None:
+        bag_size = product.default_bag_size
+
+    if payload.quantity_type == "bags" and (bag_size is None or bag_size <= 0):
+        raise HTTPException(status_code=400, detail="bag_size is required when quantity_type is 'bags'")
+
+    calculated = calculate_kg(payload.quantity, payload.quantity_type, bag_size)
+
+    entry = ProductionThroughput(
+        tenant_id=session.tenant_id,
+        production_date=payload.production_date,
+        product_id=product.id if product else None,
+        product_name_snapshot=snapshot,
+        bag_size=bag_size,
+        scales_checked=payload.scales_checked,
+        label_correct=payload.label_correct,
+        bag_sealed=payload.bag_sealed,
+        pallet_good_condition=payload.pallet_good_condition,
+        sample_box_no=payload.sample_box_no,
+        test_weight_1=payload.test_weight_1,
+        test_weight_2=payload.test_weight_2,
+        test_weight_3=payload.test_weight_3,
+        test_weight_4=payload.test_weight_4,
+        test_weight_5=payload.test_weight_5,
+        quantity=payload.quantity,
+        quantity_type=payload.quantity_type,
+        calculated_kg=calculated,
+        staff_name=normalise_staff_name(payload.staff_name),
+        notes=payload.notes,
+        created_by=session.email,
+    )
+    db.add(entry)
+    db.commit()
+    db.refresh(entry)
+    return serialize_entry(entry)
+
+
+@router.get("/entries/{entry_id}", response_model=ThroughputEntryRead)
+def get_entry(
+    entry_id: int,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY)),
+    db: Session = Depends(get_db),
+):
+    entry = db.scalar(
+        select(ProductionThroughput).where(
+            ProductionThroughput.id == entry_id,
+            ProductionThroughput.tenant_id == session.tenant_id,
+        )
+    )
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Entry not found")
+    return serialize_entry(entry)
+
+
+@router.patch("/entries/{entry_id}", response_model=ThroughputEntryRead)
+def update_entry(
+    entry_id: int,
+    payload: ThroughputEntryUpdate,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY, "edit")),
+    db: Session = Depends(get_db),
+):
+    entry = db.scalar(
+        select(ProductionThroughput).where(
+            ProductionThroughput.id == entry_id,
+            ProductionThroughput.tenant_id == session.tenant_id,
+        )
+    )
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Entry not found")
+
+    data = payload.model_dump(exclude_unset=True)
+    if "staff_name" in data:
+        data["staff_name"] = normalise_staff_name(data["staff_name"])
+    for field, value in data.items():
+        setattr(entry, field, value)
+
+    entry.calculated_kg = calculate_kg(entry.quantity, entry.quantity_type, entry.bag_size)
+
+    db.commit()
+    db.refresh(entry)
+    return serialize_entry(entry)
+
+
+@router.delete("/entries/{entry_id}", status_code=status.HTTP_204_NO_CONTENT)
+def delete_entry(
+    entry_id: int,
+    session: AuthSession = Depends(require_client_module_access(MODULE_KEY, "manage")),
+    db: Session = Depends(get_db),
+):
+    entry = db.scalar(
+        select(ProductionThroughput).where(
+            ProductionThroughput.id == entry_id,
+            ProductionThroughput.tenant_id == session.tenant_id,
+        )
+    )
+    if entry is None:
+        raise HTTPException(status_code=404, detail="Entry not found")
+    db.delete(entry)
+    db.commit()
+    return None

backend/app/core/access.py

@@ -51,6 +51,8 @@ _PERMISSION_TO_MODULE_LEVEL: dict[str, tuple[str, str]] = {
     "edit_products": ("products", "edit"),
     "view_mixes": ("mix_master", "view"),
     "edit_mixes": ("mix_master", "edit"),
+    "view_throughput": ("operations_throughput", "view"),
+    "edit_throughput": ("operations_throughput", "edit"),
     # Admin-only permissions (view_users, manage_users, manage_permissions,
     # view_settings, edit_settings) are intentionally excluded — they don't
     # correspond to any of the legacy module keys and remain accessible only

backend/app/core/config.py

@@ -1,5 +1,10 @@
 import os
 from dataclasses import dataclass
+from pathlib import Path
+
+
+DEFAULT_SQLITE_PATH = (Path(__file__).resolve().parents[2] / "data_entry_app.db").as_posix()
+DEFAULT_DATABASE_URL = f"sqlite:///{DEFAULT_SQLITE_PATH}"
 
 
 DEFAULT_CORS_ALLOW_ORIGIN_REGEX = (
@@ -63,7 +68,10 @@ class Settings:
             port=int(os.getenv("PORT", "8000")),
             log_level=os.getenv("LOG_LEVEL", "DEBUG" if os.getenv("LOG_VERBOSE") in {"1", "true", "TRUE", "yes", "on"} else "INFO"),
             log_verbose=_env_flag("LOG_VERBOSE"),
-            database_url=os.getenv("DATABASE_URL", "sqlite:///./data_entry_app.db"),
+            # Keep the default SQLite location stable regardless of the current
+            # working directory so local dev does not silently fork data into
+            # multiple `data_entry_app.db` files.
+            database_url=os.getenv("DATABASE_URL", DEFAULT_DATABASE_URL),
             client_name=os.getenv("CLIENT_NAME", "Hunter Premium Produce"),
             client_email=os.getenv("CLIENT_EMAIL", "operator@example.com"),
             client_password=os.getenv("CLIENT_PASSWORD", "changeme"),

backend/app/db/migrations.py

@@ -25,6 +25,7 @@ TENANT_TABLES = {
     "raw_material_price_versions": None,
     "mixes": None,
     "mix_ingredients": None,
+    "product_ingredients": None,
     "mix_calculator_sessions": None,
     "mix_calculator_session_lines": None,
     "products": None,
@@ -33,6 +34,8 @@ TENANT_TABLES = {
     "process_cost_rules": None,
     "packaging_cost_rules": None,
     "freight_cost_rules": None,
+    "throughput_products": None,
+    "production_throughput_entries": None,
 }
 
 
@@ -99,6 +102,7 @@ def ensure_tenant_columns(engine: Engine) -> tuple[str, ...]:
 _LEGACY_COLUMN_PATCHES: tuple[tuple[str, str, str], ...] = (
     ("users", "password_hash", "VARCHAR(255)"),
     ("products", "visible", "BOOLEAN NOT NULL DEFAULT TRUE"),
+    ("throughput_products", "is_stock_item", "BOOLEAN NOT NULL DEFAULT TRUE"),
 )
 
 
@@ -243,6 +247,20 @@ def sync_tenant_ids(engine: Engine) -> dict[str, int]:
                 """
                 ),
             ),
+            (
+                "product_ingredients",
+                text(
+                """
+                UPDATE product_ingredients
+                SET tenant_id = (
+                    SELECT products.tenant_id
+                    FROM products
+                    WHERE products.id = product_ingredients.product_id
+                )
+                WHERE tenant_id IS NULL OR tenant_id = '' OR tenant_id = 'default'
+                """
+                ),
+            ),
             (
                 "products",
                 text(

backend/app/main.py

@@ -28,6 +28,7 @@ from app.api.powerbi import router as powerbi_router
 from app.api.products import router as products_router
 from app.api.raw_materials import router as raw_materials_router
 from app.api.scenarios import router as scenarios_router
+from app.api.throughput import router as throughput_router
 from app.core.config import settings
 from app.core.logging import (
     LoggingSettings,
@@ -46,7 +47,7 @@ from app.core.logging import (
 )
 from app.db.session import Base, engine
 from app.db.migrations import MigrationReport, bootstrap_schema, sync_product_visibility, sync_tenant_ids
-from app.seed import seed_if_empty
+from app.seed import seed_startup_basics
 
 
 def _resolve_version() -> str:
@@ -100,7 +101,7 @@ def ensure_database_ready() -> MigrationReport:
             return MigrationReport()
 
         schema_report = bootstrap_schema(engine, Base.metadata)
-        seed_if_empty()
+        seed_startup_basics()
         tenant_sync_report = sync_tenant_ids(engine)
         hidden_product_count = sync_product_visibility(engine)
 
@@ -153,7 +154,10 @@ async def lifespan(app: FastAPI):
 
     section_heading("Services")
     success("HTTP API ready")
+    if settings.docs_enabled:
         info("Docs available at /docs", logger_name="data_entry_app.services")
+    else:
+        info("Docs disabled in this environment", logger_name="data_entry_app.services")
     info("Health probe available at /health", logger_name="data_entry_app.services")
 
     yield
@@ -195,6 +199,7 @@ app.include_router(mixes_router)
 app.include_router(mix_calculator_router)
 app.include_router(products_router)
 app.include_router(scenarios_router)
+app.include_router(throughput_router)
 app.include_router(powerbi_router)
 
 
@@ -300,6 +305,7 @@ def root():
             "mix_calculator": "/api/mix-calculator",
             "products": "/api/products",
             "scenarios": "/api/scenarios",
+            "operations_throughput": "/api/throughput",
             "client_access": "/api/client-access",
             "docs": "/docs",
         },

backend/app/models/__init__.py

@@ -3,9 +3,10 @@ from app.models.assumption import FreightCostRule, PackagingCostRule, ProcessCos
 from app.models.client_access import ClientAccessAuditEvent, ClientAccount, ClientFeatureAccess, ClientUser, ClientUserModulePermission
 from app.models.mix_calculator import MixCalculatorSession, MixCalculatorSessionLine
 from app.models.mix import Mix, MixIngredient
-from app.models.product import Product
+from app.models.product import Product, ProductIngredient
 from app.models.raw_material import RawMaterial, RawMaterialPriceVersion
 from app.models.scenario import CostingResult, Scenario
+from app.models.throughput import ProductionThroughput, ThroughputProduct
 
 __all__ = [
     "ClientAccount",
@@ -23,6 +24,9 @@ __all__ = [
     "Permission",
     "ProcessCostRule",
     "Product",
+    "ProductIngredient",
+    "ProductionThroughput",
+    "ThroughputProduct",
     "RawMaterial",
     "RawMaterialPriceVersion",
     "Role",

backend/app/models/product.py

@@ -2,7 +2,7 @@ from __future__ import annotations
 
 from datetime import datetime
 
-from sqlalchemy import Boolean, DateTime, Float, ForeignKey, Integer, String, Text
+from sqlalchemy import Boolean, DateTime, Float, ForeignKey, Integer, String, Text, UniqueConstraint
 from sqlalchemy.orm import Mapped, mapped_column, relationship
 
 from app.db.session import Base
@@ -29,6 +29,28 @@ class Product(Base):
     created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
 
     mix: Mapped["Mix"] = relationship(back_populates="products")
+    ingredients: Mapped[list["ProductIngredient"]] = relationship(
+        back_populates="product",
+        cascade="all, delete-orphan",
+        order_by="ProductIngredient.sort_order",
+    )
+
+
+class ProductIngredient(Base):
+    __tablename__ = "product_ingredients"
+    __table_args__ = (UniqueConstraint("product_id", "raw_material_id", name="uq_product_ingredient"),)
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tenant_id: Mapped[str] = mapped_column(String(64), default="default", index=True)
+    product_id: Mapped[int] = mapped_column(ForeignKey("products.id"), index=True)
+    raw_material_id: Mapped[int] = mapped_column(ForeignKey("raw_materials.id"), index=True)
+    quantity_kg: Mapped[float] = mapped_column(Float)
+    sort_order: Mapped[int] = mapped_column(Integer, default=0)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    product: Mapped[Product] = relationship(back_populates="ingredients")
+    raw_material: Mapped["RawMaterial"] = relationship()
 
 
 from app.models.mix import Mix  # noqa: E402
+from app.models.raw_material import RawMaterial  # noqa: E402

backend/app/models/throughput.py

@@ -0,0 +1,70 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+
+from sqlalchemy import Boolean, Date, DateTime, Float, ForeignKey, Index, Integer, String, Text
+from sqlalchemy.orm import Mapped, mapped_column, relationship
+
+from app.db.session import Base
+
+
+class ThroughputProduct(Base):
+    __tablename__ = "throughput_products"
+    __table_args__ = (
+        Index("ix_throughput_products_tenant_item", "tenant_id", "item_id", unique=True),
+        Index("ix_throughput_products_tenant_name", "tenant_id", "name"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tenant_id: Mapped[str] = mapped_column(String(64), default="default", index=True)
+    item_id: Mapped[str | None] = mapped_column(String(64), nullable=True)
+    name: Mapped[str] = mapped_column(String(255))
+    default_bag_size: Mapped[float | None] = mapped_column(Float, nullable=True)
+    is_bulka_default: Mapped[bool] = mapped_column(Boolean, default=False)
+    active: Mapped[bool] = mapped_column(Boolean, default=True)
+    is_stock_item: Mapped[bool] = mapped_column(Boolean, default=True)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    entries: Mapped[list["ProductionThroughput"]] = relationship(back_populates="product")
+
+
+class ProductionThroughput(Base):
+    __tablename__ = "production_throughput_entries"
+    __table_args__ = (
+        Index("ix_throughput_entries_tenant_date", "tenant_id", "production_date"),
+    )
+
+    id: Mapped[int] = mapped_column(primary_key=True)
+    tenant_id: Mapped[str] = mapped_column(String(64), default="default", index=True)
+    production_date: Mapped[date] = mapped_column(Date)
+    product_id: Mapped[int | None] = mapped_column(ForeignKey("throughput_products.id"), nullable=True, index=True)
+    product_name_snapshot: Mapped[str] = mapped_column(String(255))
+    bag_size: Mapped[float | None] = mapped_column(Float, nullable=True)
+
+    scales_checked: Mapped[bool] = mapped_column(Boolean, default=True)
+    label_correct: Mapped[bool] = mapped_column(Boolean, default=True)
+    bag_sealed: Mapped[bool] = mapped_column(Boolean, default=True)
+    pallet_good_condition: Mapped[bool] = mapped_column(Boolean, default=True)
+
+    sample_box_no: Mapped[str | None] = mapped_column(String(64), nullable=True)
+
+    test_weight_1: Mapped[float | None] = mapped_column(Float, nullable=True)
+    test_weight_2: Mapped[float | None] = mapped_column(Float, nullable=True)
+    test_weight_3: Mapped[float | None] = mapped_column(Float, nullable=True)
+    test_weight_4: Mapped[float | None] = mapped_column(Float, nullable=True)
+    test_weight_5: Mapped[float | None] = mapped_column(Float, nullable=True)
+
+    quantity: Mapped[float] = mapped_column(Float, default=0.0)
+    quantity_type: Mapped[str] = mapped_column(String(8), default="bags")
+    calculated_kg: Mapped[float] = mapped_column(Float, default=0.0)
+
+    staff_name: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    notes: Mapped[str | None] = mapped_column(Text, nullable=True)
+
+    created_by: Mapped[str | None] = mapped_column(String(255), nullable=True)
+    created_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow)
+    updated_at: Mapped[datetime] = mapped_column(DateTime, default=datetime.utcnow, onupdate=datetime.utcnow)
+
+    product: Mapped[ThroughputProduct | None] = relationship(back_populates="entries")

backend/app/schemas/throughput.py

@@ -0,0 +1,128 @@
+from __future__ import annotations
+
+from datetime import date, datetime
+from typing import Literal
+
+from pydantic import BaseModel, ConfigDict, Field, field_validator
+
+
+QuantityType = Literal["bags", "kg"]
+
+
+class ThroughputProductBase(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    item_id: str | None = Field(default=None, max_length=64)
+    name: str = Field(min_length=1, max_length=255)
+    default_bag_size: float | None = Field(default=None, ge=0)
+    is_bulka_default: bool = False
+    active: bool = True
+    is_stock_item: bool = True
+    notes: str | None = Field(default=None, max_length=2000)
+
+
+class ThroughputProductCreate(ThroughputProductBase):
+    pass
+
+
+class ThroughputProductUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    item_id: str | None = Field(default=None, max_length=64)
+    name: str | None = Field(default=None, min_length=1, max_length=255)
+    default_bag_size: float | None = Field(default=None, ge=0)
+    is_bulka_default: bool | None = None
+    active: bool | None = None
+    is_stock_item: bool | None = None
+    notes: str | None = Field(default=None, max_length=2000)
+
+
+class ThroughputProductRead(ThroughputProductBase):
+    id: int
+    tenant_id: str
+    created_at: datetime
+    updated_at: datetime
+    model_config = ConfigDict(from_attributes=True)
+
+
+class ThroughputEntryBase(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    production_date: date
+    product_id: int | None = None
+    product_name_snapshot: str | None = Field(default=None, max_length=255)
+    bag_size: float | None = Field(default=None, ge=0)
+    scales_checked: bool = True
+    label_correct: bool = True
+    bag_sealed: bool = True
+    pallet_good_condition: bool = True
+    sample_box_no: str | None = Field(default=None, max_length=64)
+    test_weight_1: float | None = Field(default=None, ge=0)
+    test_weight_2: float | None = Field(default=None, ge=0)
+    test_weight_3: float | None = Field(default=None, ge=0)
+    test_weight_4: float | None = Field(default=None, ge=0)
+    test_weight_5: float | None = Field(default=None, ge=0)
+    quantity: float = Field(ge=0)
+    quantity_type: QuantityType = "bags"
+    staff_name: str | None = Field(default=None, max_length=255)
+    notes: str | None = Field(default=None, max_length=2000)
+
+    @field_validator("staff_name")
+    @classmethod
+    def _normalize_staff(cls, value: str | None) -> str | None:
+        if value is None:
+            return None
+        stripped = value.strip()
+        return stripped or None
+
+
+class ThroughputEntryCreate(ThroughputEntryBase):
+    pass
+
+
+class ThroughputEntryUpdate(BaseModel):
+    model_config = ConfigDict(extra="forbid")
+    production_date: date | None = None
+    product_id: int | None = None
+    product_name_snapshot: str | None = Field(default=None, max_length=255)
+    bag_size: float | None = Field(default=None, ge=0)
+    scales_checked: bool | None = None
+    label_correct: bool | None = None
+    bag_sealed: bool | None = None
+    pallet_good_condition: bool | None = None
+    sample_box_no: str | None = Field(default=None, max_length=64)
+    test_weight_1: float | None = Field(default=None, ge=0)
+    test_weight_2: float | None = Field(default=None, ge=0)
+    test_weight_3: float | None = Field(default=None, ge=0)
+    test_weight_4: float | None = Field(default=None, ge=0)
+    test_weight_5: float | None = Field(default=None, ge=0)
+    quantity: float | None = Field(default=None, ge=0)
+    quantity_type: QuantityType | None = None
+    staff_name: str | None = Field(default=None, max_length=255)
+    notes: str | None = Field(default=None, max_length=2000)
+
+
+class ThroughputEntryRead(BaseModel):
+    id: int
+    tenant_id: str
+    production_date: date
+    product_id: int | None
+    product_name_snapshot: str
+    bag_size: float | None
+    scales_checked: bool
+    label_correct: bool
+    bag_sealed: bool
+    pallet_good_condition: bool
+    sample_box_no: str | None
+    test_weight_1: float | None
+    test_weight_2: float | None
+    test_weight_3: float | None
+    test_weight_4: float | None
+    test_weight_5: float | None
+    quantity: float
+    quantity_type: QuantityType
+    calculated_kg: float
+    staff_name: str | None
+    notes: str | None
+    qa_passed: bool
+    created_by: str | None
+    created_at: datetime
+    updated_at: datetime
+    model_config = ConfigDict(from_attributes=True)

backend/app/seed.py

@@ -9,21 +9,26 @@ import re
 
 from openpyxl import load_workbook
 from sqlalchemy import select
+from sqlalchemy.orm import selectinload
 
 from app.db.session import Base, SessionLocal, engine
 from app.models.assumption import FreightCostRule, PackagingCostRule, ProcessCostRule
 from app.models.client_access import ClientAccessAuditEvent, ClientAccount, ClientFeatureAccess, ClientUser, ClientUserModulePermission
 from app.models.mix import Mix, MixIngredient
-from app.models.product import Product
+from app.models.product import Product, ProductIngredient
 from app.models.raw_material import RawMaterial, RawMaterialPriceVersion
+from app.models.throughput import ProductionThroughput, ThroughputProduct
 from app.seed_access import seed_access
 from app.services.client_access_service import MODULE_CATALOG, default_access_level_for_role
+from app.services.throughput_service import import_workbook as import_throughput_workbook
+from app.services.throughput_service import resolve_workbook_path as resolve_throughput_workbook_path
 
 
 TENANT_ID = "hunter-premium-produce"
 WORKBOOK_EFFECTIVE_DATE = date(2025, 9, 1)
 WORKBOOK_SENTINEL_ITEM_ID = "404266"
-WORKBOOK_FILENAME = "Input Cost Spreadsheet(1).xlsx"
+WORKBOOK_FILENAME = "1.xlsx"
+LEGACY_WORKBOOK_FILENAME = "Input Cost Spreadsheet(1).xlsx"
 logger = logging.getLogger("data_entry_app.seed")
 HIDDEN_PRODUCT_CLIENTS = frozenset(
     {
@@ -46,11 +51,18 @@ def _workbook_candidates() -> list[Path]:
 
     candidates = [
         Path(env_path) if env_path else None,
+        repo_root / "input_data" / WORKBOOK_FILENAME,
+        cwd / "input_data" / WORKBOOK_FILENAME,
         Path("/srv/lean101-clients") / WORKBOOK_FILENAME,
         repo_root / WORKBOOK_FILENAME,
         cwd / WORKBOOK_FILENAME,
         Path("/app") / WORKBOOK_FILENAME,
         Path("/") / WORKBOOK_FILENAME,
+        repo_root / LEGACY_WORKBOOK_FILENAME,
+        cwd / LEGACY_WORKBOOK_FILENAME,
+        Path("/srv/lean101-clients") / LEGACY_WORKBOOK_FILENAME,
+        Path("/app") / LEGACY_WORKBOOK_FILENAME,
+        Path("/") / LEGACY_WORKBOOK_FILENAME,
     ]
 
     ordered: list[Path] = []
@@ -73,9 +85,6 @@ def _resolve_workbook_path() -> Path:
     return _workbook_candidates()[0]
 
 
-WORKBOOK_PATH = _resolve_workbook_path()
-
-
 def _text(value) -> str | None:
     if value is None:
         return None
@@ -178,7 +187,21 @@ def _build_process_key(label, grading_cost: float, bagging_cost: float, cracking
     return f"{base}_g{int(round(grading_cost * 1000))}_b{int(round(bagging_cost * 1000))}_c{int(round(cracking_cost * 1000))}"
 
 
-def _load_workbook():
+def _load_workbook(*required_sheets: str):
+    for candidate in _workbook_candidates():
+        if not candidate.exists():
+            continue
+        workbook = load_workbook(candidate, data_only=True)
+        if all(sheet_name in workbook.sheetnames for sheet_name in required_sheets):
+            return workbook
+
+    if required_sheets:
+        raise FileNotFoundError(
+            "No workbook with required sheets found. "
+            f"Required sheets: {', '.join(required_sheets)}. "
+            f"Checked: {', '.join(str(path) for path in _workbook_candidates())}"
+        )
+
     workbook_path = _resolve_workbook_path()
     if not workbook_path.exists():
         raise FileNotFoundError(
@@ -258,6 +281,44 @@ def _read_mix_rows(workbook) -> dict[tuple[str, str], dict]:
     return best_rows
 
 
+def _read_product_ingredient_rows(workbook) -> dict[tuple[str, str], dict]:
+    worksheet = workbook["mix_quantites_per_client_per_pr"]
+    header_row = next(worksheet.iter_rows(min_row=1, max_row=1, values_only=True))
+    ingredient_names = [_text(value) for value in header_row[3:] if _text(value)]
+    rows: dict[tuple[str, str], dict] = {}
+
+    for row in worksheet.iter_rows(min_row=2, values_only=True):
+        client_name = _text(row[0])
+        product_name = _text(row[1])
+        if not client_name or not product_name:
+            continue
+
+        ingredients = []
+        for sort_order, (ingredient_name, quantity) in enumerate(zip(ingredient_names, row[3 : 3 + len(ingredient_names)]), start=1):
+            numeric_quantity = _number(quantity)
+            if ingredient_name and numeric_quantity and numeric_quantity > 0:
+                ingredients.append(
+                    {
+                        "raw_material_name": ingredient_name,
+                        "quantity_kg": numeric_quantity,
+                        "sort_order": sort_order,
+                    }
+                )
+
+        if not ingredients:
+            continue
+
+        total_kg = _number(row[2]) or round(sum(item["quantity_kg"] for item in ingredients), 4)
+        rows[(client_name, product_name)] = {
+            "client_name": client_name,
+            "product_name": product_name,
+            "total_kg": total_kg,
+            "ingredients": ingredients,
+        }
+
+    return rows
+
+
 def _read_product_rows(workbook) -> list[dict]:
     worksheet = workbook["Product Cost - Price"]
     raw_rows: list[dict] = []
@@ -606,6 +667,184 @@ def _upsert_products(db, products: list[dict], mix_lookup: dict[tuple[str, str],
             product.notes = "Seeded from Input Cost Spreadsheet(1).xlsx"
 
 
+def _upsert_product_ingredients(
+    db,
+    *,
+    product_rows: list[dict],
+    product_ingredient_rows: dict[tuple[str, str], dict],
+    raw_material_map: dict[str, RawMaterial],
+) -> None:
+    products = db.scalars(
+        select(Product).where(Product.tenant_id == TENANT_ID).options(selectinload(Product.mix))
+    ).all()
+
+    products_by_formula_key: dict[tuple[str, str], list[Product]] = {}
+    for product in products:
+        candidate_keys = {
+            (product.client_name, product.name),
+        }
+        if product.mix is not None:
+            candidate_keys.add((product.client_name, product.mix.name))
+        for key in candidate_keys:
+            products_by_formula_key.setdefault(key, []).append(product)
+
+    for key, formula in product_ingredient_rows.items():
+        matched_products = products_by_formula_key.get(key, [])
+        if not matched_products:
+            continue
+
+        for product in matched_products:
+            existing_ingredients = {
+                ingredient.raw_material_id: ingredient
+                for ingredient in db.scalars(select(ProductIngredient).where(ProductIngredient.product_id == product.id)).all()
+            }
+            desired_ids: set[int] = set()
+
+            for row in formula["ingredients"]:
+                raw_material = raw_material_map.get(row["raw_material_name"])
+                if raw_material is None:
+                    continue
+
+                desired_ids.add(raw_material.id)
+                ingredient = existing_ingredients.get(raw_material.id)
+                if ingredient is None:
+                    db.add(
+                        ProductIngredient(
+                            tenant_id=TENANT_ID,
+                            product_id=product.id,
+                            raw_material_id=raw_material.id,
+                            quantity_kg=row["quantity_kg"],
+                            sort_order=row["sort_order"],
+                        )
+                    )
+                else:
+                    ingredient.quantity_kg = row["quantity_kg"]
+                    ingredient.sort_order = row["sort_order"]
+
+            for raw_material_id, ingredient in existing_ingredients.items():
+                if raw_material_id not in desired_ids:
+                    db.delete(ingredient)
+
+
+def _infer_throughput_bag_size(product: Product) -> float | None:
+    if product.sale_type == "bulka":
+        return None
+    unit = (product.unit_of_measure or "").strip().lower()
+    match = re.search(r"(\d+(?:\.\d+)?)\s*kg", unit)
+    if match:
+        return float(match.group(1))
+    if unit == "kg":
+        return 1.0
+    if unit == "tonne":
+        return 1000.0
+    return None
+
+
+def _infer_throughput_bulka_default(product: Product) -> bool:
+    unit = (product.unit_of_measure or "").lower()
+    return product.sale_type == "bulka" or "bulka" in product.name.lower() or "bulka" in unit
+
+
+def seed_throughput_products_from_costing(db) -> dict[str, int]:
+    """Mirror costing products into the throughput product dropdown."""
+    costing_products = db.scalars(
+        select(Product)
+        .where(Product.tenant_id == TENANT_ID)
+        .order_by(Product.name, Product.id)
+    ).all()
+    if not costing_products:
+        return {"created": 0, "updated": 0, "skipped": 0}
+
+    throughput_products = db.scalars(
+        select(ThroughputProduct).where(ThroughputProduct.tenant_id == TENANT_ID)
+    ).all()
+    by_item = {
+        throughput_product.item_id: throughput_product
+        for throughput_product in throughput_products
+        if throughput_product.item_id
+    }
+    by_name = {
+        throughput_product.name.strip().lower(): throughput_product
+        for throughput_product in throughput_products
+        if throughput_product.name
+    }
+
+    created = 0
+    updated = 0
+    skipped = 0
+    seen_item_ids: set[str] = set()
+    seen_names: set[str] = set()
+    for costing_product in costing_products:
+        name = (costing_product.name or "").strip()
+        if not name:
+            skipped += 1
+            continue
+
+        item_id = (costing_product.item_id or "").strip() or None
+        name_key = name.lower()
+        if item_id and item_id in seen_item_ids:
+            skipped += 1
+            continue
+        if not item_id and name_key in seen_names:
+            skipped += 1
+            continue
+        if item_id:
+            seen_item_ids.add(item_id)
+        seen_names.add(name_key)
+
+        default_bag_size = _infer_throughput_bag_size(costing_product)
+        is_bulka_default = _infer_throughput_bulka_default(costing_product)
+        product = (by_item.get(item_id) if item_id else None) or by_name.get(name_key)
+        if product is None:
+            product = ThroughputProduct(
+                tenant_id=TENANT_ID,
+                item_id=item_id,
+                name=name,
+                default_bag_size=default_bag_size,
+                is_bulka_default=is_bulka_default,
+                active=costing_product.visible,
+                is_stock_item=True,
+                notes="Seeded from costing products",
+            )
+            db.add(product)
+            created += 1
+            if item_id:
+                by_item[item_id] = product
+            by_name[name_key] = product
+            continue
+
+        changed = False
+        if item_id and product.item_id != item_id:
+            product.item_id = item_id
+            changed = True
+        if product.name != name:
+            old_name_key = product.name.strip().lower() if product.name else None
+            product.name = name
+            if old_name_key:
+                by_name.pop(old_name_key, None)
+            by_name[name_key] = product
+            changed = True
+        if product.default_bag_size != default_bag_size:
+            product.default_bag_size = default_bag_size
+            changed = True
+        if product.is_bulka_default != is_bulka_default:
+            product.is_bulka_default = is_bulka_default
+            changed = True
+        if product.active != costing_product.visible:
+            product.active = costing_product.visible
+            changed = True
+        if product.is_stock_item is not True:
+            product.is_stock_item = True
+            changed = True
+        if product.notes in {None, "", "Seeded from costing products"}:
+            product.notes = "Seeded from costing products"
+        if changed:
+            updated += 1
+
+    db.flush()
+    return {"created": created, "updated": updated, "skipped": skipped}
+
+
 def seed_client_access(db):
     existing = db.scalar(select(ClientAccount.id))
     if existing is not None:
@@ -667,7 +906,7 @@ def seed_client_access(db):
     )
 
     enabled_feature_map = {
-        TENANT_ID: {"dashboard", "raw_materials", "mix_master", "mix_calculator", "products", "scenarios", "powerbi_export", "client_access"},
+        TENANT_ID: {"dashboard", "raw_materials", "mix_master", "mix_calculator", "products", "scenarios", "powerbi_export", "client_access", "operations_throughput"},
         "loft-grains": {"dashboard", "mix_calculator", "products", "powerbi_export"},
     }
 
@@ -713,10 +952,13 @@ def seed_client_access(db):
 
 
 def seed_costing_workspace(db):
-    workbook = _load_workbook()
-    raw_material_rows = _read_raw_material_rows(workbook)
-    mix_rows = _read_mix_rows(workbook)
-    product_rows = _read_product_rows(workbook)
+    costing_workbook = _load_workbook("C- Raw Products Costs", "M - All", "Product Cost - Price")
+    formula_workbook = _load_workbook("mix_quantites_per_client_per_pr")
+
+    raw_material_rows = _read_raw_material_rows(costing_workbook)
+    mix_rows = _read_mix_rows(costing_workbook)
+    product_rows = _read_product_rows(costing_workbook)
+    product_ingredient_rows = _read_product_ingredient_rows(formula_workbook)
 
     raw_material_map = _upsert_raw_materials(db, raw_material_rows)
     _upsert_process_rules(db, product_rows)
@@ -735,9 +977,53 @@ def seed_costing_workspace(db):
         mix_cache[(mix_row["client_name"], mix_row["name"])] = mix
 
     _upsert_products(db, product_rows, mix_cache, raw_material_map)
+    _upsert_product_ingredients(
+        db,
+        product_rows=product_rows,
+        product_ingredient_rows=product_ingredient_rows,
+        raw_material_map=raw_material_map,
+    )
 
 
-def seed_if_empty():
+def seed_throughput_workbook(db):
+    """Import the Operations Throughput workbook on first run if tables are empty."""
+    has_products = db.scalar(select(ThroughputProduct.id)) is not None
+    has_entries = db.scalar(select(ProductionThroughput.id)) is not None
+    if not has_products and not has_entries:
+        workbook_path = resolve_throughput_workbook_path()
+        if workbook_path is None:
+            logger.info("Operations Throughput workbook not found; seeding throughput products from costing products")
+        else:
+            try:
+                report = import_throughput_workbook(db, workbook_path, TENANT_ID)
+            except Exception:
+                logger.exception("Failed to seed Operations Throughput workbook from %s", workbook_path)
+            else:
+                logger.info("Operations Throughput seeded from %s: %s", workbook_path, report)
+
+    report = seed_throughput_products_from_costing(db)
+    if any(report.values()):
+        logger.info("Throughput products synced from costing products: %s", report)
+
+
+def seed_throughput_products(db):
+    """Sync throughput products from costing products without importing historical entries."""
+    report = seed_throughput_products_from_costing(db)
+    if any(report.values()):
+        logger.info("Throughput products synced from costing products: %s", report)
+        return
+
+
+def seed_startup_basics():
+    Base.metadata.create_all(bind=engine)
+    with SessionLocal() as db:
+        seed_client_access(db)
+        seed_access(db)
+        seed_throughput_workbook(db)
+        db.commit()
+
+
+def seed_all():
     Base.metadata.create_all(bind=engine)
     with SessionLocal() as db:
         workbook_path = _resolve_workbook_path()
@@ -748,10 +1034,29 @@ def seed_if_empty():
                 "Skipping costing workspace seed because workbook is missing. Checked: %s",
                 ", ".join(str(path) for path in _workbook_candidates()),
             )
+        seed_throughput_products(db)
+        seed_client_access(db)
+        seed_access(db)
+        db.commit()
+
+
+def seed_if_empty():
+    Base.metadata.create_all(bind=engine)
+    with SessionLocal() as db:
+        if db.scalar(select(RawMaterial.id)) is None:
+            workbook_path = _resolve_workbook_path()
+            if workbook_path.exists():
+                seed_costing_workspace(db)
+            else:
+                logger.warning(
+                    "Skipping costing workspace seed because workbook is missing. Checked: %s",
+                    ", ".join(str(path) for path in _workbook_candidates()),
+                )
+        seed_throughput_products(db)
         seed_client_access(db)
         seed_access(db)
         db.commit()
 
 
 if __name__ == "__main__":
-    seed_if_empty()
+    seed_all()

backend/app/seed_access.py

@@ -3,13 +3,18 @@
 Re-running this is safe: it upserts permissions, syncs each role's permission
 set to the declared list, and creates or updates the seed users without
 duplicating rows. Permission grants are the source of truth — change them
-here (or in the DB) rather than in route code.
+here (or in the DB) rather than in route code. Existing password hashes are
+left intact; only users with no password hash get the current default
+``ADMIN_PASSWORD`` hashed into the row.
 """
 from __future__ import annotations
 
 from sqlalchemy import select
 from sqlalchemy.orm import Session, selectinload
 
+from app.core.config import settings
+from app.core.security import hash_password
+from app.db.session import SessionLocal
 from app.models.access import Permission, Role, User
 
 
@@ -24,6 +29,8 @@ PERMISSION_DEFINITIONS: tuple[tuple[str, str], ...] = (
     ("edit_products", "Create and edit finished products"),
     ("view_mixes", "View mix master recipes"),
     ("edit_mixes", "Create and edit mix master recipes"),
+    ("view_throughput", "View operations throughput"),
+    ("edit_throughput", "Create and edit operations throughput entries"),
     ("view_users", "View internal users and roles"),
     ("manage_users", "Create, deactivate, and assign user roles"),
     ("manage_permissions", "Modify roles and role-permission assignments"),
@@ -44,6 +51,8 @@ ROLE_DEFINITIONS: dict[str, dict] = {
             "edit_raw_materials",
             "view_products",
             "view_mixes",
+            "view_throughput",
+            "edit_throughput",
             "view_users",
             "manage_users",
             "manage_permissions",
@@ -52,11 +61,13 @@ ROLE_DEFINITIONS: dict[str, dict] = {
         ],
     },
     "Operations": {
-        "description": "Mix calculator only — cannot edit raw materials, products, mixes, users, or settings.",
+        "description": "Mix calculator and operations throughput — cannot edit raw materials, products, mixes, users, or settings.",
         "permissions": [
             "view_mix_calculator",
             "use_mix_calculator",
             "save_mix_calculator_session",
+            "view_throughput",
+            "edit_throughput",
         ],
     },
     "Full Access": {
@@ -72,6 +83,8 @@ ROLE_DEFINITIONS: dict[str, dict] = {
             "edit_products",
             "view_mixes",
             "edit_mixes",
+            "view_throughput",
+            "edit_throughput",
         ],
     },
 }
@@ -154,6 +167,8 @@ def _upsert_users(db: Session, roles_by_name: dict[str, Role]) -> None:
             user.role_id = role.id
             if not user.is_active:
                 user.is_active = True
+        if user.password_hash is None:
+            user.password_hash = hash_password(settings.admin_password)
     db.flush()
 
 
@@ -162,3 +177,13 @@ def seed_access(db: Session) -> None:
     permissions_by_key = _upsert_permissions(db)
     roles_by_name = _upsert_roles(db, permissions_by_key)
     _upsert_users(db, roles_by_name)
+
+
+def seed_access_from_session() -> None:
+    with SessionLocal() as db:
+        seed_access(db)
+        db.commit()
+
+
+if __name__ == "__main__":
+    seed_access_from_session()

backend/app/services/client_access_service.py

@@ -20,6 +20,7 @@ MODULE_CATALOG = (
     ("mix_calculator", "Mix Calculator", "production", "Create and review client-specific mix calculation sessions"),
     ("products", "Products", "pricing", "Review finished product pricing"),
     ("scenarios", "Scenarios", "planning", "Run scenario overrides and comparisons"),
+    ("operations_throughput", "Operations Throughput", "production", "Log production throughput and QA checks for grain/feed packing"),
     ("powerbi_export", "Power BI Export", "reporting", "Expose client access data to BI consumers"),
     ("client_access", "Client Access", "administration", "Manage user access, module permissions, and audit history"),
 )
@@ -78,15 +79,15 @@ def has_access_level(access_level: str | None, minimum_level: str) -> bool:
 def default_access_level_for_role(role: str, module_key: str) -> str:
     normalized = role.strip().lower()
     if normalized == "superadmin":
-        return "manage" if module_key in {"client_access", "mix_calculator"} else "edit"
+        return "manage" if module_key in {"client_access", "mix_calculator", "operations_throughput"} else "edit"
     if normalized == "admin":
-        if module_key == "mix_calculator":
+        if module_key in {"mix_calculator", "operations_throughput"}:
             return "manage"
         return "edit" if module_key != "client_access" else "none"
     if normalized == "operator":
-        return "edit" if module_key in {"dashboard", "raw_materials", "mix_master", "mix_calculator", "products", "scenarios"} else "none"
+        return "edit" if module_key in {"dashboard", "raw_materials", "mix_master", "mix_calculator", "products", "scenarios", "operations_throughput"} else "none"
     if normalized == "viewer":
-        return "view" if module_key in {"dashboard", "mix_calculator", "products", "powerbi_export"} else "none"
+        return "view" if module_key in {"dashboard", "mix_calculator", "products", "powerbi_export", "operations_throughput"} else "none"
     return "none"
 
 

backend/app/services/costing_engine.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session, selectinload
 
 from app.models.assumption import FreightCostRule, PackagingCostRule, ProcessCostRule
 from app.models.mix import Mix, MixIngredient
-from app.models.product import Product
+from app.models.product import Product, ProductIngredient
 from app.models.raw_material import RawMaterial, RawMaterialPriceVersion
 
 
@@ -119,6 +119,78 @@ def calculate_mix_cost(db: Session, mix_id: int, overrides: dict | None = None)
     }
 
 
+def _calculate_formula_cost_from_product_ingredients(
+    product_ingredients: list[ProductIngredient],
+    overrides: dict | None = None,
+) -> dict:
+    overrides = overrides or {}
+    total_mix_kg = 0.0
+    total_mix_cost = 0.0
+    warnings: list[str] = []
+    lines: list[dict] = []
+
+    for ingredient in product_ingredients:
+        raw_material = ingredient.raw_material
+        active_price = get_active_price(raw_material)
+        if active_price is None:
+            warnings.append(f"{raw_material.name} has no active price")
+            lines.append(
+                {
+                    "id": ingredient.id,
+                    "raw_material_id": raw_material.id,
+                    "raw_material_name": raw_material.name,
+                    "quantity_kg": ingredient.quantity_kg,
+                    "cost_per_kg": None,
+                    "line_cost": None,
+                    "notes": ingredient.notes,
+                }
+            )
+            total_mix_kg += ingredient.quantity_kg
+            continue
+
+        market_value = overrides.get("raw_material_market_values", {}).get(str(raw_material.id), active_price.market_value)
+        waste_percentage = overrides.get("raw_material_waste_percentages", {}).get(str(raw_material.id), active_price.waste_percentage)
+        price_stub = RawMaterialPriceVersion(
+            raw_material_id=raw_material.id,
+            market_value=market_value,
+            waste_percentage=waste_percentage,
+            effective_date=active_price.effective_date,
+            status=active_price.status,
+        )
+        price_comp = calculate_raw_material_cost(raw_material, price_stub)
+        line_cost = round(ingredient.quantity_kg * price_comp.cost_per_kg, 4)
+        total_mix_kg += ingredient.quantity_kg
+        total_mix_cost += line_cost
+        lines.append(
+            {
+                "id": ingredient.id,
+                "raw_material_id": raw_material.id,
+                "raw_material_name": raw_material.name,
+                "quantity_kg": ingredient.quantity_kg,
+                "cost_per_kg": price_comp.cost_per_kg,
+                "line_cost": line_cost,
+                "notes": ingredient.notes,
+            }
+        )
+
+    if total_mix_kg == 0:
+        warnings.append("Mix total kg is zero")
+        mix_cost_per_kg = None
+    else:
+        mix_cost_per_kg = round(total_mix_cost / total_mix_kg, 4)
+
+    if not product_ingredients:
+        warnings.append("Mix has no ingredients")
+
+    return {
+        "ingredients": lines,
+        "total_mix_kg": round(total_mix_kg, 4),
+        "total_mix_cost": round(total_mix_cost, 4),
+        "mix_cost_per_kg": mix_cost_per_kg,
+        "warnings": warnings,
+    }
+
+
 def _get_process_costs(db: Session, process_name: str | None, overrides: dict) -> tuple[float, float, float, list[str]]:
     if not process_name:
         return 0.0, 0.0, 0.0, ["Missing bagging process"]
@@ -192,11 +264,21 @@ def extract_unit_quantity_kg(unit_of_measure: str) -> float:
 def calculate_product_cost(db: Session, product_id: int, overrides: dict | None = None) -> dict:
     overrides = overrides or {}
     overrides = {**overrides, "tenant_id": overrides.get("tenant_id")}
-    product = db.scalar(select(Product).where(Product.id == product_id).options(selectinload(Product.mix)))
+    product = db.scalar(
+        select(Product)
+        .where(Product.id == product_id)
+        .options(
+            selectinload(Product.mix),
+            selectinload(Product.ingredients).selectinload(ProductIngredient.raw_material).selectinload(RawMaterial.price_versions),
+        )
+    )
     if product is None:
         raise ValueError(f"Product {product_id} not found")
     overrides["tenant_id"] = product.tenant_id
 
+    if product.ingredients:
+        mix_result = _calculate_formula_cost_from_product_ingredients(product.ingredients, overrides=overrides)
+    else:
         mix_result = calculate_mix_cost(db, product.mix_id, overrides=overrides)
     warnings = list(mix_result["warnings"])
     sale_unit_kg = extract_unit_quantity_kg(product.unit_of_measure)

backend/app/services/mix_calculator_filenames.py

@@ -3,8 +3,14 @@ from __future__ import annotations
 import re
 
 from app.models.mix_calculator import MixCalculatorSession
+from app.schemas.mix_calculator import MixCalculatorPreviewRead
 
 
 def mix_calculator_pdf_filename(session_record: MixCalculatorSession) -> str:
     raw = f"{session_record.session_number}_{session_record.client_name}_{session_record.product_name}.pdf"
     return re.sub(r"[^\w.\-]+", "_", raw)
+
+
+def mix_calculator_preview_pdf_filename(preview: MixCalculatorPreviewRead) -> str:
+    raw = f"MixCalculator_{preview.client_name}_{preview.product_name}_{preview.mix_date}.pdf"
+    return re.sub(r"[^\w.\-]+", "_", raw)

backend/app/services/mix_calculator_pdf.py

@@ -1,7 +1,8 @@
 from __future__ import annotations
 
 from io import BytesIO
-from math import ceil
+from pathlib import Path
+from types import SimpleNamespace
 
 from app.models.mix_calculator import MixCalculatorSession
 
@@ -24,272 +25,329 @@ def _fractional_bag_warning(session_record: MixCalculatorSession) -> str | None:
     )
 
 
-def build_mix_calculator_pdf(session_record: MixCalculatorSession) -> bytes:
+def _coerce_pdf_source(source):
+    if isinstance(source, dict):
+        lines = [SimpleNamespace(**line) if isinstance(line, dict) else line for line in source.get("lines", [])]
+        return SimpleNamespace(**{**source, "lines": lines})
+    return source
+
+
+def build_mix_calculator_pdf(session_record: MixCalculatorSession | dict) -> bytes:
+    session_record = _coerce_pdf_source(session_record)
     try:
         from reportlab.lib import colors
         from reportlab.lib.pagesizes import A4
-        from reportlab.lib.styles import ParagraphStyle, getSampleStyleSheet
-        from reportlab.lib.units import mm
-        from reportlab.platypus import Paragraph, SimpleDocTemplate, Spacer, Table, TableStyle
+        from reportlab.lib.utils import ImageReader
+        from reportlab.pdfbase.pdfmetrics import stringWidth
+        from reportlab.pdfgen import canvas
     except ModuleNotFoundError as exc:
         raise MixCalculatorPdfUnavailableError(
             "PDF generation is unavailable because 'reportlab' is not installed. "
             "Install backend dependencies again to enable PDF export."
         ) from exc
 
+    page_width, page_height = A4
+    margin = 26
+    gutter = 10
+    content_width = page_width - (margin * 2)
+    page_top = page_height - 40
+
+    palette = {
+        "page": colors.HexColor("#FFFFFF"),
+        "line": colors.HexColor("#000000"),
+        "muted": colors.HexColor("#000000"),
+        "text": colors.HexColor("#000000"),
+        "warning_bg": colors.HexColor("#FFFFFF"),
+        "warning_text": colors.HexColor("#000000"),
+    }
+    logo_path = Path(__file__).resolve().parents[3] / "frontend" / "static" / "logo-hsf.png"
+
+    def clamp(value: float, minimum: float, maximum: float) -> float:
+        return max(minimum, min(maximum, value))
+
+    def fit_text(value: str, font_name: str, font_size: float, max_width: float) -> str:
+        if stringWidth(value, font_name, font_size) <= max_width:
+            return value
+        ellipsis = "..."
+        available = max_width - stringWidth(ellipsis, font_name, font_size)
+        trimmed = value
+        while trimmed and stringWidth(trimmed, font_name, font_size) > available:
+            trimmed = trimmed[:-1]
+        return f"{trimmed.rstrip()}{ellipsis}" if trimmed else ellipsis
+
+    def wrap_text(value: str, font_name: str, font_size: float, max_width: float, max_lines: int) -> list[str]:
+        words = value.split()
+        if not words:
+            return []
+        lines: list[str] = []
+        current = words[0]
+        for word in words[1:]:
+            candidate = f"{current} {word}"
+            if stringWidth(candidate, font_name, font_size) <= max_width:
+                current = candidate
+            else:
+                lines.append(current)
+                current = word
+                if len(lines) == max_lines - 1:
+                    break
+        if len(lines) < max_lines:
+            lines.append(current)
+
+        remaining_words = words[len(" ".join(lines).split()) :]
+        if remaining_words and lines:
+            lines[-1] = fit_text(f"{lines[-1]} {' '.join(remaining_words)}", font_name, font_size, max_width)
+        return lines[:max_lines]
+
+    def draw_box(pdf: canvas.Canvas, x: float, y_top: float, width: float, height: float):
+        pdf.setFillColor(palette["page"])
+        pdf.setStrokeColor(palette["line"])
+        pdf.setLineWidth(1)
+        pdf.rect(x, y_top - height, width, height, fill=1, stroke=1)
+
+    def draw_label_value_card(
+        pdf: canvas.Canvas,
+        x: float,
+        y_top: float,
+        width: float,
+        height: float,
+        label: str,
+        value: str,
+        subtitle: str | None = None,
+        value_font_size: float = 14,
+    ):
+        draw_box(pdf, x, y_top, width, height)
+        inset_x = x + 14
+        label_y = y_top - 16
+        pdf.setFillColor(palette["muted"])
+        pdf.setFont("Helvetica-Bold", 7.5)
+        pdf.drawString(inset_x, label_y, label.upper())
+
+        value_y = y_top - 38
+        pdf.setFillColor(palette["text"])
+        pdf.setFont("Helvetica-Bold", value_font_size)
+        pdf.drawString(inset_x, value_y, fit_text(value, "Helvetica-Bold", value_font_size, width - 28))
+
+        if subtitle:
+            pdf.setFillColor(palette["muted"])
+            pdf.setFont("Helvetica", 8)
+            pdf.drawString(inset_x, y_top - height + 14, fit_text(subtitle, "Helvetica", 8, width - 28))
+
     buffer = BytesIO()
-    document = SimpleDocTemplate(
-        buffer,
-        pagesize=A4,
-        leftMargin=14 * mm,
-        rightMargin=14 * mm,
-        topMargin=14 * mm,
-        bottomMargin=14 * mm,
-        title=f"{session_record.session_number} - {session_record.product_name}",
-        author="Lean 101 Clients",
+    pdf = canvas.Canvas(buffer, pagesize=A4)
+    session_number = getattr(session_record, "session_number", None)
+    document_title = (
+        f"{session_number} - {session_record.product_name}"
+        if session_number
+        else f"Mix Calculator - {session_record.product_name}"
     )
+    pdf.setTitle(document_title)
+    pdf.setAuthor("Lean 101 Clients")
 
-    styles = getSampleStyleSheet()
-    eyebrow = ParagraphStyle(
-        "Eyebrow",
-        parent=styles["BodyText"],
-        fontName="Helvetica-Bold",
-        fontSize=8,
-        leading=10,
-        textColor=colors.HexColor("#62736B"),
-        spaceAfter=5,
-    )
-    title = ParagraphStyle(
-        "Title",
-        parent=styles["Heading1"],
-        fontName="Helvetica-Bold",
-        fontSize=24,
-        leading=26,
-        textColor=colors.HexColor("#21312A"),
-        spaceAfter=6,
-    )
-    subtitle = ParagraphStyle(
-        "Subtitle",
-        parent=styles["BodyText"],
-        fontName="Helvetica",
-        fontSize=10,
-        leading=13,
-        textColor=colors.HexColor("#6B7A73"),
-    )
-    label = ParagraphStyle(
-        "Label",
-        parent=styles["BodyText"],
-        fontName="Helvetica-Bold",
-        fontSize=7,
-        leading=9,
-        textColor=colors.HexColor("#6B7A73"),
-    )
-    value = ParagraphStyle(
-        "Value",
-        parent=styles["BodyText"],
-        fontName="Helvetica-Bold",
-        fontSize=11,
-        leading=13,
-        textColor=colors.HexColor("#21312A"),
-    )
-    card_value = ParagraphStyle(
-        "CardValue",
-        parent=value,
-        fontSize=16,
-        leading=18,
-    )
-    body = ParagraphStyle(
-        "Body",
-        parent=styles["BodyText"],
-        fontName="Helvetica",
-        fontSize=9,
-        leading=12,
-        textColor=colors.HexColor("#304038"),
-    )
-    section_title = ParagraphStyle(
-        "SectionTitle",
-        parent=styles["Heading2"],
-        fontName="Helvetica-Bold",
-        fontSize=13,
-        leading=15,
-        textColor=colors.HexColor("#21312A"),
-    )
+    pdf.setFillColor(palette["page"])
+    pdf.rect(0, 0, page_width, page_height, stroke=0, fill=1)
 
-    warnings = []
-    bag_warning = _fractional_bag_warning(session_record)
-    if bag_warning:
-        warnings.append(bag_warning)
+    current_y = page_top
+    mix_date_label = f"{session_record.mix_date.day} {session_record.mix_date.strftime('%B %Y')}"
 
-    story = [
-        Paragraph(f"Mix Calculator  |  {session_record.session_number}", eyebrow),
-        Paragraph(session_record.product_name, title),
-        Paragraph(f"{session_record.client_name} &nbsp;&middot;&nbsp; {session_record.mix_name}", subtitle),
-        Spacer(1, 8),
-    ]
+    if logo_path.exists():
+        logo_source = str(logo_path)
+        try:
+            from PIL import Image
 
-    header_table = Table(
-        [
-            [
-                [
-                    Paragraph("Mix date", label),
-                    Paragraph(session_record.mix_date.strftime("%d %b %Y"), value),
-                ],
-                [
-                    Paragraph("Prepared by", label),
-                    Paragraph(session_record.prepared_by_name, value),
-                ],
-                [
-                    Paragraph("Status", label),
-                    Paragraph(session_record.status.title(), value),
-                ],
-            ]
-        ],
-        colWidths=[60 * mm, 60 * mm, 52 * mm],
-    )
-    header_table.setStyle(
-        TableStyle(
-            [
-                ("VALIGN", (0, 0), (-1, -1), "TOP"),
-                ("BOX", (0, 0), (-1, -1), 0.8, colors.HexColor("#DBE4DE")),
-                ("INNERGRID", (0, 0), (-1, -1), 0.8, colors.HexColor("#DBE4DE")),
-                ("BACKGROUND", (0, 0), (-1, -1), colors.white),
-                ("LEFTPADDING", (0, 0), (-1, -1), 10),
-                ("RIGHTPADDING", (0, 0), (-1, -1), 10),
-                ("TOPPADDING", (0, 0), (-1, -1), 9),
-                ("BOTTOMPADDING", (0, 0), (-1, -1), 9),
-            ]
-        )
-    )
-    story.extend([header_table, Spacer(1, 10)])
+            logo_source = Image.open(logo_path).convert("L")
+        except ModuleNotFoundError:
+            pass
 
-    summary_table = Table(
-        [
-            [
-                [Paragraph("Batch size", label), Paragraph(f"{_fmt_number(session_record.batch_size_kg)}kg", card_value)],
-                [Paragraph("Total output", label), Paragraph(f"{_fmt_number(session_record.total_kg)}kg", card_value)],
-                [Paragraph("Bags", label), Paragraph(_fmt_number(session_record.total_bags), card_value)],
-                [Paragraph("Unit pack", label), Paragraph(f"{_fmt_number(session_record.product_unit_size_kg)}kg", card_value)],
-            ]
-        ],
-        colWidths=[43 * mm, 43 * mm, 43 * mm, 43 * mm],
+        logo_reader = ImageReader(logo_source)
+        logo_width, logo_height = logo_reader.getSize()
+        aspect_ratio = logo_height / max(logo_width, 1)
+        draw_width = 108
+        draw_height = draw_width * aspect_ratio
+        pdf.drawImage(
+            logo_reader,
+            margin,
+            current_y - draw_height,
+            width=draw_width,
+            height=draw_height,
+            preserveAspectRatio=True,
+            mask="auto",
         )
-    summary_table.setStyle(
-        TableStyle(
-            [
-                ("BOX", (0, 0), (-1, -1), 0.8, colors.HexColor("#DBE4DE")),
-                ("INNERGRID", (0, 0), (-1, -1), 0.8, colors.HexColor("#DBE4DE")),
-                ("BACKGROUND", (0, 0), (-1, -1), colors.HexColor("#F9FBFA")),
-                ("VALIGN", (0, 0), (-1, -1), "TOP"),
-                ("LEFTPADDING", (0, 0), (-1, -1), 10),
-                ("RIGHTPADDING", (0, 0), (-1, -1), 10),
-                ("TOPPADDING", (0, 0), (-1, -1), 10),
-                ("BOTTOMPADDING", (0, 0), (-1, -1), 10),
-            ]
-        )
-    )
-    story.extend([summary_table, Spacer(1, 10)])
+        current_y -= draw_height + 20
 
-    detail_table = Table(
-        [
-            [
-                [Paragraph("Mix source", label), Paragraph(session_record.mix_name, value), Paragraph(f"Saved against {session_record.product_unit_of_measure} units.", body)],
-                [Paragraph("Composition", label), Paragraph(f"{_fmt_number(sum(line.mix_percentage for line in session_record.lines))}%", value), Paragraph(f"{len(session_record.lines)} raw material{'s' if len(session_record.lines) != 1 else ''} in the blend.", body)],
-                [Paragraph("Estimated pages", label), Paragraph(str(max(1, ceil(len(session_record.lines) / 18))), value), Paragraph("Formatted for A4 PDF export.", body)],
-            ]
-        ],
-        colWidths=[60 * mm, 60 * mm, 52 * mm],
+    pdf.setFillColor(palette["text"])
+    pdf.setFont("Helvetica-Bold", 15)
+    pdf.drawString(margin, current_y, "Calculated Output")
+    current_y -= 16
+
+    pdf.setFillColor(palette["muted"])
+    pdf.setFont("Helvetica", 10)
+    pdf.drawString(margin, current_y, "Snapshot of the scaled raw material requirements.")
+    current_y -= 20
+
+    stat_height = 66
+    stat_width = (content_width - (gutter * 2)) / 3
+    draw_label_value_card(
+        pdf,
+        margin,
+        current_y,
+        stat_width,
+        stat_height,
+        "Total kg",
+        _fmt_number(session_record.total_kg),
+        "Scaled batch size",
+        value_font_size=18,
     )
-    detail_table.setStyle(
-        TableStyle(
-            [
-                ("BACKGROUND", (0, 0), (-1, -1), colors.HexColor("#F4F8F5")),
-                ("VALIGN", (0, 0), (-1, -1), "TOP"),
-                ("LEFTPADDING", (0, 0), (-1, -1), 10),
-                ("RIGHTPADDING", (0, 0), (-1, -1), 10),
-                ("TOPPADDING", (0, 0), (-1, -1), 10),
-                ("BOTTOMPADDING", (0, 0), (-1, -1), 10),
-            ]
+    draw_label_value_card(
+        pdf,
+        margin + stat_width + gutter,
+        current_y,
+        stat_width,
+        stat_height,
+        "Total bags",
+        _fmt_number(session_record.total_bags),
+        session_record.product_unit_of_measure,
+        value_font_size=18,
     )
+    draw_label_value_card(
+        pdf,
+        margin + ((stat_width + gutter) * 2),
+        current_y,
+        stat_width,
+        stat_height,
+        "Prepared by",
+        session_record.prepared_by_name,
+        mix_date_label,
+        value_font_size=10.5,
     )
-    story.extend([detail_table, Spacer(1, 10)])
+    current_y -= stat_height + 12
+
+    detail_height = 52
+    detail_width = (content_width - gutter) / 2
+    draw_label_value_card(
+        pdf,
+        margin,
+        current_y,
+        detail_width,
+        detail_height,
+        "Client",
+        session_record.client_name,
+        value_font_size=12,
+    )
+    draw_label_value_card(
+        pdf,
+        margin + detail_width + gutter,
+        current_y,
+        detail_width,
+        detail_height,
+        "Product",
+        session_record.product_name,
+        value_font_size=12,
+    )
+    current_y -= detail_height + 8
+
+    draw_label_value_card(
+        pdf,
+        margin,
+        current_y,
+        detail_width,
+        detail_height,
+        "Mix source",
+        session_record.mix_name,
+        value_font_size=11,
+    )
+    draw_label_value_card(
+        pdf,
+        margin + detail_width + gutter,
+        current_y,
+        detail_width,
+        detail_height,
+        "Unit size",
+        f"{_fmt_number(session_record.product_unit_size_kg)}kg",
+        value_font_size=12,
+    )
+    current_y -= detail_height + 10
+
+    warning = _fractional_bag_warning(session_record)
+    note_lines: list[str] = []
+    warning_lines: list[str] = []
+    strip_height = 0
 
     if session_record.notes:
-        notes_table = Table(
-            [[Paragraph("Notes", label)], [Paragraph(session_record.notes.replace("\n", "<br/>"), body)]],
-            colWidths=[172 * mm],
-        )
-        notes_table.setStyle(
-            TableStyle(
-                [
-                    ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#F4F8F5")),
-                    ("BOX", (0, 0), (-1, -1), 0.8, colors.HexColor("#DBE4DE")),
-                    ("LEFTPADDING", (0, 0), (-1, -1), 10),
-                    ("RIGHTPADDING", (0, 0), (-1, -1), 10),
-                    ("TOPPADDING", (0, 0), (-1, -1), 8),
-                    ("BOTTOMPADDING", (0, 0), (-1, -1), 8),
-                ]
-            )
-        )
-        story.extend([notes_table, Spacer(1, 10)])
+        note_lines = wrap_text(session_record.notes.replace("\n", " "), "Helvetica", 7.5, content_width - 28, 2)
+        strip_height += 30
+    if warning:
+        warning_lines = wrap_text(warning, "Helvetica", 7.5, content_width - 28, 2)
+        strip_height += 30
+    if strip_height:
+        strip_height += 6
 
-    if warnings:
-        warning_rows = [[Paragraph("Warnings", label)]]
-        warning_rows.extend([[Paragraph(warning, body)] for warning in warnings])
-        warnings_table = Table(warning_rows, colWidths=[172 * mm])
-        warnings_table.setStyle(
-            TableStyle(
-                [
-                    ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#FFF5E6")),
-                    ("BACKGROUND", (0, 1), (-1, -1), colors.HexColor("#FFF9EF")),
-                    ("BOX", (0, 0), (-1, -1), 0.8, colors.HexColor("#E8C483")),
-                    ("LEFTPADDING", (0, 0), (-1, -1), 10),
-                    ("RIGHTPADDING", (0, 0), (-1, -1), 10),
-                    ("TOPPADDING", (0, 0), (-1, -1), 8),
-                    ("BOTTOMPADDING", (0, 0), (-1, -1), 8),
-                ]
-            )
-        )
-        story.extend([warnings_table, Spacer(1, 10)])
+    table_header_height = 24
+    table_bottom_padding = 12
+    table_top = current_y
+    available_table_height = table_top - margin - strip_height - table_header_height - table_bottom_padding
+    row_count = max(len(session_record.lines), 1)
+    row_height = clamp(available_table_height / row_count, 16, 32)
+    table_font_size = clamp(row_height * 0.36, 7, 11)
+    table_height = table_header_height + (row_height * row_count)
+    table_bottom = table_top - table_height
 
-    story.extend(
-        [
-            Paragraph("Required Raw Materials", label),
-            Paragraph("Blend composition", section_title),
-            Paragraph(f"{session_record.product_unit_of_measure} · {_fmt_number(session_record.product_unit_size_kg)}kg per unit", subtitle),
-            Spacer(1, 6),
-        ]
-    )
+    pdf.setFillColor(palette["muted"])
+    pdf.setFont("Helvetica-Bold", 7.5)
+    pdf.drawString(margin + 4, table_top - 7, "RAW MATERIAL")
+    pdf.drawString(margin + content_width - 190, table_top - 7, "REQUIRED KG")
+
+    pdf.setStrokeColor(palette["line"])
+    pdf.setLineWidth(0.8)
+    pdf.line(margin, table_top - table_header_height, margin + content_width, table_top - table_header_height)
+
+    left_col_x = margin + 6
+    right_col_x = margin + content_width - 190
+    y_cursor = table_top - table_header_height
 
-    table_rows = [["Raw material", "Mix %", "Required kg", "Unit"]]
     for line in session_record.lines:
-        table_rows.append(
-            [
-                Paragraph(f"<b>{line.raw_material_name}</b>", body),
-                Paragraph(f"{_fmt_number(line.mix_percentage)}%", body),
-                Paragraph(f"{_fmt_number(line.required_kg)}kg", body),
-                Paragraph(line.unit, body),
-            ]
-        )
+        y_cursor -= row_height
+        pdf.setStrokeColor(palette["line"])
+        pdf.setLineWidth(0.6)
+        pdf.line(margin, y_cursor, margin + content_width, y_cursor)
 
-    composition_table = Table(table_rows, colWidths=[88 * mm, 24 * mm, 34 * mm, 26 * mm], repeatRows=1)
-    composition_table.setStyle(
-        TableStyle(
-            [
-                ("BACKGROUND", (0, 0), (-1, 0), colors.HexColor("#EEF4F0")),
-                ("TEXTCOLOR", (0, 0), (-1, 0), colors.HexColor("#4F6158")),
-                ("FONTNAME", (0, 0), (-1, 0), "Helvetica-Bold"),
-                ("FONTSIZE", (0, 0), (-1, 0), 8),
-                ("BOTTOMPADDING", (0, 0), (-1, 0), 8),
-                ("TOPPADDING", (0, 0), (-1, 0), 8),
-                ("LEFTPADDING", (0, 0), (-1, -1), 9),
-                ("RIGHTPADDING", (0, 0), (-1, -1), 9),
-                ("GRID", (0, 0), (-1, -1), 0.6, colors.HexColor("#DBE4DE")),
-                ("VALIGN", (0, 0), (-1, -1), "TOP"),
-                ("ROWBACKGROUNDS", (0, 1), (-1, -1), [colors.white, colors.HexColor("#FBFCFB")]),
-            ]
+        text_y = y_cursor + (row_height / 2) - (table_font_size * 0.35)
+        pdf.setFillColor(palette["text"])
+        pdf.setFont("Helvetica-Bold", table_font_size)
+        pdf.drawString(
+            left_col_x,
+            text_y,
+            fit_text(line.raw_material_name, "Helvetica-Bold", table_font_size, content_width - 210),
         )
-    )
-    story.append(composition_table)
+        pdf.setFont("Helvetica", table_font_size)
+        pdf.drawString(right_col_x, text_y, f"{_fmt_number(line.required_kg)}kg")
 
-    document.build(story)
+    strip_y = table_bottom - 6
+    if note_lines:
+        note_height = 24 if len(note_lines) == 1 else 30
+        pdf.setFillColor(palette["page"])
+        pdf.setStrokeColor(palette["line"])
+        pdf.rect(margin, strip_y - note_height, content_width, note_height, fill=1, stroke=1)
+        pdf.setFillColor(palette["muted"])
+        pdf.setFont("Helvetica-Bold", 7)
+        pdf.drawString(margin + 10, strip_y - 10, "NOTES")
+        pdf.setFillColor(palette["text"])
+        pdf.setFont("Helvetica", 7.5)
+        for idx, text in enumerate(note_lines):
+            pdf.drawString(margin + 10, strip_y - 20 - (idx * 8), text)
+        strip_y -= note_height + 6
+
+    if warning_lines:
+        warning_height = 24 if len(warning_lines) == 1 else 30
+        pdf.setFillColor(palette["warning_bg"])
+        pdf.setStrokeColor(palette["line"])
+        pdf.rect(margin, strip_y - warning_height, content_width, warning_height, fill=1, stroke=1)
+        pdf.setFillColor(palette["warning_text"])
+        pdf.setFont("Helvetica-Bold", 7)
+        pdf.drawString(margin + 10, strip_y - 10, "WARNING")
+        pdf.setFont("Helvetica", 7.5)
+        for idx, text in enumerate(warning_lines):
+            pdf.drawString(margin + 10, strip_y - 20 - (idx * 8), text)
+
+    pdf.showPage()
+    pdf.save()
     return buffer.getvalue()

backend/app/services/mix_calculator_service.py

@@ -8,7 +8,7 @@ from sqlalchemy.orm import Session, joinedload, selectinload
 from app.api.deps import AuthSession
 from app.models.mix import Mix, MixIngredient
 from app.models.mix_calculator import MixCalculatorSession, MixCalculatorSessionLine
-from app.models.product import Product
+from app.models.product import Product, ProductIngredient
 from app.schemas.mix_calculator import MixCalculatorSessionCreate, MixCalculatorSessionUpdate
 from app.services.costing_engine import extract_unit_quantity_kg
 
@@ -28,8 +28,42 @@ def _load_product_for_calculation(db: Session, tenant_id: str, product_id: int)
     return db.scalar(
         select(Product)
         .where(Product.id == product_id, Product.tenant_id == tenant_id, Product.visible.is_(True))
-        .options(selectinload(Product.mix).selectinload(Mix.ingredients).selectinload(MixIngredient.raw_material))
+        .options(
+            selectinload(Product.ingredients).selectinload(ProductIngredient.raw_material),
+            selectinload(Product.mix).selectinload(Mix.ingredients).selectinload(MixIngredient.raw_material),
         )
+    )
+
+
+def _resolved_formula_rows(product: Product) -> tuple[list[dict], float]:
+    if product.ingredients:
+        rows = [
+            {
+                "raw_material_id": ingredient.raw_material_id,
+                "raw_material_name": ingredient.raw_material.name,
+                "quantity_kg": ingredient.quantity_kg,
+                "unit": ingredient.raw_material.unit_of_measure,
+                "sort_order": ingredient.sort_order,
+            }
+            for ingredient in product.ingredients
+            if ingredient.raw_material is not None
+        ]
+    elif product.mix is not None:
+        rows = [
+            {
+                "raw_material_id": ingredient.raw_material_id,
+                "raw_material_name": ingredient.raw_material.name if ingredient.raw_material is not None else f"Raw material {ingredient.raw_material_id}",
+                "quantity_kg": ingredient.quantity_kg,
+                "unit": ingredient.raw_material.unit_of_measure if ingredient.raw_material is not None else "kg",
+                "sort_order": index,
+            }
+            for index, ingredient in enumerate(product.mix.ingredients, start=1)
+        ]
+    else:
+        rows = []
+
+    rows.sort(key=lambda row: (row["sort_order"], row["raw_material_name"]))
+    return rows, round(sum(row["quantity_kg"] for row in rows), 4)
 
 
 def _fractional_bag_warning(batch_size_kg: float, total_bags: float, unit_of_measure: str) -> str | None:
@@ -54,12 +88,9 @@ def calculate_mix_calculator_preview(
         raise ValueError("Product not found")
     if product.client_name != values["client_name"]:
         raise ValueError("Selected product does not belong to the chosen client")
-    if product.mix is None:
-        raise ValueError("Product mix is not configured")
-
-    source_total_kg = round(sum(ingredient.quantity_kg for ingredient in product.mix.ingredients), 4)
+    formula_rows, source_total_kg = _resolved_formula_rows(product)
     if source_total_kg <= 0:
-        raise ValueError("Product mix has no source kilograms to scale")
+        raise ValueError("Product has no source kilograms to scale")
 
     batch_size_kg = float(values["batch_size_kg"])
     scale_factor = batch_size_kg / source_total_kg
@@ -72,18 +103,17 @@ def calculate_mix_calculator_preview(
         warnings.append(bag_warning)
 
     lines = []
-    for index, ingredient in enumerate(product.mix.ingredients, start=1):
-        mix_percentage = round((ingredient.quantity_kg / source_total_kg) * 100, 4)
-        required_kg = round(ingredient.quantity_kg * scale_factor, 4)
-        raw_material = ingredient.raw_material
+    for index, ingredient in enumerate(formula_rows, start=1):
+        mix_percentage = round((ingredient["quantity_kg"] / source_total_kg) * 100, 4)
+        required_kg = round(ingredient["quantity_kg"] * scale_factor, 4)
         lines.append(
             {
-                "raw_material_id": raw_material.id if raw_material is not None else ingredient.raw_material_id,
-                "raw_material_name": raw_material.name if raw_material is not None else f"Raw material {ingredient.raw_material_id}",
+                "raw_material_id": ingredient["raw_material_id"],
+                "raw_material_name": ingredient["raw_material_name"],
                 "required_kg": required_kg,
                 "mix_percentage": mix_percentage,
-                "unit": raw_material.unit_of_measure if raw_material is not None else "kg",
-                "sort_order": index,
+                "unit": ingredient["unit"],
+                "sort_order": ingredient["sort_order"] or index,
             }
         )
 
@@ -92,7 +122,7 @@ def calculate_mix_calculator_preview(
         "product_id": product.id,
         "product_name": product.name,
         "mix_id": product.mix_id,
-        "mix_name": product.mix.name,
+        "mix_name": product.mix.name if product.mix else product.name,
         "mix_date": values["mix_date"],
         "batch_size_kg": round(batch_size_kg, 4),
         "total_bags": total_bags,
@@ -108,10 +138,16 @@ def calculate_mix_calculator_preview(
 
 
 def build_mix_calculator_options(db: Session, *, tenant_id: str) -> dict:
-    # Aggregate mix totals in a single query instead of loading every
-    # ingredient row for every product. The previous implementation was the
-    # main slow path on first Mix Calculator open — it streamed the entire
-    # tenant's recipe table just to compute one sum per product.
+    # Prefer product-specific formulas where present; fall back to the shared
+    # mix master for legacy rows that have not been migrated yet.
+    product_totals_rows = db.execute(
+        select(ProductIngredient.product_id, func.coalesce(func.sum(ProductIngredient.quantity_kg), 0.0))
+        .join(Product, Product.id == ProductIngredient.product_id)
+        .where(Product.tenant_id == tenant_id)
+        .group_by(ProductIngredient.product_id)
+    ).all()
+    product_totals: dict[int, float] = {product_id: round(total or 0.0, 4) for product_id, total in product_totals_rows}
+
     mix_totals_rows = db.execute(
         select(MixIngredient.mix_id, func.coalesce(func.sum(MixIngredient.quantity_kg), 0.0))
         .join(Mix, Mix.id == MixIngredient.mix_id)
@@ -137,7 +173,7 @@ def build_mix_calculator_options(db: Session, *, tenant_id: str) -> dict:
             "mix_name": product.mix.name if product.mix else "",
             "unit_of_measure": product.unit_of_measure,
             "unit_size_kg": round(extract_unit_quantity_kg(product.unit_of_measure), 4),
-            "mix_total_kg": mix_totals.get(product.mix_id, 0.0),
+            "mix_total_kg": product_totals.get(product.id, mix_totals.get(product.mix_id, 0.0)),
         }
         for product in products
     ]

backend/app/services/throughput_service.py

@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+import logging
+from datetime import date, datetime
+from pathlib import Path
+from typing import Iterable
+
+from openpyxl import load_workbook
+from sqlalchemy import select
+from sqlalchemy.orm import Session
+
+from app.models.throughput import ProductionThroughput, ThroughputProduct
+
+logger = logging.getLogger("data_entry_app.throughput")
+
+PRODUCTION_SHEET = "Production"
+NAMES_SHEET = "Names"
+
+# Anything at or above this kg/bag is treated as a bulka batch, not a per-bag count.
+_BULKA_BAG_SIZE_THRESHOLD = 100.0
+
+
+def normalise_staff_name(value: object) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text:
+        return None
+    # Collapse internal whitespace, title-case for consistency.
+    cleaned = " ".join(text.split())
+    return cleaned
+
+
+def calculate_kg(quantity: float | None, quantity_type: str, bag_size: float | None) -> float:
+    if quantity is None:
+        return 0.0
+    if quantity_type == "kg":
+        return float(quantity)
+    if bag_size is None:
+        return 0.0
+    return float(quantity) * float(bag_size)
+
+
+def qa_passed(entry: ProductionThroughput) -> bool:
+    return bool(entry.scales_checked and entry.label_correct and entry.bag_sealed and entry.pallet_good_condition)
+
+
+def serialize_entry(entry: ProductionThroughput) -> dict:
+    return {
+        "id": entry.id,
+        "tenant_id": entry.tenant_id,
+        "production_date": entry.production_date,
+        "product_id": entry.product_id,
+        "product_name_snapshot": entry.product_name_snapshot,
+        "bag_size": entry.bag_size,
+        "scales_checked": entry.scales_checked,
+        "label_correct": entry.label_correct,
+        "bag_sealed": entry.bag_sealed,
+        "pallet_good_condition": entry.pallet_good_condition,
+        "sample_box_no": entry.sample_box_no,
+        "test_weight_1": entry.test_weight_1,
+        "test_weight_2": entry.test_weight_2,
+        "test_weight_3": entry.test_weight_3,
+        "test_weight_4": entry.test_weight_4,
+        "test_weight_5": entry.test_weight_5,
+        "quantity": entry.quantity,
+        "quantity_type": entry.quantity_type,
+        "calculated_kg": entry.calculated_kg,
+        "staff_name": entry.staff_name,
+        "notes": entry.notes,
+        "qa_passed": qa_passed(entry),
+        "created_by": entry.created_by,
+        "created_at": entry.created_at,
+        "updated_at": entry.updated_at,
+    }
+
+
+def _coerce_bool(value: object) -> bool:
+    if isinstance(value, bool):
+        return value
+    if value is None:
+        return True
+    if isinstance(value, (int, float)):
+        return bool(value)
+    text = str(value).strip().lower()
+    if text in {"yes", "y", "true", "1", "pass", "ok", "x", "checked"}:
+        return True
+    if text in {"no", "n", "false", "0", "fail"}:
+        return False
+    return True
+
+
+def _coerce_float(value: object) -> float | None:
+    if value is None or value == "":
+        return None
+    if isinstance(value, bool):
+        return float(value)
+    if isinstance(value, (int, float)):
+        return float(value)
+    text = str(value).strip().replace(",", "")
+    if not text:
+        return None
+    try:
+        return float(text)
+    except ValueError:
+        return None
+
+
+def _coerce_text(value: object) -> str | None:
+    if value is None:
+        return None
+    text = str(value).strip()
+    if not text or text.lower() in {"#value!", "#n/a", "n/a"}:
+        return None
+    return text
+
+
+def _coerce_date(value: object) -> date | None:
+    if value is None:
+        return None
+    if isinstance(value, datetime):
+        return value.date()
+    if isinstance(value, date):
+        return value
+    text = str(value).strip()
+    if not text:
+        return None
+    for fmt in ("%Y-%m-%d", "%d/%m/%Y", "%m/%d/%Y"):
+        try:
+            return datetime.strptime(text, fmt).date()
+        except ValueError:
+            continue
+    return None
+
+
+def _infer_bulka_default(name: str, bag_size: float | None) -> bool:
+    lowered = name.lower()
+    if "bulka" in lowered:
+        return True
+    if bag_size is None:
+        return False
+    return bag_size >= _BULKA_BAG_SIZE_THRESHOLD
+
+
+def import_names_sheet(db: Session, workbook, tenant_id: str) -> tuple[int, int]:
+    """Upsert product master from the Names sheet. Returns (created, updated)."""
+    if NAMES_SHEET not in workbook.sheetnames:
+        return (0, 0)
+
+    ws = workbook[NAMES_SHEET]
+    existing: dict[tuple[str, str | None], ThroughputProduct] = {}
+    by_item: dict[str, ThroughputProduct] = {}
+    by_name: dict[str, ThroughputProduct] = {}
+    for product in db.scalars(
+        select(ThroughputProduct).where(ThroughputProduct.tenant_id == tenant_id)
+    ).all():
+        if product.item_id:
+            by_item[str(product.item_id)] = product
+        by_name[product.name.lower()] = product
+
+    created = 0
+    updated = 0
+    for row in ws.iter_rows(min_row=2, values_only=True):
+        if not row:
+            continue
+        name = _coerce_text(row[0] if len(row) > 0 else None)
+        if not name:
+            continue
+        item_id_raw = row[1] if len(row) > 1 else None
+        item_id = None
+        if item_id_raw is not None:
+            if isinstance(item_id_raw, float) and item_id_raw.is_integer():
+                item_id = str(int(item_id_raw))
+            else:
+                item_id = _coerce_text(item_id_raw)
+
+        product = (by_item.get(item_id) if item_id else None) or by_name.get(name.lower())
+        if product is None:
+            product = ThroughputProduct(
+                tenant_id=tenant_id,
+                item_id=item_id,
+                name=name,
+                default_bag_size=None,
+                is_bulka_default="bulka" in name.lower(),
+                active=True,
+                notes="Imported from Operations Throughput.xlsx",
+            )
+            db.add(product)
+            created += 1
+            if item_id:
+                by_item[item_id] = product
+            by_name[name.lower()] = product
+        else:
+            if item_id and not product.item_id:
+                product.item_id = item_id
+            if name and product.name != name:
+                product.name = name
+            updated += 1
+
+    db.flush()
+    return (created, updated)
+
+
+def import_production_sheet(db: Session, workbook, tenant_id: str) -> tuple[int, int]:
+    """Import the Production sheet. Returns (imported, skipped)."""
+    if PRODUCTION_SHEET not in workbook.sheetnames:
+        return (0, 0)
+
+    ws = workbook[PRODUCTION_SHEET]
+    # Header row is row 3 in the sheet (rows 1 and 2 are display banners).
+    products_by_name: dict[str, ThroughputProduct] = {
+        product.name.lower(): product
+        for product in db.scalars(
+            select(ThroughputProduct).where(ThroughputProduct.tenant_id == tenant_id)
+        ).all()
+    }
+
+    bag_size_seen: dict[int, list[float]] = {}
+    imported = 0
+    skipped = 0
+
+    for row in ws.iter_rows(min_row=4, values_only=True):
+        if not row or len(row) < 15:
+            skipped += 1
+            continue
+        production_date = _coerce_date(row[0])
+        product_name = _coerce_text(row[1])
+        if production_date is None or not product_name:
+            skipped += 1
+            continue
+
+        bag_size = _coerce_float(row[2])
+        scales = _coerce_bool(row[3])
+        label = _coerce_bool(row[4])
+        sealed = _coerce_bool(row[5])
+        pallet = _coerce_bool(row[6])
+        sample_box = _coerce_text(row[7])
+        tw1 = _coerce_float(row[8])
+        tw2 = _coerce_float(row[9])
+        tw3 = _coerce_float(row[10])
+        tw4 = _coerce_float(row[11])
+        tw5 = _coerce_float(row[12])
+        quantity = _coerce_float(row[13]) or 0.0
+        staff = normalise_staff_name(row[14])
+        notes = _coerce_text(row[15]) if len(row) > 15 else None
+
+        # Infer quantity_type: bulka-style rows have a blank or very large bag size.
+        if bag_size is None or bag_size >= _BULKA_BAG_SIZE_THRESHOLD or "bulka" in product_name.lower():
+            quantity_type = "kg"
+        else:
+            quantity_type = "bags"
+
+        product = products_by_name.get(product_name.lower())
+        if product is None:
+            product = ThroughputProduct(
+                tenant_id=tenant_id,
+                item_id=None,
+                name=product_name,
+                default_bag_size=bag_size,
+                is_bulka_default=_infer_bulka_default(product_name, bag_size),
+                active=True,
+                notes="Auto-created during Operations Throughput import",
+            )
+            db.add(product)
+            db.flush()
+            products_by_name[product_name.lower()] = product
+
+        if product.id is not None and bag_size is not None and bag_size > 0:
+            bag_size_seen.setdefault(product.id, []).append(bag_size)
+
+        calculated = calculate_kg(quantity, quantity_type, bag_size)
+        entry = ProductionThroughput(
+            tenant_id=tenant_id,
+            production_date=production_date,
+            product_id=product.id,
+            product_name_snapshot=product_name,
+            bag_size=bag_size,
+            scales_checked=scales,
+            label_correct=label,
+            bag_sealed=sealed,
+            pallet_good_condition=pallet,
+            sample_box_no=sample_box,
+            test_weight_1=tw1,
+            test_weight_2=tw2,
+            test_weight_3=tw3,
+            test_weight_4=tw4,
+            test_weight_5=tw5,
+            quantity=quantity,
+            quantity_type=quantity_type,
+            calculated_kg=calculated,
+            staff_name=staff,
+            notes=notes,
+            created_by="workbook-import",
+        )
+        db.add(entry)
+        imported += 1
+
+    # Backfill default_bag_size on products that don't have one but appear in entries.
+    for product_id, sizes in bag_size_seen.items():
+        product = db.get(ThroughputProduct, product_id)
+        if product and product.default_bag_size is None:
+            # Use the most common bag size seen.
+            common = max(set(sizes), key=sizes.count)
+            product.default_bag_size = common
+            if not product.is_bulka_default:
+                product.is_bulka_default = _infer_bulka_default(product.name, common)
+
+    db.flush()
+    return (imported, skipped)
+
+
+def import_workbook(db: Session, workbook_path: Path, tenant_id: str) -> dict:
+    workbook = load_workbook(workbook_path, data_only=True)
+    products_created, products_updated = import_names_sheet(db, workbook, tenant_id)
+    entries_imported, entries_skipped = import_production_sheet(db, workbook, tenant_id)
+    return {
+        "products_created": products_created,
+        "products_updated": products_updated,
+        "entries_imported": entries_imported,
+        "entries_skipped": entries_skipped,
+    }
+
+
+def workbook_candidates() -> Iterable[Path]:
+    repo_root = Path(__file__).resolve().parents[3]
+    candidates = [
+        repo_root / "Operations Throughput.xlsx",
+        repo_root.parent / "Operations Throughput.xlsx",
+        Path.cwd() / "Operations Throughput.xlsx",
+        Path("/srv/lean101-clients") / "Operations Throughput.xlsx",
+        Path("/app") / "Operations Throughput.xlsx",
+    ]
+    seen: set[str] = set()
+    ordered: list[Path] = []
+    for candidate in candidates:
+        key = str(candidate)
+        if key in seen:
+            continue
+        seen.add(key)
+        ordered.append(candidate)
+    return ordered
+
+
+def resolve_workbook_path() -> Path | None:
+    for candidate in workbook_candidates():
+        if candidate.exists():
+            return candidate
+    return None

backend/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "data-entry-app-backend"
-version = "0.1.5"
+version = "0.1.8"
 description = "Costing platform MVP backend"
 requires-python = ">=3.11"
 dependencies = [

backend/tests/test_access.py

@@ -7,6 +7,7 @@ from sqlalchemy import create_engine
 from sqlalchemy.orm import Session, sessionmaker
 from sqlalchemy.pool import StaticPool
 
+from app.api.access import router as access_router
 from app.core.access import (
     INTERNAL_USER_SUBJECT,
     get_user_permissions,
@@ -15,7 +16,8 @@ from app.core.access import (
     require_permission,
     user_has_permission,
 )
-from app.core.security import issue_token
+from app.core.config import settings
+from app.core.security import issue_token, verify_password
 from app.db.session import Base, get_db
 from app.models.access import Permission, Role, User
 from app.seed_access import PERMISSION_DEFINITIONS, ROLE_DEFINITIONS, SEED_USERS, seed_access
@@ -42,6 +44,10 @@ def test_seed_creates_roles_permissions_and_users():
     assert {role.name for role in db.query(Role).all()} == set(ROLE_DEFINITIONS.keys())
     assert {p.key for p in db.query(Permission).all()} == {key for key, _ in PERMISSION_DEFINITIONS}
     assert {user.email for user in db.query(User).all()} == {entry["email"] for entry in SEED_USERS}
+    for user in db.query(User).all():
+        assert user.password_hash is not None
+        assert user.password_hash != settings.admin_password
+        assert verify_password(settings.admin_password, user.password_hash)
 
 
 def test_seed_is_idempotent():
@@ -71,14 +77,20 @@ def test_admin_role_permissions_match_spec():
     assert "edit_mixes" not in granted
 
 
-def test_operations_role_is_mix_calculator_only():
+def test_operations_role_is_mix_calculator_and_throughput_only():
     db = _build_session()
     seed_access(db)
 
     ops = db.query(User).filter_by(email="ops@hunterstockfeeds.com").one()
     granted = get_user_permissions(ops)
 
-    assert granted == {"view_mix_calculator", "use_mix_calculator", "save_mix_calculator_session"}
+    assert granted == {
+        "view_mix_calculator",
+        "use_mix_calculator",
+        "save_mix_calculator_session",
+        "view_throughput",
+        "edit_throughput",
+    }
     assert not user_has_permission(ops, "edit_raw_materials")
     assert not user_has_permission(ops, "view_dashboard")
     assert not user_has_permission(ops, "manage_users")
@@ -158,6 +170,22 @@ def _token_for(user: User) -> str:
     return issue_token({"sub": INTERNAL_USER_SUBJECT, "user_id": user.id, "email": user.email})
 
 
+@pytest.fixture()
+def access_app_and_db():
+    db = _build_session()
+    seed_access(db)
+    db.commit()
+
+    app = FastAPI()
+
+    def override_get_db():
+        yield db
+
+    app.dependency_overrides[get_db] = override_get_db
+    app.include_router(access_router)
+    return TestClient(app), db
+
+
 def test_route_allows_user_with_permission(app_and_db):
     client, db = app_and_db
     craig = db.query(User).filter_by(email="craig@hunterstockfeeds.com").one()
@@ -234,3 +262,55 @@ def test_require_all_permissions(app_and_db):
 
     denied = client.get("/needs-all", headers={"Authorization": f"Bearer {_token_for(ops)}"})
     assert denied.status_code == 403
+
+
+def test_internal_login_uses_user_password_hash(access_app_and_db):
+    client, db = access_app_and_db
+    admin = db.query(User).filter_by(email="admin@hunterstockfeeds.com").one()
+
+    admin.password_hash = issue_token({"not": "a password"})
+    db.commit()
+
+    denied = client.post(
+        "/api/access/login",
+        json={"email": admin.email, "password": settings.admin_password},
+    )
+    assert denied.status_code == 401
+
+
+def test_internal_user_can_change_own_password(access_app_and_db):
+    client, db = access_app_and_db
+    admin = db.query(User).filter_by(email="admin@hunterstockfeeds.com").one()
+
+    login_response = client.post(
+        "/api/access/login",
+        json={"email": admin.email, "password": settings.admin_password},
+    )
+    assert login_response.status_code == 200
+
+    update_response = client.patch(
+        "/api/access/me",
+        json={
+            "current_password": settings.admin_password,
+            "new_password": "new-personal-password",
+        },
+        cookies=login_response.cookies,
+    )
+    assert update_response.status_code == 200
+
+    db.refresh(admin)
+    assert admin.password_hash is not None
+    assert verify_password("new-personal-password", admin.password_hash)
+    assert not verify_password(settings.admin_password, admin.password_hash)
+
+    old_login = client.post(
+        "/api/access/login",
+        json={"email": admin.email, "password": settings.admin_password},
+    )
+    assert old_login.status_code == 401
+
+    new_login = client.post(
+        "/api/access/login",
+        json={"email": admin.email, "password": "new-personal-password"},
+    )
+    assert new_login.status_code == 200

backend/tests/test_costing_engine.py

@@ -1,7 +1,7 @@
 from datetime import date
 
 from fastapi.testclient import TestClient
-from sqlalchemy import create_engine, inspect, text
+from sqlalchemy import create_engine, inspect, select, text
 from sqlalchemy.orm import Session, sessionmaker
 from sqlalchemy.pool import StaticPool
 
@@ -13,7 +13,7 @@ from app.models.assumption import FreightCostRule, PackagingCostRule, ProcessCos
 from app.models.client_access import ClientAccessAuditEvent, ClientAccount, ClientFeatureAccess, ClientUser
 from app.schemas.mix_calculator import MixCalculatorSessionCreate
 from app.models.mix import Mix, MixIngredient
-from app.models.product import Product
+from app.models.product import Product, ProductIngredient
 from app.models.raw_material import RawMaterial, RawMaterialPriceVersion
 from app.services.client_access_service import build_client_access_export, ensure_user_module_permissions, serialize_client_account
 from app.services.costing_engine import calculate_mix_cost, calculate_product_cost, calculate_raw_material_cost, serialize_raw_material
@@ -97,12 +97,13 @@ def test_mix_and_product_cost_breakdown():
     assert product_result["wholesale_price"] == 17.3268
 
 
-def test_mix_calculator_preview_scales_saved_mix_and_warns_on_fractional_bags():
+def test_mix_calculator_preview_prefers_product_specific_ingredients_and_warns_on_fractional_bags():
     db = build_session()
 
     maize = RawMaterial(name="Maize", unit_of_measure="tonne", kg_per_unit=1000, status="active")
     barley = RawMaterial(name="Barley", unit_of_measure="tonne", kg_per_unit=1000, status="active")
-    db.add_all([maize, barley])
+    wheat = RawMaterial(name="Wheat", unit_of_measure="tonne", kg_per_unit=1000, status="active")
+    db.add_all([maize, barley, wheat])
     db.flush()
 
     mix = Mix(tenant_id="specialty-feeds", client_name="Specialty Feeds", name="Pigeon Mix", status="active", version=1)
@@ -128,6 +129,25 @@ def test_mix_calculator_preview_scales_saved_mix_and_warns_on_fractional_bags():
         bagging_process="standard_bagging",
     )
     db.add(product)
+    db.flush()
+    db.add_all(
+        [
+            ProductIngredient(
+                tenant_id="specialty-feeds",
+                product_id=product.id,
+                raw_material_id=maize.id,
+                quantity_kg=300,
+                sort_order=1,
+            ),
+            ProductIngredient(
+                tenant_id="specialty-feeds",
+                product_id=product.id,
+                raw_material_id=wheat.id,
+                quantity_kg=200,
+                sort_order=2,
+            ),
+        ]
+    )
     db.commit()
 
     preview = calculate_mix_calculator_preview(
@@ -145,8 +165,9 @@ def test_mix_calculator_preview_scales_saved_mix_and_warns_on_fractional_bags():
 
     assert preview["batch_size_kg"] == 550
     assert preview["total_bags"] == 27.5
-    assert preview["lines"][0]["required_kg"] == 353.5714
-    assert preview["lines"][1]["required_kg"] == 196.4286
+    assert [line["raw_material_name"] for line in preview["lines"]] == ["Maize", "Wheat"]
+    assert preview["lines"][0]["required_kg"] == 330
+    assert preview["lines"][1]["required_kg"] == 220
     assert len(preview["warnings"]) == 1
     assert "not a whole-bag quantity" in preview["warnings"][0]
 
@@ -155,7 +176,8 @@ def test_mix_calculator_options_hide_invisible_products_and_clients():
     db = build_session()
 
     maize = RawMaterial(name="Maize", unit_of_measure="tonne", kg_per_unit=1000, status="active")
-    db.add(maize)
+    barley = RawMaterial(name="Barley", unit_of_measure="tonne", kg_per_unit=1000, status="active")
+    db.add_all([maize, barley])
     db.flush()
 
     visible_mix = Mix(tenant_id="hunter-premium-produce", client_name="Peckish", name="Visible Mix", status="active", version=1)
@@ -197,12 +219,89 @@ def test_mix_calculator_options_hide_invisible_products_and_clients():
             ),
         ]
     )
+    db.flush()
+
+    visible_product = db.scalar(select(Product).where(Product.name == "Visible Product"))
+    assert visible_product is not None
+    db.add_all(
+        [
+            ProductIngredient(
+                tenant_id="hunter-premium-produce",
+                product_id=visible_product.id,
+                raw_material_id=maize.id,
+                quantity_kg=12,
+                sort_order=1,
+            ),
+            ProductIngredient(
+                tenant_id="hunter-premium-produce",
+                product_id=visible_product.id,
+                raw_material_id=barley.id,
+                quantity_kg=8,
+                sort_order=2,
+            ),
+        ]
+    )
     db.commit()
 
     options = build_mix_calculator_options(db, tenant_id="hunter-premium-produce")
 
     assert options["clients"] == ["Peckish"]
     assert [product["product_name"] for product in options["products"]] == ["Visible Product"]
+    assert options["products"][0]["mix_total_kg"] == 20
+
+
+def test_calculate_product_cost_prefers_product_specific_ingredients():
+    db = build_session()
+
+    maize = RawMaterial(name="Maize", unit_of_measure="tonne", kg_per_unit=1000, status="active")
+    maize.price_versions.append(RawMaterialPriceVersion(market_value=520, waste_percentage=0.02, effective_date=date(2026, 4, 1)))
+    barley = RawMaterial(name="Barley", unit_of_measure="tonne", kg_per_unit=1000, status="active")
+    barley.price_versions.append(RawMaterialPriceVersion(market_value=470, waste_percentage=0.015, effective_date=date(2026, 4, 1)))
+    wheat = RawMaterial(name="Wheat", unit_of_measure="tonne", kg_per_unit=1000, status="active")
+    wheat.price_versions.append(RawMaterialPriceVersion(market_value=600, waste_percentage=0.01, effective_date=date(2026, 4, 1)))
+    db.add_all([maize, barley, wheat])
+    db.flush()
+
+    mix = Mix(client_name="Specialty Feeds", name="Pigeon Mix", status="active", version=1)
+    db.add(mix)
+    db.flush()
+    db.add_all(
+        [
+            MixIngredient(mix_id=mix.id, raw_material_id=maize.id, quantity_kg=180),
+            MixIngredient(mix_id=mix.id, raw_material_id=barley.id, quantity_kg=100),
+        ]
+    )
+    db.add(ProcessCostRule(process_name="standard_bagging", grading_cost=0.055, bagging_cost=0.04, cracking_cost=0.0))
+    db.add(PackagingCostRule(sale_type="standard", unit_of_measure="20kg bag", own_bag=False, bag_cost=0.63))
+    db.add(FreightCostRule(sale_type="standard", unit_of_measure="20kg bag", cost_per_unit=1.45))
+    db.flush()
+    product = Product(
+        client_name="Specialty Feeds",
+        name="Specialty Pigeon Breeder 20kg",
+        mix_id=mix.id,
+        sale_type="standard",
+        own_bag=False,
+        unit_of_measure="20kg bag",
+        items_per_pallet=50,
+        bagging_process="standard_bagging",
+        distributor_margin=0.225,
+        wholesale_margin=0.18,
+    )
+    db.add(product)
+    db.flush()
+    db.add_all(
+        [
+            ProductIngredient(product_id=product.id, raw_material_id=maize.id, quantity_kg=300, sort_order=1),
+            ProductIngredient(product_id=product.id, raw_material_id=wheat.id, quantity_kg=200, sort_order=2),
+        ]
+    )
+    db.commit()
+
+    product_result = calculate_product_cost(db, product.id)
+
+    assert product_result["finished_product_delivered"] == 15.192
+    assert product_result["distributor_price"] == 19.6026
+    assert product_result["wholesale_price"] == 18.5268
 
 
 def test_sync_product_visibility_hides_configured_clients():

backend/tests/test_throughput.py

@@ -0,0 +1,239 @@
+from datetime import date
+from io import BytesIO
+
+from openpyxl import Workbook
+from sqlalchemy import create_engine, select
+from sqlalchemy.orm import Session, sessionmaker
+
+from app.db.session import Base
+from app.models.mix import Mix
+from app.models.product import Product
+from app.models.raw_material import RawMaterial
+from app.models.throughput import ProductionThroughput, ThroughputProduct
+from app.seed import seed_throughput_products_from_costing
+from app.services.throughput_service import (
+    calculate_kg,
+    import_names_sheet,
+    import_production_sheet,
+    normalise_staff_name,
+    qa_passed,
+)
+
+
+def _session() -> Session:
+    engine = create_engine("sqlite:///:memory:")
+    Base.metadata.create_all(bind=engine)
+    return sessionmaker(bind=engine, expire_on_commit=False)()
+
+
+def _costing_mix(db: Session, tenant_id: str = "hunter-premium-produce") -> Mix:
+    raw_material = RawMaterial(
+        tenant_id=tenant_id,
+        name="Maize",
+        unit_of_measure="tonne",
+        kg_per_unit=1000,
+        status="active",
+    )
+    db.add(raw_material)
+    db.flush()
+    mix = Mix(tenant_id=tenant_id, client_name="Hunter", name="Maize Mix")
+    db.add(mix)
+    db.flush()
+    return mix
+
+
+def test_calculate_kg_bags():
+    assert calculate_kg(10, "bags", 20) == 200.0
+
+
+def test_calculate_kg_kg_ignores_bag_size():
+    assert calculate_kg(550, "kg", None) == 550.0
+    assert calculate_kg(550, "kg", 20) == 550.0
+
+
+def test_calculate_kg_zero_quantity():
+    assert calculate_kg(0, "bags", 20) == 0.0
+    assert calculate_kg(None, "bags", 20) == 0.0
+
+
+def test_staff_name_normalisation():
+    assert normalise_staff_name("  Jake ") == "Jake"
+    assert normalise_staff_name("jake  smith") == "jake smith"
+    assert normalise_staff_name("") is None
+    assert normalise_staff_name(None) is None
+
+
+def test_qa_passed_flag():
+    entry = ProductionThroughput(
+        production_date=date(2026, 1, 1),
+        product_name_snapshot="X",
+        quantity=1,
+        quantity_type="bags",
+        scales_checked=True,
+        label_correct=True,
+        bag_sealed=True,
+        pallet_good_condition=True,
+    )
+    assert qa_passed(entry) is True
+    entry.bag_sealed = False
+    assert qa_passed(entry) is False
+
+
+def _make_workbook() -> BytesIO:
+    wb = Workbook()
+    names = wb.active
+    names.title = "Names"
+    names.append(["Name", "Item ID"])
+    names.append(["Whole Wheat 20kg", 1001])
+    names.append(["Bulka Maize", 1002])
+
+    production = wb.create_sheet("Production")
+    production.append(["#VALUE!", "Operations Throughput"])
+    production.append([None] * 8 + ["TEST WEIGHT"])
+    production.append([
+        "DATE", "GRAIN", "BAG SIZE", "SCALES", "LABEL", "SEALED", "PALLET",
+        "BOX", 1, 2, 3, 4, 5, "QTY", "STAFF", "NOTES",
+    ])
+    production.append([date(2026, 4, 1), "Whole Wheat 20kg", 20, True, True, True, True, None, None, None, None, None, None, 100, "  Jake  ", None])
+    production.append([date(2026, 4, 1), "Bulka Maize", None, True, True, False, True, "B7", None, None, None, None, None, 1500, "Alex", "ok"])
+    production.append([date(2026, 4, 2), "Whole Wheat 20kg", 20, False, True, True, True, None, None, None, None, None, None, 50, "Jake", None])
+
+    buf = BytesIO()
+    wb.save(buf)
+    buf.seek(0)
+    return buf
+
+
+def test_import_names_and_production():
+    from openpyxl import load_workbook
+
+    db = _session()
+    wb = load_workbook(_make_workbook(), data_only=True)
+    created, _ = import_names_sheet(db, wb, "test-tenant")
+    assert created == 2
+
+    imported, skipped = import_production_sheet(db, wb, "test-tenant")
+    assert imported == 3
+    assert skipped == 0
+
+    entries = db.scalars(select(ProductionThroughput).order_by(ProductionThroughput.id)).all()
+    bags_entry = entries[0]
+    assert bags_entry.quantity_type == "bags"
+    assert bags_entry.calculated_kg == 2000.0
+    assert bags_entry.staff_name == "Jake"  # whitespace trimmed
+
+    bulka_entry = entries[1]
+    assert bulka_entry.quantity_type == "kg"
+    assert bulka_entry.calculated_kg == 1500.0
+    assert qa_passed(bulka_entry) is False  # bag_sealed was False
+
+    # Product master should have absorbed default_bag_size for the wheat product
+    wheat = db.scalar(
+        select(ThroughputProduct).where(ThroughputProduct.name == "Whole Wheat 20kg")
+    )
+    assert wheat is not None
+    assert wheat.default_bag_size == 20
+
+
+def test_product_name_snapshot_preserved_when_product_renamed():
+    db = _session()
+    product = ThroughputProduct(tenant_id="t", name="Original Name", default_bag_size=20)
+    db.add(product)
+    db.flush()
+    entry = ProductionThroughput(
+        tenant_id="t",
+        production_date=date(2026, 4, 1),
+        product_id=product.id,
+        product_name_snapshot=product.name,
+        bag_size=20,
+        quantity=10,
+        quantity_type="bags",
+        calculated_kg=200,
+    )
+    db.add(entry)
+    db.flush()
+
+    product.name = "Renamed Product"
+    db.flush()
+
+    reloaded = db.scalar(select(ProductionThroughput).where(ProductionThroughput.id == entry.id))
+    assert reloaded.product_name_snapshot == "Original Name"
+
+
+def test_seed_throughput_products_from_costing_products():
+    db = _session()
+    mix = _costing_mix(db)
+    db.add_all(
+        [
+            Product(
+                tenant_id="hunter-premium-produce",
+                client_name="Hunter",
+                item_id="1001",
+                name="Whole Wheat 20kg",
+                mix_id=mix.id,
+                sale_type="standard",
+                unit_of_measure="20kg bag",
+                visible=True,
+            ),
+            Product(
+                tenant_id="hunter-premium-produce",
+                client_name="Hunter",
+                item_id="1002",
+                name="Bulka Maize",
+                mix_id=mix.id,
+                sale_type="bulka",
+                unit_of_measure="tonne",
+                visible=False,
+            ),
+        ]
+    )
+    db.flush()
+
+    report = seed_throughput_products_from_costing(db)
+
+    assert report == {"created": 2, "updated": 0, "skipped": 0}
+    products = db.scalars(select(ThroughputProduct).order_by(ThroughputProduct.item_id)).all()
+    assert [product.name for product in products] == ["Whole Wheat 20kg", "Bulka Maize"]
+    assert products[0].default_bag_size == 20
+    assert products[0].is_bulka_default is False
+    assert products[0].active is True
+    assert products[1].default_bag_size is None
+    assert products[1].is_bulka_default is True
+    assert products[1].active is False
+
+
+def test_seed_throughput_products_from_costing_updates_existing_by_item_id():
+    db = _session()
+    mix = _costing_mix(db)
+    db.add(
+        Product(
+            tenant_id="hunter-premium-produce",
+            client_name="Hunter",
+            item_id="1001",
+            name="Updated Wheat 25kg",
+            mix_id=mix.id,
+            sale_type="standard",
+            unit_of_measure="25kg bag",
+            visible=True,
+        )
+    )
+    db.add(
+        ThroughputProduct(
+            tenant_id="hunter-premium-produce",
+            item_id="1001",
+            name="Old Wheat",
+            default_bag_size=20,
+            active=False,
+            notes="Seeded from costing products",
+        )
+    )
+    db.flush()
+
+    report = seed_throughput_products_from_costing(db)
+
+    assert report == {"created": 0, "updated": 1, "skipped": 0}
+    products = db.scalars(select(ThroughputProduct)).all()
+    assert len(products) == 1
+    assert products[0].name == "Updated Wheat 25kg"
+    assert products[0].default_bag_size == 25
+    assert products[0].active is True

deploy/Deploy.ps1

@@ -1,6 +1,6 @@
 <#
 .SYNOPSIS
-  Deploy the Lean 101 Clients app to a Digital Ocean droplet over SSH.
+  Lean 101 deployment script — ships an app to a Digital Ocean droplet over SSH.
 
 .DESCRIPTION
   Tars the local source tree, uploads it to the droplet, and runs
@@ -8,14 +8,33 @@
 
   The same script handles first-time setup and subsequent updates.
 
+  Designed to be swappable across Lean 101 apps. Override -AppName and
+  -AppSlug (and any defaults derived from them) to deploy a different app.
+
 .PARAMETER RemoteHost
   Hostname or IP of the Digital Ocean droplet. Required.
 
 .PARAMETER RemoteUser
   SSH user. Defaults to 'root'.
 
+.PARAMETER AppName
+  Human-readable app name shown in the banner and log output.
+  Defaults to 'Clients'.
+
+.PARAMETER AppSlug
+  Lowercase slug used to derive default remote path, container names, env files,
+  and archive names. Defaults to 'clients'. Override to retarget the script at
+  a different Lean 101 app (e.g. -AppSlug 'ops' for the Ops portal).
+
 .PARAMETER RemotePath
-  Absolute path on the droplet. Defaults to '/srv/lean101-clients'.
+  Absolute path on the droplet. Defaults to '/srv/lean101-<AppSlug>'.
+
+.PARAMETER BackendContainer
+  Backend container name to inspect for health. Defaults to 'lean101-<AppSlug>-backend'.
+
+.PARAMETER PortEnvKey
+  Env var name in the env file that holds the published port.
+  Defaults to '<APPSLUG_UPPER>_APP_PORT' (e.g. CLIENTS_APP_PORT).
 
 .PARAMETER EnvFile
   Local path to the production env file. Defaults to '.env.production'.
@@ -23,6 +42,11 @@
 .PARAMETER SshKey
   Optional path to an SSH private key.
 
+.PARAMETER Password
+  Optional SSH password for password-based auth (no key). Requires sshpass on
+  PATH. The password is handed to ssh/scp via the SSHPASS environment variable
+  rather than an interactive prompt, because the script redirects ssh's I/O.
+
 .PARAMETER ComposeFile
   Compose file name on the remote host. Defaults to 'docker-compose.production.yml'.
 
@@ -35,54 +59,276 @@
 .PARAMETER SkipBuild
   Pass --no-build to docker compose (use when only env changed).
 
+.PARAMETER Force
+  Skip the remote port-availability preflight. Use when you know the port is
+  held by this same stack and want to redeploy over it regardless.
+
+.PARAMETER NoBanner
+  Suppress the ASCII banner (useful in CI).
+
 .EXAMPLE
   ./deploy/Deploy.ps1 -RemoteHost 209.38.24.231
 
 .EXAMPLE
   ./deploy/Deploy.ps1 -RemoteHost 209.38.24.231 -Seed -Logs
+
+.EXAMPLE
+  # Password auth instead of an SSH key (requires sshpass on PATH):
+  ./deploy/Deploy.ps1 -RemoteHost 209.38.24.231 -Password 'your-password' -Seed -Logs
+
+.EXAMPLE
+  # Retarget the script at a different Lean 101 app:
+  ./deploy/Deploy.ps1 -RemoteHost 1.2.3.4 -AppName 'Ops' -AppSlug 'ops'
 #>
 
 [CmdletBinding()]
 param(
   [Parameter(Mandatory = $true)] [string] $RemoteHost,
   [string] $RemoteUser        = "root",
-  [string] $RemotePath     = "/srv/lean101-clients",
+  [string] $AppName           = "Clients",
+  [string] $AppSlug           = "clients",
+  [string] $RemotePath,
+  [string] $BackendContainer,
+  [string] $PortEnvKey,
   [string] $EnvFile           = ".env.production",
   [string] $SshKey,
+  [string] $Password,
   [string] $ComposeFile       = "docker-compose.production.yml",
   [switch] $Seed,
   [switch] $Logs,
-  [switch] $SkipBuild
+  [switch] $SkipBuild,
+  [switch] $Force,
+  [switch] $NoBanner
 )
 
 $ErrorActionPreference = "Stop"
 Set-StrictMode -Version Latest
 
-# ── Helpers ───────────────────────────────────────────────────────────────────
-function Write-Step($msg) { Write-Host "==> $msg" -ForegroundColor Cyan }
-function Write-Warn($msg) { Write-Host "!!  $msg" -ForegroundColor Yellow }
+# ── App identity (swappable) ──────────────────────────────────────────────────
+$AppSlug = $AppSlug.ToLowerInvariant()
+$AppStack = "lean101-$AppSlug"
+if (-not $RemotePath)        { $RemotePath        = "/srv/$AppStack" }
+if (-not $BackendContainer)  { $BackendContainer  = "$AppStack-backend" }
+if (-not $PortEnvKey)        { $PortEnvKey        = "$($AppSlug.ToUpperInvariant())_APP_PORT" }
 
+# ── Palette ───────────────────────────────────────────────────────────────────
+# ANSI escapes give us truecolor + dim/bold that Write-Host -ForegroundColor cannot.
+$Esc = [char]27
+$C = @{
+  Reset   = "$Esc[0m"
+  Dim     = "$Esc[2m"
+  Bold    = "$Esc[1m"
+  Italic  = "$Esc[3m"
+  Magenta = "$Esc[38;5;177m"  # soft violet
+  Pink    = "$Esc[38;5;213m"
+  Cyan    = "$Esc[38;5;87m"
+  Teal    = "$Esc[38;5;79m"
+  Green   = "$Esc[38;5;120m"
+  Yellow  = "$Esc[38;5;221m"
+  Red     = "$Esc[38;5;203m"
+  Grey    = "$Esc[38;5;244m"
+  Blue    = "$Esc[38;5;117m"
+}
+
+$Glyph = @{
+  Step    = '▸'
+  OK      = '✓'
+  Warn    = '!'
+  Info    = '·'
+  Fail    = '✗'
+  Arrow   = '→'
+  Spark   = '✦'
+}
+
+function Write-Banner {
+  if ($NoBanner) { return }
+  $line   = '─' * 62
+  $title  = "Lean 101 Deployment Script"
+  $sub    = "App: $AppName    Slug: $AppSlug    Target: $RemoteUser@$RemoteHost"
+  Write-Host ""
+  Write-Host ("$($C.Magenta)╭$line╮$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ██╗     ███████╗ █████╗ ███╗   ██╗   ███╗ ██████╗ ███╗$($C.Reset)$($C.Magenta)  │$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ██║     ██╔════╝██╔══██╗████╗  ██║  ████║██╔═████╗ ██║$($C.Reset)$($C.Magenta)  │$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ██║     █████╗  ███████║██╔██╗ ██║ ██╔██║██║██╔██║ ██║$($C.Reset)$($C.Magenta)  │$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ██║     ██╔══╝  ██╔══██║██║╚██╗██║ ╚═╝██║████╔╝██║ ██║$($C.Reset)$($C.Magenta)  │$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ███████╗███████╗██║  ██║██║ ╚████║ ███████╗╚██████╔╝ ██║$($C.Reset)$($C.Magenta)│$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)$($C.Bold)$($C.Pink)        ╚══════╝╚══════╝╚═╝  ╚═╝╚═╝  ╚═══╝ ╚══════╝ ╚═════╝  ╚═╝$($C.Reset)$($C.Magenta)│$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)                                                              $($C.Magenta)│$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)  $($C.Bold)$($C.Cyan)$($Glyph.Spark) $title$($C.Reset)" + (' ' * (60 - $title.Length - 3)) + "$($C.Magenta)│$($C.Reset)")
+  Write-Host ("$($C.Magenta)│$($C.Reset)  $($C.Dim)$($C.Grey)$sub$($C.Reset)" + (' ' * [Math]::Max(0, 60 - $sub.Length - 2)) + "$($C.Magenta)│$($C.Reset)")
+  Write-Host ("$($C.Magenta)╰$line╯$($C.Reset)")
+  Write-Host ""
+}
+
+# ── Output helpers ────────────────────────────────────────────────────────────
+$script:StepIndex = 0
+function Write-Step([string]$msg) {
+  $script:StepIndex++
+  $num = "{0:D2}" -f $script:StepIndex
+  Write-Host ("$($C.Dim)$($C.Grey)[$num]$($C.Reset) $($C.Bold)$($C.Cyan)$($Glyph.Step)$($C.Reset) $($C.Bold)$msg$($C.Reset)")
+}
+function Write-Ok([string]$msg)   { Write-Host ("     $($C.Green)$($Glyph.OK)$($C.Reset) $($C.Green)$msg$($C.Reset)") }
+function Write-Warn([string]$msg) { Write-Host ("     $($C.Yellow)$($Glyph.Warn)$($C.Reset) $($C.Yellow)$msg$($C.Reset)") }
+function Write-Info([string]$msg) { Write-Host ("     $($C.Dim)$($C.Grey)$($Glyph.Info) $msg$($C.Reset)") }
+function Write-Fail([string]$msg) { Write-Host ("     $($C.Red)$($Glyph.Fail)$($C.Reset) $($C.Red)$msg$($C.Reset)") }
+
+# ── Spinner ───────────────────────────────────────────────────────────────────
+$Spinner = @('⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏')
+
+function Invoke-Spinner {
+  <#
+    Runs an external process while animating a braille spinner with elapsed time.
+    Captures stdout/stderr and surfaces them on failure (or via -Quiet:$false).
+  #>
+  param(
+    [Parameter(Mandatory = $true)] [string]   $Label,
+    [Parameter(Mandatory = $true)] [string]   $FilePath,
+    [string[]] $ArgList = @(),
+    [string]   $StdinFile,
+    [switch]   $ShowOutput
+  )
+  $outFile = [System.IO.Path]::GetTempFileName()
+  $errFile = [System.IO.Path]::GetTempFileName()
+  $startParams = @{
+    FilePath               = $FilePath
+    NoNewWindow            = $true
+    PassThru               = $true
+    RedirectStandardOutput = $outFile
+    RedirectStandardError  = $errFile
+  }
+  if ($ArgList.Count -gt 0) { $startParams.ArgumentList = $ArgList }
+  if ($StdinFile)           { $startParams.RedirectStandardInput = $StdinFile }
+
+  $proc = Start-Process @startParams
+  $start = Get-Date
+  $i = 0
+  try {
+    while (-not $proc.HasExited) {
+      $elapsed = ((Get-Date) - $start).TotalSeconds
+      $frame = $Spinner[$i % $Spinner.Count]
+      Write-Host ("`r     $($C.Cyan)$frame$($C.Reset) $($C.Dim)$($C.Grey)$Label  $($C.Reset)$($C.Teal)$('{0,5:0.0}s' -f $elapsed)$($C.Reset)   ") -NoNewline
+      Start-Sleep -Milliseconds 90
+      $i++
+    }
+    $proc.WaitForExit()
+    $elapsed = ((Get-Date) - $start).TotalSeconds
+    $stdout = if (Test-Path $outFile) { Get-Content $outFile -Raw } else { '' }
+    $stderr = if (Test-Path $errFile) { Get-Content $errFile -Raw } else { '' }
+
+    if ($proc.ExitCode -eq 0) {
+      Write-Host ("`r     $($C.Green)$($Glyph.OK)$($C.Reset) $Label  $($C.Dim)$($C.Grey)$('{0,5:0.0}s' -f $elapsed)$($C.Reset)" + (' ' * 12))
+      if ($ShowOutput -and $stdout) {
+        foreach ($ln in ($stdout -split "`r?`n")) { if ($ln) { Write-Info $ln } }
+      }
+      return $stdout
+    }
+    else {
+      Write-Host ("`r     $($C.Red)$($Glyph.Fail)$($C.Reset) $Label  $($C.Dim)$($C.Grey)$('{0,5:0.0}s' -f $elapsed) (exit $($proc.ExitCode))$($C.Reset)" + (' ' * 8))
+      if ($stdout) { foreach ($ln in ($stdout -split "`r?`n")) { if ($ln) { Write-Host "       $($C.Dim)$($C.Grey)$ln$($C.Reset)" } } }
+      if ($stderr) { foreach ($ln in ($stderr -split "`r?`n")) { if ($ln) { Write-Host "       $($C.Red)$ln$($C.Reset)" } } }
+      throw "$Label failed (exit $($proc.ExitCode))"
+    }
+  }
+  finally {
+    Remove-Item $outFile -Force -ErrorAction SilentlyContinue
+    Remove-Item $errFile -Force -ErrorAction SilentlyContinue
+  }
+}
+
+# ── Helpers ───────────────────────────────────────────────────────────────────
 function Get-RepoRoot {
   $dir = Split-Path -Parent $PSScriptRoot
   if (-not $dir) { $dir = (Get-Location).Path }
   return $dir
 }
 
+function Get-EnvValue([string] $path, [string] $key) {
+  foreach ($line in Get-Content $path) {
+    $trimmed = $line.Trim()
+    if (-not $trimmed -or $trimmed.StartsWith("#")) { continue }
+    if ($trimmed -notmatch "=") { continue }
+    $parts = $trimmed -split "=", 2
+    if ($parts[0].Trim() -eq $key) {
+      return $parts[1].Trim()
+    }
+  }
+  return $null
+}
+
 $RepoRoot   = Get-RepoRoot
 $SshTarget  = "$RemoteUser@$RemoteHost"
 $SshOpts    = @("-o", "StrictHostKeyChecking=accept-new", "-o", "BatchMode=no")
 if ($SshKey) { $SshOpts += @("-i", $SshKey) }
 
-function Invoke-Ssh([string] $cmd) {
-  & ssh @SshOpts $SshTarget $cmd
-  if ($LASTEXITCODE -ne 0) { throw "Remote command failed (exit $LASTEXITCODE): $cmd" }
+# Password auth (no SSH key): the spinner runs ssh/scp with redirected I/O, so
+# there is no terminal for an interactive password prompt. Feed the password
+# non-interactively via sshpass instead, reading it from the SSHPASS env var.
+$SshExe    = 'ssh'
+$ScpExe    = 'scp'
+$SshPrefix = @()
+$ScpPrefix = @()
+if ($Password) {
+  if (-not (Get-Command sshpass -ErrorAction SilentlyContinue)) {
+    throw "sshpass is required for -Password but was not found on PATH. Install it (e.g. 'scoop install sshpass') or use an SSH key."
+  }
+  $env:SSHPASS = $Password
+  $SshExe = 'sshpass'; $SshPrefix = @('-e', 'ssh')
+  $ScpExe = 'sshpass'; $ScpPrefix = @('-e', 'scp')
+  $SshOpts += @("-o", "PubkeyAuthentication=no", "-o", "PreferredAuthentications=password")
 }
 
-function Invoke-Scp([string] $local, [string] $remote) {
-  & scp @SshOpts $local "${SshTarget}:${remote}"
-  if ($LASTEXITCODE -ne 0) { throw "scp failed: $local -> $remote" }
+function Write-RemoteScript([string] $path, [string] $content) {
+  # Remote bash chokes on Windows CRLF line endings (each line gets a trailing
+  # \r) and on a UTF-8 BOM. Write LF-only, no BOM.
+  $lf = $content -replace "`r`n", "`n" -replace "`r", "`n"
+  [System.IO.File]::WriteAllText($path, $lf, (New-Object System.Text.UTF8Encoding($false)))
 }
 
+function Invoke-Ssh([string] $cmd, [string] $Label, [switch] $ShowOutput) {
+  if (-not $Label) { $Label = "ssh $($cmd.Substring(0, [Math]::Min(48, $cmd.Length)))..." }
+  # Send the command over stdin to `bash -s` rather than as a command-line
+  # argument. Complex commands (quotes, pipes, $(), newlines) get corrupted
+  # when passed as an argv token through sshpass's cygwin argument parsing;
+  # stdin keeps the only argv tokens simple ("bash -s").
+  $tmp = [System.IO.Path]::GetTempFileName()
+  try {
+    Write-RemoteScript $tmp $cmd
+    Invoke-Spinner -Label $Label -FilePath $SshExe -ArgList (@($SshPrefix) + @($SshOpts) + @($SshTarget, "bash -s")) -StdinFile $tmp -ShowOutput:$ShowOutput
+  } finally {
+    Remove-Item $tmp -Force -ErrorAction SilentlyContinue
+  }
+}
+
+function Invoke-Scp([string] $local, [string] $remote, [string] $Label) {
+  if (-not $Label) { $Label = "scp $(Split-Path -Leaf $local) $($Glyph.Arrow) $remote" }
+  Invoke-Spinner -Label $Label -FilePath $ScpExe -ArgList (@($ScpPrefix) + @($SshOpts) + @($local, "${SshTarget}:${remote}"))
+}
+
+function Try-Ssh([string] $cmd) {
+  $tmp = [System.IO.Path]::GetTempFileName()
+  try {
+    Write-RemoteScript $tmp $cmd
+    Get-Content $tmp -Raw | & $SshExe @SshPrefix @SshOpts $SshTarget "bash -s"
+    return $LASTEXITCODE
+  } finally {
+    Remove-Item $tmp -Force -ErrorAction SilentlyContinue
+  }
+}
+
+function Invoke-SshScript([string] $script, [string] $Label) {
+  if (-not $Label) { $Label = "ssh (remote script)" }
+  $tmp = [System.IO.Path]::GetTempFileName()
+  try {
+    Write-RemoteScript $tmp $script
+    Invoke-Spinner -Label $Label -FilePath $SshExe -ArgList (@($SshPrefix) + @($SshOpts) + @($SshTarget, "bash -s")) -StdinFile $tmp -ShowOutput
+  } finally {
+    Remove-Item $tmp -Force -ErrorAction SilentlyContinue
+  }
+}
+
+# ── Render banner ─────────────────────────────────────────────────────────────
+Write-Banner
+
 # ── Resolve paths ─────────────────────────────────────────────────────────────
 Push-Location $RepoRoot
 try {
@@ -90,15 +336,69 @@ try {
   if (-not (Test-Path $EnvPath)) {
     throw "Env file not found at '$EnvPath'. Copy .env.production.example and fill in secrets."
   }
+  $WorkbookCandidates = @(
+    (Join-Path $RepoRoot "input_data\\1.xlsx"),
+    (Join-Path $RepoRoot "Input Cost Spreadsheet(1).xlsx")
+  )
+  $WorkbookPath = $WorkbookCandidates | Where-Object { Test-Path $_ } | Select-Object -First 1
+  if (-not $WorkbookPath) {
+    throw "Workbook not found. Checked: $($WorkbookCandidates -join ', '). The production seed expects at least one workbook file to exist."
+  }
+
+  $AppPort = Get-EnvValue $EnvPath $PortEnvKey
+  if (-not $AppPort) { $AppPort = "8081" }
+  $Origin = Get-EnvValue $EnvPath "ORIGIN"
+  if (-not $Origin) { $Origin = "https://clients.lean-101.com.au" }
+
+  Write-Step "Preflight"
+  Write-Info "App           : $AppName ($AppSlug)"
+  Write-Info "Remote host   : $SshTarget"
+  Write-Info "Remote path   : $RemotePath"
+  Write-Info "Container     : $BackendContainer"
+  Write-Info "Env file      : $EnvPath"
+  Write-Info "Compose file  : $ComposeFile"
+  Write-Info "Origin        : $Origin"
+  Write-Info "Port ($PortEnvKey) : $AppPort"
 
   # ── Connectivity check ──────────────────────────────────────────────────────
-  Write-Step "Checking SSH connectivity to $SshTarget"
-  Invoke-Ssh "echo connected as `$(whoami) on `$(hostname)"
+  Write-Step "Verifying SSH connectivity"
+  Invoke-Ssh "echo connected as `$(whoami) on `$(hostname)" -Label "ssh handshake" -ShowOutput
+
+  # ── Remote port availability ───────────────────────────────────────────────
+  # A re-deploy of this same stack is expected to replace its containers in
+  # place, so any container belonging to this stack (name == STACK or STACK-*)
+  # is treated as "ours". Only a genuinely different service triggers an abort.
+  if ($Force) {
+    Write-Step "Skipping remote port check for $AppStack (-Force)"
+  }
+  else {
+    Write-Step "Checking that remote port $AppPort is free for $AppStack"
+    $portCheckCmd = @'
+set -e
+PORT='__APP_PORT__'
+STACK='__APP_STACK__'
+OWNER=$(docker ps --format '{{.Names}} {{.Ports}}' | grep -m1 ":${PORT}->" | cut -d' ' -f1 || true)
+if [ -n "$OWNER" ]; then
+  case "$OWNER" in
+    "$STACK"|"$STACK"-*) : ;;
+    *)
+      echo "Port $PORT is already owned by container: $OWNER" >&2
+      exit 2 ;;
+  esac
+fi
+'@.Replace('__APP_PORT__', $AppPort).Replace('__APP_STACK__', $AppStack)
+    try {
+      Invoke-Ssh $portCheckCmd -Label "port $AppPort availability"
+    }
+    catch {
+      throw "Remote port $AppPort is already in use by a different service. Change $PortEnvKey in '$EnvPath', retire the conflicting service, or re-run with -Force to deploy anyway."
+    }
+  }
 
   # ── Package source files ────────────────────────────────────────────────────
-  Write-Step "Packaging source files (excluding node_modules, caches, etc.)"
+  Write-Step "Packaging source tree (excluding node_modules, caches, secrets)"
 
-  $TarFile = Join-Path $env:TEMP "lean101-deploy-$(Get-Date -Format 'yyyyMMdd-HHmmss').tar.gz"
+  $TarFile = Join-Path $env:TEMP "$AppStack-deploy-$(Get-Date -Format 'yyyyMMdd-HHmmss').tar.gz"
 
   $excludes = @(
     "--exclude=./node_modules",
@@ -106,9 +406,14 @@ try {
     "--exclude=./frontend/.svelte-kit",
     "--exclude=./frontend/build",
     "--exclude=./.git",
+    "--exclude=./.pytest_cache",
     "--exclude=./__pycache__",
     "--exclude=./backend/__pycache__",
     "--exclude=./backend/app/__pycache__",
+    "--exclude=./backend/.pytest_cache",
+    "--exclude=./backend/.tmp",
+    "--exclude=./backend/.venv",
+    "--exclude=./backend/data_entry_app_backend.egg-info",
     "--exclude=./**/__pycache__",
     "--exclude=./*.pyc",
     "--exclude=./.env",
@@ -118,39 +423,48 @@ try {
     "--exclude=./*.db"
   )
 
-  & tar -czf $TarFile @excludes -C $RepoRoot .
-  if ($LASTEXITCODE -ne 0) { throw "tar failed" }
+  Invoke-Spinner -Label "tar -czf $(Split-Path -Leaf $TarFile)" -FilePath 'tar' -ArgList (@('-czf', $TarFile) + $excludes + @('-C', $RepoRoot, '.'))
 
   $TarSize = [math]::Round((Get-Item $TarFile).Length / 1MB, 1)
-  Write-Host "    Archive: $TarFile ($TarSize MB)"
+  Write-Info "Archive: $TarFile ($($C.Bold)$TarSize MB$($C.Reset))"
 
   # ── Upload env file ─────────────────────────────────────────────────────────
-  Write-Step "Uploading env file"
-  Invoke-Scp $EnvPath "$RemotePath/.env.production"
-  Invoke-Ssh "chmod 600 '$RemotePath/.env.production'"
+  Write-Step "Uploading env file to droplet"
+  Invoke-Scp $EnvPath "$RemotePath/.env.production" -Label "scp .env.production $($Glyph.Arrow) $RemotePath/"
+  Invoke-Ssh "chmod 600 '$RemotePath/.env.production'" -Label "chmod 600 .env.production"
 
   # ── Upload and extract source ────────────────────────────────────────────────
-  Write-Step "Uploading source archive"
-  Invoke-Scp $TarFile "/tmp/lean101-deploy.tar.gz"
+  Write-Step "Uploading source archive ($TarSize MB)"
+  Invoke-Scp $TarFile "/tmp/$AppStack-deploy.tar.gz" -Label "scp archive $($Glyph.Arrow) /tmp/"
   Remove-Item $TarFile -Force
 
-  Write-Step "Extracting on server"
-  Invoke-Ssh "mkdir -p '$RemotePath' && tar -xzf /tmp/lean101-deploy.tar.gz -C '$RemotePath' && rm /tmp/lean101-deploy.tar.gz"
+  Write-Step "Extracting archive on server"
+  Invoke-Ssh "mkdir -p '$RemotePath' && tar -xzf /tmp/$AppStack-deploy.tar.gz -C '$RemotePath' && rm /tmp/$AppStack-deploy.tar.gz" -Label "untar into $RemotePath"
 
   # ── Docker compose up ───────────────────────────────────────────────────────
   $ComposeArgs = "--env-file .env.production -f $ComposeFile"
   $BuildFlag   = if ($SkipBuild) { "--no-build" } else { "--build" }
 
-  Write-Step "Bringing stack up (build=$(-not $SkipBuild))"
-  Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs up -d $BuildFlag --remove-orphans"
+  $buildMsg = if ($SkipBuild) { "without rebuild" } else { "with --build" }
+  Write-Step "Bringing the $AppName stack up $buildMsg"
+  $composeUpCmd = "cd '$RemotePath' && docker compose $ComposeArgs up -d $BuildFlag --remove-orphans"
+  try {
+    Invoke-Ssh $composeUpCmd -Label "docker compose up $BuildFlag"
+  }
+  catch {
+    Write-Warn "docker compose up failed; collecting remote status and backend logs"
+    Try-Ssh "cd '$RemotePath' && docker compose $ComposeArgs ps"
+    Try-Ssh "cd '$RemotePath' && docker compose $ComposeArgs logs --tail=120 backend"
+    throw
+  }
 
   # ── Health check ────────────────────────────────────────────────────────────
-  Write-Step "Waiting for backend health check"
+  Write-Step "Waiting for backend health check ($BackendContainer)"
   $healthScript = @"
 set -e
 cd '$RemotePath'
 for i in `$(seq 1 30); do
-  status=`$(docker inspect --format='{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' lean101-clients-backend 2>/dev/null || echo missing)
+  status=`$(docker inspect --format='{{if .State.Health}}{{.State.Health.Status}}{{else}}{{.State.Status}}{{end}}' $BackendContainer 2>/dev/null || echo missing)
   case "`$status" in
     healthy|running) echo "backend is `$status"; exit 0 ;;
     *) printf '.'; sleep 4 ;;
@@ -158,25 +472,114 @@ for i in `$(seq 1 30); do
 done
 echo; echo 'backend did not become healthy in time' >&2; exit 1
 "@
-  Invoke-Ssh $healthScript
+  Invoke-SshScript $healthScript -Label "backend health (up to ~2 min)"
+
+  # ── Seed access ─────────────────────────────────────────────────────────────
+  Write-Step "Seeding default internal users and permissions"
+  Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs exec -T backend python -m app.seed_access" -Label "python -m app.seed_access"
 
-  # ── Optional seed ───────────────────────────────────────────────────────────
   if ($Seed) {
     Write-Step "Seeding reference data"
-    Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs exec -T backend python -m app.seed"
+    Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs exec -T backend python -m app.seed" -Label "python -m app.seed"
   }
 
   # ── Final status ────────────────────────────────────────────────────────────
   Write-Step "Stack status"
-  Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs ps"
+  Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs ps" -Label "docker compose ps" -ShowOutput
+
+  # ── Frontend asset verification ─────────────────────────────────────────────
+  Write-Step "Verifying published Inter font asset"
+  $fontCheckBody = @'
+set -e
+ORIGIN="__ORIGIN__"
+
+fetch() {
+  URL="$1"
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsSL "$URL"
+    return
+  fi
+  if command -v wget >/dev/null 2>&1; then
+    wget -qO- "$URL"
+    return
+  fi
+  echo "Neither curl nor wget is available on the remote host." >&2
+  exit 1
+}
+
+fetch_status() {
+  URL="$1"
+  if command -v curl >/dev/null 2>&1; then
+    curl -fsS -o /dev/null -w "%{http_code}" "$URL"
+    return
+  fi
+  if command -v wget >/dev/null 2>&1; then
+    wget -S --spider "$URL" 2>&1 | awk '/^  HTTP\// { code=$2 } END { if (code) print code; else print "000" }'
+    return
+  fi
+  echo "000"
+}
+
+INDEX_HTML=$(fetch "$ORIGIN")
+CSS_PATHS=$(printf '%s' "$INDEX_HTML" | grep -oE '/_app/immutable/assets/[^"]+\.css' | sort -u || true)
+if [ -z "$CSS_PATHS" ]; then
+  echo "Could not find a built CSS asset on $ORIGIN" >&2
+  exit 1
+fi
+
+FONT_URL=""
+for CSS_PATH in $CSS_PATHS; do
+  CSS_URL="${ORIGIN%/}${CSS_PATH}"
+  CSS_CONTENT=$(fetch "$CSS_URL")
+  FONT_PATH=$(printf '%s' "$CSS_CONTENT" | grep -oE 'inter-latin-400-normal\.[^")]+\.woff2' | head -n 1 || true)
+  if [ -n "$FONT_PATH" ]; then
+    FONT_URL="${CSS_URL%/*}/${FONT_PATH}"
+    break
+  fi
+done
+
+if [ -z "$FONT_PATH" ]; then
+  echo "Could not find the Inter Latin 400 woff2 asset in any built CSS asset from $ORIGIN" >&2
+  exit 1
+fi
+
+FONT_STATUS=$(fetch_status "$FONT_URL")
+if [ "$FONT_STATUS" != "200" ]; then
+  echo "Inter font check failed: $FONT_URL returned HTTP $FONT_STATUS" >&2
+  exit 1
+fi
+
+echo "Verified Inter font asset: $FONT_URL"
+'@.Replace('__ORIGIN__', $Origin)
+  Invoke-SshScript $fontCheckBody -Label "Inter font asset check"
 
   if ($Logs) {
     Write-Step "Recent logs (last 60 lines)"
-    Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs logs --tail=60"
+    Invoke-Ssh "cd '$RemotePath' && docker compose $ComposeArgs logs --tail=60" -Label "docker compose logs --tail=60" -ShowOutput
   }
 
+  Write-Step "Published access"
+  Write-Info "Container port : $($C.Bold)$AppPort$($C.Reset)"
+  Write-Info "Origin         : $($C.Bold)$($C.Blue)$Origin$($C.Reset)"
+  if ($AppPort -ne "80" -and $AppPort -ne "443") {
+    Write-Warn "This stack is published on port $AppPort. The public domain may still point at another service until you swap the reverse proxy or port mapping."
+  }
+
+  # ── Done ────────────────────────────────────────────────────────────────────
+  $line   = '─' * 62
   Write-Host ""
-  Write-Host "Deployment complete -> https://clients.lean-101.com.au" -ForegroundColor Green
+  Write-Host ("$($C.Green)╭$line╮$($C.Reset)")
+  $done = "$($Glyph.Spark) $AppName deployed $($Glyph.Arrow) $Origin"
+  $pad  = [Math]::Max(0, 60 - ($done.Length - 2))   # subtract 2 for two-byte glyphs
+  Write-Host ("$($C.Green)│$($C.Reset)  $($C.Bold)$($C.Green)$done$($C.Reset)" + (' ' * $pad) + "$($C.Green)│$($C.Reset)")
+  Write-Host ("$($C.Green)╰$line╯$($C.Reset)")
+  Write-Host ""
+}
+catch {
+  Write-Host ""
+  Write-Fail "Deployment aborted: $($_.Exception.Message)"
+  Write-Host ""
+  throw
 }
 finally {
   Pop-Location

deploy/nginx/clients.lean-101.conf

@@ -27,7 +27,7 @@ server {
   add_header X-Content-Type-Options "nosniff" always;
   add_header Referrer-Policy "strict-origin-when-cross-origin" always;
   add_header Permissions-Policy "camera=(), microphone=(), geolocation=()" always;
-  add_header Content-Security-Policy "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self'; font-src 'self' data:; connect-src 'self'; frame-ancestors 'self'; base-uri 'self'; form-action 'self'" always;
+  add_header Content-Security-Policy "default-src 'self'; img-src 'self' data:; style-src 'self' 'unsafe-inline'; script-src 'self' 'unsafe-inline'; font-src 'self' data:; connect-src 'self'; frame-ancestors 'self'; base-uri 'self'; form-action 'self'" always;
 
   location /_app/immutable/ {
     expires 1y;
@@ -88,6 +88,9 @@ server {
   }
 
   location / {
+    add_header Cache-Control "no-store, no-cache, must-revalidate" always;
+    add_header Pragma "no-cache" always;
+    expires -1;
     proxy_pass http://lean101_clients_frontend;
     proxy_http_version 1.1;
     proxy_set_header Host $host;

frontend/package-lock.json

@@ -1,13 +1,14 @@
 {
   "name": "hunter-app",
-  "version": "1.5.6",
+  "version": "0.1.8",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "hunter-app",
-      "version": "1.5.6",
+      "version": "0.1.8",
       "dependencies": {
+        "@fontsource/inter": "^5.2.8",
         "lucide-svelte": "^1.0.1"
       },
       "devDependencies": {
@@ -54,6 +55,15 @@
         "tslib": "^2.4.0"
       }
     },
+    "node_modules/@fontsource/inter": {
+      "version": "5.2.8",
+      "resolved": "https://registry.npmjs.org/@fontsource/inter/-/inter-5.2.8.tgz",
+      "integrity": "sha512-P6r5WnJoKiNVV+zvW2xM13gNdFhAEpQ9dQJHt3naLvfg+LkF2ldgSLiF4T41lf1SQCM9QmkqPTn4TH568IRagg==",
+      "license": "OFL-1.1",
+      "funding": {
+        "url": "https://github.com/sponsors/ayuhito"
+      }
+    },
     "node_modules/@jridgewell/gen-mapping": {
       "version": "0.3.13",
       "resolved": "https://registry.npmjs.org/@jridgewell/gen-mapping/-/gen-mapping-0.3.13.tgz",

frontend/package.json

@@ -1,6 +1,6 @@
 {
   "name": "hunter-app",
-  "version": "1.5.6",
+  "version": "0.1.8",
   "private": true,
   "type": "module",
   "scripts": {
@@ -19,6 +19,7 @@
     "vitest": "^4.0.0"
   },
   "dependencies": {
+    "@fontsource/inter": "^5.2.8",
     "lucide-svelte": "^1.0.1"
   }
 }

frontend/src/lib/api.ts

@@ -33,7 +33,13 @@ import type {
   RawMaterial,
   RawMaterialCreateInput,
   RawMaterialPriceCreateInput,
-  Scenario
+  Scenario,
+  ThroughputEntry,
+  ThroughputEntryCreateInput,
+  ThroughputEntryListParams,
+  ThroughputProduct,
+  ThroughputProductCreateInput,
+  ThroughputProductUpdateInput
 } from '$lib/types';
 import { getStoredAdminSession, getStoredClientSession } from '$lib/session';
 
@@ -248,12 +254,18 @@ async function request<T>(
 
 async function requestBlob(
   path: string,
+  options: RequestInit = {},
   auth: AuthMode = 'none',
   fetcher: ApiFetch = fetch
 ): Promise<Blob> {
   try {
     const response = await fetcher(resolveRequestUrl(path, fetcher), {
-      credentials: 'include'
+      headers: {
+        'Content-Type': 'application/json',
+        ...(options.headers ?? {})
+      },
+      credentials: 'include',
+      ...options
     });
 
     if (!response.ok) {
@@ -284,12 +296,17 @@ export const api = {
   mixCalculatorSession: (sessionId: number, fetcher?: ApiFetch) =>
     request<MixCalculatorSession>(`/api/mix-calculator/${sessionId}`, { method: 'GET' }, 'client', fetcher),
   mixCalculatorSessionPdf: (sessionId: number, fetcher?: ApiFetch) =>
-    requestBlob(`/api/mix-calculator/${sessionId}/pdf`, 'client', fetcher),
+    requestBlob(`/api/mix-calculator/${sessionId}/pdf`, {}, 'client', fetcher),
   previewMixCalculatorSession: (payload: MixCalculatorCreateInput) =>
     request<MixCalculatorPreview>('/api/mix-calculator/preview', {
       method: 'POST',
       body: JSON.stringify(payload)
     }, 'client'),
+  previewMixCalculatorPdf: (payload: MixCalculatorCreateInput) =>
+    requestBlob('/api/mix-calculator/preview/pdf', {
+      method: 'POST',
+      body: JSON.stringify(payload)
+    }, 'client'),
   createMixCalculatorSession: (payload: MixCalculatorCreateInput) =>
     request<MixCalculatorSession>('/api/mix-calculator', {
       method: 'POST',
@@ -304,6 +321,35 @@ export const api = {
   productCosts: (fetcher?: ApiFetch) =>
     cachedFetchJson<ProductCostBreakdown[]>('/api/powerbi/product-costs', mockCosts, 'client', fetcher),
   scenarios: (fetcher?: ApiFetch) => cachedFetchJson<Scenario[]>('/api/scenarios', mockScenarios, 'client', fetcher),
+  throughputProducts: (fetcher?: ApiFetch) =>
+    cachedFetchJson<ThroughputProduct[]>('/api/throughput/products', [], 'client', fetcher),
+  throughputEntries: (params?: ThroughputEntryListParams, fetcher?: ApiFetch) => {
+    const search = new URLSearchParams();
+    if (params?.date_from) search.set('date_from', params.date_from);
+    if (params?.date_to) search.set('date_to', params.date_to);
+    if (params?.product_id != null) search.set('product_id', String(params.product_id));
+    if (params?.staff_name) search.set('staff_name', params.staff_name);
+    if (params?.quantity_type) search.set('quantity_type', params.quantity_type);
+    if (params?.limit) search.set('limit', String(params.limit));
+    const qs = search.toString();
+    const path = qs ? `/api/throughput/entries?${qs}` : '/api/throughput/entries';
+    return cachedFetchJson<ThroughputEntry[]>(path, [], 'client', fetcher);
+  },
+  createThroughputEntry: (payload: ThroughputEntryCreateInput) =>
+    request<ThroughputEntry>('/api/throughput/entries', {
+      method: 'POST',
+      body: JSON.stringify(payload)
+    }, 'client'),
+  createThroughputProduct: (payload: ThroughputProductCreateInput) =>
+    request<ThroughputProduct>('/api/throughput/products', {
+      method: 'POST',
+      body: JSON.stringify(payload)
+    }, 'client'),
+  updateThroughputProduct: (productId: number, payload: ThroughputProductUpdateInput) =>
+    request<ThroughputProduct>(`/api/throughput/products/${productId}`, {
+      method: 'PATCH',
+      body: JSON.stringify(payload)
+    }, 'client'),
   clientAccess: (fetcher?: ApiFetch) => cachedFetchJson<ClientAccessAccount[]>('/api/client-access', mockClientAccess, 'manager', fetcher),
   clientAccessExport: (fetcher?: ApiFetch) =>
     cachedFetchJson<ClientAccessPowerBiExport>('/api/powerbi/client-access', mockClientAccessExport, 'manager', fetcher),

frontend/src/lib/components/ClientShell.svelte

@@ -21,6 +21,7 @@
     canOpenReporting as sessionCanOpenReporting,
     canOpenScenarios as sessionCanOpenScenarios,
     canOpenSettings as sessionCanOpenSettings,
+    canOpenThroughput as sessionCanOpenThroughput,
     canUseWorkspaceSearch as sessionCanUseWorkspaceSearch,
     getWorkspaceRole,
     getWorkspaceHomeHref as sessionWorkspaceHomeHref,
@@ -36,6 +37,7 @@
     mixCalculatorItem,
     pageTitle,
     reportingItem,
+    throughputItem,
     type FooterLink,
     type SearchItem,
     type NavItem,
@@ -67,7 +69,6 @@
   let seededSearchKey = $state<string | null>(null);
   let paletteInput: HTMLInputElement | null = $state(null);
   const appVersion = `v${packageInfo.version}`;
-  const releaseStage = 'Beta';
   const currentYear = new Date().getFullYear();
   const canOpenDashboard = $derived(sessionCanOpenDashboard($clientSession));
   const canOpenRawMaterials = $derived(sessionCanOpenRawMaterials($clientSession));
@@ -85,7 +86,9 @@
   const routeGuardPending = $derived(!!$clientSession && (isRestoringSession || !currentRouteAllowed));
   const shellPathname = $derived(routeGuardPending ? workspaceHomeHref : page.url.pathname);
   const shellTitle = $derived(routeGuardPending ? 'Loading Workspace' : pageTitle(page.url.pathname));
-  const shellBreadcrumbs = $derived(routeGuardPending ? clientBreadcrumbs(workspaceHomeHref) : clientBreadcrumbs(page.url.pathname));
+  const shellBreadcrumbs = $derived(
+    routeGuardPending ? clientBreadcrumbs(workspaceHomeHref, $clientSession) : clientBreadcrumbs(page.url.pathname, $clientSession)
+  );
   const visibleDashboardItem = $derived(canOpenDashboard ? dashboardItem : null);
   const visibleWorkingDocumentItems = $derived(
     !$clientSession
@@ -99,6 +102,8 @@
         })
   );
   const visibleMixCalculatorItem = $derived(canOpenMixCalculator ? mixCalculatorItem : null);
+  const canOpenThroughput = $derived(sessionCanOpenThroughput($clientSession));
+  const visibleThroughputItem = $derived(canOpenThroughput ? throughputItem : null);
   const visibleReportingItem = $derived(sessionCanOpenReporting($clientSession) ? reportingItem : null);
   const isOperationsUser = $derived($clientSession?.role_name === 'Operations');
   const workspaceRole = $derived(getWorkspaceRole($clientSession));
@@ -125,7 +130,6 @@
       if (item.href === '/mixes') return canOpenMixMaster;
       if (item.href === '/mixes/new') return canCreateMixWorksheet;
       if (item.href === '/mix-calculator') return canOpenMixCalculator;
-      if (item.href === '/mix-calculator/new') return canCreateMixSession;
       if (item.href === '/products') return canOpenProducts;
       if (item.href === '/reporting') return sessionCanOpenReporting($clientSession);
       if (item.href === '/settings') return canOpenSettings;
@@ -390,13 +394,13 @@
       primaryItems={[
         ...(visibleDashboardItem ? [visibleDashboardItem] : []),
         ...(visibleMixCalculatorItem ? [visibleMixCalculatorItem] : []),
+        ...(visibleThroughputItem ? [visibleThroughputItem] : []),
         ...(visibleReportingItem ? [visibleReportingItem] : [])
       ]}
       brandHref={workspaceHomeHref}
       workingDocumentItems={visibleWorkingDocumentItems}
       footerItems={visibleFooterLinks}
       {appVersion}
-      {releaseStage}
       {currentYear}
       {canOpenSettings}
       onOpenSettings={openSettings}
@@ -449,10 +453,10 @@
           <a href="/mixes/new">Create mix worksheet</a>
         {/if}
         {#if canOpenMixCalculator}
-          <a href={featureFlags.mixCalculatorSessionHistory ? '/mix-calculator' : '/mix-calculator/new'}>Open mix calculator</a>
+          <a href="/mix-calculator">Open mix calculator</a>
         {/if}
         {#if canCreateMixSession}
-          <a href="/mix-calculator/new">Create mix session</a>
+          <a href="/mix-calculator">Create mix session</a>
         {/if}
         {#if canOpenProducts}
           <a href="/products">Review delivered pricing</a>
@@ -540,6 +544,15 @@
             </a>
           {/if}
 
+          {#if visibleThroughputItem}
+            {@const Icon = visibleThroughputItem.icon}
+            <a class:active={matchesRoute(visibleThroughputItem.href, page.url.pathname)} href={visibleThroughputItem.href} onclick={() => (navOpen = false)}>
+              <span class="nav-icon"><Icon size={18} strokeWidth={1.75} /></span>
+              <span>{visibleThroughputItem.label}</span>
+              {#if visibleThroughputItem.badge}<span class="drawer-badge">{visibleThroughputItem.badge}</span>{/if}
+            </a>
+          {/if}
+
           {#if visibleReportingItem}
             {@const Icon = visibleReportingItem.icon}
             <a class:active={matchesRoute(visibleReportingItem.href, page.url.pathname)} href={visibleReportingItem.href} onclick={() => (navOpen = false)}>
@@ -569,7 +582,7 @@
             </a>
           {/if}
           {#if canCreateMixSession}
-            <a href="/mix-calculator/new" onclick={() => (navOpen = false)}>
+            <a href="/mix-calculator" onclick={() => (navOpen = false)}>
               <span class="nav-icon"><Calculator size={18} strokeWidth={1.75} /></span>
               <span>Create mix session</span>
             </a>
@@ -659,8 +672,6 @@
 {/if}
 
 <style>
-  @import url('https://fonts.googleapis.com/css2?family=Inter:wght@400;500;600;700&display=swap');
-
   :global(:root) {
     /* ── Brand ──────────────────────────────────────────────── */
     --color-brand:       #15803d;
@@ -705,7 +716,7 @@
     min-height: 100%;
     background: var(--color-bg-app);
     color: var(--color-text-primary);
-    font-family: Inter, "Segoe UI", sans-serif;
+    font-family: "Inter", "Segoe UI", sans-serif;
     font-size: 14px;
   }
 
@@ -714,7 +725,7 @@
   }
 
   :global(h1, h2, h3, h4, h5, h6) {
-    font-family: Inter, "Segoe UI", sans-serif;
+    font-family: "Inter", "Segoe UI", sans-serif;
     letter-spacing: -0.03em;
   }
 
@@ -734,6 +745,7 @@
     display: grid;
     grid-template-columns: 252px minmax(0, 1fr);
     min-height: 100vh;
+    background: var(--color-bg-app);
   }
 
   .signed-out-shell {
@@ -954,6 +966,7 @@
     min-height: 100vh;
     height: 100vh;
     overflow: hidden;
+    background: var(--color-bg-app);
   }
 
   .workspace-label {
@@ -1069,6 +1082,7 @@
     min-width: 0;
     padding: var(--content-padding);
     overflow: auto;
+    background: var(--color-bg-app);
   }
 
   .locked-card {
@@ -1346,6 +1360,18 @@
       background: var(--green-soft);
     }
 
+    .drawer-badge {
+      margin-left: auto;
+      padding: 0.08rem 0.4rem;
+      border-radius: 999px;
+      background: #fdf0d2;
+      color: #8a5a00;
+      font-size: 0.62rem;
+      font-weight: 700;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+    }
+
     .drawer-group {
       display: grid;
       gap: 0.4rem;

frontend/src/lib/components/MixCalculatorPrintDocument.svelte

@@ -4,7 +4,7 @@
   let {
     session,
     generatedAt = null,
-    showGeneratedStamp = true
+    showGeneratedStamp = false
   }: {
     session: MixCalculatorPreview | MixCalculatorSession;
     generatedAt?: string | null;
@@ -35,111 +35,66 @@
 
   const sessionNumber = $derived(hasSessionNumber(session) ? session.session_number : null);
   const issuedAt = $derived(generatedAt ?? new Date().toISOString());
-  const blendTotal = $derived(session.lines.reduce((sum, line) => sum + line.mix_percentage, 0));
 </script>
 
 <article class="print-document">
-  <header class="hero">
-    <div class="hero-copy">
-      <div class="hero-kicker">
-        <span>Mix Calculator</span>
-        {#if sessionNumber}
-          <strong>{sessionNumber}</strong>
-        {/if}
-      </div>
+  <header class="document-header">
+    <img class="brand-mark" src="/logo-hsf.png" alt="Hunter Stock Feeds" />
+
+    <div class="title-block">
+      <p class="eyebrow">Calculated Output</p>
       <h1>{session.product_name}</h1>
-      <p>{session.client_name} · {session.mix_name}</p>
+      <p class="subtitle">Snapshot of the scaled raw material requirements.</p>
     </div>
 
-    <div class="hero-side">
-      <div>
-        <span>Mix date</span>
-        <strong>{formatDate(session.mix_date)}</strong>
-      </div>
-      <div>
-        <span>Prepared by</span>
-        <strong>{session.prepared_by_name}</strong>
-      </div>
-      <div>
-        <span>Status</span>
-        <strong>{session.status}</strong>
-      </div>
+    <div class="session-block">
+      {#if sessionNumber}
+        <span>Session {sessionNumber}</span>
+      {/if}
+      {#if showGeneratedStamp}
+        <span>Generated {formatTimestamp(issuedAt)}</span>
+      {/if}
     </div>
   </header>
 
-  <section class="summary-band" aria-label="Session summary">
-    <article>
-      <span>Batch size</span>
-      <strong>{formatNumber(session.batch_size_kg, 2)}kg</strong>
-    </article>
-    <article>
-      <span>Total output</span>
-      <strong>{formatNumber(session.total_kg, 2)}kg</strong>
-    </article>
-    <article>
-      <span>Bags</span>
-      <strong>{formatNumber(session.total_bags, 2)}</strong>
-    </article>
-    <article>
-      <span>Unit pack</span>
-      <strong>{formatNumber(session.product_unit_size_kg, 2)}kg</strong>
-    </article>
-  </section>
-
-  <section class="detail-grid">
-    <article class="detail-card">
-      <span>Mix source</span>
-      <strong>{session.mix_name}</strong>
-      <p>Saved against {session.product_unit_of_measure} units.</p>
-    </article>
-    <article class="detail-card">
-      <span>Composition</span>
-      <strong>{formatNumber(blendTotal, 2)}%</strong>
-      <p>{session.lines.length} raw material{session.lines.length === 1 ? '' : 's'} in the blend.</p>
-    </article>
-    {#if showGeneratedStamp}
-      <article class="detail-card">
-        <span>Generated</span>
-        <strong>{formatTimestamp(issuedAt)}</strong>
-        <p>Prepared for print or PDF export.</p>
-      </article>
-    {/if}
+  <section class="meta-grid" aria-label="Print summary">
+    <div><span>Total kg</span><strong>{formatNumber(session.total_kg, 2)}</strong><small>Scaled batch size</small></div>
+    <div><span>Total bags</span><strong>{formatNumber(session.total_bags, 2)}</strong><small>{session.product_unit_of_measure}</small></div>
+    <div><span>Prepared by</span><strong>{session.prepared_by_name}</strong><small>{formatDate(session.mix_date)}</small></div>
+    <div><span>Client</span><strong>{session.client_name}</strong></div>
+    <div><span>Product</span><strong>{session.product_name}</strong></div>
+    <div><span>Mix source</span><strong>{session.mix_name}</strong></div>
+    <div><span>Unit size</span><strong>{formatNumber(session.product_unit_size_kg, 2)}kg</strong></div>
+    <div><span>Batch size</span><strong>{formatNumber(session.batch_size_kg, 2)}kg</strong></div>
   </section>
 
   {#if session.notes}
-    <section class="callout notes">
+    <section class="inline-note">
       <span>Notes</span>
       <p>{session.notes}</p>
     </section>
   {/if}
 
   {#if session.warnings.length}
-    <section class="callout warning">
+    <section class="inline-note warning">
       <span>Warnings</span>
-      <ul>
-        {#each session.warnings as warning}
-          <li>{warning}</li>
-        {/each}
-      </ul>
+      <p>{session.warnings.join(' | ')}</p>
     </section>
   {/if}
 
   <section class="composition-card">
     <div class="section-heading">
       <div>
-        <span>Required Raw Materials</span>
-        <h2>Blend composition</h2>
+        <span>Raw Material</span>
       </div>
-      <p>{session.product_unit_of_measure} · {formatNumber(session.product_unit_size_kg, 2)}kg per unit</p>
+      <p>Required kg</p>
     </div>
 
     <table>
       <thead>
         <tr>
           <th>Raw material</th>
-          <th>Mix %</th>
           <th>Required kg</th>
-          <th>Unit</th>
         </tr>
       </thead>
       <tbody>
@@ -148,9 +103,7 @@
             <td>
               <strong>{line.raw_material_name}</strong>
             </td>
-            <td>{formatNumber(line.mix_percentage, 2)}%</td>
             <td>{formatNumber(line.required_kg, 2)}kg</td>
-            <td>{line.unit}</td>
           </tr>
         {/each}
       </tbody>
@@ -162,232 +115,204 @@
   :global(:root) {
     --print-page-width: 210mm;
     --print-page-height: 297mm;
-    --print-page-padding-x: 14mm;
-    --print-page-padding-y: 15mm;
+    --print-page-padding-x: 8mm;
+    --print-page-padding-y: 14mm;
   }
 
   h1,
   h2,
-  p,
-  ul {
+  p {
     margin: 0;
   }
 
   .print-document {
     display: grid;
-    gap: 1.4rem;
+    gap: 0.6rem;
     width: min(100%, var(--print-page-width));
-    min-height: var(--print-page-height);
+    height: var(--print-page-height);
     margin: 0 auto;
     padding: var(--print-page-padding-y) var(--print-page-padding-x);
-    border: 1px solid #dbe4de;
-    border-radius: 0.8rem;
-    background:
-      radial-gradient(circle at top right, rgba(21, 128, 61, 0.08), transparent 22rem),
-      linear-gradient(180deg, #fff 0%, #fbfcfb 100%);
-    color: #21312a;
-    box-shadow:
-      0 28px 48px rgba(21, 33, 26, 0.08),
-      0 0 0 1px rgba(219, 228, 222, 0.55);
+    border: 1px solid #000;
+    background: #fff;
+    color: #000;
+    box-shadow: none;
+    overflow: hidden;
+    box-sizing: border-box;
   }
 
-  .hero {
+  .document-header {
     display: grid;
-    grid-template-columns: minmax(0, 1fr) 17rem;
-    gap: 1.25rem;
+    grid-template-columns: auto 1fr auto;
     align-items: start;
-    padding-bottom: 1.3rem;
-    border-bottom: 1px solid color-mix(in srgb, var(--line) 88%, #dce7df);
+    gap: 0.75rem;
+    padding-bottom: 0.75rem;
+    border-bottom: 1px solid #000;
   }
 
-  .hero-kicker {
-    display: inline-flex;
-    align-items: center;
-    gap: 0.65rem;
-    margin-bottom: 0.75rem;
-    color: #62736b;
-    font-size: 0.76rem;
-    font-weight: 700;
-    letter-spacing: 0.12em;
-    text-transform: uppercase;
+  .brand-mark {
+    width: 32mm;
+    height: auto;
+    object-fit: contain;
+    filter: grayscale(1) contrast(1.2);
   }
 
-  .hero-kicker strong {
-    padding: 0.36rem 0.55rem;
-    border: 1px solid #d5dfd9;
-    border-radius: 999px;
-    color: #214233;
-    font-size: 0.68rem;
-    letter-spacing: 0.08em;
-  }
-
-  .hero h1 {
-    max-width: 11ch;
-    font-size: clamp(2rem, 4vw, 3.3rem);
-    line-height: 0.96;
-    letter-spacing: -0.05em;
-  }
-
-  .hero-copy p,
-  .section-heading p,
-  .detail-card p {
-    color: #6b7a73;
-  }
-
-  .hero-copy p {
-    margin-top: 0.7rem;
-    font-size: 1rem;
-  }
-
-  .hero-side,
-  .summary-band,
-  .detail-grid {
-    display: grid;
-    gap: 0.8rem;
-  }
-
-  .hero-side div,
-  .summary-band article,
-  .detail-card {
-    display: grid;
-    gap: 0.25rem;
-  }
-
-  .hero-side span,
-  .summary-band span,
-  .detail-card span,
-  .callout span,
+  .eyebrow,
+  .meta-grid span,
+  .inline-note span,
+  .section-heading span,
   th,
-  .section-heading span {
-    color: #6b7a73;
-    font-size: 0.72rem;
+  .session-block span {
+    color: #000;
+    font-size: 0.6rem;
     font-weight: 700;
-    letter-spacing: 0.12em;
+    letter-spacing: 0.09em;
     text-transform: uppercase;
   }
 
-  .hero-side strong,
-  .detail-card strong {
-    font-size: 1rem;
+  .title-block {
+    min-width: 0;
   }
 
-  .summary-band {
-    grid-template-columns: repeat(4, minmax(0, 1fr));
+  .title-block h1 {
+    font-size: 1.2rem;
+    line-height: 1.05;
+    letter-spacing: -0.03em;
   }
 
-  .summary-band article {
-    min-height: 6.2rem;
-    padding: 1rem 1.05rem;
-    border: 1px solid #dfe7e2;
-    border-radius: 1.2rem;
-    background: rgba(255, 255, 255, 0.92);
+  .subtitle {
+    margin-top: 0.12rem;
+    color: #000;
+    font-size: 0.72rem;
   }
 
-  .summary-band strong {
-    margin-top: auto;
-    font-size: clamp(1.4rem, 2.4vw, 2rem);
-    letter-spacing: -0.04em;
-  }
-
-  .detail-grid {
-    grid-template-columns: repeat(3, minmax(0, 1fr));
-  }
-
-  .detail-card {
-    min-height: 7rem;
-    padding: 1rem 1.05rem;
-    border-radius: 1.15rem;
-    background: #f6f9f7;
-  }
-
-  .callout {
+  .session-block {
     display: grid;
-    gap: 0.55rem;
-    padding: 1rem 1.1rem;
-    border-radius: 1.15rem;
-    break-inside: avoid;
+    justify-items: end;
+    gap: 0.18rem;
+    text-align: right;
   }
 
-  .callout.notes {
-    background: #f6f9f7;
-    border: 1px solid #dfe7e2;
+  .meta-grid {
+    display: grid;
+    grid-template-columns: repeat(4, minmax(0, 1fr));
+    gap: 0.38rem;
   }
 
-  .callout.warning {
-    background: #fff7ea;
-    border: 1px solid #f0cf97;
-    color: #82561b;
+  .meta-grid div {
+    display: grid;
+    gap: 0.08rem;
+    min-height: 2.1rem;
+    padding: 0.34rem 0.42rem;
+    border: 1px solid #000;
+    background: #fff;
   }
 
-  .callout ul {
-    padding-left: 1rem;
+  .meta-grid strong {
+    font-size: 0.84rem;
+    line-height: 1.1;
+  }
+
+  .meta-grid small {
+    font-size: 0.64rem;
+    line-height: 1.15;
+  }
+
+  .inline-note {
+    display: grid;
+    gap: 0.12rem;
+    padding: 0.35rem 0.42rem;
+    border: 1px solid #000;
+    background: #fff;
+  }
+
+  .inline-note p {
+    font-size: 0.68rem;
+    line-height: 1.25;
+    overflow: hidden;
+  }
+
+  .inline-note.warning {
+    border-color: #000;
+    background: #fff;
+    color: #000;
   }
 
   .composition-card {
     display: grid;
-    gap: 0.9rem;
-    break-inside: avoid;
+    gap: 0.35rem;
+    min-height: 0;
   }
 
   .section-heading {
     display: flex;
-    align-items: end;
     justify-content: space-between;
-    gap: 1rem;
+    align-items: end;
+    gap: 0.5rem;
   }
 
   .section-heading h2 {
-    margin-top: 0.32rem;
-    font-size: 1.5rem;
-    letter-spacing: -0.04em;
+    margin-top: 0.05rem;
+    font-size: 0.95rem;
+    line-height: 1.05;
+  }
+
+  .section-heading p {
+    color: #000;
+    font-size: 0.66rem;
+    white-space: nowrap;
   }
 
   table {
     width: 100%;
     border-collapse: collapse;
-    background: rgba(255, 255, 255, 0.8);
-    border: 1px solid #dfe7e2;
-    border-radius: 1.2rem;
-    overflow: hidden;
+    table-layout: fixed;
+    border: 1px solid #000;
+    background: #fff;
   }
 
   th,
   td {
-    padding: 0.95rem 1rem;
+    padding: 0.28rem 0.42rem;
     text-align: left;
-    border-bottom: 1px solid #e6ede9;
+    border-bottom: 1px solid #000;
+    line-height: 1.15;
   }
 
-  thead {
-    display: table-header-group;
+  th:last-child,
+  td:last-child {
+    width: 32mm;
   }
 
-  tr,
-  td,
   th {
-    break-inside: avoid;
+    background: #fff;
+    font-size: 0.6rem;
+  }
+
+  td {
+    font-size: 0.7rem;
+    vertical-align: top;
+  }
+
+  td strong {
+    font-size: 0.72rem;
+    font-weight: 700;
+    color: #000;
   }
 
   tbody tr:last-child td {
     border-bottom: none;
   }
 
-  td strong {
-    font-size: 0.98rem;
-    font-weight: 700;
-    color: #203128;
+  tr,
+  td,
+  th,
+  section {
+    break-inside: avoid;
   }
 
   @media (max-width: 900px) {
-    .hero,
-    .summary-band,
-    .detail-grid {
-      grid-template-columns: 1fr;
-    }
-
-    .section-heading {
-      flex-direction: column;
-      align-items: start;
+    .meta-grid {
+      grid-template-columns: repeat(2, minmax(0, 1fr));
     }
   }
 
@@ -395,7 +320,7 @@
     :global(html),
     :global(body) {
       width: var(--print-page-width);
-      min-height: var(--print-page-height);
+      height: var(--print-page-height);
       margin: 0;
       background: #fff;
       print-color-adjust: exact;
@@ -404,28 +329,13 @@
 
     .print-document {
       width: var(--print-page-width);
-      min-height: var(--print-page-height);
+      height: var(--print-page-height);
       margin: 0;
       padding: var(--print-page-padding-y) var(--print-page-padding-x);
       border: none;
-      border-radius: 0;
-      background: #fff;
-      color: #1e2622;
       box-shadow: none;
     }
 
-    .summary-band article,
-    .detail-card,
-    table,
-    .callout {
-      border-color: #d5ddd8;
-      background: #fff;
-    }
-
-    .callout.warning {
-      background: #fff8ef;
-    }
-
     @page {
       size: A4 portrait;
       margin: 0;

frontend/src/lib/components/MixCalculatorPrintSheet.svelte

@@ -9,6 +9,13 @@
     `MixCalculator_${session.client_name}_${session.product_name}_${session.mix_date}_${session.session_number}`.replace(/[^\w.-]+/g, '_')
   );
 
+  async function openPdf() {
+    const blob = await api.mixCalculatorSessionPdf(session.id);
+    const url = URL.createObjectURL(blob);
+    window.open(url, '_blank', 'noopener,noreferrer');
+    setTimeout(() => URL.revokeObjectURL(url), 60_000);
+  }
+
   async function downloadPdf() {
     const blob = await api.mixCalculatorSessionPdf(session.id);
     const url = URL.createObjectURL(blob);
@@ -29,8 +36,8 @@
 <section class="print-page">
   <div class="print-toolbar">
     <a class="secondary-button" href={`/mix-calculator/${session.id}`}>Back to session</a>
+    <button class="primary-button" type="button" onclick={openPdf}>Open Styled PDF</button>
     <button class="secondary-button" type="button" onclick={downloadPdf}>Download PDF</button>
-    <button class="primary-button" type="button" onclick={() => window.print()}>Print / Save PDF</button>
   </div>
 
   <MixCalculatorPrintDocument session={session} generatedAt={new Date().toISOString()} />

frontend/src/lib/components/mix-calculator/MixCalculatorEditor.svelte

@@ -1,5 +1,4 @@
 <script lang="ts">
-  import { goto } from '$app/navigation';
   import { api } from '$lib/api';
   import MixCalculatorPrintDocument from '$lib/components/MixCalculatorPrintDocument.svelte';
   import { featureFlags } from '$lib/features';
@@ -11,7 +10,6 @@
     MixCalculatorPreview,
     MixCalculatorSession
   } from '$lib/types';
-  import MixCalculatorPreviewModal from './MixCalculatorPreviewModal.svelte';
   import MixCalculatorResultsPanel from './MixCalculatorResultsPanel.svelte';
 
   let { options, initialSession = null }: { options: MixCalculatorOptions; initialSession?: MixCalculatorSession | null } = $props();
@@ -56,11 +54,8 @@
   let formError = $state('');
   let formHint = $state('Select a mix date and prepared by name, then choose a client to unlock products.');
   let previewLoading = $state(false);
-  let saveLoading = $state(false);
-  let previewModalOpen = $state(false);
 
   const canEdit = $derived(hasModuleAccess($clientSession, 'mix_calculator', 'edit'));
-  const isExistingSession = $derived(initialSession !== null);
   const availableClients = $derived(
     Array.from(new Set([...(options.clients ?? []), ...(initialSession ? [initialSession.client_name] : [])]))
   );
@@ -198,20 +193,21 @@
     formHint = `Ready to calculate ${selectedProduct?.product_name ?? 'the selected product'}.`;
   });
 
-  function printPreview() {
-    if (typeof window !== 'undefined') {
-      window.print();
-    }
-  }
-
-  async function downloadSessionPdf(sessionId: number) {
+  async function downloadPdf() {
     const tid = toast.loading('Generating PDF…');
     try {
-      const blob = await api.mixCalculatorSessionPdf(sessionId);
+      const payload = buildPayload();
+      if (!payload) {
+        toast.dismiss(tid);
+        toast.error(formError || 'Complete the mix details first.');
+        return;
+      }
+
+      const blob = await api.previewMixCalculatorPdf(payload);
       const url = URL.createObjectURL(blob);
       const anchor = document.createElement('a');
       anchor.href = url;
-      anchor.download = `mix_calculator_${sessionId}.pdf`;
+      anchor.download = `mix_calculator_${payload.client_name}_${payload.mix_date}.pdf`.replace(/[^\w.-]+/g, '_');
       document.body.appendChild(anchor);
       anchor.click();
       anchor.remove();
@@ -223,43 +219,27 @@
     }
   }
 
-  function openPreviewModal() {
-    if (!preview) {
-      return;
-    }
-
-    previewModalOpen = true;
-  }
-
-  function closePreviewModal() {
-    previewModalOpen = false;
-  }
-
-  async function saveSession(mode: 'update' | 'create', destination: 'detail' | 'print' = 'detail') {
+  async function openPdf() {
+    const tid = toast.loading('Opening styled PDF…');
+    try {
       const payload = buildPayload();
       if (!payload) {
+        toast.dismiss(tid);
+        toast.error(formError || 'Complete the mix details first.');
         return;
       }
 
-    saveLoading = true;
-    const tid = toast.loading(mode === 'update' ? 'Saving session…' : 'Creating session…');
-    try {
-      const saved =
-        mode === 'update' && initialSession
-          ? await api.updateMixCalculatorSession(initialSession.id, payload)
-          : await api.createMixCalculatorSession(payload);
-
+      const blob = await api.previewMixCalculatorPdf(payload);
+      const url = URL.createObjectURL(blob);
+      window.open(url, '_blank', 'noopener,noreferrer');
+      setTimeout(() => URL.revokeObjectURL(url), 60_000);
       toast.dismiss(tid);
-      toast.success(mode === 'update' ? 'Session saved' : 'Session created');
-      const target = destination === 'print' ? `/mix-calculator/${saved.id}/print` : `/mix-calculator/${saved.id}`;
-      await goto(target);
     } catch (error) {
       toast.dismiss(tid);
-      toast.error(error instanceof Error ? error.message : 'Unable to save the mix calculator session.');
-      formError = error instanceof Error ? error.message : 'Unable to save the mix calculator session.';
-      saveLoading = false;
+      toast.error(error instanceof Error ? error.message : 'Unable to open the styled PDF.');
     }
   }
+
 </script>
 
 {#if !canEdit && !initialSession}
@@ -278,8 +258,9 @@
         <a class="secondary-button" href="/mix-calculator">Session history</a>
       {/if}
       {#if initialSession}
-        <a class="secondary-button" href={`/mix-calculator/${initialSession.id}/print`}>Printable view</a>
-        <button class="secondary-button" type="button" onclick={() => downloadSessionPdf(initialSession.id)}>Download PDF</button>
+        <a class="secondary-button" href={`/mix-calculator/${initialSession.id}/print`}>Open PDF page</a>
+        <button class="primary-button" type="button" onclick={openPdf}>Open PDF in new tab</button>
+        <button class="secondary-button" type="button" onclick={downloadPdf}>Download PDF</button>
       {/if}
     </section>
   {/if}
@@ -364,38 +345,12 @@
 
       {#if canEdit}
         <div class="action-row">
-          <button class="primary-button" disabled={previewLoading || saveLoading} type="button" onclick={calculatePreview}>
+          <button class="primary-button" disabled={previewLoading} type="button" onclick={calculatePreview}>
             <span class="button-icon" style="--button-icon-url: url('/icons/calculator.svg');" aria-hidden="true"></span>
             <span>{previewLoading ? 'Calculating...' : 'Calculate mix'}</span>
           </button>
 
-          {#if featureFlags.mixCalculatorSessionSave}
-            <button class="secondary-button" disabled={saveLoading || previewLoading} type="button" onclick={() => saveSession(isExistingSession ? 'update' : 'create')}>
-              {saveLoading ? 'Saving...' : isExistingSession ? 'Save changes' : 'Save session'}
-            </button>
-
-            <button class="secondary-button" disabled={saveLoading || previewLoading} type="button" onclick={() => saveSession(isExistingSession ? 'update' : 'create', 'print')}>
-              <span class="button-icon" style="--button-icon-url: url('/icons/print.svg');" aria-hidden="true"></span>
-              <span>{saveLoading ? 'Saving...' : 'Save & print'}</span>
-            </button>
-
-            {#if initialSession}
-              <button class="secondary-button" disabled={saveLoading || previewLoading} type="button" onclick={() => saveSession('create')}>
-                Save as new
-              </button>
-            {/if}
-          {:else}
-            <button class="secondary-button" disabled={previewLoading || saveLoading || !preview} type="button" onclick={openPreviewModal}>
-              <span>Preview</span>
-            </button>
-
-            <button class="secondary-button" disabled={previewLoading || saveLoading || !preview} type="button" onclick={printPreview}>
-              <span class="button-icon" style="--button-icon-url: url('/icons/print.svg');" aria-hidden="true"></span>
-              <span>Print</span>
-            </button>
-          {/if}
-
-          <button class="secondary-button" disabled={previewLoading || saveLoading} type="button" onclick={clearForm}>
+          <button class="danger-button" disabled={previewLoading} type="button" onclick={clearForm}>
             <span class="button-icon" style="--button-icon-url: url('/icons/trash.svg');" aria-hidden="true"></span>
             <span>Clear</span>
           </button>
@@ -406,20 +361,12 @@
     <MixCalculatorResultsPanel
       preview={preview}
       sessionNumber={initialSession?.session_number ?? null}
+      onOpenPdf={preview ? openPdf : null}
+      onDownloadPdf={preview ? downloadPdf : null}
     />
   </section>
 
   {#if preview}
-    {#if previewModalOpen}
-      <MixCalculatorPreviewModal
-        preview={preview}
-        sessionId={initialSession?.id ?? null}
-        onClose={closePreviewModal}
-        onPrint={printPreview}
-        onDownloadPdf={downloadSessionPdf}
-      />
-    {/if}
-
     <section class="print-only" aria-hidden="true">
       <MixCalculatorPrintDocument session={preview} />
     </section>
@@ -474,7 +421,7 @@
   .form-card,
   .locked-card {
     border: 1px solid var(--line);
-    border-radius: 1.3rem;
+    border-radius: 0.8rem;
     background: var(--panel);
     box-shadow: var(--shadow);
   }
@@ -511,7 +458,7 @@
     gap: 0.14rem;
     padding: 0.72rem 0.82rem;
     border: 1px solid var(--line);
-    border-radius: 0.92rem;
+    border-radius: 0.65rem;
     background: var(--panel-soft);
   }
 
@@ -548,9 +495,20 @@
     width: 100%;
     padding: 0.78rem 0.82rem;
     border: 1px solid var(--line-strong);
-    border-radius: 0.88rem;
+    border-radius: 0.6rem;
     background: #fff;
     color: var(--text);
+    transition:
+      border-color 160ms ease,
+      box-shadow 160ms ease;
+  }
+
+  input:focus-visible,
+  select:focus-visible,
+  textarea:focus-visible {
+    outline: none;
+    border-color: var(--color-brand);
+    box-shadow: 0 0 0 3px color-mix(in srgb, var(--color-brand) 18%, transparent);
   }
 
   textarea {
@@ -562,14 +520,14 @@
     gap: 0.2rem;
     margin-top: 1rem;
     padding: 0.92rem;
-    border-radius: 1rem;
+    border-radius: 0.65rem;
     background: var(--panel-soft);
   }
 
   .message {
     margin-bottom: 0.85rem;
     padding: 0.75rem 0.85rem;
-    border-radius: 0.88rem;
+    border-radius: 0.6rem;
     font-size: 0.9rem;
   }
 
@@ -589,21 +547,20 @@
   }
 
   .primary-button,
-  .secondary-button {
+  .secondary-button,
+  .danger-button {
     display: inline-flex;
     align-items: center;
     justify-content: center;
     gap: 0.5rem;
     padding: 0.78rem 0.96rem;
-    border-radius: 0.9rem;
+    border-radius: 0.6rem;
     border: 1px solid var(--line-strong);
     font-weight: 600;
     cursor: pointer;
     transition:
-      transform 140ms ease,
-      box-shadow 140ms ease,
-      background-color 140ms ease,
-      border-color 140ms ease;
+      background-color 160ms ease,
+      border-color 160ms ease;
   }
 
   .primary-button {
@@ -617,20 +574,35 @@
     color: #304038;
   }
 
-  .primary-button:hover:not(:disabled),
-  .secondary-button:hover:not(:disabled) {
-    transform: translateY(-1px);
+  .danger-button {
+    background: #c63d32;
+    color: #fff;
+    border-color: #c63d32;
   }
 
   .primary-button:hover:not(:disabled) {
-    box-shadow: none;
-    filter: brightness(1.04);
+    background: #126a33;
+  }
+
+  .primary-button:active:not(:disabled) {
+    background: #0f5a2b;
   }
 
   .secondary-button:hover:not(:disabled) {
-    border-color: #9fb0a6;
-    background: #f6faf7;
-    box-shadow: none;
+    border-color: var(--color-text-muted);
+    background: var(--color-bg-app);
+  }
+
+  .danger-button:hover:not(:disabled) {
+    background: #b2352b;
+    border-color: #b2352b;
+  }
+
+  .primary-button:focus-visible,
+  .secondary-button:focus-visible,
+  .danger-button:focus-visible {
+    outline: 3px solid color-mix(in srgb, var(--color-brand) 45%, transparent);
+    outline-offset: 2px;
   }
 
   .button-icon {

frontend/src/lib/components/mix-calculator/MixCalculatorPreviewModal.svelte

@@ -6,14 +6,14 @@
     preview,
     sessionId = null,
     onClose,
-    onPrint,
+    onOpenPdf,
     onDownloadPdf
   }: {
     preview: MixCalculatorPreview | MixCalculatorSession;
     sessionId?: number | null;
     onClose: () => void;
-    onPrint: () => void;
-    onDownloadPdf: (sessionId: number) => void;
+    onOpenPdf: () => void;
+    onDownloadPdf: () => void;
   } = $props();
 </script>
 
@@ -22,7 +22,7 @@
     class="preview-modal"
     role="dialog"
     aria-modal="true"
-    aria-label="Print preview"
+    aria-label="Styled PDF preview"
     tabindex="-1"
     onclick={(event) => event.stopPropagation()}
     onkeydown={(event) => {
@@ -33,16 +33,16 @@
   >
     <div class="preview-modal-toolbar">
       <div>
-        <p class="preview-modal-kicker">Print Preview</p>
+        <p class="preview-modal-kicker">Styled PDF Preview</p>
         <h3>{preview.product_name}</h3>
       </div>
       <div class="preview-modal-actions">
         <button class="secondary-button" type="button" onclick={onClose}>Close</button>
+        <button class="primary-button" type="button" onclick={onOpenPdf}>Open PDF in new tab</button>
         {#if sessionId}
-          <a class="secondary-button" href={`/mix-calculator/${sessionId}/print`}>Open page</a>
-          <button class="secondary-button" type="button" onclick={() => onDownloadPdf(sessionId)}>Download PDF</button>
+          <a class="secondary-button" href={`/mix-calculator/${sessionId}/print`}>Open PDF page</a>
         {/if}
-        <button class="primary-button" type="button" onclick={onPrint}>Print / Save PDF</button>
+        <button class="secondary-button" type="button" onclick={onDownloadPdf}>Download PDF</button>
       </div>
     </div>
 
@@ -77,10 +77,9 @@
     width: min(1180px, 100%);
     max-height: calc(100vh - 2rem);
     padding: 1rem;
-    border: 1px solid rgba(255, 255, 255, 0.32);
-    border-radius: 1.6rem;
-    background:
-      linear-gradient(180deg, rgba(248, 250, 248, 0.96), rgba(240, 246, 242, 0.96));
+    border: 1px solid var(--color-border);
+    border-radius: 0.9rem;
+    background: var(--color-bg-surface);
   }
 
   .preview-modal-toolbar {
@@ -116,9 +115,9 @@
     display: grid;
     place-items: start center;
     padding: 1.1rem;
-    border-radius: 1.35rem;
-    background:
-      linear-gradient(135deg, #dfe8e2 0%, #eef3ef 45%, #d7e2db 100%);
+    border: 1px solid var(--color-border);
+    border-radius: 0.8rem;
+    background: var(--color-bg-app);
   }
 
   .preview-sheet-scroll {
@@ -135,10 +134,13 @@
     justify-content: center;
     gap: 0.5rem;
     padding: 0.78rem 0.96rem;
-    border-radius: 0.9rem;
+    border-radius: 0.6rem;
     border: 1px solid var(--line-strong);
     font-weight: 600;
     cursor: pointer;
+    transition:
+      background-color 160ms ease,
+      border-color 160ms ease;
   }
 
   .primary-button {
@@ -152,6 +154,25 @@
     color: #304038;
   }
 
+  .primary-button:hover {
+    background: #126a33;
+  }
+
+  .primary-button:active {
+    background: #0f5a2b;
+  }
+
+  .secondary-button:hover {
+    border-color: var(--color-text-muted);
+    background: var(--color-bg-app);
+  }
+
+  .primary-button:focus-visible,
+  .secondary-button:focus-visible {
+    outline: 3px solid color-mix(in srgb, var(--color-brand) 45%, transparent);
+    outline-offset: 2px;
+  }
+
   @media (max-width: 720px) {
     .preview-modal-toolbar {
       flex-direction: column;

frontend/src/lib/components/mix-calculator/MixCalculatorResultsPanel.svelte

@@ -1,12 +1,17 @@
 <script lang="ts">
+  import { Download, Printer } from 'lucide-svelte';
   import type { MixCalculatorPreview, MixCalculatorSession } from '$lib/types';
 
   let {
     preview,
-    sessionNumber = null
+    sessionNumber = null,
+    onOpenPdf = null,
+    onDownloadPdf = null
   }: {
     preview: MixCalculatorPreview | MixCalculatorSession | null;
     sessionNumber?: string | null;
+    onOpenPdf?: (() => void) | null;
+    onDownloadPdf?: (() => void) | null;
   } = $props();
 
   function formatDate(value: string) {
@@ -89,9 +94,7 @@
         <thead>
           <tr>
             <th>Raw material</th>
-            <th>Mix %</th>
             <th>Required kg</th>
-            <th>Unit</th>
           </tr>
         </thead>
         <tbody>
@@ -100,14 +103,23 @@
               <td data-label="Raw material">
                 <strong>{line.raw_material_name}</strong>
               </td>
-              <td data-label="Mix %">{formatNumber(line.mix_percentage, 2)}%</td>
               <td data-label="Required kg">{formatNumber(line.required_kg, 2)}kg</td>
-              <td data-label="Unit">{line.unit}</td>
             </tr>
           {/each}
         </tbody>
       </table>
     </div>
+
+    <div class="output-actions">
+      <button class="primary-button" disabled={!onOpenPdf} type="button" onclick={() => onOpenPdf?.()}>
+        <Printer size={18} strokeWidth={1.9} aria-hidden="true" />
+        Print
+      </button>
+      <button class="secondary-button" disabled={!onDownloadPdf} type="button" onclick={() => onDownloadPdf?.()}>
+        <Download size={18} strokeWidth={1.9} aria-hidden="true" />
+        Download PDF
+      </button>
+    </div>
   {:else}
     <div class="empty-state">
       <div class="empty-shimmer-metrics">
@@ -127,8 +139,6 @@
           <div class="shimmer-row">
             <div class="shimmer-line wide"></div>
             <div class="shimmer-line medium"></div>
-            <div class="shimmer-line medium"></div>
-            <div class="shimmer-line short"></div>
           </div>
         {/each}
       </div>
@@ -152,7 +162,7 @@
   .result-card,
   .metric-card {
     border: 1px solid var(--line);
-    border-radius: 1.3rem;
+    border-radius: 0.8rem;
     background: var(--panel);
     box-shadow: var(--shadow);
   }
@@ -179,7 +189,7 @@
     gap: 0.14rem;
     padding: 0.72rem 0.82rem;
     border: 1px solid var(--line);
-    border-radius: 0.92rem;
+    border-radius: 0.65rem;
     background: var(--panel-soft);
   }
 
@@ -222,9 +232,9 @@
     gap: 0.45rem;
     margin-top: 1rem;
     padding: 0.92rem;
-    border-radius: 1rem;
-    background: #fff6e6;
-    color: #8b5b1e;
+    border-radius: 0.65rem;
+    background: #fdf6e9;
+    color: #8a5a00;
   }
 
   .summary-grid {
@@ -235,7 +245,7 @@
   .summary-grid div {
     padding: 0.88rem 0.92rem;
     border: 1px solid var(--line);
-    border-radius: 1rem;
+    border-radius: 0.65rem;
     background: var(--panel-soft);
   }
 
@@ -251,6 +261,14 @@
     overflow-x: auto;
   }
 
+  .output-actions {
+    display: flex;
+    justify-content: flex-start;
+    gap: 0.75rem;
+    flex-wrap: wrap;
+    margin-top: 1rem;
+  }
+
   table {
     width: 100%;
     min-width: 30rem;
@@ -272,6 +290,57 @@
     text-transform: uppercase;
   }
 
+  .primary-button,
+  .secondary-button {
+    display: inline-flex;
+    align-items: center;
+    justify-content: center;
+    gap: 0.5rem;
+    padding: 0.78rem 0.96rem;
+    border-radius: 0.6rem;
+    border: 1px solid var(--line-strong);
+    font-weight: 600;
+    cursor: pointer;
+    transition:
+      background-color 160ms ease,
+      border-color 160ms ease;
+  }
+
+  .primary-button {
+    border: none;
+    background: var(--color-brand);
+    color: #fff;
+  }
+
+  .secondary-button {
+    background: #fff;
+    color: #304038;
+  }
+
+  .primary-button:hover:not(:disabled) {
+    background: #126a33;
+  }
+
+  .primary-button:active:not(:disabled) {
+    background: #0f5a2b;
+  }
+
+  .secondary-button:hover:not(:disabled) {
+    border-color: var(--color-text-muted);
+    background: var(--color-bg-app);
+  }
+
+  .primary-button:focus-visible,
+  .secondary-button:focus-visible {
+    outline: 3px solid color-mix(in srgb, var(--color-brand) 45%, transparent);
+    outline-offset: 2px;
+  }
+
+  button:disabled {
+    cursor: not-allowed;
+    opacity: 0.65;
+  }
+
   .empty-state {
     display: flex;
     flex-direction: column;
@@ -355,7 +424,7 @@
 
   .shimmer-row {
     display: grid;
-    grid-template-columns: 2fr 1fr 1fr 0.75fr;
+    grid-template-columns: 2fr 1fr;
     gap: 1rem;
     align-items: center;
     padding: 0.78rem 1rem;

frontend/src/lib/components/navigation/AppNavSection.svelte

@@ -8,6 +8,7 @@
     active?: boolean;
     onSelect?: () => void;
     type?: 'button' | 'link';
+    badge?: string;
   };
 
   let {
@@ -33,14 +34,14 @@
         {#if Icon}
           <span class="nav-icon"><Icon size={18} strokeWidth={1.75} /></span>
         {/if}
-        <span>{item.label}</span>
+        <span>{item.label}</span>{#if item.badge}<span class="nav-badge">{item.badge}</span>{/if}
       </a>
     {:else}
       <button type="button" class="nav-button" class:active={item.active} onclick={item.onSelect}>
         {#if Icon}
           <span class="nav-icon"><Icon size={18} strokeWidth={1.75} /></span>
         {/if}
-        <span>{item.label}</span>
+        <span>{item.label}</span>{#if item.badge}<span class="nav-badge">{item.badge}</span>{/if}
       </button>
     {/if}
   {/each}
@@ -105,6 +106,26 @@
     background: var(--nav-item-active-marker, var(--color-brand));
   }
 
+  .nav-badge {
+    margin-left: auto;
+    flex-shrink: 0;
+    padding: 0.08rem 0.4rem;
+    border-radius: 999px;
+    background: #fdf0d2;
+    color: #8a5a00;
+    font-size: 0.62rem;
+    font-weight: 700;
+    letter-spacing: 0.06em;
+    text-transform: uppercase;
+    line-height: 1.5;
+  }
+
+  .nav-list a.active .nav-badge,
+  .nav-button.active .nav-badge {
+    background: rgba(255, 255, 255, 0.92);
+    color: #8a5a00;
+  }
+
   .nav-icon {
     display: inline-flex;
     align-items: center;

frontend/src/lib/components/navigation/ClientPrimaryRail.svelte

@@ -11,7 +11,6 @@
     workingDocumentItems,
     footerItems,
     appVersion,
-    releaseStage,
     currentYear,
     canOpenSettings,
     onOpenSettings,
@@ -23,7 +22,6 @@
     workingDocumentItems: NavItem[];
     footerItems: FooterLink[];
     appVersion: string;
-    releaseStage: string;
     currentYear: number;
     canOpenSettings: boolean;
     onOpenSettings: () => void;
@@ -46,6 +44,7 @@
         label: item.label,
         href: item.href,
         icon: item.icon,
+        badge: item.badge,
         active: matchesRoute(item.href, currentPath)
       }))}
     />
@@ -105,7 +104,6 @@
             <span class="meta-label">Build</span>
             <span>{appVersion}</span>
           </span>
-          <span class="release-pill">{releaseStage}</span>
         </div>
         <div class="sidebar-meta-bottom">
           <small>&copy; {currentYear} Hunter Premium Produce</small>
@@ -242,18 +240,4 @@
     text-transform: uppercase;
   }
 
-  .release-pill {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    padding: 0.2rem 0.52rem;
-    border: 1px solid color-mix(in srgb, var(--color-brand) 14%, transparent);
-    border-radius: 999px;
-    background: color-mix(in srgb, var(--color-brand) 8%, white);
-    color: var(--color-brand);
-    font-size: 0.64rem;
-    font-weight: 700;
-    letter-spacing: 0.07em;
-    text-transform: uppercase;
-  }
 </style>

frontend/src/lib/navigation/client-navigation.ts

@@ -4,6 +4,7 @@ import {
   ClipboardList,
   DollarSign,
   FlaskConical,
+  Gauge,
   LayoutDashboard,
   ShieldCheck,
   TrendingUp,
@@ -13,6 +14,10 @@ import {
 import type { ComponentType } from 'svelte';
 
 import { featureFlags } from '$lib/features';
+import {
+  canOpenDashboard
+} from '$lib/workspace-access';
+import type { AppSession } from '$lib/session';
 
 export type SearchItem = {
   href: string;
@@ -27,6 +32,7 @@ export type NavItem = {
   shortLabel: string;
   icon: ComponentType;
   moduleKey?: string;
+  badge?: string;
 };
 
 export type FooterLink = {
@@ -50,7 +56,7 @@ export const dashboardItem: NavItem = {
 };
 
 export const mixCalculatorItem: NavItem = {
-  href: featureFlags.mixCalculatorSessionHistory ? '/mix-calculator' : '/mix-calculator/new',
+  href: '/mix-calculator',
   label: 'Mix Calculator',
   shortLabel: 'MC',
   icon: Calculator,
@@ -65,6 +71,15 @@ export const reportingItem: NavItem = {
   moduleKey: 'products'
 };
 
+export const throughputItem: NavItem = {
+  href: '/throughput',
+  label: 'Throughput',
+  shortLabel: 'OT',
+  icon: Gauge,
+  moduleKey: 'operations_throughput',
+  badge: 'test'
+};
+
 export const workingDocumentItems: NavItem[] = [
   { href: '/raw-materials', label: 'Raw Materials', shortLabel: 'RM', icon: Wheat, moduleKey: 'raw_materials' },
   { href: '/mixes', label: 'Mix Master', shortLabel: 'MM', icon: FlaskConical, moduleKey: 'mix_master' },
@@ -83,6 +98,7 @@ export const accessControlItem: NavItem = {
 export const clientNavigationItems: NavItem[] = [
   dashboardItem,
   mixCalculatorItem,
+  throughputItem,
   ...workingDocumentItems,
   accessControlItem
 ];
@@ -128,8 +144,8 @@ export const baseSearchItems: SearchItem[] = [
       ]
     : []),
   {
-    href: '/mix-calculator/new',
-    label: 'Create Mix Calculation',
+    href: '/mix-calculator',
+    label: 'Open Mix Calculator',
     description: 'Run a new client-specific mix calculation session.',
     keywords: 'new mix calculator session client batch size product bags print'
   },
@@ -167,26 +183,30 @@ export function pageTitle(pathname: string) {
   return clientNavigationItems.find((item) => matchesRoute(item.href, pathname))?.label ?? 'Dashboard';
 }
 
-export function clientBreadcrumbs(pathname: string): Crumb[] {
-  const root: Crumb = { label: 'Workspace', href: '/' };
+export function clientBreadcrumbs(pathname: string, session?: AppSession | null): Crumb[] {
+  const crumbs: Crumb[] = [];
+
+  if (canOpenDashboard(session)) {
+    crumbs.push({ label: 'Workspace', href: '/' });
+  }
 
   if (pathname === '/') {
-    return [root, { label: 'Dashboard' }];
+    return crumbs.length ? [...crumbs, { label: 'Dashboard' }] : [{ label: 'Dashboard' }];
   }
 
   if (pathname.startsWith('/mix-calculator')) {
-    const trail: Crumb[] = [root, { label: 'Mix Calculator', href: '/mix-calculator' }];
-    if (pathname === '/mix-calculator/new') trail.push({ label: 'New Session' });
-    else if (pathname.endsWith('/print')) trail.push({ label: 'Print' });
-    else if (pathname !== '/mix-calculator') trail.push({ label: 'Session' });
-    return trail;
+    return [...crumbs, { label: 'Mix Calculator' }];
   }
 
   if (pathname.startsWith('/mixes')) {
-    const trail: Crumb[] = [root, { label: 'Mix Master', href: '/mixes' }];
-    if (pathname === '/mixes/new') trail.push({ label: 'New Mix' });
-    else if (pathname !== '/mixes') trail.push({ label: 'Detail' });
-    return trail;
+    return [...crumbs, { label: 'Mix Master' }];
+  }
+
+  if (pathname.startsWith('/throughput')) {
+    const base: Crumb[] = [...crumbs, { label: 'Throughput', href: '/throughput' }];
+    if (pathname === '/throughput/add') return [...base, { label: 'Add Entry' }];
+    if (pathname === '/throughput') return base.slice(0, -1).concat([{ label: 'Throughput' }]);
+    return base;
   }
 
   const sectionMap: Record<string, string> = {
@@ -195,10 +215,11 @@ export function clientBreadcrumbs(pathname: string): Crumb[] {
     '/scenarios': 'Scenarios',
     '/client-access': 'Client Access',
     '/reporting': 'Reporting',
-    '/settings': 'Settings'
+    '/settings': 'Settings',
+    '/throughput': 'Throughput'
   };
   const section = sectionMap[pathname];
-  if (section) return [root, { label: section }];
+  if (section) return [...crumbs, { label: section }];
 
-  return [root, { label: pageTitle(pathname) }];
+  return [...crumbs, { label: pageTitle(pathname) }];
 }

frontend/src/lib/types.ts

@@ -388,3 +388,89 @@ export type ClientUserUpdateInput = {
   status?: string;
   is_new_user?: boolean;
 };
+
+export type ThroughputProduct = {
+  id: number;
+  tenant_id: string;
+  item_id: string | null;
+  name: string;
+  default_bag_size: number | null;
+  is_bulka_default: boolean;
+  active: boolean;
+  is_stock_item: boolean;
+  notes: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export type ThroughputQuantityType = 'bags' | 'kg';
+
+export type ThroughputEntry = {
+  id: number;
+  tenant_id: string;
+  production_date: string;
+  product_id: number | null;
+  product_name_snapshot: string;
+  bag_size: number | null;
+  scales_checked: boolean;
+  label_correct: boolean;
+  bag_sealed: boolean;
+  pallet_good_condition: boolean;
+  sample_box_no: string | null;
+  test_weight_1: number | null;
+  test_weight_2: number | null;
+  test_weight_3: number | null;
+  test_weight_4: number | null;
+  test_weight_5: number | null;
+  quantity: number;
+  quantity_type: ThroughputQuantityType;
+  calculated_kg: number;
+  staff_name: string | null;
+  notes: string | null;
+  qa_passed: boolean;
+  created_by: string | null;
+  created_at: string;
+  updated_at: string;
+};
+
+export type ThroughputEntryCreateInput = {
+  production_date: string;
+  product_id?: number | null;
+  product_name_snapshot?: string;
+  bag_size?: number | null;
+  scales_checked?: boolean;
+  label_correct?: boolean;
+  bag_sealed?: boolean;
+  pallet_good_condition?: boolean;
+  sample_box_no?: string | null;
+  test_weight_1?: number | null;
+  test_weight_2?: number | null;
+  test_weight_3?: number | null;
+  test_weight_4?: number | null;
+  test_weight_5?: number | null;
+  quantity: number;
+  quantity_type: ThroughputQuantityType;
+  staff_name?: string | null;
+  notes?: string | null;
+};
+
+export type ThroughputEntryListParams = {
+  date_from?: string;
+  date_to?: string;
+  product_id?: number | null;
+  staff_name?: string;
+  quantity_type?: ThroughputQuantityType;
+  limit?: number;
+};
+
+export type ThroughputProductCreateInput = {
+  item_id?: string | null;
+  name: string;
+  default_bag_size?: number | null;
+  is_bulka_default?: boolean;
+  active?: boolean;
+  is_stock_item?: boolean;
+  notes?: string | null;
+};
+
+export type ThroughputProductUpdateInput = Partial<ThroughputProductCreateInput>;

frontend/src/lib/workspace-access.test.ts

@@ -23,7 +23,7 @@ describe('workspace access policy', () => {
 
   it('classifies operations users and sends them to mix calculator by default', () => {
     expect(getWorkspaceRole(operationsSession)).toBe('operations');
-    expect(getDefaultRouteForRole(operationsSession)).toBe('/mix-calculator/new');
+    expect(getDefaultRouteForRole(operationsSession)).toBe('/mix-calculator');
   });
 
   it('prevents operations users from opening the dashboard route', () => {

frontend/src/lib/workspace-access.ts

@@ -1,4 +1,3 @@
-import { featureFlags } from '$lib/features';
 import { hasModuleAccess, hasPermission, type AppSession } from '$lib/session';
 
 export type WorkspaceRole = 'admin' | 'operations' | 'full' | 'client' | 'unknown';
@@ -90,6 +89,14 @@ export function canOpenScenarios(session: AppSession | null | undefined) {
   return !!session && hasModuleAccess(session, 'scenarios');
 }
 
+export function canOpenThroughput(session: AppSession | null | undefined) {
+  return canAccessWorkspaceArea(session, 'operations_throughput', ['view_throughput', 'edit_throughput']);
+}
+
+export function canEditThroughput(session: AppSession | null | undefined) {
+  return canAccessWorkspaceArea(session, 'operations_throughput', ['edit_throughput'], 'edit');
+}
+
 export function canOpenReporting(session: AppSession | null | undefined) {
   return canOpenProducts(session);
 }
@@ -133,6 +140,11 @@ export const routeAccessRules: RouteAccessRule[] = [
     path: '/client-access',
     roles: ['admin', 'client'],
     matches: (pathname) => hasPathPrefix(pathname, '/client-access')
+  },
+  {
+    path: '/throughput',
+    roles: ['admin', 'operations', 'full', 'client'],
+    matches: (pathname) => hasPathPrefix(pathname, '/throughput')
   }
 ];
 
@@ -140,12 +152,12 @@ export function getDefaultRouteForRole(session: AppSession | null | undefined) {
   const role = getWorkspaceRole(session);
 
   if (role === 'operations') {
-    return featureFlags.mixCalculatorSessionHistory ? '/mix-calculator' : '/mix-calculator/new';
+    return '/mix-calculator';
   }
 
   if (role === 'admin' || role === 'full' || role === 'client') {
     if (canOpenDashboard(session)) return '/';
-    if (canOpenMixCalculator(session)) return featureFlags.mixCalculatorSessionHistory ? '/mix-calculator' : '/mix-calculator/new';
+    if (canOpenMixCalculator(session)) return '/mix-calculator';
     if (canOpenRawMaterials(session)) return '/raw-materials';
     if (canOpenMixMaster(session)) return '/mixes';
     if (canOpenProducts(session)) return '/products';
@@ -176,6 +188,7 @@ export function canAccessRoute(session: AppSession | null | undefined, pathname:
   if (pathname.startsWith('/reporting')) return canOpenReporting(session);
   if (pathname.startsWith('/settings')) return canOpenSettings(session);
   if (pathname.startsWith('/client-access')) return canOpenClientAccess(session);
+  if (pathname.startsWith('/throughput')) return canOpenThroughput(session);
   return true;
 }
 

frontend/src/routes/+error.svelte

@@ -42,30 +42,21 @@
 
     <div class="error-actions">
       <a class="primary-link" href="/">Return to Workspace</a>
-      <a class="secondary-link" href="/mix-calculator/new">Open Mix Calculator</a>
+      <a class="secondary-link" href="/mix-calculator">Open Mix Calculator</a>
     </div>
   </div>
 </section>
 
 <style>
-  :global(body) {
-    margin: 0;
-    min-height: 100vh;
-    background:
-      radial-gradient(circle at top left, rgba(214, 234, 221, 0.86), transparent 36%),
-      linear-gradient(180deg, #f4f7f2 0%, #eef4ee 100%);
-    color: #1d3528;
-    font-family:
-      "Segoe UI",
-      system-ui,
-      sans-serif;
-  }
-
   .error-stage {
     min-height: 100vh;
     display: grid;
     place-items: center;
     padding: 2rem;
+    background:
+      radial-gradient(circle at top left, rgba(214, 234, 221, 0.86), transparent 36%),
+      linear-gradient(180deg, #f4f7f2 0%, #eef4ee 100%);
+    color: #1d3528;
   }
 
   .error-card {

frontend/src/routes/+layout.svelte

@@ -1,4 +1,8 @@
 <script lang="ts">
+  import '@fontsource/inter/latin-400.css';
+  import '@fontsource/inter/latin-500.css';
+  import '@fontsource/inter/latin-600.css';
+  import '@fontsource/inter/latin-700.css';
   import { beforeNavigate, afterNavigate } from '$app/navigation';
   import { page } from '$app/state';
   import AdminShell from '$lib/components/AdminShell.svelte';
@@ -46,3 +50,20 @@
 {/if}
 
 <Toast />
+
+<style>
+  :global(html, body) {
+    font-family: "Inter", "Segoe UI", sans-serif;
+  }
+
+  :global(button),
+  :global(input),
+  :global(select),
+  :global(textarea) {
+    font: inherit;
+  }
+
+  :global(h1, h2, h3, h4, h5, h6) {
+    font-family: "Inter", "Segoe UI", sans-serif;
+  }
+</style>

frontend/src/routes/+page.svelte

@@ -42,7 +42,6 @@
   let loginFocusArmed = $state(true);
   const currentYear = new Date().getFullYear();
   const appVersion = `v${packageInfo.version}`;
-  const releaseStage = 'Beta';
 
   const monthLabels = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep'];
 
@@ -353,10 +352,7 @@
           <span class="powered-by-label">Powered by Lean 101</span>
         </div>
         <div class="auth-meta">
-          <span class="version-badge">
-            <span>{appVersion}</span>
-            <span class="release-pill">{releaseStage}</span>
-          </span>
+          <span class="version-badge">{appVersion}</span>
           <span>&copy; {currentYear} Hunter Premium Produce</span>
         </div>
       </div>
@@ -375,13 +371,12 @@
         </div>
         <div class="auth-status-row">
           <span class="auth-status-pill">Secure Workspace Access</span>
-          <span class="release-pill">{releaseStage}</span>
         </div>
       </div>
 
       <div class="auth-copy">
-        <h2>Login</h2>
-        <p>Enter your username & password below:</p>
+        <h2>Welcome back</h2>
+        <p>Sign in with your email and password to continue.</p>
       </div>
 
       <form class="signin-form auth-form" onsubmit={handleLogin}>
@@ -422,10 +417,7 @@
           <span class="powered-by-label">Powered by Lean 101</span>
         </div>
         <div class="auth-meta">
-          <span class="version-badge">
-            <span>{appVersion}</span>
-            <span class="release-pill">{releaseStage}</span>
-          </span>
+          <span class="version-badge">{appVersion}</span>
           <span>&copy; {currentYear} Lean 101</span>
         </div>
       </div>
@@ -806,25 +798,23 @@
     width: min(100%, 38rem);
     display: grid;
     gap: 1.35rem;
-    padding: 1.5rem;
-    border: 1px solid rgba(212, 226, 218, 0.95);
-    border-radius: 1.7rem;
-    background:
-      radial-gradient(circle at top left, rgba(115, 197, 146, 0.16), transparent 32%),
-      radial-gradient(circle at bottom right, rgba(33, 94, 60, 0.1), transparent 30%),
-      rgba(255, 255, 255, 0.96);
-    box-shadow: none;
-    backdrop-filter: blur(14px);
+    padding: 2.1rem 2rem 1.6rem;
+    border: 1px solid var(--color-border);
+    border-radius: 1.25rem;
+    background: var(--color-bg-surface);
     overflow: hidden;
   }
 
+  /* Crisp brand accent along the top edge, clipped to the card radius.
+     Replaces the old green radial glow, which read as a muddy shadow. */
   .auth-card::before {
     content: '';
     position: absolute;
-    inset: 0;
-    background:
-      linear-gradient(135deg, rgba(255, 255, 255, 0.42), transparent 35%),
-      linear-gradient(180deg, transparent, rgba(238, 248, 242, 0.55));
+    top: 0;
+    left: 0;
+    right: 0;
+    height: 4px;
+    background: var(--color-brand);
     pointer-events: none;
   }
 
@@ -913,21 +903,6 @@
     flex-wrap: wrap;
   }
 
-  .release-pill {
-    display: inline-flex;
-    align-items: center;
-    justify-content: center;
-    padding: 0.28rem 0.62rem;
-    border: 1px solid color-mix(in srgb, var(--color-brand) 16%, transparent);
-    border-radius: 999px;
-    background: var(--color-brand-tint);
-    color: var(--color-success);
-    font-size: 0.72rem;
-    font-weight: 700;
-    letter-spacing: 0.08em;
-    text-transform: uppercase;
-  }
-
   .auth-copy {
     display: grid;
     gap: 0.55rem;
@@ -994,20 +969,25 @@
   }
 
   .auth-form input {
-    padding: 1rem 1.05rem;
-    border: 1px solid #d6e3db;
-    border-radius: 1rem;
-    background: rgba(248, 251, 249, 0.94);
+    padding: 0.95rem 1rem;
+    border: 1px solid var(--color-border);
+    border-radius: 0.7rem;
+    background: var(--color-bg-app);
+    color: var(--color-text-primary);
     transition:
       border-color 160ms ease,
       box-shadow 160ms ease,
       background-color 160ms ease;
   }
 
+  .auth-form input::placeholder {
+    color: var(--color-text-muted);
+  }
+
   .auth-form input:focus {
     outline: none;
     border-color: var(--color-brand);
-    box-shadow: 0 0 0 0.24rem color-mix(in srgb, var(--color-brand) 12%, transparent);
+    box-shadow: 0 0 0 3px color-mix(in srgb, var(--color-brand) 22%, transparent);
     background: #fff;
   }
 
@@ -1021,6 +1001,26 @@
     width: 100%;
     min-height: 3.35rem;
     margin-top: 0.2rem;
+    font-size: 1.02rem;
+    transition: background-color 160ms cubic-bezier(0.22, 1, 0.36, 1);
+  }
+
+  .auth-submit:hover:not(:disabled) {
+    background: #126a33;
+  }
+
+  .auth-submit:active:not(:disabled) {
+    background: #0f5a2b;
+  }
+
+  .auth-submit:focus-visible {
+    outline: 3px solid color-mix(in srgb, var(--color-brand) 45%, transparent);
+    outline-offset: 2px;
+  }
+
+  .auth-submit:disabled {
+    opacity: 0.7;
+    cursor: progress;
   }
 
   .auth-footer {
@@ -1221,23 +1221,20 @@
 
   .signin-form {
     display: grid;
-    grid-template-columns: repeat(3, minmax(0, 1fr));
-    gap: 0.75rem;
-    width: min(100%, 38rem);
-  }
-
-  .signin-form input {
+    grid-template-columns: 1fr;
+    gap: 0.95rem;
     width: 100%;
-    padding: 0.9rem 0.95rem;
-    border: 1px solid var(--line-strong);
-    border-radius: 0.95rem;
-    background: var(--panel-soft);
-    color: var(--text);
   }
 
   .login-error {
-    color: #a03737;
+    margin: 0;
+    padding: 0.75rem 0.95rem;
+    border: 1px solid rgba(160, 55, 55, 0.3);
+    border-radius: 0.7rem;
+    background: #fdf2f2;
+    color: #8a1622;
     font-weight: 600;
+    font-size: 0.95rem;
   }
 
   .focus-card {
@@ -1905,8 +1902,8 @@
     }
 
     .auth-card {
-      padding: 1.15rem;
-      border-radius: 1.35rem;
+      padding: 1.5rem 1.15rem 1.15rem;
+      border-radius: 1.1rem;
     }
 
     .auth-header,

frontend/src/routes/load-fetch.test.ts

@@ -118,10 +118,10 @@ describe('route loaders use the SvelteKit fetch argument', () => {
     expect(apiMocks.productCosts).toHaveBeenCalledWith(fetcher);
   });
 
-  it('passes fetch through the mix calculator history loader', async () => {
+  it('passes fetch through the mix calculator loader', async () => {
     await mixCalculatorLoad({ fetch: fetcher } as never);
 
-    expect(apiMocks.mixCalculatorSessions).toHaveBeenCalledWith(fetcher);
+    expect(apiMocks.mixCalculatorOptions).toHaveBeenCalledWith(fetcher);
   });
 
   it('passes fetch through the new mix calculator loader', async () => {

frontend/src/routes/mix-calculator/+page.svelte

@@ -1,9 +1,13 @@
 <script lang="ts">
   import { clientSession, hasModuleAccess } from '$lib/session';
-  import type { MixCalculatorSession } from '$lib/types';
+  import { featureFlags } from '$lib/features';
+  import MixCalculatorEditor from '$lib/components/mix-calculator/MixCalculatorEditor.svelte';
+  import type { MixCalculatorOptions, MixCalculatorSession } from '$lib/types';
 
-  let { data }: { data: { sessions: MixCalculatorSession[] } } = $props();
+  let { data }: { data: { sessions?: MixCalculatorSession[]; options?: MixCalculatorOptions } } =
+    $props();
 
+  const sessions = $derived(data.sessions ?? []);
   const canEdit = $derived(hasModuleAccess($clientSession, 'mix_calculator', 'edit'));
 
   function formatDate(value: string) {
@@ -18,6 +22,9 @@
   }
 </script>
 
+{#if !featureFlags.mixCalculatorSessionHistory}
+  <MixCalculatorEditor options={data.options} />
+{:else}
 {#if canEdit}
   <section class="page-actions">
     <a class="primary-button" href="/mix-calculator/new">New mix session</a>
@@ -27,17 +34,17 @@
 <section class="metric-row">
   <article class="metric-card">
     <span>Saved Sessions</span>
-    <strong>{data.sessions.length}</strong>
+    <strong>{sessions.length}</strong>
     <p>Visible under your access scope</p>
   </article>
   <article class="metric-card">
     <span>Total Planned Kg</span>
-    <strong>{formatNumber(data.sessions.reduce((sum, session) => sum + session.total_kg, 0), 2)}</strong>
+    <strong>{formatNumber(sessions.reduce((sum, session) => sum + session.total_kg, 0), 2)}</strong>
     <p>Across the visible history</p>
   </article>
   <article class="metric-card">
     <span>Sessions With Warnings</span>
-    <strong>{data.sessions.filter((session) => session.warnings.length).length}</strong>
+    <strong>{sessions.filter((session) => session.warnings.length).length}</strong>
     <p>Fractional bag outputs need review</p>
   </article>
 </section>
@@ -50,7 +57,7 @@
     </div>
   </div>
 
-  {#if data.sessions.length}
+  {#if sessions.length}
     <div class="table-wrap">
       <table>
         <thead>
@@ -65,7 +72,7 @@
           </tr>
         </thead>
         <tbody>
-          {#each data.sessions as session}
+          {#each sessions as session}
             <tr>
               <td data-label="Session">
                 <strong>{session.session_number}</strong>
@@ -102,6 +109,7 @@
     </div>
   {/if}
 </section>
+{/if}
 
 <style>
   h2,
@@ -140,10 +148,24 @@
     align-items: center;
     justify-content: center;
     padding: 0.78rem 0.96rem;
-    border-radius: 0.9rem;
+    border-radius: 0.6rem;
     background: var(--color-brand);
     color: #fff;
     font-weight: 600;
+    transition: background-color 160ms ease;
+  }
+
+  .primary-button:hover {
+    background: #126a33;
+  }
+
+  .primary-button:active {
+    background: #0f5a2b;
+  }
+
+  .primary-button:focus-visible {
+    outline: 3px solid color-mix(in srgb, var(--color-brand) 45%, transparent);
+    outline-offset: 2px;
   }
 
   .metric-row {
@@ -155,7 +177,7 @@
   .metric-card,
   .table-card {
     border: 1px solid var(--line);
-    border-radius: 1.3rem;
+    border-radius: 0.8rem;
     background: var(--panel);
     box-shadow: var(--shadow);
   }
@@ -222,12 +244,12 @@
 
   tbody td:first-child {
     border-left: 1px solid var(--line);
-    border-radius: 1rem 0 0 1rem;
+    border-radius: 0.65rem 0 0 0.65rem;
   }
 
   tbody td:last-child {
     border-right: 1px solid var(--line);
-    border-radius: 0 1rem 1rem 0;
+    border-radius: 0 0.65rem 0.65rem 0;
   }
 
   .row-actions {
@@ -245,8 +267,8 @@
     margin-left: 0.55rem;
     padding: 0.25rem 0.5rem;
     border-radius: 999px;
-    background: #fff6e6;
-    color: #8b5b1e;
+    background: #fdf6e9;
+    color: #8a5a00;
     font-size: 0.72rem;
     font-weight: 700;
     text-transform: uppercase;
@@ -257,7 +279,7 @@
     display: grid;
     gap: 0.2rem;
     padding: 1rem;
-    border-radius: 1rem;
+    border-radius: 0.65rem;
     background: var(--panel-soft);
   }
 
@@ -299,7 +321,7 @@
     tbody tr {
       padding: 0.3rem;
       border: 1px solid var(--line);
-      border-radius: 1rem;
+      border-radius: 0.65rem;
       background: var(--panel-soft);
     }
 

frontend/src/routes/mix-calculator/+page.ts

@@ -2,17 +2,35 @@ import { redirect } from '@sveltejs/kit';
 import { api } from '$lib/api';
 import { featureFlags } from '$lib/features';
 import { getStoredClientSession, hasModuleAccess, hasStoredClientSession } from '$lib/session';
-import { canOpenMixCalculator, getWorkspaceHomeHref } from '$lib/workspace-access';
+import { canCreateMixSession, canOpenMixCalculator, getWorkspaceHomeHref } from '$lib/workspace-access';
 
 export async function load({ fetch }) {
+  // Single-page mode (session history disabled): this route IS the calculator.
   if (!featureFlags.mixCalculatorSessionHistory) {
-    throw redirect(307, '/mix-calculator/new');
+    if (!hasStoredClientSession()) {
+      return { options: { clients: [], products: [] } };
     }
 
-  if (!hasStoredClientSession()) {
+    const session = getStoredClientSession();
+    if (!canCreateMixSession(session)) {
+      throw redirect(307, getWorkspaceHomeHref(session));
+    }
+
+    try {
       return {
-      sessions: []
+        options:
+          hasModuleAccess(session, 'mix_calculator', 'edit') || session?.role === 'internal'
+            ? await api.mixCalculatorOptions(fetch)
+            : { clients: [], products: [] }
       };
+    } catch {
+      return { options: { clients: [], products: [] } };
+    }
+  }
+
+  // History mode: list saved sessions.
+  if (!hasStoredClientSession()) {
+    return { sessions: [] };
   }
 
   const session = getStoredClientSession();
@@ -22,11 +40,12 @@ export async function load({ fetch }) {
 
   try {
     return {
-      sessions: hasModuleAccess(session, 'mix_calculator') || session?.role === 'internal' ? await api.mixCalculatorSessions(fetch) : []
+      sessions:
+        hasModuleAccess(session, 'mix_calculator') || session?.role === 'internal'
+          ? await api.mixCalculatorSessions(fetch)
+          : []
     };
   } catch {
-    return {
-      sessions: []
-    };
+    return { sessions: [] };
   }
 }

frontend/src/routes/mix-calculator/[id]/+page.svelte

@@ -15,7 +15,7 @@
     {#if featureFlags.mixCalculatorSessionHistory}
       <a class="secondary-button" href="/mix-calculator">Back to session history</a>
     {:else}
-      <a class="secondary-button" href="/mix-calculator/new">New mix session</a>
+      <a class="secondary-button" href="/mix-calculator">New mix session</a>
     {/if}
   </section>
 {/if}
@@ -38,7 +38,7 @@
     max-width: 42rem;
     padding: 1.25rem;
     border: 1px solid var(--line);
-    border-radius: 1.25rem;
+    border-radius: 0.8rem;
     background: var(--panel);
     box-shadow: var(--shadow);
   }
@@ -58,7 +58,7 @@
     margin-top: 1rem;
     padding: 0.78rem 0.92rem;
     border: 1px solid var(--line-strong);
-    border-radius: 0.88rem;
+    border-radius: 0.6rem;
     background: #fff;
     color: #304038;
     font-weight: 600;

frontend/src/routes/mix-calculator/[id]/print/+page.svelte

@@ -15,7 +15,7 @@
     {#if featureFlags.mixCalculatorSessionHistory}
       <a class="secondary-button" href="/mix-calculator">Back to session history</a>
     {:else}
-      <a class="secondary-button" href="/mix-calculator/new">New mix session</a>
+      <a class="secondary-button" href="/mix-calculator">New mix session</a>
     {/if}
   </section>
 {/if}

frontend/src/routes/root-access.test.ts

@@ -31,7 +31,7 @@ describe('root route access', () => {
     sessionMocks.hasModuleAccess.mockReturnValue(false);
 
     expect(() => load({ fetch: vi.fn() as typeof fetch })).toThrow(
-      expect.objectContaining({ status: 307, location: '/mix-calculator/new' })
+      expect.objectContaining({ status: 307, location: '/mix-calculator' })
     );
   });
 

frontend/src/routes/settings/settings-access.test.ts

@@ -30,6 +30,6 @@ describe('settings route access', () => {
     sessionMocks.hasPermission.mockImplementation((session, key) => session?.permissions?.includes(key) ?? false);
     sessionMocks.hasModuleAccess.mockReturnValue(false);
 
-    expect(() => load()).toThrow(expect.objectContaining({ status: 307, location: '/mix-calculator/new' }));
+    expect(() => load()).toThrow(expect.objectContaining({ status: 307, location: '/mix-calculator' }));
   });
 });

frontend/src/routes/throughput/+page.ts

@@ -0,0 +1,30 @@
+import { redirect } from '@sveltejs/kit';
+import { api } from '$lib/api';
+import { getStoredClientSession, hasStoredClientSession } from '$lib/session';
+import { canOpenThroughput, getWorkspaceHomeHref } from '$lib/workspace-access';
+
+export async function load({ fetch }) {
+  if (!hasStoredClientSession()) {
+    return { entries: [], products: [] };
+  }
+
+  const session = getStoredClientSession();
+  if (!canOpenThroughput(session)) {
+    throw redirect(307, getWorkspaceHomeHref(session));
+  }
+
+  // Default view shows the last 30 days; "Find past entries" surfaces older ones.
+  const recentFrom = new Date();
+  recentFrom.setDate(recentFrom.getDate() - 30);
+  const dateFrom = recentFrom.toISOString().slice(0, 10);
+
+  try {
+    const [entries, products] = await Promise.all([
+      api.throughputEntries({ date_from: dateFrom, limit: 200 }, fetch),
+      api.throughputProducts(fetch)
+    ]);
+    return { entries, products };
+  } catch {
+    return { entries: [], products: [] };
+  }
+}

frontend/src/routes/throughput/add/+page.svelte

@@ -0,0 +1,389 @@
+<script lang="ts">
+  import { goto } from '$app/navigation';
+  import { api } from '$lib/api';
+  import type {
+    ThroughputEntryCreateInput,
+    ThroughputProduct,
+    ThroughputQuantityType
+  } from '$lib/types';
+  import { CheckCircle2, AlertTriangle, ArrowLeft } from 'lucide-svelte';
+
+  let { data } = $props<{ data: { products: ThroughputProduct[] } }>();
+  const products = $derived(data.products ?? []);
+
+  const today = new Date().toISOString().slice(0, 10);
+
+  let productionDate = $state(today);
+  let productId = $state<string>('');
+  let bagSize = $state<string>('');
+  let quantity = $state<string>('');
+  let quantityType = $state<ThroughputQuantityType>('bags');
+  let scalesChecked = $state(true);
+  let labelCorrect = $state(true);
+  let bagSealed = $state(true);
+  let palletGood = $state(true);
+  let sampleBoxNo = $state('');
+  let tw1 = $state('');
+  let tw2 = $state('');
+  let tw3 = $state('');
+  let tw4 = $state('');
+  let tw5 = $state('');
+  let staffName = $state('');
+  let notes = $state('');
+
+  let saving = $state(false);
+  let successMessage = $state('');
+  let errorMessage = $state('');
+
+  const selectedProduct = $derived(
+    productId ? products.find((p: ThroughputProduct) => String(p.id) === productId) ?? null : null
+  );
+
+  $effect(() => {
+    if (selectedProduct) {
+      if (!bagSize && selectedProduct.default_bag_size != null) {
+        bagSize = String(selectedProduct.default_bag_size);
+      }
+      if (selectedProduct.is_bulka_default) {
+        quantityType = 'kg';
+      }
+    }
+  });
+
+  const qaWarning = $derived(!(scalesChecked && labelCorrect && bagSealed && palletGood));
+
+  function toNum(value: string): number | null {
+    const trimmed = value.trim();
+    if (!trimmed) return null;
+    const n = Number(trimmed);
+    return Number.isFinite(n) ? n : null;
+  }
+
+  function resetExceptDateAndStaff() {
+    productId = '';
+    bagSize = '';
+    quantity = '';
+    quantityType = 'bags';
+    scalesChecked = true;
+    labelCorrect = true;
+    bagSealed = true;
+    palletGood = true;
+    sampleBoxNo = '';
+    tw1 = '';
+    tw2 = '';
+    tw3 = '';
+    tw4 = '';
+    tw5 = '';
+    notes = '';
+  }
+
+  function buildPayload(): ThroughputEntryCreateInput | null {
+    const qty = toNum(quantity);
+    if (qty === null || qty < 0) {
+      errorMessage = 'Quantity is required and must be 0 or greater.';
+      return null;
+    }
+    if (!productionDate) {
+      errorMessage = 'Date is required.';
+      return null;
+    }
+    if (!productId) {
+      errorMessage = 'Product is required.';
+      return null;
+    }
+    const bag = toNum(bagSize);
+    if (quantityType === 'bags' && (bag === null || bag <= 0)) {
+      errorMessage = 'Bag size is required when quantity type is "bags".';
+      return null;
+    }
+
+    return {
+      production_date: productionDate,
+      product_id: Number(productId),
+      product_name_snapshot: selectedProduct?.name ?? '',
+      bag_size: bag,
+      scales_checked: scalesChecked,
+      label_correct: labelCorrect,
+      bag_sealed: bagSealed,
+      pallet_good_condition: palletGood,
+      sample_box_no: sampleBoxNo.trim() || null,
+      test_weight_1: toNum(tw1),
+      test_weight_2: toNum(tw2),
+      test_weight_3: toNum(tw3),
+      test_weight_4: toNum(tw4),
+      test_weight_5: toNum(tw5),
+      quantity: qty,
+      quantity_type: quantityType,
+      staff_name: staffName.trim() || null,
+      notes: notes.trim() || null
+    };
+  }
+
+  async function submit(mode: 'save' | 'save-and-add') {
+    errorMessage = '';
+    successMessage = '';
+    const payload = buildPayload();
+    if (!payload) return;
+
+    saving = true;
+    try {
+      await api.createThroughputEntry(payload);
+      if (mode === 'save') {
+        await goto('/throughput');
+        return;
+      }
+      successMessage = 'Entry saved. Ready for the next one.';
+      resetExceptDateAndStaff();
+    } catch (err) {
+      errorMessage = err instanceof Error ? err.message : 'Failed to save entry';
+    } finally {
+      saving = false;
+    }
+  }
+</script>
+
+<section class="add-entry">
+  <header class="page-header">
+    <a class="back-link" href="/throughput"><ArrowLeft size={16} /> Back to log</a>
+    <h1>Add Throughput Entry</h1>
+  </header>
+
+  {#if successMessage}
+    <div class="banner banner-ok"><CheckCircle2 size={16} /> {successMessage}</div>
+  {/if}
+  {#if errorMessage}
+    <div class="banner banner-error"><AlertTriangle size={16} /> {errorMessage}</div>
+  {/if}
+
+  <form onsubmit={(e) => { e.preventDefault(); submit('save'); }}>
+    <div class="grid">
+      <label>
+        <span>Date *</span>
+        <input type="date" bind:value={productionDate} required />
+      </label>
+
+      <label>
+        <span>Product *</span>
+        <select bind:value={productId} required>
+          <option value="">Select product…</option>
+          {#each products as p (p.id)}
+            <option value={String(p.id)}>{p.name}{p.item_id ? ` · ${p.item_id}` : ''}</option>
+          {/each}
+        </select>
+      </label>
+
+      <label>
+        <span>Bag size (kg)</span>
+        <input type="number" min="0" step="0.01" bind:value={bagSize} placeholder="e.g. 20" />
+      </label>
+
+      <label>
+        <span>Quantity *</span>
+        <input type="number" min="0" step="0.01" bind:value={quantity} required />
+      </label>
+
+      <label>
+        <span>Quantity type *</span>
+        <select bind:value={quantityType}>
+          <option value="bags">Bags</option>
+          <option value="kg">Kilograms (bulka / bulk)</option>
+        </select>
+      </label>
+
+      <label>
+        <span>Sample box no.</span>
+        <input type="text" bind:value={sampleBoxNo} />
+      </label>
+    </div>
+
+    <fieldset class="qa">
+      <legend>QA checklist</legend>
+      <label class="check"><input type="checkbox" bind:checked={scalesChecked} /> Scales checked</label>
+      <label class="check"><input type="checkbox" bind:checked={labelCorrect} /> Label correct</label>
+      <label class="check"><input type="checkbox" bind:checked={bagSealed} /> Bag sealed</label>
+      <label class="check"><input type="checkbox" bind:checked={palletGood} /> Pallet in good condition</label>
+      {#if qaWarning}
+        <p class="qa-warning"><AlertTriangle size={14} /> One or more QA checks failed — this entry will be flagged.</p>
+      {/if}
+    </fieldset>
+
+    <fieldset class="weights">
+      <legend>Test weights (optional, RCP 001)</legend>
+      <div class="weight-grid">
+        <label><span>1</span><input type="number" step="0.01" bind:value={tw1} /></label>
+        <label><span>2</span><input type="number" step="0.01" bind:value={tw2} /></label>
+        <label><span>3</span><input type="number" step="0.01" bind:value={tw3} /></label>
+        <label><span>4</span><input type="number" step="0.01" bind:value={tw4} /></label>
+        <label><span>5</span><input type="number" step="0.01" bind:value={tw5} /></label>
+      </div>
+    </fieldset>
+
+    <div class="grid">
+      <label>
+        <span>Staff name</span>
+        <input type="text" bind:value={staffName} placeholder="e.g. Jake" />
+      </label>
+      <label class="full">
+        <span>Notes</span>
+        <textarea rows="2" bind:value={notes}></textarea>
+      </label>
+    </div>
+
+    <div class="actions">
+      <button type="submit" class="primary-button" disabled={saving}>Save</button>
+      <button type="button" class="secondary-button" disabled={saving} onclick={() => submit('save-and-add')}>
+        Save and add another
+      </button>
+      <a href="/throughput" class="ghost-button">Cancel</a>
+    </div>
+  </form>
+</section>
+
+<style>
+  .add-entry {
+    display: flex;
+    flex-direction: column;
+    gap: 1.25rem;
+    padding: 1rem 0;
+    max-width: 980px;
+  }
+  .page-header {
+    display: flex;
+    flex-direction: column;
+    gap: 0.4rem;
+  }
+  .page-header h1 {
+    margin: 0;
+    font-size: 1.5rem;
+  }
+  .back-link {
+    display: inline-flex;
+    align-items: center;
+    gap: 0.3rem;
+    color: var(--text-muted, #6b7280);
+    font-size: 0.85rem;
+    text-decoration: none;
+  }
+  form {
+    display: flex;
+    flex-direction: column;
+    gap: 1rem;
+    padding: 1.25rem;
+    background: var(--surface, #fff);
+    border: 1px solid var(--border, #e5e7eb);
+    border-radius: 0.65rem;
+  }
+  .grid {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 0.75rem;
+  }
+  label {
+    display: flex;
+    flex-direction: column;
+    gap: 0.3rem;
+    font-size: 0.85rem;
+  }
+  label.full {
+    grid-column: 1 / -1;
+  }
+  input,
+  select,
+  textarea {
+    padding: 0.5rem 0.65rem;
+    border: 1px solid var(--border, #d1d5db);
+    border-radius: 0.4rem;
+    font: inherit;
+  }
+  fieldset {
+    border: 1px solid var(--border, #e5e7eb);
+    border-radius: 0.5rem;
+    padding: 0.75rem 1rem;
+    display: flex;
+    flex-direction: column;
+    gap: 0.5rem;
+  }
+  legend {
+    padding: 0 0.4rem;
+    font-weight: 600;
+    font-size: 0.85rem;
+  }
+  .qa {
+    display: grid;
+    grid-template-columns: repeat(auto-fit, minmax(200px, 1fr));
+    gap: 0.4rem 1rem;
+  }
+  .check {
+    flex-direction: row;
+    align-items: center;
+    gap: 0.45rem;
+  }
+  .qa-warning {
+    grid-column: 1 / -1;
+    margin: 0;
+    color: #92400e;
+    display: inline-flex;
+    align-items: center;
+    gap: 0.35rem;
+    font-size: 0.85rem;
+  }
+  .weight-grid {
+    display: grid;
+    grid-template-columns: repeat(5, minmax(0, 1fr));
+    gap: 0.5rem;
+  }
+  .weight-grid label {
+    flex-direction: column;
+    gap: 0.25rem;
+  }
+  .weight-grid label span {
+    font-size: 0.75rem;
+    color: var(--text-muted, #6b7280);
+  }
+  .actions {
+    display: flex;
+    gap: 0.5rem;
+    flex-wrap: wrap;
+  }
+  .primary-button {
+    padding: 0.6rem 1rem;
+    background: var(--accent, #1f2937);
+    color: white;
+    border-radius: 0.5rem;
+    border: 0;
+    font-weight: 600;
+    cursor: pointer;
+  }
+  .secondary-button {
+    padding: 0.6rem 1rem;
+    background: white;
+    border: 1px solid var(--border, #d1d5db);
+    border-radius: 0.5rem;
+    font-weight: 600;
+    cursor: pointer;
+  }
+  .ghost-button {
+    padding: 0.6rem 1rem;
+    border-radius: 0.5rem;
+    text-decoration: none;
+    color: var(--text-muted, #6b7280);
+    align-self: center;
+  }
+  .banner {
+    display: flex;
+    align-items: center;
+    gap: 0.5rem;
+    padding: 0.65rem 0.85rem;
+    border-radius: 0.5rem;
+  }
+  .banner-ok {
+    background: #ecfdf5;
+    color: #065f46;
+    border: 1px solid #a7f3d0;
+  }
+  .banner-error {
+    background: #fef2f2;
+    color: #991b1b;
+    border: 1px solid #fecaca;
+  }
+</style>

frontend/src/routes/throughput/add/+page.ts

@@ -0,0 +1,22 @@
+import { redirect } from '@sveltejs/kit';
+import { api } from '$lib/api';
+import { getStoredClientSession, hasStoredClientSession } from '$lib/session';
+import { canEditThroughput, getWorkspaceHomeHref } from '$lib/workspace-access';
+
+export async function load({ fetch }) {
+  if (!hasStoredClientSession()) {
+    return { products: [] };
+  }
+
+  const session = getStoredClientSession();
+  if (!canEditThroughput(session)) {
+    throw redirect(307, getWorkspaceHomeHref(session));
+  }
+
+  try {
+    const products = await api.throughputProducts(fetch);
+    return { products };
+  } catch {
+    return { products: [] };
+  }
+}