Merge pull request 'initiated migrations fix in warranty' (#46) from fix/migrations-warrenty into Dev

Reviewed-on: #46

.gitignore

@@ -30,9 +30,10 @@ yarn-error.log*
 Thumbs.db
 .idea/
 
-# ── Migrations ─────────────────────────────────────────────────────────
+# ── Playwright E2E (Testing/e2e) ──────────────────────────────────────
-# New EF Core migrations are not committed. Note the 4 migrations already in
+Testing/e2e/playwright-report/
-# Backend/ERPCore/Infra/Persistence/Migrations/ stay tracked — .gitignore does
+Testing/e2e/test-results/
-# not apply to tracked files — so edits to those still get committed as normal.
+Testing/e2e/.auth/
-# Untracking them too takes `git rm --cached`.
+Testing/e2e/blob-report/
-**/Migrations/
+
+

Backend/ERPCore/Controllers/BundleSalesController.cs

@@ -0,0 +1,80 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/bundle-sales")]
+public sealed class BundleSalesController : ApiControllerBase
+{
+    private readonly IBundleSaleService _bundles;
+
+    public BundleSalesController(IBundleSaleService bundles) => _bundles = bundles;
+
+    [HttpGet("templates")]
+    [ProducesResponseType(typeof(PagedResponse<BundleSaleTemplateSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<BundleSaleTemplateSummaryDto>>> ListTemplates(
+        [FromQuery] PageQuery query,
+        CancellationToken ct)
+        => Ok(await _bundles.ListTemplatesAsync(query, ct));
+
+    [HttpGet("templates/{bundleSaleTemplateId:int}")]
+    [ProducesResponseType(typeof(BundleSaleTemplateDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<BundleSaleTemplateDto>> GetTemplate(int bundleSaleTemplateId, CancellationToken ct)
+    {
+        var result = await _bundles.GetTemplateAsync(bundleSaleTemplateId, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<BundleSaleSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<BundleSaleSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] BundleSaleStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _bundles.ListAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{bundleSaleId:int}")]
+    [ProducesResponseType(typeof(BundleSaleDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<BundleSaleDto>> GetById(int bundleSaleId, CancellationToken ct)
+    {
+        var result = await _bundles.GetAsync(bundleSaleId, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+
+    [HttpGet("{bundleSaleId:int}/posting-check")]
+    [ProducesResponseType(typeof(BundleSalePostingCheckDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BundleSalePostingCheckDto>> PostingCheck(int bundleSaleId, CancellationToken ct)
+        => Ok(await _bundles.CheckPostingAsync(bundleSaleId, ct));
+
+    [HttpPost]
+    [ProducesResponseType(typeof(BundleSaleDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<BundleSaleDto>> Create([FromBody] CreateBundleSaleRequest request, CancellationToken ct)
+    {
+        var result = await _bundles.CreateAsync(request, ct);
+        return Created($"/api/v1/bundle-sales/{result.BundleSaleId}", result);
+    }
+
+    [HttpPut("{bundleSaleId:int}")]
+    [ProducesResponseType(typeof(BundleSaleDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BundleSaleDto>> Update(int bundleSaleId, [FromBody] UpdateBundleSaleRequest request, CancellationToken ct)
+    {
+        return Ok(await _bundles.UpdateAsync(bundleSaleId, request, ct));
+    }
+
+    [HttpPost("{bundleSaleId:int}/post")]
+    [ProducesResponseType(typeof(BundleSaleDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BundleSaleDto>> Post(int bundleSaleId, CancellationToken ct)
+        => Ok(await _bundles.PostAsync(bundleSaleId, ct));
+
+    [HttpPost("{bundleSaleId:int}/cancel")]
+    [ProducesResponseType(typeof(BundleSaleDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BundleSaleDto>> Cancel(int bundleSaleId, CancellationToken ct)
+        => Ok(await _bundles.CancelAsync(bundleSaleId, ct));
+}

Backend/ERPCore/Controllers/CustomersController.cs

@@ -0,0 +1,69 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Customers;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Customer master endpoints for Phase 1 sales.</summary>
+[Route("api/v1/customers")]
+public sealed class CustomersController : ApiControllerBase
+{
+    private readonly ICustomerService _customers;
+
+    public CustomersController(ICustomerService customers) => _customers = customers;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<CustomerDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<CustomerDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] EntityStatus? status,
+        [FromQuery] CustomerType? customerType,
+        CancellationToken ct)
+        => Ok(await _customers.ListAsync(query, status, customerType, ct));
+
+    [HttpGet("{customerId:int}")]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<CustomerDto>> GetById(int customerId, CancellationToken ct)
+    {
+        var result = await _customers.GetAsync(customerId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<CustomerDto>> Create([FromBody] CreateCustomerRequest request, CancellationToken ct)
+    {
+        var result = await _customers.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/customers/{result.Value.CustomerId}", result.Value);
+    }
+
+    [HttpPut("{customerId:int}")]
+    [ProducesResponseType(typeof(CustomerDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<CustomerDto>> Update(int customerId, [FromBody] UpdateCustomerRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _customers.UpdateAsync(customerId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPatch("{customerId:int}/status")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> SetStatus(int customerId, [FromBody] UpdateCustomerStatusRequest request, CancellationToken ct)
+    {
+        await _customers.SetStatusAsync(customerId, request.Status, ct);
+        return NoContent();
+    }
+}

Backend/ERPCore/Controllers/FreeIssuesController.cs

@@ -0,0 +1,78 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Thin API alias for free-issue handling. Free issues are modeled as sales slips
+/// with line-level <c>IsFreeIssue</c>/<c>FreeQty</c> flags, so this controller reuses
+/// the existing sales-slip CRUD surface under a more business-friendly route.
+/// </summary>
+[Route("api/v1/free-issues")]
+public sealed class FreeIssuesController : ApiControllerBase
+{
+    private readonly ISalesSlipService _slips;
+
+    public FreeIssuesController(ISalesSlipService slips) => _slips = slips;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<FreeIssueSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<FreeIssueSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] SalesSlipStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _slips.ListFreeIssuesAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{freeIssueId:int}")]
+    [ProducesResponseType(typeof(FreeIssueDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<FreeIssueDto>> GetById(int freeIssueId, CancellationToken ct)
+    {
+        var result = await _slips.GetFreeIssueAsync(freeIssueId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpGet("{freeIssueId:int}/posting-check")]
+    [ProducesResponseType(typeof(SalesSlipPostingCheckDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesSlipPostingCheckDto>> PostingCheck(int freeIssueId, CancellationToken ct)
+        => Ok(await _slips.CheckPostingAsync(freeIssueId, ct));
+
+    [HttpPost]
+    [ProducesResponseType(typeof(FreeIssueDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<FreeIssueDto>> Create([FromBody] CreateSalesSlipRequest request, CancellationToken ct)
+    {
+        var result = await _slips.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/free-issues/{result.Value.SalesSlipId}", result.Value);
+    }
+
+    [HttpPut("{freeIssueId:int}")]
+    [ProducesResponseType(typeof(FreeIssueDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<FreeIssueDto>> Update(int freeIssueId, [FromBody] UpdateSalesSlipRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _slips.UpdateAsync(freeIssueId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{freeIssueId:int}/post")]
+    [ProducesResponseType(typeof(FreeIssueDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<FreeIssueDto>> Post(int freeIssueId, CancellationToken ct)
+        => Ok(await _slips.PostAsync(freeIssueId, ct));
+
+    [HttpPost("{freeIssueId:int}/cancel")]
+    [ProducesResponseType(typeof(FreeIssueDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<FreeIssueDto>> Cancel(int freeIssueId, CancellationToken ct)
+        => Ok(await _slips.CancelAsync(freeIssueId, ct));
+}

Backend/ERPCore/Controllers/GeneralLedgerController.cs

@@ -0,0 +1,43 @@
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Generic reverse proxy into the external General Ledger service — forwards every
+/// method/path/query/body under this prefix verbatim via
+/// <see cref="IGeneralLedgerService"/> and returns GL's response (status, content-type,
+/// body) unchanged. No endpoint-specific shape lives here; see
+/// docs/12-GENERAL-LEDGER-INTEGRATION.md for the full GL contract and what this proxy
+/// does and doesn't do. Gated by the same ERP door policy as every other v1 endpoint
+/// (<see cref="ApiControllerBase"/>) — the shared GL API key is attached server-side
+/// only and is never exposed to the frontend.
+/// </summary>
+[Route("api/v1/gl")]
+public sealed class GeneralLedgerController : ApiControllerBase
+{
+    private readonly IGeneralLedgerService _gl;
+
+    public GeneralLedgerController(IGeneralLedgerService gl) => _gl = gl;
+
+    [HttpGet("{**path}")]
+    public Task<IActionResult> Get(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Get, path, ct);
+
+    [HttpPost("{**path}")]
+    public Task<IActionResult> Post(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Post, path, ct);
+
+    [HttpPut("{**path}")]
+    public Task<IActionResult> Put(string path, CancellationToken ct) => ForwardAsync(HttpMethod.Put, path, ct);
+
+    private async Task<IActionResult> ForwardAsync(HttpMethod method, string path, CancellationToken ct)
+    {
+        var body = method == HttpMethod.Get ? null : Request.Body;
+        var result = await _gl.ForwardAsync(method, path, Request.QueryString.Value, Request.ContentType, body, ct);
+        return new ContentResult
+        {
+            StatusCode = result.StatusCode,
+            Content = result.Body,
+            ContentType = result.ContentType ?? "application/json"
+        };
+    }
+}

Backend/ERPCore/Controllers/ItemsController.cs

@@ -81,11 +81,4 @@ public sealed class ItemsController : ApiControllerBase
     [ProducesResponseType(StatusCodes.Status404NotFound)]
     public async Task<ActionResult<ItemReorderSettingsDto>> UpdateReorder(int itemId, [FromBody] UpdateReorderRequest request, CancellationToken ct)
         => Ok(await _items.UpdateReorderAsync(itemId, request, ct));
-
-    /// <summary>Replace the item's UOM conversions (FR-MD-02).</summary>
-    [HttpPut("{itemId:int}/uom-conversions")]
-    [ProducesResponseType(typeof(ItemUomConversionsDto), StatusCodes.Status200OK)]
-    [ProducesResponseType(StatusCodes.Status404NotFound)]
-    public async Task<ActionResult<ItemUomConversionsDto>> UpdateUomConversions(int itemId, [FromBody] UpdateUomConversionsRequest request, CancellationToken ct)
-        => Ok(await _items.UpdateUomConversionsAsync(itemId, request, ct));
 }

Backend/ERPCore/Controllers/SalesInvoicesController.cs

@@ -0,0 +1,73 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/sales-invoices")]
+public sealed class SalesInvoicesController : ApiControllerBase
+{
+    private readonly ISalesInvoiceService _invoices;
+
+    public SalesInvoicesController(ISalesInvoiceService invoices) => _invoices = invoices;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesInvoiceSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesInvoiceSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] SalesInvoiceStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{salesInvoiceId:int}")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesInvoiceDto>> GetById(int salesInvoiceId, CancellationToken ct)
+    {
+        var result = await _invoices.GetAsync(salesInvoiceId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpGet("{salesInvoiceId:int}/posting-check")]
+    [ProducesResponseType(typeof(SalesInvoicePostingCheckDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesInvoicePostingCheckDto>> PostingCheck(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.CheckPostingAsync(salesInvoiceId, ct));
+
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<SalesInvoiceDto>> Create([FromBody] CreateSalesInvoiceRequest request, CancellationToken ct)
+    {
+        var result = await _invoices.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/sales-invoices/{result.Value.SalesInvoiceId}", result.Value);
+    }
+
+    [HttpPut("{salesInvoiceId:int}")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<SalesInvoiceDto>> Update(int salesInvoiceId, [FromBody] UpdateSalesInvoiceRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _invoices.UpdateAsync(salesInvoiceId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{salesInvoiceId:int}/post")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesInvoiceDto>> Post(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.PostAsync(salesInvoiceId, ct));
+
+    [HttpPost("{salesInvoiceId:int}/cancel")]
+    [ProducesResponseType(typeof(SalesInvoiceDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesInvoiceDto>> Cancel(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.CancelAsync(salesInvoiceId, ct));
+}

Backend/ERPCore/Controllers/SalesReportsController.cs

@@ -0,0 +1,35 @@
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/reports/sales")]
+public sealed class SalesReportsController : ApiControllerBase
+{
+    private readonly ISalesReportService _reports;
+
+    public SalesReportsController(ISalesReportService reports) => _reports = reports;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesReportDefinitionDto>), StatusCodes.Status200OK)]
+    public ActionResult<IReadOnlyList<SalesReportDefinitionDto>> ListReports()
+        => Ok(_reports.ListReports());
+
+    [HttpGet("{reportId}")]
+    [ProducesResponseType(typeof(SalesReportDefinitionDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public ActionResult<SalesReportDefinitionDto> GetReport(string reportId)
+    {
+        var report = _reports.GetReport(reportId);
+        return report is null ? NotFound() : Ok(report);
+    }
+
+    [HttpPost("query")]
+    [ProducesResponseType(typeof(SalesReportQueryResponse), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesReportQueryResponse>> Query([FromBody] SalesReportQueryRequest request, CancellationToken ct)
+    {
+        var rows = await _reports.QueryAsync(request.ReportType, request.From, request.To, request.ItemId, request.CustomerId, request.WarehouseId, ct);
+        return Ok(new SalesReportQueryResponse(request.ReportType, request.From, request.To, rows));
+    }
+}

Backend/ERPCore/Controllers/SalesReturnsController.cs

@@ -0,0 +1,49 @@
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Sales-return endpoints — customer returns of previously sold goods.</summary>
+[Route("api/v1/sales-returns")]
+public sealed class SalesReturnsController : ApiControllerBase
+{
+    private readonly ISalesReturnService _returns;
+
+    public SalesReturnsController(ISalesReturnService returns) => _returns = returns;
+
+    /// <summary>List posted returns, newest first.</summary>
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesReturnSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesReturnSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] int? customerId, [FromQuery] int? warehouseId, CancellationToken ct)
+        => Ok(await _returns.ListAsync(query, customerId, warehouseId, ct));
+
+    /// <summary>Remaining returnable qty per line of one sales invoice (invoiced qty minus already-returned).</summary>
+    [HttpGet("remaining")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoiceLineRemainingDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<SalesInvoiceLineRemainingDto>>> GetRemaining([FromQuery] int salesInvoiceId, CancellationToken ct)
+        => Ok(await _returns.GetRemainingByInvoiceAsync(salesInvoiceId, ct));
+
+    /// <summary>Get one return with its lines and the ledger entries it posted.</summary>
+    [HttpGet("{returnId:int}")]
+    [ProducesResponseType(typeof(SalesReturnDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesReturnDto>> GetById(int returnId, CancellationToken ct)
+    {
+        var dto = await _returns.GetAsync(returnId, ct);
+        return dto is null ? NotFound() : Ok(dto);
+    }
+
+    /// <summary>Create + auto-post a return (inbound movement).</summary>
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesReturnDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<SalesReturnDto>> Create([FromBody] CreateSalesReturnRequest request, CancellationToken ct)
+    {
+        var dto = await _returns.CreateAsync(request, ct);
+        return Created($"/api/v1/sales-returns/{dto.ReturnId}", dto);
+    }
+}

Backend/ERPCore/Controllers/SalesSlipPromotionsController.cs

@@ -0,0 +1,22 @@
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/sales-slips/{salesSlipId:int}/free-issue-suggestions")]
+public sealed class SalesSlipPromotionsController : ApiControllerBase
+{
+    private readonly ISalesPromotionSuggestionService _suggestions;
+
+    public SalesSlipPromotionsController(ISalesPromotionSuggestionService suggestions) => _suggestions = suggestions;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(SalesFreeIssueSuggestionDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesFreeIssueSuggestionDto>> Get(int salesSlipId, CancellationToken ct)
+    {
+        var result = await _suggestions.GetFreeIssueSuggestionsAsync(salesSlipId, ct);
+        return result is null ? NotFound() : Ok(result);
+    }
+}

Backend/ERPCore/Controllers/SalesSlipsController.cs

@@ -0,0 +1,73 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/sales-slips")]
+public sealed class SalesSlipsController : ApiControllerBase
+{
+    private readonly ISalesSlipService _slips;
+
+    public SalesSlipsController(ISalesSlipService slips) => _slips = slips;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesSlipSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesSlipSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] SalesSlipStatus? status,
+        [FromQuery] int? customerId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _slips.ListAsync(query, status, customerId, warehouseId, ct));
+
+    [HttpGet("{salesSlipId:int}")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesSlipDto>> GetById(int salesSlipId, CancellationToken ct)
+    {
+        var result = await _slips.GetAsync(salesSlipId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpGet("{salesSlipId:int}/posting-check")]
+    [ProducesResponseType(typeof(SalesSlipPostingCheckDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesSlipPostingCheckDto>> PostingCheck(int salesSlipId, CancellationToken ct)
+        => Ok(await _slips.CheckPostingAsync(salesSlipId, ct));
+
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<SalesSlipDto>> Create([FromBody] CreateSalesSlipRequest request, CancellationToken ct)
+    {
+        var result = await _slips.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/sales-slips/{result.Value.SalesSlipId}", result.Value);
+    }
+
+    [HttpPut("{salesSlipId:int}")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<SalesSlipDto>> Update(int salesSlipId, [FromBody] UpdateSalesSlipRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _slips.UpdateAsync(salesSlipId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{salesSlipId:int}/post")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesSlipDto>> Post(int salesSlipId, CancellationToken ct)
+        => Ok(await _slips.PostAsync(salesSlipId, ct));
+
+    [HttpPost("{salesSlipId:int}/cancel")]
+    [ProducesResponseType(typeof(SalesSlipDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesSlipDto>> Cancel(int salesSlipId, CancellationToken ct)
+        => Ok(await _slips.CancelAsync(salesSlipId, ct));
+}

Backend/ERPCore/Domain/DocumentTypes.cs

@@ -17,4 +17,8 @@ public static class DocumentTypes
 
     /// <summary>Production run (docs/30 FR-MFG-08) — <c>PRD-2026-00001</c>.</summary>
     public const string Production = "PRD";
+    public const string SalesInvoice = "SI";
+    public const string SalesSlip = "SSL";
+    public const string BundleSale = "BND";
+    public const string SalesReturn = "SRET";
 }

Backend/ERPCore/Domain/Entities/BundleSale.cs

@@ -0,0 +1,33 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class BundleSale
+{
+    public int BundleSaleId { get; set; }
+    public string BundleNo { get; set; } = string.Empty;
+    public DateTime BundleDate { get; set; }
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+    public string CustomerSnapshotName { get; set; } = string.Empty;
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+    public int CashierUserId { get; set; }
+    public User? CashierUser { get; set; }
+    public int BundleSaleTemplateId { get; set; }
+    public BundleSaleTemplate? BundleSaleTemplate { get; set; }
+    public string BundleName { get; set; } = string.Empty;
+    public string BundleCode { get; set; } = string.Empty;
+    public BundleSaleStatus Status { get; set; } = BundleSaleStatus.Draft;
+    public decimal ComponentSubtotal { get; set; }
+    public decimal BundlePrice { get; set; }
+    public decimal MarginAmount { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public int ConcurrencyStamp { get; set; }
+
+    public ICollection<BundleSaleLine> Lines { get; set; } = new List<BundleSaleLine>();
+}

Backend/ERPCore/Domain/Entities/BundleSaleLine.cs

@@ -0,0 +1,22 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class BundleSaleLine
+{
+    public int BundleSaleLineId { get; set; }
+    public int BundleSaleId { get; set; }
+    public BundleSale? BundleSale { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+    public string Description { get; set; } = string.Empty;
+    public decimal Qty { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+    public decimal UnitPrice { get; set; }
+    public decimal LineTotal { get; set; }
+    public bool IncludeInBundle { get; set; } = true;
+    public bool IsComponent { get; set; } = true;
+    public int? ParentLineId { get; set; }
+}

Backend/ERPCore/Domain/Entities/BundleSaleTemplate.cs

@@ -0,0 +1,17 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class BundleSaleTemplate
+{
+    public int BundleSaleTemplateId { get; set; }
+    public string TemplateCode { get; set; } = string.Empty;
+    public string TemplateName { get; set; } = string.Empty;
+    public string? Description { get; set; }
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+    public int ConcurrencyStamp { get; set; }
+
+    public ICollection<BundleSaleTemplateLine> Lines { get; set; } = new List<BundleSaleTemplateLine>();
+}

Backend/ERPCore/Domain/Entities/BundleSaleTemplateLine.cs

@@ -0,0 +1,18 @@
+namespace ERPCore.Domain.Entities;
+
+public class BundleSaleTemplateLine
+{
+    public int BundleSaleTemplateLineId { get; set; }
+    public int BundleSaleTemplateId { get; set; }
+    public BundleSaleTemplate? BundleSaleTemplate { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public decimal Qty { get; set; }
+    public decimal UnitPrice { get; set; }
+    public bool IncludeInBundle { get; set; } = true;
+    public int SortOrder { get; set; }
+}

Backend/ERPCore/Domain/Entities/Customer.cs

@@ -0,0 +1,38 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Customer master for both B2B and B2C sales.
+/// Phase 1 keeps this lean: identity, contact, tax, credit, and default warehouse.
+/// </summary>
+public class Customer
+{
+    public int CustomerId { get; set; }
+    public string CustomerCode { get; set; } = string.Empty;
+    public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+
+    public string Name { get; set; } = string.Empty;
+    public string? DisplayName { get; set; }
+    public string? Phone { get; set; }
+    public string? Email { get; set; }
+
+    public string? AddressLine1 { get; set; }
+    public string? AddressLine2 { get; set; }
+    public string? City { get; set; }
+    public string? Country { get; set; }
+
+    public string? TaxRegistrationNo { get; set; }
+    public decimal CreditLimit { get; set; }
+    public int CreditDays { get; set; }
+
+    public int? DefaultWarehouseId { get; set; }
+    public Warehouse? DefaultWarehouse { get; set; }
+
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/GrnLine.cs

@@ -25,9 +25,6 @@ public class GrnLine
     public int ItemId { get; set; }
     public Item? Item { get; set; }
 
-    public int UomId { get; set; }
-    public Uom? Uom { get; set; }
-
     public int? BinId { get; set; }
     public Bin? Bin { get; set; }
 
@@ -61,4 +58,11 @@ public class GrnLine
     public decimal LineTotal { get; set; }
 
     public HoldStatus HoldStatus { get; set; } = HoldStatus.Available;
+
+    /// <summary>
+    /// One row per received unit when <see cref="Item.Warranty"/> is
+    /// <see cref="Enums.Warranty.Warranty"/> — count must equal <see cref="Qty"/>.
+    /// Empty for a non-warranty item.
+    /// </summary>
+    public ICollection<GrnLineWarrantyNumber> WarrantyNumbers { get; set; } = new List<GrnLineWarrantyNumber>();
 }

Backend/ERPCore/Domain/Entities/GrnLineWarrantyNumber.cs

@@ -0,0 +1,20 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One warranty number captured against a single received unit of a warranty-tracked
+/// item (<see cref="Item.Warranty"/> = <see cref="Enums.Warranty.Warranty"/>). A GRN line
+/// for such an item must carry exactly <see cref="GrnLine.Qty"/> of these — one per unit —
+/// mirroring how a Serial-tracked item requires one serial per unit (docs/10 Part C.3).
+/// </summary>
+public class GrnLineWarrantyNumber
+{
+    public int GrnLineWarrantyNumberId { get; set; }
+
+    public int GrnLineId { get; set; }
+    public GrnLine? GrnLine { get; set; }
+
+    public string WarrantyNo { get; set; } = string.Empty;
+
+    /// <summary>Warranty coverage length in months, selected at receipt (e.g. 3/6/12/18).</summary>
+    public int WarrantyPeriodMonths { get; set; }
+}

Backend/ERPCore/Domain/Entities/Item.cs

@@ -24,6 +24,12 @@ public class Item
     public int? BrandId { get; set; }
     public Brand? Brand { get; set; }
 
+    /// <summary>
+    /// The stocking unit — the pack the item is counted in (BOTTLE, PACKET, BOX, PCS).
+    /// <b>Every</b> quantity in the system is a count of these: stock layers, the ledger,
+    /// and every document line. Nothing converts, so this is the sole meaning of a
+    /// quantity and cannot be changed once the item has stock history.
+    /// </summary>
     public int BaseUomId { get; set; }
     public Uom? BaseUom { get; set; }
 
@@ -32,6 +38,9 @@ public class Item
 
     public StockNature StockNature { get; set; }
     public TrackingMode TrackingMode { get; set; }
+    public Warranty Warranty { get; set; } = Warranty.NonWarranty;
+    /// <summary>Coverage length in months (see <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; null otherwise.</summary>
+    public int? WarrantyPeriodMonths { get; set; }
     public string? TaxClass { get; set; }
 
     /// <summary>
@@ -41,6 +50,34 @@ public class Item
     /// </summary>
     public decimal? SalePrice { get; set; }
 
+    /// <summary>
+    /// How much one pack holds, as the user entered it — <c>500</c> with
+    /// <see cref="ContentUnit"/> <c>Ml</c> for a 500 ml bottle, <c>1.5</c> with <c>L</c>
+    /// for a 1.5 L one. Null (together with the other three) when the item has no
+    /// measurable content: a screw, a label, a service.
+    /// <para>
+    /// Content never affects stock — that is always a pack count. It exists so production
+    /// can express a formula in millilitres or grams and resolve it to packs
+    /// (see <c>IItemMeasure</c>).
+    /// </para>
+    /// <para>
+    /// A loose bulk item bought by weight is modelled the same way:
+    /// <c>BaseUom = KG, ContentQty = 1, ContentUnit = Kg</c> ⇒ 1000 g per stocked unit.
+    /// </para>
+    /// </summary>
+    public decimal? ContentQty { get; set; }
+    public MeasureUnit? ContentUnit { get; set; }
+
+    /// <summary>
+    /// <see cref="ContentQty"/>/<see cref="ContentUnit"/> normalised to a base unit
+    /// (L→Ml, Kg→G, both ×1000) at write time by <c>ItemContent.Normalize</c>. Server-derived
+    /// and never accepted from a client. <see cref="ContentBaseUnit"/> is therefore only ever
+    /// <see cref="MeasureUnit.Ml"/> or <see cref="MeasureUnit.G"/>.
+    /// <para>Stored rather than recomputed so every consumer reads one settled number.</para>
+    /// </summary>
+    public decimal? ContentBaseQty { get; set; }
+    public MeasureUnit? ContentBaseUnit { get; set; }
+
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
     public DateTime CreatedAt { get; set; }
@@ -50,5 +87,4 @@ public class Item
     public uint RowVersion { get; set; }
 
     public ICollection<ItemReorder> ReorderSettings { get; set; } = new List<ItemReorder>();
-    public ICollection<UomConversion> UomConversions { get; set; } = new List<UomConversion>();
 }

Backend/ERPCore/Domain/Entities/ItemType.cs

@@ -7,12 +7,15 @@ namespace ERPCore.Domain.Entities;
 /// Material.
 /// <para>
 /// <b>Deliberately unlinked.</b> Nothing references this entity and it references
-/// nothing: there is no value table and no join to <see cref="Item"/>. Its only job is
+/// nothing: there is no value table and no join to <see cref="Item"/>. The chosen
-/// to feed the frontend's item-builder dropdown via <c>GET /item-types</c>. The chosen
 /// values (Red, S, M) are encoded by the client into the generated SKU
 /// (e.g. <c>BL-100-0003</c>) and are never stored or parsed server-side — the item list
 /// is the record of what was built. See the accepted trade-off in docs/10 Part C.9.
 /// </para>
+/// <para>
+/// It does, however, carry one piece of meaning the client acts on:
+/// <see cref="IsMeasurable"/>. So this is no longer purely a dropdown source.
+/// </para>
 /// Not to be confused with <see cref="Enums.StockNature"/> (Stocked/NonStocked/Service),
 /// which is what the old <c>ItemType</c> enum became.
 /// Model: docs/10-BACKEND-PHASE1.md Part C.1.
@@ -21,6 +24,24 @@ public class ItemType
 {
     public int ItemTypeId { get; set; }
     public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// When true, this dimension's values are content <b>measurements</b> (500 ml, 1 L) rather
+    /// than plain labels (Red, S). The item builder then captures a number + unit per value and
+    /// stamps that pair onto each generated item's <see cref="Item.ContentQty"/> /
+    /// <see cref="Item.ContentUnit"/>, instead of copying one form-level pair into every variant
+    /// — which is what makes "Coca-Cola in 500 ml / 1 L / 250 ml" three correctly sized items.
+    /// <para>
+    /// This is what lets an apparel <c>Size</c> (S/M/L) stay plain text while a
+    /// <c>Pack Size</c>/<c>Volume</c> dimension carries ml/g/L/kg.
+    /// </para>
+    /// <para>
+    /// A client hint only: the server never reads it when writing an item. Each item's pair is
+    /// still validated and normalised on its own by <c>ItemContent</c>.
+    /// </para>
+    /// </summary>
+    public bool IsMeasurable { get; set; }
+
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
     public DateTime CreatedAt { get; set; }

Backend/ERPCore/Domain/Entities/PoLine.cs

@@ -15,9 +15,6 @@ public class PoLine
     public int ItemId { get; set; }
     public Item? Item { get; set; }
 
-    public int UomId { get; set; }
-    public Uom? Uom { get; set; }
-
     public int WarehouseId { get; set; }
     public Warehouse? Warehouse { get; set; }
 

Backend/ERPCore/Domain/Entities/RunStageInput.cs

@@ -31,10 +31,14 @@ public class RunStageInput
     public int? FromRunOutputId { get; set; }
     public RunStageOutput? FromRunOutput { get; set; }
 
-    public int UomId { get; set; }
+    /// <summary>Copied from the template input: what <see cref="PlannedQty"/> is expressed in.</summary>
-    public Uom? Uom { get; set; }
+    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
 
-    /// <summary>Scaled at creation; per-run editable until the stage starts (FR-MFG-08, <c>409 STAGE_NOT_EDITABLE</c>).</summary>
+    /// <summary>
+    /// Scaled at creation; per-run editable until the stage starts (FR-MFG-08,
+    /// <c>409 STAGE_NOT_EDITABLE</c>). Expressed in <see cref="QtyUnit"/> — so unlike the
+    /// consumption figures below it is <b>not</b> necessarily a pack count.
+    /// </summary>
     public decimal PlannedQty { get; set; }
 
     /// <summary>

Backend/ERPCore/Domain/Entities/RunStageOutput.cs

@@ -23,10 +23,17 @@ public class RunStageOutput
 
     public string Name { get; set; } = string.Empty;
 
-    public int UomId { get; set; }
+    /// <summary>
+    /// Display label for intermediate WIP; null on the terminal output, whose unit is the
+    /// finished item's base UOM. Never converted — see <see cref="StageOutput.UomId"/>.
+    /// </summary>
+    public int? UomId { get; set; }
     public Uom? Uom { get; set; }
 
-    /// <summary>Scaled at creation; per-run editable until the stage starts.</summary>
+    /// <summary>
+    /// Scaled at creation; per-run editable until the stage starts. Every quantity on an
+    /// output is a pack count, so scrap is recorded in whole broken bottles rather than ml.
+    /// </summary>
     public decimal PlannedQty { get; set; }
 
     /// <summary>Recorded at complete. A re-complete after a rework <b>overwrites</b> this, never adds to it.</summary>

Backend/ERPCore/Domain/Entities/SalesInvoice.cs

@@ -0,0 +1,41 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesInvoice
+{
+    public int SalesInvoiceId { get; set; }
+    public string InvoiceNo { get; set; } = string.Empty;
+    public DateTime InvoiceDate { get; set; }
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public string CustomerSnapshotName { get; set; } = string.Empty;
+    public string? CustomerSnapshotTaxNo { get; set; }
+
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    public SalesInvoiceStatus Status { get; set; } = SalesInvoiceStatus.Draft;
+
+    public decimal Subtotal { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public decimal RoundOff { get; set; }
+    public decimal NetPayable { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<SalesInvoiceLine> Lines { get; set; } = new List<SalesInvoiceLine>();
+}

Backend/ERPCore/Domain/Entities/SalesInvoiceLine.cs

@@ -0,0 +1,36 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesInvoiceLine
+{
+    public int SalesInvoiceLineId { get; set; }
+
+    public int SalesInvoiceId { get; set; }
+    public SalesInvoice? SalesInvoice { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Description { get; set; } = string.Empty;
+
+    public decimal Qty { get; set; }
+    public decimal FreeQty { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public decimal UnitPrice { get; set; }
+    public decimal BaseCost { get; set; }
+    public string PriceSource { get; set; } = string.Empty;
+    public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    public decimal DiscountPct { get; set; }
+    public decimal DiscountAmount { get; set; }
+    public decimal NetUnitPrice { get; set; }
+    public decimal LineTotal { get; set; }
+    public decimal TaxPct { get; set; }
+    public decimal TaxAmount { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesReturn.cs

@@ -0,0 +1,32 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Sales return header — a customer returns previously sold goods, generating an
+/// inbound stock movement. Auto-posts with a mandatory reason code, mirroring
+/// <see cref="PurchaseReturn"/> with the direction reversed.
+/// </summary>
+public class SalesReturn
+{
+    public int ReturnId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public int ReasonCodeId { get; set; }
+    public ReasonCode? ReasonCode { get; set; }
+
+    public ReturnStatus Status { get; set; } = ReturnStatus.Posted;
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    public ICollection<SalesReturnLine> Lines { get; set; } = new List<SalesReturnLine>();
+}

Backend/ERPCore/Domain/Entities/SalesReturnLine.cs

@@ -0,0 +1,21 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Sales-return line referencing the original sales invoice line for traceability.
+/// <see cref="Qty"/> is in base UOM.
+/// </summary>
+public class SalesReturnLine
+{
+    public int ReturnLineId { get; set; }
+
+    public int ReturnId { get; set; }
+    public SalesReturn? Return { get; set; }
+
+    public int? SalesInvoiceLineId { get; set; }
+    public SalesInvoiceLine? SalesInvoiceLine { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public decimal Qty { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesSlip.cs

@@ -0,0 +1,36 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesSlip
+{
+    public int SalesSlipId { get; set; }
+    public string SlipNo { get; set; } = string.Empty;
+    public DateTime SlipDate { get; set; }
+
+    public int CustomerId { get; set; }
+    public Customer? Customer { get; set; }
+
+    public string CustomerSnapshotName { get; set; } = string.Empty;
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public int CashierUserId { get; set; }
+    public User? CashierUser { get; set; }
+
+    public SalesSlipStatus Status { get; set; } = SalesSlipStatus.Draft;
+
+    public decimal Subtotal { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<SalesSlipLine> Lines { get; set; } = new List<SalesSlipLine>();
+}

Backend/ERPCore/Domain/Entities/SalesSlipLine.cs

@@ -0,0 +1,36 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+public class SalesSlipLine
+{
+    public int SalesSlipLineId { get; set; }
+
+    public int SalesSlipId { get; set; }
+    public SalesSlip? SalesSlip { get; set; }
+
+    public int ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Description { get; set; } = string.Empty;
+
+    public decimal Qty { get; set; }
+    public decimal FreeQty { get; set; }
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    public decimal UnitPrice { get; set; }
+    public decimal BaseCost { get; set; }
+    public string PriceSource { get; set; } = string.Empty;
+    public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    public decimal DiscountPct { get; set; }
+    public decimal DiscountAmount { get; set; }
+    public decimal NetUnitPrice { get; set; }
+    public decimal LineTotal { get; set; }
+    public decimal TaxPct { get; set; }
+    public decimal TaxAmount { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/StageInput.cs

@@ -32,8 +32,13 @@ public class StageInput
     public int? FromOutputId { get; set; }
     public StageOutput? FromOutput { get; set; }
 
-    public int UomId { get; set; }
+    /// <summary>
-    public Uom? Uom { get; set; }
+    /// What <see cref="QtyPerBatch"/> is expressed in. Stock inputs may use
+    /// <see cref="StageQtyUnit.Content"/> (ml/g) when the item has a content size; Upstream
+    /// inputs are always <see cref="StageQtyUnit.Pack"/> — WIP is counted in the unit its
+    /// source output declares.
+    /// </summary>
+    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
 
     public decimal QtyPerBatch { get; set; }
 }

Backend/ERPCore/Domain/Entities/StageOutput.cs

@@ -20,8 +20,14 @@ public class StageOutput
 
     public string Name { get; set; } = string.Empty;
 
-    public int UomId { get; set; }
+    /// <summary>
+    /// Display label for intermediate work-in-progress. Required when <see cref="ItemId"/>
+    /// is null and must be null when it is set — a real item's unit is its own base UOM.
+    /// WIP never touches stock or the ledger, so this is never converted, only shown.
+    /// </summary>
+    public int? UomId { get; set; }
     public Uom? Uom { get; set; }
 
+    /// <summary>Always a pack count: of the WIP unit above, or of the item's base UOM.</summary>
     public decimal QtyPerBatch { get; set; }
 }

Backend/ERPCore/Domain/Entities/Uom.cs

@@ -1,8 +1,10 @@
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Unit of Measure (FR-MD-02). Referenced as an item's base UOM and as the
+/// Unit of Measure (FR-MD-02). A flat lookup, used as an item's base UOM — the pack every
-/// endpoints of a <see cref="UomConversion"/>. Model: docs/10-BACKEND-PHASE1.md Part C.1.
+/// quantity in the system counts — and as the display label on an intermediate production
+/// output. There are no conversions between UOMs: an item is stocked in exactly one, and a
+/// differently sized pack is a different item. Model: docs/10-BACKEND-PHASE1.md Part C.1.
 /// </summary>
 public class Uom
 {

Backend/ERPCore/Domain/Entities/UomConversion.cs

@@ -1,22 +0,0 @@
-namespace ERPCore.Domain.Entities;
-
-/// <summary>
-/// Per-item conversion factor between two UOMs (FR-MD-02/03): quantity in
-/// <see cref="FromUomId"/> × <see cref="Factor"/> = quantity in <see cref="ToUomId"/>.
-/// Model: docs/10-BACKEND-PHASE1.md Part C.1.
-/// </summary>
-public class UomConversion
-{
-    public int ConversionId { get; set; }
-
-    public int ItemId { get; set; }
-    public Item? Item { get; set; }
-
-    public int FromUomId { get; set; }
-    public Uom? FromUom { get; set; }
-
-    public int ToUomId { get; set; }
-    public Uom? ToUom { get; set; }
-
-    public decimal Factor { get; set; }
-}

Backend/ERPCore/Domain/Enums/BundleSaleStatus.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum BundleSaleStatus
+{
+    Draft = 0,
+    Posted = 1,
+    Cancelled = 2
+}

Backend/ERPCore/Domain/Enums/CustomerType.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum CustomerType
+{
+    B2B = 1,
+    B2C = 2,
+    WalkIn = 3
+}

Backend/ERPCore/Domain/Enums/MeasureUnit.cs

@@ -0,0 +1,23 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Unit of an item's <b>content size</b> — how much a single stocked pack holds
+/// (a 500 ml bottle, a 50 kg sack). Stored as a string in the database.
+/// <para>
+/// This is <b>not</b> a stocking unit. Stock is always counted in packs
+/// (<c>Item.BaseUomId</c>); content is a separate, optional attribute used by
+/// production to turn "2000 ml of syrup" into a pack count.
+/// </para>
+/// <para>
+/// Only <see cref="Ml"/> and <see cref="G"/> are ever stored as a <i>base</i> content
+/// unit. <see cref="L"/> and <see cref="Kg"/> are entry conveniences normalised ×1000
+/// on write by <c>ItemContent.Normalize</c>, so nothing downstream has to convert.
+/// </para>
+/// </summary>
+public enum MeasureUnit
+{
+    Ml,
+    L,
+    G,
+    Kg
+}

Backend/ERPCore/Domain/Enums/SalesDiscountMode.cs

@@ -0,0 +1,7 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesDiscountMode
+{
+    Percentage = 1,
+    Amount = 2
+}

Backend/ERPCore/Domain/Enums/SalesInvoiceStatus.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesInvoiceStatus
+{
+    Draft = 1,
+    Posted = 2,
+    Cancelled = 3
+}

Backend/ERPCore/Domain/Enums/SalesInvoiceType.cs

@@ -0,0 +1,9 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesInvoiceType
+{
+    B2B = 1,
+    B2C = 2,
+    Cash = 3,
+    Credit = 4
+}

Backend/ERPCore/Domain/Enums/SalesSlipStatus.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Enums;
+
+public enum SalesSlipStatus
+{
+    Draft = 1,
+    Posted = 2,
+    Cancelled = 3
+}

Backend/ERPCore/Domain/Enums/StageQtyUnit.cs

@@ -0,0 +1,22 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// What a stage input's quantity is expressed in (FR-MFG-04). Stored as a string.
+/// <para>
+/// Deliberately explicit rather than inferred from whether the item happens to have a
+/// content size: templates outlive item edits, so an inferred unit would let adding a
+/// content size to an existing item silently reinterpret every saved formula — "300"
+/// meaning 300 packs would become 300 ml.
+/// </para>
+/// </summary>
+public enum StageQtyUnit
+{
+    /// <summary>A count of the item's base UOM — bottles, packets, pieces.</summary>
+    Pack,
+
+    /// <summary>
+    /// An amount of the item's content in its base content unit (ml or g), resolved to
+    /// packs by <c>IItemMeasure</c> at stage start. Requires the item to have a content size.
+    /// </summary>
+    Content
+}

Backend/ERPCore/Domain/Enums/Warranty.cs

@@ -0,0 +1,17 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Whether an item is sold under warranty (FR-MD-01). Stored as a string, same
+/// convention as <see cref="StockNature"/> and <see cref="TrackingMode"/>.
+/// </summary>
+public enum Warranty
+{
+    NonWarranty,
+    Warranty
+}
+
+/// <summary>Allowed warranty coverage lengths, in months — set once on the item (FR-MD-01).</summary>
+public static class WarrantyPeriods
+{
+    public static readonly int[] AllowedMonths = { 3, 6, 12, 18 };
+}

Backend/ERPCore/Dtos/Customers/CustomerDtos.cs

@@ -0,0 +1,66 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Customers;
+
+/// <summary>Customer resource used by sales documents.</summary>
+public sealed record CustomerDto(
+    int CustomerId,
+    string CustomerCode,
+    CustomerType CustomerType,
+    string Name,
+    string? DisplayName,
+    string? Phone,
+    string? Email,
+    string? AddressLine1,
+    string? AddressLine2,
+    string? City,
+    string? Country,
+    string? TaxRegistrationNo,
+    decimal CreditLimit,
+    int CreditDays,
+    int? DefaultWarehouseId,
+    EntityStatus Status,
+    DateTime CreatedAt,
+    DateTime? UpdatedAt);
+
+public sealed class CreateCustomerRequest
+{
+    [Required, StringLength(50)] public string CustomerCode { get; set; } = string.Empty;
+    [Required, EnumDataType(typeof(CustomerType))] public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+    [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+    [StringLength(200)] public string? DisplayName { get; set; }
+    [StringLength(30)] public string? Phone { get; set; }
+    [StringLength(100)] public string? Email { get; set; }
+    [StringLength(250)] public string? AddressLine1 { get; set; }
+    [StringLength(250)] public string? AddressLine2 { get; set; }
+    [StringLength(100)] public string? City { get; set; }
+    [StringLength(100)] public string? Country { get; set; }
+    [StringLength(50)] public string? TaxRegistrationNo { get; set; }
+    [Range(0, double.MaxValue)] public decimal CreditLimit { get; set; }
+    [Range(0, int.MaxValue)] public int CreditDays { get; set; }
+    public int? DefaultWarehouseId { get; set; }
+}
+
+public sealed class UpdateCustomerRequest
+{
+    [Required, StringLength(50)] public string CustomerCode { get; set; } = string.Empty;
+    [Required, EnumDataType(typeof(CustomerType))] public CustomerType CustomerType { get; set; } = CustomerType.B2C;
+    [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+    [StringLength(200)] public string? DisplayName { get; set; }
+    [StringLength(30)] public string? Phone { get; set; }
+    [StringLength(100)] public string? Email { get; set; }
+    [StringLength(250)] public string? AddressLine1 { get; set; }
+    [StringLength(250)] public string? AddressLine2 { get; set; }
+    [StringLength(100)] public string? City { get; set; }
+    [StringLength(100)] public string? Country { get; set; }
+    [StringLength(50)] public string? TaxRegistrationNo { get; set; }
+    [Range(0, double.MaxValue)] public decimal CreditLimit { get; set; }
+    [Range(0, int.MaxValue)] public int CreditDays { get; set; }
+    public int? DefaultWarehouseId { get; set; }
+}
+
+public sealed class UpdateCustomerStatusRequest
+{
+    [Required, EnumDataType(typeof(EntityStatus))] public EntityStatus Status { get; set; }
+}

Backend/ERPCore/Dtos/Grn/GrnDtos.cs

@@ -5,12 +5,14 @@ namespace ERPCore.Dtos.Grn;
 
 // Responses (docs/11 §4) --------------------------------------------------------
 
+public sealed record GrnLineWarrantyNumberDto(string WarrantyNo, int WarrantyPeriodMonths);
+
 public sealed record GrnLineDto(
-    int GrnLineId, int? PoLineId, int ItemId, int UomId, int? BinId,
+    int GrnLineId, int? PoLineId, int ItemId, int? BinId,
     decimal Qty, decimal UnitCost, decimal? PoUnitPrice,
     decimal DiscountPct, decimal NetUnitCost, decimal VatPct, decimal VatAmount,
     decimal ReceivedValue, decimal LineTotal, decimal PriceVariance,
-    HoldStatus HoldStatus, int? BatchId);
+    HoldStatus HoldStatus, int? BatchId, IReadOnlyList<GrnLineWarrantyNumberDto> WarrantyNumbers);
 
 public sealed record GrnDto(
     int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, GrnStatus Status,
@@ -44,7 +46,6 @@ public sealed class CreateGrnLineInput
     /// <summary>Set for a PO-based receipt; cost is then derived from the PO line (02-SECURITY C.3).</summary>
     public int? PoLineId { get; set; }
     [Required] public int ItemId { get; set; }
-    [Required] public int UomId { get; set; }
     public int? BinId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     /// <summary>
@@ -59,6 +60,11 @@ public sealed class CreateGrnLineInput
     [Range(0, 100)] public decimal VatPct { get; set; }
     [EnumDataType(typeof(HoldStatus))] public HoldStatus HoldStatus { get; set; } = HoldStatus.Available;
     public BatchInput? Batch { get; set; }
+    /// <summary>
+    /// Required, one per unit (count must equal <see cref="Qty"/>), when the item is
+    /// warranty-tracked (<c>Item.Warranty == Warranty.Warranty</c>). Ignored otherwise.
+    /// </summary>
+    public List<string>? WarrantyNumbers { get; set; }
 }
 
 public sealed class CreateGrnRequest

Backend/ERPCore/Dtos/ItemTypes/ItemTypeDtos.cs

@@ -5,12 +5,16 @@ namespace ERPCore.Dtos.ItemTypes;
 
 /// <summary>
 /// Item type resource (docs/11-BACKEND-PHASE1.md §2.7) — a dimension name such as Color
-/// or Size. Carries no values and no item linkage: <c>GET /item-types</c> exists to
+/// or Size. Carries no values and no item linkage: the chosen values are encoded into the
-/// populate the frontend builder's dropdown, and the chosen values are encoded into the
 /// client-generated SKU rather than stored (docs/10 Part C.9).
+/// <para>
+/// <c>IsMeasurable</c> marks a dimension whose values are content measurements (500 ml, 1 L)
+/// rather than plain labels; the builder captures a number + unit per value and writes it to
+/// each generated item's content size.
+/// </para>
 /// </summary>
 public sealed record ItemTypeDto(
-    int ItemTypeId, string Name, EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
+    int ItemTypeId, string Name, bool IsMeasurable, EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
 
 // Request DTOs — narrow: server-controlled fields (status, ids, timestamps)
 // are intentionally excluded to prevent over-posting (02-SECURITY B.6 / C.1). ----
@@ -18,11 +22,21 @@ public sealed record ItemTypeDto(
 public sealed class CreateItemTypeRequest
 {
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+
+    /// <summary>Omitted ⇒ false, i.e. plain-text values. See <see cref="ItemTypeDto"/>.</summary>
+    public bool IsMeasurable { get; set; }
 }
 
 public sealed class UpdateItemTypeRequest
 {
     [Required, StringLength(200)] public string Name { get; set; } = string.Empty;
+
+    /// <summary>
+    /// Nullable on purpose: a plain <c>bool</c> binds an absent property as <c>false</c>, so any
+    /// client that PUT only a name — as the item-types screen used to — would silently clear the
+    /// flag on every rename. Omitting this field <b>preserves</b> the stored value.
+    /// </summary>
+    public bool? IsMeasurable { get; set; }
 }
 
 public sealed class UpdateItemTypeStatusRequest

Backend/ERPCore/Dtos/Items/ItemDtos.cs

@@ -9,7 +9,11 @@ namespace ERPCore.Dtos.Items;
 public sealed record ItemListItemDto(
     int ItemId, string Sku, string Name, int CategoryId, int? SubCategoryId, int? BrandId,
     int BaseUomId, int? DefaultVendorId, StockNature StockNature, TrackingMode TrackingMode,
-    string? TaxClass, decimal? SalePrice, EntityStatus Status);
+    Warranty Warranty, int? WarrantyPeriodMonths,
+    string? TaxClass, decimal? SalePrice,
+    decimal? ContentQty, MeasureUnit? ContentUnit,
+    decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
+    EntityStatus Status);
 
 /// <summary>A single per-warehouse reorder policy row.</summary>
 public sealed record ItemReorderDto(int WarehouseId, decimal ReorderPoint, decimal ReorderQty);
@@ -17,26 +21,22 @@ public sealed record ItemReorderDto(int WarehouseId, decimal ReorderPoint, decim
 /// <summary>
 /// Full item resource for <c>GET /items/{id}</c> and create/update responses.
 /// <para>
-/// <see cref="Conversions"/> is embedded because they are otherwise unreadable: they can
+/// <c>ContentBaseQty</c>/<c>ContentBaseUnit</c> are echoed back so a detail screen can show
-/// only be written via <c>PUT /items/{id}/uom-conversions</c>, which returns them, but no
+/// what the entered size normalised to (1.5 L ⇒ 1500 ml) — they are server-derived and are
-/// endpoint reads them back — so a detail screen could never show current state before
+/// not accepted on write.
-/// editing. Mirrors how <see cref="Reorder"/> is already inlined.
 /// </para>
 /// </summary>
 public sealed record ItemDetailDto(
     int ItemId, string Sku, string Name, string? Description, int CategoryId,
     int? SubCategoryId, int? BrandId, int BaseUomId, int? DefaultVendorId,
     StockNature StockNature, TrackingMode TrackingMode,
-    string? TaxClass, decimal? SalePrice, EntityStatus Status, IReadOnlyList<ItemReorderDto> Reorder,
+    Warranty Warranty, int? WarrantyPeriodMonths,
-    IReadOnlyList<UomConversionDto> Conversions,
+    string? TaxClass, decimal? SalePrice,
+    decimal? ContentQty, MeasureUnit? ContentUnit,
+    decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
+    EntityStatus Status, IReadOnlyList<ItemReorderDto> Reorder,
     DateTime CreatedAt, DateTime? UpdatedAt);
 
-/// <summary>UOM conversion row (docs/11 §2.2).</summary>
-public sealed record UomConversionDto(int ConversionId, int FromUom, int ToUom, decimal Factor);
-
-/// <summary>Response body for <c>PUT /items/{id}/uom-conversions</c>.</summary>
-public sealed record ItemUomConversionsDto(int ItemId, int BaseUomId, IReadOnlyList<UomConversionDto> Conversions);
-
 /// <summary>Response body for <c>PUT /items/{id}/reorder</c>.</summary>
 public sealed record ItemReorderSettingsDto(IReadOnlyList<ItemReorderDto> Settings);
 
@@ -61,9 +61,20 @@ public sealed class CreateItemRequest
     public int? DefaultVendorId { get; set; }
     [Required, EnumDataType(typeof(StockNature))] public StockNature StockNature { get; set; }
     [EnumDataType(typeof(TrackingMode))] public TrackingMode TrackingMode { get; set; } = TrackingMode.None;
+    [EnumDataType(typeof(Warranty))] public Warranty Warranty { get; set; } = Warranty.NonWarranty;
+    /// <summary>Required (one of <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; ignored otherwise.</summary>
+    public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
     [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
+
+    /// <summary>
+    /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null
+    /// for items with no measurable content. The normalised base pair is derived by the
+    /// server and is deliberately not accepted here.
+    /// </summary>
+    [Range(0.0001, double.MaxValue)] public decimal? ContentQty { get; set; }
+    [EnumDataType(typeof(MeasureUnit))] public MeasureUnit? ContentUnit { get; set; }
 }
 
 public sealed class UpdateItemRequest
@@ -80,9 +91,20 @@ public sealed class UpdateItemRequest
     public int? DefaultVendorId { get; set; }
     [Required, EnumDataType(typeof(StockNature))] public StockNature StockNature { get; set; }
     [EnumDataType(typeof(TrackingMode))] public TrackingMode TrackingMode { get; set; } = TrackingMode.None;
+    [EnumDataType(typeof(Warranty))] public Warranty Warranty { get; set; } = Warranty.NonWarranty;
+    /// <summary>Required (one of <see cref="Enums.WarrantyPeriods.AllowedMonths"/>) when <see cref="Warranty"/> is Warranty; ignored otherwise.</summary>
+    public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
     [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
+
+    /// <summary>
+    /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null
+    /// for items with no measurable content. The normalised base pair is derived by the
+    /// server and is deliberately not accepted here.
+    /// </summary>
+    [Range(0.0001, double.MaxValue)] public decimal? ContentQty { get; set; }
+    [EnumDataType(typeof(MeasureUnit))] public MeasureUnit? ContentUnit { get; set; }
 }
 
 public sealed class UpdateItemStatusRequest
@@ -101,15 +123,3 @@ public sealed class UpdateReorderRequest
 {
     [Required, MinLength(1)] public List<ReorderSettingInput> Settings { get; set; } = new();
 }
-
-public sealed class UomConversionInput
-{
-    [Required] public int FromUom { get; set; }
-    [Required] public int ToUom { get; set; }
-    [Range(0.000001, double.MaxValue)] public decimal Factor { get; set; }
-}
-
-public sealed class UpdateUomConversionsRequest
-{
-    [Required, MinLength(1)] public List<UomConversionInput> Conversions { get; set; } = new();
-}

Backend/ERPCore/Dtos/Procurement/PurchaseOrderDtos.cs

@@ -6,7 +6,7 @@ namespace ERPCore.Dtos.Procurement;
 // Responses (docs/11 §3.3) ------------------------------------------------------
 
 public sealed record PoLineDto(
-    int PoLineId, int ItemId, int UomId, int WarehouseId,
+    int PoLineId, int ItemId, int WarehouseId,
     decimal Qty, decimal UnitPrice, decimal Tax, decimal QtyReceived);
 
 public sealed record PoTotalsDto(decimal SubTotal, decimal Tax, decimal GrandTotal, string Currency);
@@ -25,7 +25,6 @@ public sealed record PurchaseOrderSummaryDto(
 public sealed class CreatePoLineInput
 {
     [Required] public int ItemId { get; set; }
-    [Required] public int UomId { get; set; }
     [Required] public int WarehouseId { get; set; }
     [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
     [Range(0, double.MaxValue)] public decimal UnitPrice { get; set; }

Backend/ERPCore/Dtos/Production/RunDtos.cs

@@ -29,17 +29,23 @@ public sealed record RunSummaryDto(
 /// </summary>
 public sealed record CostPoolDto(decimal Consumed, decimal Returned, decimal Net);
 
+/// <summary>
+/// One input of a run stage. <c>PlannedQty</c> is expressed in <c>QtyUnit</c> — content
+/// (ml/g) or packs — while every consumption figure is always a pack count, so the two are
+/// not directly comparable for a Content input.
+/// </summary>
 public sealed record RunStageInputDto(
-    int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, int UomId,
+    int RunInputId, StageInputSource Source, int? ItemId, int? FromRunOutputId, StageQtyUnit QtyUnit,
     decimal PlannedQty, decimal ConsumedQty, decimal ConsumedValue,
     decimal DeliveredQty, decimal ReturnedQty, decimal ReturnedValue);
 
 /// <summary>
 /// One output of a run stage. <c>AvailableToTransfer</c> is derived — produced − scrapped −
-/// transferred (FR-MFG-12) — and never stored.
+/// transferred (FR-MFG-12) — and never stored. <c>UomId</c> is the WIP label and is null on
+/// the terminal output, whose unit is the finished item's base UOM.
 /// </summary>
 public sealed record RunStageOutputDto(
-    int RunOutputId, int? ItemId, string Name, int UomId,
+    int RunOutputId, int? ItemId, string Name, int? UomId,
     decimal PlannedQty, decimal ProducedQty, decimal ScrappedQty, int? ScrapReasonCodeId,
     decimal TransferredQty, decimal AvailableToTransfer);
 

Backend/ERPCore/Dtos/Production/TemplateDtos.cs

@@ -35,10 +35,11 @@ public sealed record FieldDefDto(
 
 public sealed record StageInputDto(
     int InputId, StageInputSource Source, int? ItemId,
-    int? FromOutputId, string? FromOutputKey, int UomId, decimal QtyPerBatch);
+    int? FromOutputId, string? FromOutputKey, StageQtyUnit QtyUnit, decimal QtyPerBatch);
 
+/// <summary><c>UomId</c> is the WIP label and is null exactly when <c>ItemId</c> is set.</summary>
 public sealed record StageOutputDto(
-    int OutputId, string Key, int? ItemId, string Name, int UomId, decimal QtyPerBatch);
+    int OutputId, string Key, int? ItemId, string Name, int? UomId, decimal QtyPerBatch);
 
 public sealed record TemplateStageDto(
     int StageId, string Key, string Name, string? RoleLabel, int EstimatedMinutes,
@@ -134,8 +135,12 @@ public sealed class SaveInputRequest
     [StringLength(60)]
     public string? FromOutputKey { get; set; }
 
-    [Range(1, int.MaxValue)]
+    /// <summary>
-    public int UomId { get; set; }
+    /// What <see cref="QtyPerBatch"/> means. <c>Content</c> (ml/g) is allowed only on a Stock
+    /// input whose item has a content size; Upstream inputs must be <c>Pack</c>.
+    /// </summary>
+    [EnumDataType(typeof(StageQtyUnit))]
+    public StageQtyUnit QtyUnit { get; set; } = StageQtyUnit.Pack;
 
     [Range(0.0001, double.MaxValue)]
     public decimal QtyPerBatch { get; set; }
@@ -153,8 +158,12 @@ public sealed class SaveOutputRequest
     [Required, StringLength(150, MinimumLength = 1)]
     public string Name { get; set; } = string.Empty;
 
+    /// <summary>
+    /// The WIP display unit. Required when <see cref="ItemId"/> is null; must be null when it
+    /// is set, because a real item's unit is its own base UOM.
+    /// </summary>
     [Range(1, int.MaxValue)]
-    public int UomId { get; set; }
+    public int? UomId { get; set; }
 
     [Range(0.0001, double.MaxValue)]
     public decimal QtyPerBatch { get; set; }

Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs

@@ -0,0 +1,82 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+public sealed record BundleSaleLineDto(
+    int BundleSaleLineId, int ItemId, string Description, decimal Qty, int WarehouseId,
+    decimal UnitPrice, decimal LineTotal, bool IncludeInBundle, bool IsComponent, int? ParentLineId);
+
+public sealed record BundleSaleDto(
+    int BundleSaleId, string BundleNo, DateTime BundleDate, int CustomerId, string CustomerSnapshotName,
+    int WarehouseId, int CashierUserId, int BundleSaleTemplateId, string BundleName, string BundleCode,
+    BundleSaleStatus Status, decimal ComponentSubtotal, decimal BundlePrice, decimal MarginAmount,
+    decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal, DateTime CreatedAt, DateTime? UpdatedAt,
+    IReadOnlyList<BundleSaleLineDto> Lines);
+
+public sealed record BundleSaleSummaryDto(
+    int BundleSaleId, string BundleNo, DateTime BundleDate, int CustomerId, string CustomerSnapshotName,
+    int WarehouseId, string BundleName, string BundleCode, BundleSaleStatus Status,
+    decimal ComponentSubtotal, decimal BundlePrice, decimal GrandTotal, DateTime CreatedAt);
+
+public sealed record BundleSaleTemplateLineDto(
+    int BundleSaleTemplateLineId, int ItemId, int WarehouseId, decimal Qty,
+    decimal UnitPrice, bool IncludeInBundle, int SortOrder);
+
+public sealed record BundleSaleTemplateDto(
+    int BundleSaleTemplateId, string TemplateCode, string TemplateName, string? Description,
+    EntityStatus Status, DateTime CreatedAt, DateTime? UpdatedAt, IReadOnlyList<BundleSaleTemplateLineDto> Lines);
+
+public sealed record BundleSaleTemplateSummaryDto(
+    int BundleSaleTemplateId, string TemplateCode, string TemplateName, string? Description,
+    EntityStatus Status, int LineCount, DateTime CreatedAt, DateTime? UpdatedAt);
+
+public sealed record BundleSalePostingIssueDto(
+    int BundleSaleLineId, int ItemId, string ItemSku, string ItemName, int WarehouseId,
+    decimal RequestedQty, decimal AvailableQty, decimal ShortQty);
+
+public sealed record BundleSalePostingCheckDto(
+    int BundleSaleId, string BundleNo, BundleSaleStatus Status, bool CanPost,
+    IReadOnlyList<BundleSalePostingIssueDto> Issues);
+
+public sealed class CreateBundleSaleTemplateLineRequest
+{
+    [Required] public int ItemId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    [Range(0, double.MaxValue)] public decimal UnitPrice { get; set; }
+    public bool IncludeInBundle { get; set; } = true;
+    public int SortOrder { get; set; }
+}
+
+public sealed class CreateBundleSaleTemplateRequest
+{
+    [Required] public string TemplateCode { get; set; } = string.Empty;
+    [Required] public string TemplateName { get; set; } = string.Empty;
+    public string? Description { get; set; }
+    [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class CreateBundleSaleRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required] public int BundleSaleTemplateId { get; set; }
+    [Required] public string BundleName { get; set; } = string.Empty;
+    [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
+    public bool AllowPriceOverride { get; set; }
+    [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class UpdateBundleSaleRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required] public int BundleSaleTemplateId { get; set; }
+    [Required] public string BundleName { get; set; } = string.Empty;
+    [Range(0, double.MaxValue)] public decimal BundlePrice { get; set; }
+    public bool AllowPriceOverride { get; set; }
+    [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();
+}

Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs

@@ -0,0 +1,66 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesInvoiceLineDto(
+    int SalesInvoiceLineId, int ItemId, string Description, decimal Qty, decimal FreeQty,
+    int WarehouseId, decimal UnitPrice, decimal BaseCost, string PriceSource, decimal DiscountPct,
+    decimal DiscountAmount, SalesDiscountMode DiscountMode, decimal NetUnitPrice, decimal LineTotal,
+    decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId);
+
+public sealed record SalesInvoiceTotalsDto(
+    decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
+    decimal RoundOff, decimal NetPayable, decimal PaidAmount, decimal BalanceAmount);
+
+public sealed record SalesInvoiceDto(
+    int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
+    string CustomerSnapshotName, string? CustomerSnapshotTaxNo, int WarehouseId,
+    SalesInvoiceType InvoiceType, SalesInvoiceStatus Status, int CreatedBy, DateTime CreatedAt,
+    DateTime? UpdatedAt, SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
+
+public sealed record SalesInvoiceSummaryDto(
+    int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, SalesInvoiceType InvoiceType,
+    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt);
+
+public sealed record SalesInvoicePostingIssueDto(
+    int SalesInvoiceLineId, int ItemId, string ItemSku, string ItemName, int WarehouseId,
+    decimal RequestedQty, decimal AvailableQty, decimal ShortQty, bool IsFreeIssue);
+
+public sealed record SalesInvoicePostingCheckDto(
+    int SalesInvoiceId, string InvoiceNo, SalesInvoiceStatus Status, bool CanPost,
+    IReadOnlyList<SalesInvoicePostingIssueDto> Issues);
+
+public sealed class CreateSalesInvoiceLineRequest
+{
+    [Required] public int ItemId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    [Range(0, double.MaxValue)] public decimal FreeQty { get; set; }
+    [Range(0, double.MaxValue)] public decimal? UnitPrice { get; set; }
+    public bool AllowManualPriceOverride { get; set; }
+    [Required, EnumDataType(typeof(SalesDiscountMode))] public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    [Range(0, 100)] public decimal DiscountPct { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountAmount { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountValue { get; set; }
+    [Range(0, 100)] public decimal TaxPct { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+}
+
+public sealed class CreateSalesInvoiceRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class UpdateSalesInvoiceRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required, EnumDataType(typeof(SalesInvoiceType))] public SalesInvoiceType InvoiceType { get; set; } = SalesInvoiceType.B2C;
+    [Required, MinLength(1)] public List<CreateSalesInvoiceLineRequest> Lines { get; set; } = new();
+}

Backend/ERPCore/Dtos/Sales/SalesPromotionSuggestionDtos.cs

@@ -0,0 +1,23 @@
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesFreeIssueRewardOptionDto(
+    int ItemId,
+    string Sku,
+    string Name,
+    decimal? SalePrice);
+
+public sealed record SalesFreeIssueSuggestionLineDto(
+    int SalesSlipLineId,
+    int ItemId,
+    string ItemSku,
+    string ItemName,
+    decimal Qty,
+    decimal SuggestedFreeQty,
+    decimal TriggerQty,
+    IReadOnlyList<SalesFreeIssueRewardOptionDto> RewardOptions);
+
+public sealed record SalesFreeIssueSuggestionDto(
+    int SalesSlipId,
+    string SlipNo,
+    DateTime SlipDate,
+    IReadOnlyList<SalesFreeIssueSuggestionLineDto> Lines);

Backend/ERPCore/Dtos/Sales/SalesReportDtos.cs

@@ -0,0 +1,68 @@
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesDailySummaryRowDto(
+    DateOnly Date,
+    int InvoiceCount,
+    int SlipCount,
+    decimal InvoiceSubtotal,
+    decimal SlipSubtotal,
+    decimal DiscountTotal,
+    decimal FreeQtyTotal,
+    decimal TaxTotal,
+    decimal GrandTotal);
+
+public sealed record SalesItemSummaryRowDto(
+    int ItemId,
+    string ItemName,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesCustomerSummaryRowDto(
+    int CustomerId,
+    string CustomerName,
+    int InvoiceCount,
+    int SlipCount,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesWarehouseSummaryRowDto(
+    int WarehouseId,
+    string WarehouseName,
+    int InvoiceCount,
+    int SlipCount,
+    decimal SoldQty,
+    decimal FreeQty,
+    decimal GrossAmount,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesDiscountSummaryRowDto(
+    string DocumentType,
+    string DocumentNo,
+    DateTime DocumentDate,
+    string CustomerName,
+    decimal Subtotal,
+    decimal DiscountTotal,
+    decimal TaxTotal,
+    decimal NetAmount);
+
+public sealed record SalesFreeIssueSummaryRowDto(
+    string DocumentType,
+    string DocumentNo,
+    DateTime DocumentDate,
+    string CustomerName,
+    int ItemId,
+    string ItemName,
+    decimal FreeQty,
+    decimal FreeValue,
+    int WarehouseId,
+    string WarehouseName);

Backend/ERPCore/Dtos/Sales/SalesReportQueryDtos.cs

@@ -0,0 +1,21 @@
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesReportDefinitionDto(
+    string Id,
+    string Name,
+    string Description,
+    IReadOnlyList<string> SupportedFilters);
+
+public sealed record SalesReportQueryRequest(
+    string ReportType,
+    DateOnly From,
+    DateOnly To,
+    int? ItemId = null,
+    int? CustomerId = null,
+    int? WarehouseId = null);
+
+public sealed record SalesReportQueryResponse(
+    string ReportType,
+    DateOnly From,
+    DateOnly To,
+    IReadOnlyList<object> Rows);

Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs

@@ -0,0 +1,43 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+// Responses -----------------------------------------------------------------
+
+public sealed record SalesReturnLineDto(int ReturnLineId, int? SalesInvoiceLineId, int ItemId, decimal Qty);
+
+public sealed record SalesReturnDto(
+    int ReturnId, string DocNo, int CustomerId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
+    int CreatedBy, DateTime CreatedAt, IReadOnlyList<SalesReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+
+/// <summary>Row shape for <c>GET /sales-returns</c> — no lines/ledgerRefs (those need a per-row query).</summary>
+public sealed record SalesReturnSummaryDto(
+    int ReturnId, string DocNo, int CustomerId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
+    int CreatedBy, DateTime CreatedAt, int LineCount, decimal TotalQty);
+
+/// <summary>
+/// Remaining returnable qty for one sales invoice line — the invoiced qty minus
+/// whatever has already been returned against it. The invoice line's own <c>Qty</c>
+/// is never mutated by a return, so this is computed on read from return history.
+/// </summary>
+public sealed record SalesInvoiceLineRemainingDto(int SalesInvoiceLineId, decimal RemainingQty);
+
+// Requests --------------------------------------------------------------------
+
+public sealed class CreateSalesReturnLineInput
+{
+    /// <summary>Original sales invoice line, for traceability against the sale.</summary>
+    public int? SalesInvoiceLineId { get; set; }
+    [Required] public int ItemId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+}
+
+public sealed class CreateSalesReturnRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    /// <summary>Nullable so an omitted value is a distinct <c>REASON_CODE_REQUIRED</c> error.</summary>
+    public int? ReasonCodeId { get; set; }
+    [Required, MinLength(1)] public List<CreateSalesReturnLineInput> Lines { get; set; } = new();
+}

Backend/ERPCore/Dtos/Sales/SalesSlipDtos.cs

@@ -0,0 +1,76 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Sales;
+
+public sealed record SalesSlipLineDto(
+    int SalesSlipLineId, int ItemId, string Description, decimal Qty, decimal FreeQty,
+    int WarehouseId, decimal UnitPrice, decimal BaseCost, string PriceSource, decimal DiscountPct,
+    decimal DiscountAmount, SalesDiscountMode DiscountMode, decimal NetUnitPrice, decimal LineTotal,
+    decimal TaxPct, decimal TaxAmount, bool IsFreeIssue, int? ParentLineId);
+
+public sealed record SalesSlipTotalsDto(
+    decimal Subtotal, decimal DiscountTotal, decimal FreeQtyTotal, decimal TaxTotal, decimal GrandTotal,
+    decimal PaidAmount, decimal BalanceAmount);
+
+public sealed record SalesSlipDto(
+    int SalesSlipId, string SlipNo, DateTime SlipDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, int CashierUserId, SalesSlipStatus Status,
+    DateTime CreatedAt, DateTime? UpdatedAt, SalesSlipTotalsDto Totals, IReadOnlyList<SalesSlipLineDto> Lines);
+
+public sealed record SalesSlipSummaryDto(
+    int SalesSlipId, string SlipNo, DateTime SlipDate, int CustomerId,
+    string CustomerSnapshotName, int WarehouseId, SalesSlipStatus Status,
+    SalesSlipTotalsDto Totals, DateTime CreatedAt);
+
+public sealed record SalesSlipPostingIssueDto(
+    int SalesSlipLineId, int ItemId, string ItemSku, string ItemName, int WarehouseId,
+    decimal RequestedQty, decimal AvailableQty, decimal ShortQty, bool IsFreeIssue);
+
+public sealed record SalesSlipPostingCheckDto(
+    int SalesSlipId, string SlipNo, SalesSlipStatus Status, bool CanPost,
+    IReadOnlyList<SalesSlipPostingIssueDto> Issues);
+
+public sealed record FreeIssueSummaryDto(
+    int SalesSlipId, string SlipNo, SalesSlipStatus Status, DateTime CreatedAt,
+    int WarehouseId, string WarehouseName, int ItemId, string ItemSku, string ItemName,
+    string UomName, decimal Qty, decimal FreeQty, string SchemeLabel);
+
+public sealed record FreeIssueDto(
+    int SalesSlipId, string SlipNo, DateTime SlipDate, SalesSlipStatus Status,
+    int CustomerId, string CustomerSnapshotName, int WarehouseId, string WarehouseName,
+    int CashierUserId, DateTime CreatedAt, DateTime? UpdatedAt, FreeIssueSummaryDto Summary,
+    IReadOnlyList<SalesSlipLineDto> Lines);
+
+public sealed class CreateSalesSlipLineRequest
+{
+    [Required] public int ItemId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Range(0.0001, double.MaxValue)] public decimal Qty { get; set; }
+    [Range(0, double.MaxValue)] public decimal FreeQty { get; set; }
+    [Range(0, double.MaxValue)] public decimal? UnitPrice { get; set; }
+    public bool AllowManualPriceOverride { get; set; }
+    [Required, EnumDataType(typeof(SalesDiscountMode))] public SalesDiscountMode DiscountMode { get; set; } = SalesDiscountMode.Percentage;
+    [Range(0, 100)] public decimal DiscountPct { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountAmount { get; set; }
+    [Range(0, double.MaxValue)] public decimal DiscountValue { get; set; }
+    [Range(0, 100)] public decimal TaxPct { get; set; }
+    public bool IsFreeIssue { get; set; }
+    public int? ParentLineId { get; set; }
+}
+
+public sealed class CreateSalesSlipRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required, MinLength(1)] public List<CreateSalesSlipLineRequest> Lines { get; set; } = new();
+}
+
+public sealed class UpdateSalesSlipRequest
+{
+    [Required] public int CustomerId { get; set; }
+    [Required] public int WarehouseId { get; set; }
+    [Required] public int CashierUserId { get; set; }
+    [Required, MinLength(1)] public List<CreateSalesSlipLineRequest> Lines { get; set; } = new();
+}

Backend/ERPCore/Infra/Gl/GeneralLedgerClient.cs

@@ -0,0 +1,55 @@
+using ERPCore.System.Errors;
+
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// HTTP implementation of <see cref="IGeneralLedgerClient"/>. Registered as a typed
+/// client (`AddHttpClient&lt;IGeneralLedgerClient, GeneralLedgerClient&gt;`) with its
+/// `BaseAddress` bound from `GeneralLedgerService:BaseUrl`. Every call attaches the
+/// shared `GeneralLedgerService:ApiKey` as `X-Api-Key` and streams the request/response
+/// body straight through, unparsed — GL's own response (status, content-type, body) is
+/// returned exactly as received; nothing here reshapes it.
+/// </summary>
+public sealed class GeneralLedgerClient(HttpClient http, IConfiguration configuration) : IGeneralLedgerClient
+{
+    private readonly HttpClient _http = http;
+    private readonly string _apiKey = configuration["GeneralLedgerService:ApiKey"] ?? string.Empty;
+
+    public async Task<GeneralLedgerResponse> SendAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
+    {
+        var relativeUri = path.TrimStart('/') + queryString;
+        using var request = new HttpRequestMessage(method, relativeUri);
+        request.Headers.TryAddWithoutValidation("X-Api-Key", _apiKey);
+
+        if (body is not null && method != HttpMethod.Get)
+        {
+            var content = new StreamContent(body);
+            if (!string.IsNullOrEmpty(contentType))
+                content.Headers.TryAddWithoutValidation("Content-Type", contentType);
+            request.Content = content;
+        }
+
+        HttpResponseMessage response;
+        try
+        {
+            response = await _http.SendAsync(request, ct);
+        }
+        catch (HttpRequestException)
+        {
+            throw new DomainException(ErrorCodes.GlServiceUnavailable, "The General Ledger service is unreachable.", 503);
+        }
+        catch (TaskCanceledException) when (!ct.IsCancellationRequested)
+        {
+            throw new DomainException(ErrorCodes.GlServiceUnavailable, "The General Ledger service timed out.", 503);
+        }
+
+        var responseBody = await response.Content.ReadAsStringAsync(ct);
+        return new GeneralLedgerResponse
+        {
+            StatusCode = (int)response.StatusCode,
+            ContentType = response.Content.Headers.ContentType?.ToString(),
+            Body = responseBody
+        };
+    }
+}

Backend/ERPCore/Infra/Gl/GeneralLedgerResponse.cs

@@ -0,0 +1,15 @@
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// Raw HTTP result from the external General Ledger service — status code, content
+/// type, and body exactly as GL returned them. Deliberately un-reshaped: GL's own
+/// envelope (see the GL service's own API reference) is passed through byte-for-byte
+/// so its camelCase-success/PascalCase-error inconsistency and full decimal precision
+/// survive the hop unchanged (docs/12-GENERAL-LEDGER-INTEGRATION.md).
+/// </summary>
+public sealed class GeneralLedgerResponse
+{
+    public int StatusCode { get; init; }
+    public string? ContentType { get; init; }
+    public string Body { get; init; } = string.Empty;
+}

Backend/ERPCore/Infra/Gl/IGeneralLedgerClient.cs

@@ -0,0 +1,13 @@
+namespace ERPCore.Infra.Gl;
+
+/// <summary>
+/// Typed HTTP transport to the external General Ledger service. Injects the shared
+/// `X-Api-Key` secret and forwards method/path/query/body/content-type verbatim —
+/// see docs/12-GENERAL-LEDGER-INTEGRATION.md. Internal: only
+/// <see cref="ERPCore.Services.Interfaces.IGeneralLedgerService"/> consumes this.
+/// </summary>
+public interface IGeneralLedgerClient
+{
+    Task<GeneralLedgerResponse> SendAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct);
+}

Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleConfiguration.cs

@@ -0,0 +1,46 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class BundleSaleConfiguration : IEntityTypeConfiguration<BundleSale>
+{
+    public void Configure(EntityTypeBuilder<BundleSale> builder)
+    {
+        builder.ToTable("bundle_sales");
+        builder.HasKey(x => x.BundleSaleId);
+        builder.Property(x => x.BundleNo).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.BundleNo).IsUnique();
+        builder.Property(x => x.BundleDate).IsRequired();
+        builder.Property(x => x.CustomerSnapshotName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.BundleName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.BundleCode).IsRequired().HasMaxLength(50);
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(BundleSaleStatus.Draft);
+        builder.Property(x => x.ComponentSubtotal).HasPrecision(18, 4);
+        builder.Property(x => x.BundlePrice).HasPrecision(18, 4);
+        builder.Property(x => x.MarginAmount).HasPrecision(18, 4);
+        builder.Property(x => x.DiscountTotal).HasPrecision(18, 4);
+        builder.Property(x => x.TaxTotal).HasPrecision(18, 4);
+        builder.Property(x => x.GrandTotal).HasPrecision(18, 4);
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.ConcurrencyStamp)
+            .IsRequired()
+            .HasColumnType("integer")
+            .HasDefaultValue(0)
+            .IsConcurrencyToken();
+
+        builder.HasOne(x => x.Customer).WithMany().HasForeignKey(x => x.CustomerId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Warehouse).WithMany().HasForeignKey(x => x.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.CashierUser).WithMany().HasForeignKey(x => x.CashierUserId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.BundleSaleTemplate).WithMany().HasForeignKey(x => x.BundleSaleTemplateId).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.BundleSale)
+            .HasForeignKey(x => x.BundleSaleId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleLineConfiguration.cs

@@ -0,0 +1,23 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class BundleSaleLineConfiguration : IEntityTypeConfiguration<BundleSaleLine>
+{
+    public void Configure(EntityTypeBuilder<BundleSaleLine> builder)
+    {
+        builder.ToTable("bundle_sale_lines");
+        builder.HasKey(x => x.BundleSaleLineId);
+        builder.Property(x => x.Description).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+        builder.Property(x => x.IncludeInBundle).HasDefaultValue(true);
+        builder.Property(x => x.IsComponent).HasDefaultValue(true);
+
+        builder.HasOne(x => x.Item).WithMany().HasForeignKey(x => x.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Warehouse).WithMany().HasForeignKey(x => x.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleTemplateConfiguration.cs

@@ -0,0 +1,34 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class BundleSaleTemplateConfiguration : IEntityTypeConfiguration<BundleSaleTemplate>
+{
+    public void Configure(EntityTypeBuilder<BundleSaleTemplate> builder)
+    {
+        builder.ToTable("bundle_sale_templates");
+        builder.HasKey(x => x.BundleSaleTemplateId);
+
+        builder.Property(x => x.TemplateCode).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.TemplateCode).IsUnique();
+        builder.Property(x => x.TemplateName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.Description).HasMaxLength(1000);
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(EntityStatus.Active);
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.ConcurrencyStamp)
+            .IsRequired()
+            .HasColumnType("integer")
+            .HasDefaultValue(0)
+            .IsConcurrencyToken();
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.BundleSaleTemplate)
+            .HasForeignKey(x => x.BundleSaleTemplateId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/BundleSaleTemplateLineConfiguration.cs

@@ -0,0 +1,20 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class BundleSaleTemplateLineConfiguration : IEntityTypeConfiguration<BundleSaleTemplateLine>
+{
+    public void Configure(EntityTypeBuilder<BundleSaleTemplateLine> builder)
+    {
+        builder.ToTable("bundle_sale_template_lines");
+        builder.HasKey(x => x.BundleSaleTemplateLineId);
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.SortOrder).HasDefaultValue(0);
+
+        builder.HasOne(x => x.Item).WithMany().HasForeignKey(x => x.ItemId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.Warehouse).WithMany().HasForeignKey(x => x.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/CustomerConfiguration.cs

@@ -0,0 +1,50 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class CustomerConfiguration : IEntityTypeConfiguration<Customer>
+{
+    public void Configure(EntityTypeBuilder<Customer> builder)
+    {
+        builder.ToTable("customers");
+        builder.HasKey(c => c.CustomerId);
+
+        builder.Property(c => c.CustomerCode).IsRequired().HasMaxLength(50);
+        builder.HasIndex(c => c.CustomerCode).IsUnique();
+
+        builder.Property(c => c.CustomerType)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(CustomerType.B2C);
+
+        builder.Property(c => c.Name).IsRequired().HasMaxLength(200);
+        builder.Property(c => c.DisplayName).HasMaxLength(200);
+        builder.Property(c => c.Phone).HasMaxLength(30);
+        builder.Property(c => c.Email).HasMaxLength(100);
+        builder.Property(c => c.AddressLine1).HasMaxLength(250);
+        builder.Property(c => c.AddressLine2).HasMaxLength(250);
+        builder.Property(c => c.City).HasMaxLength(100);
+        builder.Property(c => c.Country).HasMaxLength(100);
+        builder.Property(c => c.TaxRegistrationNo).HasMaxLength(50);
+
+        builder.Property(c => c.CreditLimit).HasPrecision(18, 4);
+        builder.Property(c => c.CreditDays).IsRequired();
+
+        builder.HasOne(c => c.DefaultWarehouse)
+            .WithMany()
+            .HasForeignKey(c => c.DefaultWarehouseId)
+            .OnDelete(DeleteBehavior.SetNull);
+
+        builder.Property(c => c.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(EntityStatus.Active);
+
+        builder.Property(c => c.CreatedAt).IsRequired();
+        builder.Property(c => c.RowVersion).IsRowVersion();
+
+        builder.HasIndex(c => c.Status);
+        builder.HasIndex(c => c.CustomerType);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/GrnConfiguration.cs

@@ -49,8 +49,25 @@ public sealed class GrnLineConfiguration : IEntityTypeConfiguration<GrnLine>
         builder.HasOne(l => l.Grn).WithMany(g => g.Lines).HasForeignKey(l => l.GrnId).OnDelete(DeleteBehavior.Cascade);
         builder.HasOne(l => l.PoLine).WithMany().HasForeignKey(l => l.PoLineId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(l => l.Item).WithMany().HasForeignKey(l => l.ItemId).OnDelete(DeleteBehavior.Restrict);
-        builder.HasOne(l => l.Uom).WithMany().HasForeignKey(l => l.UomId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(l => l.Bin).WithMany().HasForeignKey(l => l.BinId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(l => l.Batch).WithMany().HasForeignKey(l => l.BatchId).OnDelete(DeleteBehavior.Restrict);
     }
 }
+
+public sealed class GrnLineWarrantyNumberConfiguration : IEntityTypeConfiguration<GrnLineWarrantyNumber>
+{
+    public void Configure(EntityTypeBuilder<GrnLineWarrantyNumber> builder)
+    {
+        builder.ToTable("grn_line_warranty_numbers");
+        builder.HasKey(w => w.GrnLineWarrantyNumberId);
+
+        builder.Property(w => w.WarrantyNo).IsRequired().HasMaxLength(100);
+
+        builder.HasOne(w => w.GrnLine).WithMany(l => l.WarrantyNumbers)
+            .HasForeignKey(w => w.GrnLineId).OnDelete(DeleteBehavior.Cascade);
+
+        // A warranty number entered twice on the same line is almost certainly a typo —
+        // catch it at the DB, not just client-side.
+        builder.HasIndex(w => new { w.GrnLineId, w.WarrantyNo }).IsUnique();
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/ItemConfiguration.cs

@@ -22,10 +22,23 @@ public sealed class ItemConfiguration : IEntityTypeConfiguration<Item>
         // Sales-only fixed selling price; nullable (null ⇒ sell at stock/FIFO value).
         builder.Property(i => i.SalePrice).HasPrecision(18, 4);
 
+        // Optional content size (how much one stocked pack holds). All four are nullable
+        // together: null ⇒ the item has no measurable content. The base pair is derived
+        // server-side by ItemContent.Normalize and is only ever Ml or G.
+        builder.Property(i => i.ContentQty).HasPrecision(18, 4);
+        builder.Property(i => i.ContentBaseQty).HasPrecision(18, 4);
+        builder.Property(i => i.ContentUnit)
+            .HasConversion<string>().HasMaxLength(20);
+        builder.Property(i => i.ContentBaseUnit)
+            .HasConversion<string>().HasMaxLength(20);
+
         builder.Property(i => i.StockNature)
             .HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(i => i.TrackingMode)
             .HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(i => i.Warranty)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(Warranty.NonWarranty);
         builder.Property(i => i.Status)
             .HasConversion<string>().HasMaxLength(20).IsRequired()
             .HasDefaultValue(EntityStatus.Active);

Backend/ERPCore/Infra/Persistence/Configurations/ItemTypeConfiguration.cs

@@ -19,6 +19,11 @@ public sealed class ItemTypeConfiguration : IEntityTypeConfiguration<ItemType>
         builder.Property(t => t.Name).IsRequired().HasMaxLength(200);
         builder.HasIndex(t => t.Name).IsUnique();
 
+        // false is the only safe default here: EF uses the CLR default as its "unset" sentinel,
+        // so if the store default were true, inserting an explicit false would be mistaken for
+        // "not set" and silently written as true. Sentinel and store default must agree.
+        builder.Property(t => t.IsMeasurable).IsRequired().HasDefaultValue(false);
+
         builder.Property(t => t.Status)
             .HasConversion<string>().HasMaxLength(20).IsRequired()
             .HasDefaultValue(EntityStatus.Active);

Backend/ERPCore/Infra/Persistence/Configurations/NavItemConfiguration.cs

@@ -36,7 +36,10 @@ public sealed class NavItemConfiguration : IEntityTypeConfiguration<NavItem>
             new NavItem { NavItemId = 7, Code = "warehouses", Label = "Warehouses", Href = "/dashboard/warehouse", SortOrder = 7 },
             new NavItem { NavItemId = 8, Code = "orders", Label = "Orders", Href = "/dashboard/orders", SortOrder = 8 },
             new NavItem { NavItemId = 9, Code = "settings", Label = "Settings", Href = "/dashboard/settings", SortOrder = 9 },
-            new NavItem { NavItemId = 10, Code = "help", Label = "Help", Href = "/dashboard/help", SortOrder = 10 }
+            new NavItem { NavItemId = 10, Code = "help", Label = "Help", Href = "/dashboard/help", SortOrder = 10 },
+            new NavItem { NavItemId = 11, Code = "ledgers", Label = "Ledgers", Href = "/dashboard/ledgers", SortOrder = 11 },
+            new NavItem { NavItemId = 12, Code = "accounts", Label = "Accounts", Href = "/dashboard/accounts", SortOrder = 12 },
+            new NavItem { NavItemId = 13, Code = "sales", Label = "Sales", Href = "/dashboard/sales", SortOrder = 13 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/Configurations/PermissionConfiguration.cs

@@ -42,10 +42,26 @@ public sealed class PermissionConfiguration : IEntityTypeConfiguration<Permissio
             new Permission { PermissionId = 16, Code = "NAV:products.configuration", SubNavItemId = 6 },
             new Permission { PermissionId = 17, Code = "NAV:settings.roles", SubNavItemId = 7 },
             new Permission { PermissionId = 18, Code = "NAV:settings.users", SubNavItemId = 8 },
-            new Permission { PermissionId = 19, Code = "NAV:procurement.requisitions", SubNavItemId = 9 },
+            // IDs 28-31 (not 19-22): 19-22 were already claimed by the Ledgers permissions below;
-            new Permission { PermissionId = 20, Code = "NAV:procurement.rfqs", SubNavItemId = 10 },
+            // these procurement rows were never actually migrated into the database before now.
-            new Permission { PermissionId = 21, Code = "NAV:procurement.purchase-orders", SubNavItemId = 11 },
+            new Permission { PermissionId = 28, Code = "NAV:procurement.requisitions", SubNavItemId = 17 },
-            new Permission { PermissionId = 22, Code = "NAV:procurement.purchase-returns", SubNavItemId = 12 }
+            new Permission { PermissionId = 29, Code = "NAV:procurement.rfqs", SubNavItemId = 18 },
+            new Permission { PermissionId = 30, Code = "NAV:procurement.purchase-orders", SubNavItemId = 19 },
+            new Permission { PermissionId = 31, Code = "NAV:procurement.purchase-returns", SubNavItemId = 20 },
+            new Permission { PermissionId = 19, Code = "NAV:ledgers", NavItemId = 11 },
+            new Permission { PermissionId = 20, Code = "NAV:ledgers.trial-balance", SubNavItemId = 9 },
+            new Permission { PermissionId = 21, Code = "NAV:ledgers.balance-sheet", SubNavItemId = 10 },
+            new Permission { PermissionId = 22, Code = "NAV:ledgers.general-ledger", SubNavItemId = 11 },
+            new Permission { PermissionId = 23, Code = "NAV:ledgers.profit-and-loss", SubNavItemId = 12 },
+            new Permission { PermissionId = 24, Code = "NAV:ledgers.cash-flow", SubNavItemId = 13 },
+            new Permission { PermissionId = 25, Code = "NAV:ledgers.budget-vs-actual", SubNavItemId = 14 },
+            new Permission { PermissionId = 27, Code = "NAV:ledgers.tax-report", SubNavItemId = 16 },
+            // Moved under the new Accounts nav item (2026-07-31) — same PermissionId (26), just a
+            // renamed Code, so any role already granted this permission keeps it.
+            new Permission { PermissionId = 26, Code = "NAV:accounts.bank-accounts", SubNavItemId = 15 },
+            new Permission { PermissionId = 32, Code = "NAV:accounts", NavItemId = 12 },
+            new Permission { PermissionId = 33, Code = "NAV:accounts.cheque-books", SubNavItemId = 21 },
+            new Permission { PermissionId = 34, Code = "NAV:accounts.received-cheques", SubNavItemId = 22 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/Configurations/ProductionConfiguration.cs

@@ -91,13 +91,13 @@ public sealed class StageInputConfiguration : IEntityTypeConfiguration<StageInpu
         builder.HasKey(i => i.InputId);
 
         builder.Property(i => i.Source).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(i => i.QtyUnit).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(i => i.QtyPerBatch).HasPrecision(18, 4);
 
         builder.HasOne(i => i.Stage).WithMany(s => s.Inputs)
             .HasForeignKey(i => i.StageId).OnDelete(DeleteBehavior.Cascade);
 
         builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict);
-        builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(i => i.FromOutput).WithMany()
             .HasForeignKey(i => i.FromOutputId).OnDelete(DeleteBehavior.Restrict);
     }
@@ -206,6 +206,7 @@ public sealed class RunStageInputConfiguration : IEntityTypeConfiguration<RunSta
         builder.HasKey(i => i.RunInputId);
 
         builder.Property(i => i.Source).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(i => i.QtyUnit).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(i => i.PlannedQty).HasPrecision(18, 4);
         builder.Property(i => i.ConsumedQty).HasPrecision(18, 4);
         builder.Property(i => i.ConsumedValue).HasPrecision(18, 4);
@@ -217,7 +218,6 @@ public sealed class RunStageInputConfiguration : IEntityTypeConfiguration<RunSta
             .HasForeignKey(i => i.RunStageId).OnDelete(DeleteBehavior.Cascade);
 
         builder.HasOne(i => i.Item).WithMany().HasForeignKey(i => i.ItemId).OnDelete(DeleteBehavior.Restrict);
-        builder.HasOne(i => i.Uom).WithMany().HasForeignKey(i => i.UomId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(i => i.FromRunOutput).WithMany()
             .HasForeignKey(i => i.FromRunOutputId).OnDelete(DeleteBehavior.Restrict);
 

Backend/ERPCore/Infra/Persistence/Configurations/PurchaseOrderConfiguration.cs

@@ -63,11 +63,6 @@ public sealed class PoLineConfiguration : IEntityTypeConfiguration<PoLine>
             .HasForeignKey(l => l.ItemId)
             .OnDelete(DeleteBehavior.Restrict);
 
-        builder.HasOne(l => l.Uom)
-            .WithMany()
-            .HasForeignKey(l => l.UomId)
-            .OnDelete(DeleteBehavior.Restrict);
-
         builder.HasOne(l => l.Warehouse)
             .WithMany()
             .HasForeignKey(l => l.WarehouseId)

Backend/ERPCore/Infra/Persistence/Configurations/SalesInvoiceConfiguration.cs

@@ -0,0 +1,90 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesInvoiceConfiguration : IEntityTypeConfiguration<SalesInvoice>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoice> builder)
+    {
+        builder.ToTable("sales_invoices");
+        builder.HasKey(x => x.SalesInvoiceId);
+
+        builder.Property(x => x.InvoiceNo).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.InvoiceNo).IsUnique();
+
+        builder.Property(x => x.InvoiceDate).IsRequired();
+
+        builder.HasOne(x => x.Customer)
+            .WithMany()
+            .HasForeignKey(x => x.CustomerId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.CustomerSnapshotName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.CustomerSnapshotTaxNo).HasMaxLength(50);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.InvoiceType)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesInvoiceType.B2C);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesInvoiceStatus.Draft);
+
+        foreach (var p in new[] { nameof(SalesInvoice.Subtotal), nameof(SalesInvoice.DiscountTotal), nameof(SalesInvoice.TaxTotal), nameof(SalesInvoice.GrandTotal), nameof(SalesInvoice.RoundOff), nameof(SalesInvoice.NetPayable), nameof(SalesInvoice.PaidAmount), nameof(SalesInvoice.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.InvoiceDate);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.SalesInvoice)
+            .HasForeignKey(x => x.SalesInvoiceId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class SalesInvoiceLineConfiguration : IEntityTypeConfiguration<SalesInvoiceLine>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoiceLine> builder)
+    {
+        builder.ToTable("sales_invoice_lines");
+        builder.HasKey(x => x.SalesInvoiceLineId);
+
+        builder.HasOne(x => x.Item)
+            .WithMany()
+            .HasForeignKey(x => x.ItemId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Description).IsRequired().HasMaxLength(200);
+
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.FreeQty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.BaseCost).HasPrecision(18, 4);
+        builder.Property(x => x.DiscountPct).HasPrecision(9, 4);
+        builder.Property(x => x.DiscountAmount).HasPrecision(18, 4);
+        builder.Property(x => x.NetUnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+        builder.Property(x => x.TaxPct).HasPrecision(9, 4);
+        builder.Property(x => x.TaxAmount).HasPrecision(18, 4);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.PriceSource).HasMaxLength(50);
+        builder.Property(x => x.RowVersion).IsRowVersion();
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SalesReturnConfiguration.cs

@@ -0,0 +1,40 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesReturnConfiguration : IEntityTypeConfiguration<SalesReturn>
+{
+    public void Configure(EntityTypeBuilder<SalesReturn> builder)
+    {
+        builder.ToTable("sales_returns");
+        builder.HasKey(r => r.ReturnId);
+
+        builder.Property(r => r.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(r => r.DocNo).IsUnique();
+
+        builder.Property(r => r.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
+        builder.Property(r => r.CreatedAt).IsRequired();
+
+        builder.HasOne(r => r.Customer).WithMany().HasForeignKey(r => r.CustomerId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.Warehouse).WithMany().HasForeignKey(r => r.WarehouseId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.ReasonCode).WithMany().HasForeignKey(r => r.ReasonCodeId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(r => r.Creator).WithMany().HasForeignKey(r => r.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+    }
+}
+
+public sealed class SalesReturnLineConfiguration : IEntityTypeConfiguration<SalesReturnLine>
+{
+    public void Configure(EntityTypeBuilder<SalesReturnLine> builder)
+    {
+        builder.ToTable("sales_return_lines");
+        builder.HasKey(l => l.ReturnLineId);
+
+        builder.Property(l => l.Qty).HasPrecision(18, 4);
+
+        builder.HasOne(l => l.Return).WithMany(r => r.Lines).HasForeignKey(l => l.ReturnId).OnDelete(DeleteBehavior.Cascade);
+        builder.HasOne(l => l.SalesInvoiceLine).WithMany().HasForeignKey(l => l.SalesInvoiceLineId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(l => l.Item).WithMany().HasForeignKey(l => l.ItemId).OnDelete(DeleteBehavior.Restrict);
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SalesSlipConfiguration.cs

@@ -0,0 +1,90 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesSlipConfiguration : IEntityTypeConfiguration<SalesSlip>
+{
+    public void Configure(EntityTypeBuilder<SalesSlip> builder)
+    {
+        builder.ToTable("sales_slips");
+        builder.HasKey(x => x.SalesSlipId);
+
+        builder.Property(x => x.SlipNo).IsRequired().HasMaxLength(50);
+        builder.HasIndex(x => x.SlipNo).IsUnique();
+
+        builder.Property(x => x.SlipDate).IsRequired();
+
+        builder.HasOne(x => x.Customer)
+            .WithMany()
+            .HasForeignKey(x => x.CustomerId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.CustomerSnapshotName).IsRequired().HasMaxLength(200);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasOne(x => x.CashierUser)
+            .WithMany()
+            .HasForeignKey(x => x.CashierUserId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(SalesSlipStatus.Draft);
+
+        foreach (var p in new[] { nameof(SalesSlip.Subtotal), nameof(SalesSlip.DiscountTotal), nameof(SalesSlip.TaxTotal), nameof(SalesSlip.GrandTotal), nameof(SalesSlip.PaidAmount), nameof(SalesSlip.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.SlipDate);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.SalesSlip)
+            .HasForeignKey(x => x.SalesSlipId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class SalesSlipLineConfiguration : IEntityTypeConfiguration<SalesSlipLine>
+{
+    public void Configure(EntityTypeBuilder<SalesSlipLine> builder)
+    {
+        builder.ToTable("sales_slip_lines");
+        builder.HasKey(x => x.SalesSlipLineId);
+
+        builder.HasOne(x => x.Item)
+            .WithMany()
+            .HasForeignKey(x => x.ItemId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.Description).IsRequired().HasMaxLength(200);
+
+        builder.Property(x => x.Qty).HasPrecision(18, 4);
+        builder.Property(x => x.FreeQty).HasPrecision(18, 4);
+        builder.Property(x => x.UnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.BaseCost).HasPrecision(18, 4);
+        builder.Property(x => x.DiscountPct).HasPrecision(9, 4);
+        builder.Property(x => x.DiscountAmount).HasPrecision(18, 4);
+        builder.Property(x => x.NetUnitPrice).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+        builder.Property(x => x.TaxPct).HasPrecision(9, 4);
+        builder.Property(x => x.TaxAmount).HasPrecision(18, 4);
+
+        builder.HasOne(x => x.Warehouse)
+            .WithMany()
+            .HasForeignKey(x => x.WarehouseId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.PriceSource).HasMaxLength(50);
+        builder.Property(x => x.RowVersion).IsRowVersion();
+    }
+}

Backend/ERPCore/Infra/Persistence/Configurations/SubNavItemConfiguration.cs

@@ -33,11 +33,27 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 6, NavItemId = 2, Code = "products.configuration", Label = "Configuration", Href = "/dashboard/products/settings", SortOrder = 6 },
             new SubNavItem { SubNavItemId = 7, NavItemId = 9, Code = "settings.roles", Label = "Roles", Href = "/dashboard/settings/roles", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 8, NavItemId = 9, Code = "settings.users", Label = "Users", Href = "/dashboard/settings/users", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 23, NavItemId = 13, Code = "sales.bundle-sales", Label = "Bundle Sales", Href = "/dashboard/sales/bundles", SortOrder = 1 },
             // Procurement (NavItemId 4) children — mirror the hub page order.
-            new SubNavItem { SubNavItemId = 9, NavItemId = 4, Code = "procurement.requisitions", Label = "Requisitions", Href = "/dashboard/procurement/requisitions", SortOrder = 1 },
+            // IDs 17-20 (not 9-12): 9-12 were already claimed by the Ledgers sub-items below;
-            new SubNavItem { SubNavItemId = 10, NavItemId = 4, Code = "procurement.rfqs", Label = "RFQs", Href = "/dashboard/procurement/rfqs", SortOrder = 2 },
+            // these procurement rows were never actually migrated into the database before now.
-            new SubNavItem { SubNavItemId = 11, NavItemId = 4, Code = "procurement.purchase-orders", Label = "Purchase Orders", Href = "/dashboard/procurement/purchase-orders", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 17, NavItemId = 4, Code = "procurement.requisitions", Label = "Requisitions", Href = "/dashboard/procurement/requisitions", SortOrder = 1 },
-            new SubNavItem { SubNavItemId = 12, NavItemId = 4, Code = "procurement.purchase-returns", Label = "Purchase Returns", Href = "/dashboard/procurement/purchase-returns", SortOrder = 4 }
+            new SubNavItem { SubNavItemId = 18, NavItemId = 4, Code = "procurement.rfqs", Label = "RFQs", Href = "/dashboard/procurement/rfqs", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 19, NavItemId = 4, Code = "procurement.purchase-orders", Label = "Purchase Orders", Href = "/dashboard/procurement/purchase-orders", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 20, NavItemId = 4, Code = "procurement.purchase-returns", Label = "Purchase Returns", Href = "/dashboard/procurement/purchase-returns", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 9, NavItemId = 11, Code = "ledgers.trial-balance", Label = "Trial Balance", Href = "/dashboard/ledgers/trial-balance", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 10, NavItemId = 11, Code = "ledgers.balance-sheet", Label = "Balance Sheet", Href = "/dashboard/ledgers/balance-sheet", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 11, NavItemId = 11, Code = "ledgers.general-ledger", Label = "General Ledger", Href = "/dashboard/ledgers/general-ledger", SortOrder = 3 },
+            new SubNavItem { SubNavItemId = 12, NavItemId = 11, Code = "ledgers.profit-and-loss", Label = "Profit & Loss", Href = "/dashboard/ledgers/profit-and-loss", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 13, NavItemId = 11, Code = "ledgers.cash-flow", Label = "Cash Flow", Href = "/dashboard/ledgers/cash-flow", SortOrder = 5 },
+            new SubNavItem { SubNavItemId = 14, NavItemId = 11, Code = "ledgers.budget-vs-actual", Label = "Budget vs Actual", Href = "/dashboard/ledgers/budget-vs-actual", SortOrder = 6 },
+            new SubNavItem { SubNavItemId = 16, NavItemId = 11, Code = "ledgers.tax-report", Label = "Tax Report", Href = "/dashboard/ledgers/tax-report", SortOrder = 7 },
+            // Moved under the new Accounts nav item (2026-07-31) — kept the same SubNavItemId (15)
+            // rather than delete+recreate, so any role that already had this permission granted
+            // doesn't silently lose it just because the section it lives under changed.
+            new SubNavItem { SubNavItemId = 15, NavItemId = 12, Code = "accounts.bank-accounts", Label = "Cash / Bank Accounts", Href = "/dashboard/accounts/bank-accounts", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 21, NavItemId = 12, Code = "accounts.cheque-books", Label = "Cheque Books", Href = "/dashboard/accounts/cheque-books", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 22, NavItemId = 12, Code = "accounts.received-cheques", Label = "Received Cheques", Href = "/dashboard/accounts/received-cheques", SortOrder = 3 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/Configurations/UomConversionConfiguration.cs

@@ -1,34 +0,0 @@
-using ERPCore.Domain.Entities;
-using Microsoft.EntityFrameworkCore;
-using Microsoft.EntityFrameworkCore.Metadata.Builders;
-
-namespace ERPCore.Infra.Persistence.Configurations;
-
-public sealed class UomConversionConfiguration : IEntityTypeConfiguration<UomConversion>
-{
-    public void Configure(EntityTypeBuilder<UomConversion> builder)
-    {
-        builder.ToTable("uom_conversions");
-        builder.HasKey(c => c.ConversionId);
-
-        builder.Property(c => c.Factor).HasPrecision(18, 6);
-
-        builder.HasOne(c => c.Item)
-            .WithMany(i => i.UomConversions)
-            .HasForeignKey(c => c.ItemId)
-            .OnDelete(DeleteBehavior.Cascade);
-
-        builder.HasOne(c => c.FromUom)
-            .WithMany()
-            .HasForeignKey(c => c.FromUomId)
-            .OnDelete(DeleteBehavior.Restrict);
-
-        builder.HasOne(c => c.ToUom)
-            .WithMany()
-            .HasForeignKey(c => c.ToUomId)
-            .OnDelete(DeleteBehavior.Restrict);
-
-        // One conversion per (item, from, to) triple.
-        builder.HasIndex(c => new { c.ItemId, c.FromUomId, c.ToUomId }).IsUnique();
-    }
-}

Backend/ERPCore/Infra/Persistence/DataSeeder.cs

@@ -1,4 +1,5 @@
 using ERPCore.Domain.Entities;
+using ERPCore.Domain;
 using ERPCore.Domain.Enums;
 using Microsoft.EntityFrameworkCore;
 
@@ -42,7 +43,11 @@ public static class DataSeeder
     {
         var dirty = await SeedReasonCodesAsync(db, ct);
         dirty |= await SeedItemTypesAsync(db, ct);
+       // dirty |= await SeedCompanyProfileAsync(db, ct);
         dirty |= await SeedProductConfigAsync(db, ct);
+        dirty |= await SeedSalesMastersAsync(db, ct);
+        dirty |= await SeedSalesStockAsync(db, ct);
+        dirty |= await SeedSalesAsync(db, ct);
 
         if (dirty) await db.SaveChangesAsync(ct);
     }
@@ -99,4 +104,747 @@ public static class DataSeeder
         });
         return true;
     }
+
+    /// <summary>
+    /// Seeds a printable company profile with reasonable defaults for invoice headers.
+    /// These values are intentionally editable later through the API.
+    /// </summary>
+    //private static async Task<bool> SeedCompanyProfileAsync(ErpDbContext db, CancellationToken ct)
+    //{
+    //    if (await db.CompanyProfiles.AnyAsync(c => c.CompanyProfileId == CompanyProfile.SingletonId, ct)) return false;
+
+    //    db.CompanyProfiles.Add(new CompanyProfile
+    //    {
+    //        CompanyProfileId = CompanyProfile.SingletonId,
+    //        LegalName = "ERP Core Trading (Pvt) Ltd",
+    //        TradeName = "ERP Core Trading",
+    //        TaxRegistrationNo = "TAX-DEFAULT-001",
+    //        VatRegistrationNo = "VAT-DEFAULT-001",
+    //        AddressLine1 = "1 Demo Street",
+    //        City = "Colombo",
+    //        Country = "Sri Lanka",
+    //        Phone = "+94 11 000 0000",
+    //        Email = "accounts@example.com",
+    //        BankName = "Demo Bank",
+    //        BankBranch = "Colombo Main",
+    //        AccountName = "ERP Core Trading (Pvt) Ltd",
+    //        AccountNumber = "000123456789",
+    //        SwiftCode = "DEMO1234",
+    //        FooterNote = "Thank you for your business."
+    //    });
+    //    return true;
+    //}
+
+    /// <summary>
+    /// Seeds the minimum catalog data required for the sales demo rows to exist.
+    /// These are safe additive rows and do not alter any existing data.
+    /// </summary>
+    private static async Task<bool> SeedSalesMastersAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var dirty = false;
+
+        dirty |= await SeedWarehousesAsync(db, ct);
+        dirty |= await SeedUomsAsync(db, ct);
+        dirty |= await SeedCategoriesAsync(db, ct);
+        dirty |= await SeedItemsAsync(db, ct);
+
+        return dirty;
+    }
+
+    /// <summary>
+    /// Seeds a simple on-hand FIFO layer for the demo sales item so the sample
+    /// invoices can be posted without immediately failing stock validation.
+    /// This keeps the stock-check and posting flows testable on a fresh database.
+    /// </summary>
+    private static async Task<bool> SeedSalesStockAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var warehouse = await db.Warehouses.AsNoTracking()
+            .OrderBy(w => w.WarehouseId)
+            .FirstOrDefaultAsync(ct);
+        var item = await db.Items.AsNoTracking()
+            .OrderBy(i => i.ItemId)
+            .FirstOrDefaultAsync(ct);
+        var secondItem = await db.Items.AsNoTracking()
+            .OrderByDescending(i => i.ItemId)
+            .FirstOrDefaultAsync(ct);
+
+        if (warehouse is null || item is null || secondItem is null)
+            return false;
+
+        var existing = await db.StockLayers.AnyAsync(
+            l => (l.ItemId == item.ItemId || l.ItemId == secondItem.ItemId) && l.WarehouseId == warehouse.WarehouseId && l.QtyRemaining > 0m,
+            ct);
+        if (existing) return false;
+
+        db.StockLayers.Add(new StockLayer
+        {
+            ItemId = item.ItemId,
+            WarehouseId = warehouse.WarehouseId,
+            QtyReceived = 100m,
+            QtyRemaining = 100m,
+            UnitCost = item.SalePrice.GetValueOrDefault() > 0m ? item.SalePrice.GetValueOrDefault() / 2m : 25m,
+            ReceiptDate = DateTime.UtcNow.AddDays(-7)
+        });
+        db.StockLayers.Add(new StockLayer
+        {
+            ItemId = secondItem.ItemId,
+            WarehouseId = warehouse.WarehouseId,
+            QtyReceived = 5m,
+            QtyRemaining = 5m,
+            UnitCost = secondItem.SalePrice.GetValueOrDefault() > 0m ? secondItem.SalePrice.GetValueOrDefault() / 2m : 15m,
+            ReceiptDate = DateTime.UtcNow.AddDays(-6)
+        });
+        return true;
+    }
+
+    private static async Task<bool> SeedWarehousesAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var existingCodes = await db.Warehouses.Select(w => w.Code).ToListAsync(ct);
+        var have = existingCodes.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var seeds = new[]
+        {
+            new Warehouse { Code = "MAIN", Name = "Main Warehouse" },
+            new Warehouse { Code = "SHOP", Name = "Sales Counter" }
+        };
+
+        var toAdd = seeds.Where(w => !have.Contains(w.Code)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.Warehouses.AddRange(toAdd);
+        return true;
+    }
+
+    private static async Task<bool> SeedUomsAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var existingNames = await db.Uoms.Select(u => u.Name).ToListAsync(ct);
+        var have = existingNames.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var seeds = new[]
+        {
+            new Uom { Name = "PCS" },
+            new Uom { Name = "BOX" }
+        };
+
+        var toAdd = seeds.Where(u => !have.Contains(u.Name)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.Uoms.AddRange(toAdd);
+        return true;
+    }
+
+    private static async Task<bool> SeedCategoriesAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var existingNames = await db.Categories.Select(c => c.Name).ToListAsync(ct);
+        var have = existingNames.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var seeds = new[]
+        {
+            new Category { Name = "General Goods", Status = EntityStatus.Active, CreatedAt = DateTime.UtcNow },
+            new Category { Name = "Accessories", Status = EntityStatus.Active, CreatedAt = DateTime.UtcNow }
+        };
+
+        var toAdd = seeds.Where(c => !have.Contains(c.Name)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.Categories.AddRange(toAdd);
+        return true;
+    }
+
+    private static async Task<bool> SeedItemsAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var existingSkus = await db.Items.Select(i => i.Sku).ToListAsync(ct);
+        var have = existingSkus.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var category = await db.Categories.AsNoTracking()
+            .OrderBy(c => c.CategoryId)
+            .FirstOrDefaultAsync(ct);
+        var uom = await db.Uoms.AsNoTracking()
+            .OrderBy(u => u.UomId)
+            .FirstOrDefaultAsync(ct);
+
+        if (category is null || uom is null)
+            return false;
+
+        var now = DateTime.UtcNow;
+        var seeds = new[]
+        {
+            new Item
+            {
+                Sku = "SKU-DEMO-001",
+                Name = "Demo Item 1",
+                Description = "Seeded sample item for sales documents",
+                CategoryId = category.CategoryId,
+                BaseUomId = uom.UomId,
+                StockNature = StockNature.Stocked,
+                TrackingMode = TrackingMode.None,
+                SalePrice = 100m,
+                Status = EntityStatus.Active,
+                CreatedAt = now
+            },
+            new Item
+            {
+                Sku = "SKU-DEMO-002",
+                Name = "Demo Item 2 (500 ml)",
+                Description = "Secondary seeded sample item; carries a content size so the "
+                    + "production content-unit path has a fixture",
+                CategoryId = category.CategoryId,
+                BaseUomId = uom.UomId,
+                StockNature = StockNature.Stocked,
+                TrackingMode = TrackingMode.None,
+                SalePrice = 50m,
+                ContentQty = 500m,
+                ContentUnit = MeasureUnit.Ml,
+                ContentBaseQty = 500m,
+                ContentBaseUnit = MeasureUnit.Ml,
+                Status = EntityStatus.Active,
+                CreatedAt = now
+            }
+        };
+
+        var toAdd = seeds.Where(i => !have.Contains(i.Sku)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.Items.AddRange(toAdd);
+        return true;
+    }
+
+    /// <summary>
+    /// Seeds the minimum sales bootstrap data needed for UI/backend development:
+    /// a couple of customer rows, current-year document counters, and a few draft
+    /// invoice/slip samples when the required master data already exists.
+    /// This intentionally never clears or rewrites any existing rows.
+    /// </summary>
+    private static async Task<bool> SeedSalesAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var dirty = false;
+
+        dirty |= await SeedSalesCustomersAsync(db, ct);
+        dirty |= await SeedSalesSequencesAsync(db, ct);
+        dirty |= await SeedSampleSalesDocsAsync(db, ct);
+
+        try
+        {
+            dirty |= await SeedBundleSalesAsync(db, ct);
+        }
+        catch
+        {
+            // Bundle demo data is best-effort only; never block startup because of seed drift.
+        }
+
+        return dirty;
+    }
+
+    private static async Task<bool> SeedSalesCustomersAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var existingCodes = await db.Customers.Select(c => c.CustomerCode).ToListAsync(ct);
+        var have = existingCodes.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var seeds = new[]
+        {
+            new Customer
+            {
+                CustomerCode = "CUST-WALKIN",
+                CustomerType = CustomerType.B2C,
+                Name = "Walk-in Customer",
+                DisplayName = "Walk-in Customer",
+                CreditLimit = 0m,
+                CreditDays = 0,
+                Status = EntityStatus.Active,
+                CreatedAt = DateTime.UtcNow
+            },
+            new Customer
+            {
+                CustomerCode = "CUST-DEMO",
+                CustomerType = CustomerType.B2B,
+                Name = "Demo Retail Ltd",
+                DisplayName = "Demo Retail Ltd",
+                Phone = "+94 11 000 0000",
+                Email = "sales@example.com",
+                AddressLine1 = "1 Demo Street",
+                City = "Colombo",
+                Country = "Sri Lanka",
+                TaxRegistrationNo = "VAT-DEMO-001",
+                CreditLimit = 250000m,
+                CreditDays = 30,
+                Status = EntityStatus.Active,
+                CreatedAt = DateTime.UtcNow
+            }
+        };
+
+        var toAdd = seeds.Where(c => !have.Contains(c.CustomerCode)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.Customers.AddRange(toAdd);
+        return true;
+    }
+
+    private static async Task<bool> SeedSalesSequencesAsync(ErpDbContext db, CancellationToken ct)
+    {
+        var year = DateTime.UtcNow.Year;
+        var existing = await db.NumberSequences
+            .Where(s => s.Year == year && (s.DocType == DocumentTypes.SalesInvoice || s.DocType == DocumentTypes.SalesSlip || s.DocType == DocumentTypes.BundleSale))
+            .Select(s => s.DocType)
+            .ToListAsync(ct);
+        var have = existing.ToHashSet(StringComparer.OrdinalIgnoreCase);
+
+        var seeds = new[]
+        {
+            new NumberSequence { DocType = DocumentTypes.SalesInvoice, Year = year, LastNumber = 0 },
+            new NumberSequence { DocType = DocumentTypes.SalesSlip, Year = year, LastNumber = 0 },
+            new NumberSequence { DocType = DocumentTypes.BundleSale, Year = year, LastNumber = 0 }
+        };
+
+        var toAdd = seeds.Where(s => !have.Contains(s.DocType)).ToList();
+        if (toAdd.Count == 0) return false;
+
+        db.NumberSequences.AddRange(toAdd);
+        return true;
+    }
+
+    private static async Task<bool> SeedBundleSalesAsync(ErpDbContext db, CancellationToken ct)
+    {
+        if (await db.BundleSaleTemplates.AnyAsync(ct) || await db.BundleSales.AnyAsync(ct))
+            return false;
+
+        var customer = await db.Customers.AsNoTracking()
+            .OrderBy(c => c.CustomerId)
+            .FirstOrDefaultAsync(ct);
+        var warehouse = await db.Warehouses.AsNoTracking()
+            .OrderBy(w => w.WarehouseId)
+            .FirstOrDefaultAsync(ct);
+        var secondaryWarehouse = await db.Warehouses.AsNoTracking()
+            .OrderByDescending(w => w.WarehouseId)
+            .FirstOrDefaultAsync(ct);
+        var items = await db.Items.AsNoTracking()
+            .OrderBy(i => i.ItemId)
+            .Take(2)
+            .ToListAsync(ct);
+        var uom = await db.Uoms.AsNoTracking()
+            .OrderBy(u => u.UomId)
+            .FirstOrDefaultAsync(ct);
+        var user = await db.Users.AsNoTracking()
+            .OrderBy(u => u.UserId)
+            .FirstOrDefaultAsync(ct);
+
+        if (customer is null || warehouse is null || secondaryWarehouse is null || items.Count < 2 || uom is null || user is null)
+            return false;
+
+        var now = DateTime.UtcNow;
+        var template = new BundleSaleTemplate
+        {
+            TemplateCode = "BND-DEMO-001",
+            TemplateName = "Demo Bundle Pack",
+            Description = "Seeded fixed bundle template for integration testing",
+            Status = EntityStatus.Active,
+            CreatedAt = now,
+            Lines =
+            [
+                new BundleSaleTemplateLine
+                {
+                    ItemId = items[0].ItemId,
+                    WarehouseId = warehouse.WarehouseId,
+                    Qty = 1m,
+                    UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                    IncludeInBundle = true,
+                    SortOrder = 1
+                },
+                new BundleSaleTemplateLine
+                {
+                    ItemId = items[1].ItemId,
+                    WarehouseId = warehouse.WarehouseId,
+                    Qty = 1m,
+                    UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                    IncludeInBundle = true,
+                    SortOrder = 2
+                }
+            ]
+        };
+
+        db.BundleSaleTemplates.Add(template);
+        await db.SaveChangesAsync(ct);
+
+        var bundleSales = new[]
+        {
+            new BundleSale
+            {
+                BundleNo = $"BND-{now:yyyy}-00001",
+                BundleDate = now.Date.AddDays(-2),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.DisplayName ?? customer.Name,
+                WarehouseId = warehouse.WarehouseId,
+                CashierUserId = user.UserId,
+                BundleSaleTemplateId = template.BundleSaleTemplateId,
+                BundleName = "Demo Bundle Draft",
+                BundleCode = "BND-DEMO-001",
+                Status = BundleSaleStatus.Draft,
+                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                BundlePrice = 0m,
+                MarginAmount = -(items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()),
+                DiscountTotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                TaxTotal = 0m,
+                GrandTotal = 0m,
+                CreatedAt = now.AddDays(-2),
+                Lines =
+                [
+                    new BundleSaleLine
+                    {
+                        ItemId = items[0].ItemId,
+                        Description = items[0].Name,
+                        Qty = 1m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        IncludeInBundle = true,
+                        IsComponent = true
+                    },
+                    new BundleSaleLine
+                    {
+                        ItemId = items[1].ItemId,
+                        Description = items[1].Name,
+                        Qty = 1m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[1].SalePrice.GetValueOrDefault(),
+                        IncludeInBundle = true,
+                        IsComponent = true
+                    }
+                ]
+            },
+            new BundleSale
+            {
+                BundleNo = $"BND-{now:yyyy}-00002",
+                BundleDate = now.Date.AddDays(-1),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.DisplayName ?? customer.Name,
+                WarehouseId = warehouse.WarehouseId,
+                CashierUserId = user.UserId,
+                BundleSaleTemplateId = template.BundleSaleTemplateId,
+                BundleName = "Demo Bundle Posted",
+                BundleCode = "BND-DEMO-001",
+                Status = BundleSaleStatus.Posted,
+                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                BundlePrice = (items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()) - 10m,
+                MarginAmount = -10m,
+                DiscountTotal = 10m,
+                TaxTotal = 0m,
+                GrandTotal = (items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()) - 10m,
+                CreatedAt = now.AddDays(-1),
+                UpdatedAt = now.AddHours(-2),
+                Lines =
+                [
+                    new BundleSaleLine
+                    {
+                        ItemId = items[0].ItemId,
+                        Description = items[0].Name,
+                        Qty = 1m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        IncludeInBundle = true,
+                        IsComponent = true
+                    },
+                    new BundleSaleLine
+                    {
+                        ItemId = items[1].ItemId,
+                        Description = items[1].Name,
+                        Qty = 1m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[1].SalePrice.GetValueOrDefault(),
+                        IncludeInBundle = true,
+                        IsComponent = true
+                    }
+                ]
+            },
+            new BundleSale
+            {
+                BundleNo = $"BND-{now:yyyy}-00003",
+                BundleDate = now.Date,
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.DisplayName ?? customer.Name,
+                WarehouseId = secondaryWarehouse.WarehouseId,
+                CashierUserId = user.UserId,
+                BundleSaleTemplateId = template.BundleSaleTemplateId,
+                BundleName = "Demo Bundle Cancelled",
+                BundleCode = "BND-DEMO-001",
+                Status = BundleSaleStatus.Cancelled,
+                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault(),
+                BundlePrice = items[0].SalePrice.GetValueOrDefault(),
+                MarginAmount = 0m,
+                DiscountTotal = 0m,
+                TaxTotal = 0m,
+                GrandTotal = items[0].SalePrice.GetValueOrDefault(),
+                CreatedAt = now,
+                UpdatedAt = now,
+                Lines =
+                [
+                    new BundleSaleLine
+                    {
+                        ItemId = items[0].ItemId,
+                        Description = items[0].Name,
+                        Qty = 1m,
+                        WarehouseId = secondaryWarehouse.WarehouseId,
+                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        IncludeInBundle = true,
+                        IsComponent = true
+                    }
+                ]
+            }
+        };
+
+        db.BundleSales.AddRange(bundleSales);
+        return true;
+    }
+
+    private static async Task<bool> SeedSampleSalesDocsAsync(ErpDbContext db, CancellationToken ct)
+    {
+        if (await db.SalesInvoices.AnyAsync(ct) || await db.SalesSlips.AnyAsync(ct))
+            return false;
+
+        var customer = await db.Customers.AsNoTracking()
+            .OrderBy(c => c.CustomerId)
+            .FirstOrDefaultAsync(ct);
+        var warehouse = await db.Warehouses.AsNoTracking()
+            .OrderBy(w => w.WarehouseId)
+            .FirstOrDefaultAsync(ct);
+        var secondaryWarehouse = await db.Warehouses.AsNoTracking()
+            .OrderByDescending(w => w.WarehouseId)
+            .FirstOrDefaultAsync(ct);
+        var items = await db.Items.AsNoTracking()
+            .OrderBy(i => i.ItemId)
+            .Take(2)
+            .ToListAsync(ct);
+        var uom = await db.Uoms.AsNoTracking()
+            .OrderBy(u => u.UomId)
+            .FirstOrDefaultAsync(ct);
+        var user = await db.Users.AsNoTracking()
+            .OrderBy(u => u.UserId)
+            .FirstOrDefaultAsync(ct);
+
+        if (customer is null || warehouse is null || secondaryWarehouse is null || items.Count < 2 || uom is null || user is null)
+            return false;
+
+        var postableItem = items[0];
+        var shortageItem = items[1];
+        var today = DateTime.UtcNow.Date;
+        var createdAt = DateTime.UtcNow.AddDays(-1);
+
+        db.SalesInvoices.AddRange(
+            new SalesInvoice
+            {
+                InvoiceNo = $"SI-{today:yyyy}-00001",
+                InvoiceDate = today.AddDays(-2),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.Name,
+                CustomerSnapshotTaxNo = customer.TaxRegistrationNo,
+                WarehouseId = warehouse.WarehouseId,
+                InvoiceType = SalesInvoiceType.B2C,
+                Status = SalesInvoiceStatus.Draft,
+                Subtotal = 200m,
+                DiscountTotal = 0m,
+                TaxTotal = 0m,
+                GrandTotal = 200m,
+                RoundOff = 0m,
+                NetPayable = 200m,
+                PaidAmount = 0m,
+                BalanceAmount = 200m,
+                CreatedBy = user.UserId,
+                CreatedAt = createdAt,
+                Lines =
+                [
+                    new SalesInvoiceLine
+                    {
+                        ItemId = postableItem.ItemId,
+                        Description = postableItem.Name,
+                        Qty = 2m,
+                        FreeQty = 0m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = 100m,
+                        BaseCost = 0m,
+                        PriceSource = "seed",
+                        DiscountMode = SalesDiscountMode.Percentage,
+                        DiscountPct = 0m,
+                        DiscountAmount = 0m,
+                        NetUnitPrice = 100m,
+                        LineTotal = 200m,
+                        TaxPct = 0m,
+                        TaxAmount = 0m,
+                        IsFreeIssue = false
+                    }
+                ]
+            },
+            new SalesInvoice
+            {
+                InvoiceNo = $"SI-{today:yyyy}-00002",
+                InvoiceDate = today.AddDays(-1),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.Name,
+                CustomerSnapshotTaxNo = customer.TaxRegistrationNo,
+                WarehouseId = secondaryWarehouse.WarehouseId,
+                InvoiceType = SalesInvoiceType.B2B,
+                Status = SalesInvoiceStatus.Draft,
+                Subtotal = 300m,
+                DiscountTotal = 0m,
+                TaxTotal = 0m,
+                GrandTotal = 300m,
+                RoundOff = 0m,
+                NetPayable = 300m,
+                PaidAmount = 0m,
+                BalanceAmount = 300m,
+                CreatedBy = user.UserId,
+                CreatedAt = createdAt,
+                Lines =
+                [
+                    new SalesInvoiceLine
+                    {
+                        ItemId = shortageItem.ItemId,
+                        Description = shortageItem.Name,
+                        Qty = 6m,
+                        FreeQty = 0m,
+                        WarehouseId = secondaryWarehouse.WarehouseId,
+                        UnitPrice = 50m,
+                        BaseCost = 0m,
+                        PriceSource = "seed",
+                        DiscountMode = SalesDiscountMode.Percentage,
+                        DiscountPct = 0m,
+                        DiscountAmount = 0m,
+                        NetUnitPrice = 50m,
+                        LineTotal = 300m,
+                        TaxPct = 0m,
+                        TaxAmount = 0m,
+                        IsFreeIssue = false
+                    }
+                ]
+            },
+            new SalesInvoice
+            {
+                InvoiceNo = $"SI-{today:yyyy}-00003",
+                InvoiceDate = today,
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.Name,
+                CustomerSnapshotTaxNo = customer.TaxRegistrationNo,
+                WarehouseId = warehouse.WarehouseId,
+                InvoiceType = SalesInvoiceType.B2C,
+                Status = SalesInvoiceStatus.Posted,
+                Subtotal = 100m,
+                DiscountTotal = 0m,
+                TaxTotal = 0m,
+                GrandTotal = 100m,
+                RoundOff = 0m,
+                NetPayable = 100m,
+                PaidAmount = 100m,
+                BalanceAmount = 0m,
+                CreatedBy = user.UserId,
+                CreatedAt = createdAt,
+                UpdatedAt = DateTime.UtcNow,
+                Lines =
+                [
+                    new SalesInvoiceLine
+                    {
+                        ItemId = postableItem.ItemId,
+                        Description = postableItem.Name,
+                        Qty = 1m,
+                        FreeQty = 0m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = 100m,
+                        BaseCost = 0m,
+                        PriceSource = "seed",
+                        DiscountMode = SalesDiscountMode.Percentage,
+                        DiscountPct = 0m,
+                        DiscountAmount = 0m,
+                        NetUnitPrice = 100m,
+                        LineTotal = 100m,
+                        TaxPct = 0m,
+                        TaxAmount = 0m,
+                        IsFreeIssue = false
+                    }
+                ]
+            }
+        );
+
+        db.SalesSlips.AddRange(
+            new SalesSlip
+            {
+                SlipNo = $"SSL-{today:yyyy}-00001",
+                SlipDate = today.AddDays(-2),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.Name,
+                WarehouseId = warehouse.WarehouseId,
+                CashierUserId = user.UserId,
+                Status = SalesSlipStatus.Draft,
+                Subtotal = 50m,
+                DiscountTotal = 0m,
+                TaxTotal = 0m,
+                GrandTotal = 50m,
+                PaidAmount = 0m,
+                BalanceAmount = 50m,
+                CreatedAt = createdAt,
+                Lines =
+                [
+                    new SalesSlipLine
+                    {
+                        ItemId = postableItem.ItemId,
+                        Description = postableItem.Name,
+                        Qty = 1m,
+                        FreeQty = 0m,
+                        WarehouseId = warehouse.WarehouseId,
+                        UnitPrice = 50m,
+                        BaseCost = 0m,
+                        PriceSource = "seed",
+                        DiscountMode = SalesDiscountMode.Percentage,
+                        DiscountPct = 0m,
+                        DiscountAmount = 0m,
+                        NetUnitPrice = 50m,
+                        LineTotal = 50m,
+                        TaxPct = 0m,
+                        TaxAmount = 0m,
+                        IsFreeIssue = false
+                    }
+                ]
+            },
+            new SalesSlip
+            {
+                SlipNo = $"SSL-{today:yyyy}-00002",
+                SlipDate = today.AddDays(-1),
+                CustomerId = customer.CustomerId,
+                CustomerSnapshotName = customer.Name,
+                WarehouseId = secondaryWarehouse.WarehouseId,
+                CashierUserId = user.UserId,
+                Status = SalesSlipStatus.Draft,
+                Subtotal = 150m,
+                DiscountTotal = 15m,
+                TaxTotal = 0m,
+                GrandTotal = 135m,
+                PaidAmount = 0m,
+                BalanceAmount = 135m,
+                CreatedAt = createdAt,
+                Lines =
+                [
+                    new SalesSlipLine
+                    {
+                        ItemId = shortageItem.ItemId,
+                        Description = shortageItem.Name,
+                        Qty = 3m,
+                        FreeQty = 0m,
+                        WarehouseId = secondaryWarehouse.WarehouseId,
+                        UnitPrice = 50m,
+                        BaseCost = 0m,
+                        PriceSource = "seed",
+                        DiscountMode = SalesDiscountMode.Percentage,
+                        DiscountPct = 10m,
+                        DiscountAmount = 15m,
+                        NetUnitPrice = 45m,
+                        LineTotal = 135m,
+                        TaxPct = 0m,
+                        TaxAmount = 0m,
+                        IsFreeIssue = false
+                    }
+                ]
+            }
+        );
+
+        return true;
+    }
 }

Backend/ERPCore/Infra/Persistence/ErpDbContext.cs

@@ -15,6 +15,7 @@ namespace ERPCore.Infra.Persistence;
 public class ErpDbContext : DbContext
 {
     private readonly ICurrentUser _currentUser;
+    private bool _writingAuditLogs;
 
     public ErpDbContext(DbContextOptions<ErpDbContext> options, ICurrentUser currentUser) : base(options)
     {
@@ -22,18 +23,19 @@ public class ErpDbContext : DbContext
     }
 
     // --- Master Data (docs/10 Part C.1) ---
+    public DbSet<Customer> Customers => Set<Customer>();
     public DbSet<Category> Categories => Set<Category>();
     public DbSet<SubCategory> SubCategories => Set<SubCategory>();
     public DbSet<Brand> Brands => Set<Brand>();
     /// <summary>Color/Size/Material dimension names. Unlinked to Item by design (docs/10 C.9).</summary>
     public DbSet<ItemType> ItemTypes => Set<ItemType>();
     public DbSet<Uom> Uoms => Set<Uom>();
-    public DbSet<UomConversion> UomConversions => Set<UomConversion>();
     public DbSet<Item> Items => Set<Item>();
     public DbSet<ItemReorder> ItemReorders => Set<ItemReorder>();
     public DbSet<Vendor> Vendors => Set<Vendor>();
     public DbSet<Warehouse> Warehouses => Set<Warehouse>();
     public DbSet<Bin> Bins => Set<Bin>();
+    
     /// <summary>Singleton row (FR-MD-11).</summary>
     public DbSet<ProductConfig> ProductConfig => Set<ProductConfig>();
 
@@ -82,6 +84,18 @@ public class ErpDbContext : DbContext
     public DbSet<PurchaseReturn> PurchaseReturns => Set<PurchaseReturn>();
     public DbSet<PurchaseReturnLine> PurchaseReturnLines => Set<PurchaseReturnLine>();
 
+    // --- Sales (Phase 1) ---
+    public DbSet<SalesInvoice> SalesInvoices => Set<SalesInvoice>();
+    public DbSet<SalesInvoiceLine> SalesInvoiceLines => Set<SalesInvoiceLine>();
+    public DbSet<SalesSlip> SalesSlips => Set<SalesSlip>();
+    public DbSet<SalesSlipLine> SalesSlipLines => Set<SalesSlipLine>();
+    public DbSet<BundleSaleTemplate> BundleSaleTemplates => Set<BundleSaleTemplate>();
+    public DbSet<BundleSaleTemplateLine> BundleSaleTemplateLines => Set<BundleSaleTemplateLine>();
+    public DbSet<BundleSale> BundleSales => Set<BundleSale>();
+    public DbSet<BundleSaleLine> BundleSaleLines => Set<BundleSaleLine>();
+    public DbSet<SalesReturn> SalesReturns => Set<SalesReturn>();
+    public DbSet<SalesReturnLine> SalesReturnLines => Set<SalesReturnLine>();
+
     // --- Reference data (docs/10 Part C.7) ---
     public DbSet<ReasonCode> ReasonCodes => Set<ReasonCode>();
 
@@ -178,25 +192,45 @@ public class ErpDbContext : DbContext
     // persists the logs without re-auditing them.
     public override async Task<int> SaveChangesAsync(bool acceptAllChangesOnSuccess, CancellationToken ct = default)
     {
-        var pending = AuditScribe.Capture(ChangeTracker);
+        IReadOnlyList<PendingAudit> pending = _writingAuditLogs
+            ? Array.Empty<PendingAudit>()
+            : AuditScribe.Capture(ChangeTracker);
         var result = await base.SaveChangesAsync(acceptAllChangesOnSuccess, ct);
         if (pending.Count > 0)
         {
+            try
+            {
+                _writingAuditLogs = true;
                 WriteAuditLogs(pending);
                 await base.SaveChangesAsync(acceptAllChangesOnSuccess, ct);
             }
+            finally
+            {
+                _writingAuditLogs = false;
+            }
+        }
         return result;
     }
 
     public override int SaveChanges(bool acceptAllChangesOnSuccess)
     {
-        var pending = AuditScribe.Capture(ChangeTracker);
+        IReadOnlyList<PendingAudit> pending = _writingAuditLogs
+            ? Array.Empty<PendingAudit>()
+            : AuditScribe.Capture(ChangeTracker);
         var result = base.SaveChanges(acceptAllChangesOnSuccess);
         if (pending.Count > 0)
         {
+            try
+            {
+                _writingAuditLogs = true;
                 WriteAuditLogs(pending);
                 base.SaveChanges(acceptAllChangesOnSuccess);
             }
+            finally
+            {
+                _writingAuditLogs = false;
+            }
+        }
         return result;
     }
 

Backend/ERPCore/Infra/Persistence/Migrations/20260716134938_AddBrandsSubcategoriesItemTypesAndProductConfig.cs

@@ -1,442 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <summary>
-    /// Adds the Brand / SubCategory / ItemType masters and the singleton product config,
-    /// and converts CATEGORY from a self-nesting tree into a fixed two-level
-    /// Category → SubCategory hierarchy (docs/10 Part C.1).
-    /// <para>
-    /// <b>This migration carries data, not just DDL.</b> The scaffolded version dropped
-    /// <c>categories.ParentId</c> outright, which would have silently flattened every
-    /// child category into a root and left items pointing at what is now a top-level
-    /// category — losing the parent entirely. The hand-written steps below (marked
-    /// "data migration") move child categories into <c>subcategories</c> and repoint items
-    /// onto the correct (category, subcategory) pair before the column goes away.
-    /// </para>
-    /// </summary>
-    public partial class AddBrandsSubcategoriesItemTypesAndProductConfig : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            // NOTE: the ParentId drop is deliberately deferred to the bottom of this method —
-            // the data migration reads it. Order here is load-bearing.
-            migrationBuilder.RenameColumn(
-                name: "ItemType",
-                table: "items",
-                newName: "StockNature");
-
-            migrationBuilder.AddColumn<int>(
-                name: "BrandId",
-                table: "items",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.AddColumn<int>(
-                name: "SubCategoryId",
-                table: "items",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.AddColumn<DateTime>(
-                name: "CreatedAt",
-                table: "categories",
-                type: "timestamp with time zone",
-                nullable: false,
-                defaultValue: new DateTime(1, 1, 1, 0, 0, 0, 0, DateTimeKind.Unspecified));
-
-            migrationBuilder.AddColumn<string>(
-                name: "Status",
-                table: "categories",
-                type: "character varying(20)",
-                maxLength: 20,
-                nullable: false,
-                defaultValue: "Active");
-
-            migrationBuilder.AddColumn<DateTime>(
-                name: "UpdatedAt",
-                table: "categories",
-                type: "timestamp with time zone",
-                nullable: true);
-
-            migrationBuilder.AddColumn<uint>(
-                name: "xmin",
-                table: "categories",
-                type: "xid",
-                rowVersion: true,
-                nullable: false,
-                defaultValue: 0u);
-
-            migrationBuilder.CreateTable(
-                name: "brands",
-                columns: table => new
-                {
-                    BrandId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_brands", x => x.BrandId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "item_types",
-                columns: table => new
-                {
-                    ItemTypeId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_item_types", x => x.ItemTypeId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "product_config",
-                columns: table => new
-                {
-                    ConfigId = table.Column<int>(type: "integer", nullable: false),
-                    SubcategoriesEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    BrandsEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    ItemTypesEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: true),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    UpdatedBy = table.Column<int>(type: "integer", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_product_config", x => x.ConfigId);
-                    table.CheckConstraint("ck_product_config_singleton", "\"ConfigId\" = 1");
-                    table.ForeignKey(
-                        name: "FK_product_config_users_UpdatedBy",
-                        column: x => x.UpdatedBy,
-                        principalTable: "users",
-                        principalColumn: "UserId",
-                        onDelete: ReferentialAction.Restrict);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "subcategories",
-                columns: table => new
-                {
-                    SubCategoryId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    CategoryId = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_subcategories", x => x.SubCategoryId);
-                    table.ForeignKey(
-                        name: "FK_subcategories_categories_CategoryId",
-                        column: x => x.CategoryId,
-                        principalTable: "categories",
-                        principalColumn: "CategoryId",
-                        onDelete: ReferentialAction.Restrict);
-                });
-
-            // ---------------------------------------------------------------------------
-            // DATA MIGRATION — must run before ParentId is dropped.
-            // ---------------------------------------------------------------------------
-
-            // Existing categories predate CreatedAt; the added column defaulted them to
-            // 0001-01-01. Stamp them with the migration time instead of a sentinel date.
-            migrationBuilder.Sql(@"
-                UPDATE categories SET ""CreatedAt"" = NOW() AT TIME ZONE 'utc';
-            ");
-
-            // Carry the old category id alongside each new subcategory so items can be
-            // repointed by join below. Dropped again once the repoint is done.
-            migrationBuilder.Sql(@"
-                ALTER TABLE subcategories ADD COLUMN legacy_category_id integer;
-            ");
-
-            // Walk the old tree to its roots. The previous model allowed unlimited nesting,
-            // but the new one is exactly two levels — so a category at any depth below the
-            // root collapses into a subcategory of its ROOT ancestor (a grandchild cannot
-            // become a subcategory of its immediate parent, since that parent is itself
-            // ceasing to be a category).
-            migrationBuilder.Sql(@"
-                WITH RECURSIVE tree AS (
-                    SELECT ""CategoryId"", ""ParentId"", ""Name"", ""CategoryId"" AS root_id
-                    FROM categories
-                    WHERE ""ParentId"" IS NULL
-                    UNION ALL
-                    SELECT c.""CategoryId"", c.""ParentId"", c.""Name"", t.root_id
-                    FROM categories c
-                    JOIN tree t ON c.""ParentId"" = t.""CategoryId""
-                )
-                INSERT INTO subcategories (""Name"", ""CategoryId"", ""Status"", ""CreatedAt"", legacy_category_id)
-                SELECT t.""Name"", t.root_id, 'Active', NOW() AT TIME ZONE 'utc', t.""CategoryId""
-                FROM tree t
-                WHERE t.""ParentId"" IS NOT NULL;
-            ");
-
-            // Repoint items: an item that pointed at a child category now carries the root
-            // category plus the subcategory it actually meant.
-            migrationBuilder.Sql(@"
-                UPDATE items i
-                SET ""SubCategoryId"" = s.""SubCategoryId"",
-                    ""CategoryId""    = s.""CategoryId""
-                FROM subcategories s
-                WHERE s.legacy_category_id = i.""CategoryId"";
-            ");
-
-            // The self-FK must go before the delete, or RESTRICT rejects removing a parent
-            // whose own child row is still present.
-            migrationBuilder.DropForeignKey(
-                name: "FK_categories_categories_ParentId",
-                table: "categories");
-
-            // Every non-root category now lives in `subcategories`, and no item references
-            // one any more (repointed above), so the rows can go.
-            migrationBuilder.Sql(@"
-                DELETE FROM categories WHERE ""ParentId"" IS NOT NULL;
-                ALTER TABLE subcategories DROP COLUMN legacy_category_id;
-            ");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_ParentId",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "ParentId",
-                table: "categories");
-
-            // Seed the singleton config (FR-MD-11) — all features on. Item writes read this
-            // row, so it must exist before the app serves a single request.
-            migrationBuilder.Sql(@"
-                INSERT INTO product_config (""ConfigId"", ""SubcategoriesEnabled"", ""BrandsEnabled"", ""ItemTypesEnabled"")
-                VALUES (1, TRUE, TRUE, TRUE)
-                ON CONFLICT (""ConfigId"") DO NOTHING;
-            ");
-
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.CreateIndex(
-                name: "IX_items_BrandId",
-                table: "items",
-                column: "BrandId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_items_SubCategoryId",
-                table: "items",
-                column: "SubCategoryId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_Name",
-                table: "categories",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_Status",
-                table: "categories",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_brands_Name",
-                table: "brands",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_brands_Status",
-                table: "brands",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_item_types_Name",
-                table: "item_types",
-                column: "Name",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_item_types_Status",
-                table: "item_types",
-                column: "Status");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_product_config_UpdatedBy",
-                table: "product_config",
-                column: "UpdatedBy");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_subcategories_CategoryId_Name",
-                table: "subcategories",
-                columns: new[] { "CategoryId", "Name" },
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_subcategories_Status",
-                table: "subcategories",
-                column: "Status");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_items_brands_BrandId",
-                table: "items",
-                column: "BrandId",
-                principalTable: "brands",
-                principalColumn: "BrandId",
-                onDelete: ReferentialAction.Restrict);
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_items_subcategories_SubCategoryId",
-                table: "items",
-                column: "SubCategoryId",
-                principalTable: "subcategories",
-                principalColumn: "SubCategoryId",
-                onDelete: ReferentialAction.Restrict);
-        }
-
-        /// <summary>
-        /// Reverses the schema change and puts the subcategory data back where it came from.
-        /// <para>
-        /// The scaffolded version simply dropped <c>subcategories</c>, which would have
-        /// discarded exactly what <see cref="Up"/> preserved. Instead each subcategory is
-        /// restored as a child category and its items are repointed back onto it. This is
-        /// not perfectly lossless: the old tree's depth is gone (a former grandchild comes
-        /// back as a direct child of its root), and Brand data cannot survive a schema that
-        /// has nowhere to put it.
-        /// </para>
-        /// </summary>
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_items_brands_BrandId",
-                table: "items");
-
-            migrationBuilder.DropForeignKey(
-                name: "FK_items_subcategories_SubCategoryId",
-                table: "items");
-
-            // Restore the parent column + self-FK first so subcategories have somewhere to
-            // land, then move them back before the table is dropped.
-            migrationBuilder.AddColumn<int>(
-                name: "ParentId",
-                table: "categories",
-                type: "integer",
-                nullable: true);
-
-            // ---------------------------------------------------------------------------
-            // DATA MIGRATION (reverse) — must run before `subcategories` is dropped.
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.Sql(@"
-                ALTER TABLE categories ADD COLUMN legacy_subcategory_id integer;
-            ");
-
-            // Each subcategory becomes a child category again under the same parent.
-            migrationBuilder.Sql(@"
-                INSERT INTO categories (""Name"", ""ParentId"", ""CreatedAt"", ""Status"", legacy_subcategory_id)
-                SELECT s.""Name"", s.""CategoryId"", s.""CreatedAt"", s.""Status"", s.""SubCategoryId""
-                FROM subcategories s;
-            ");
-
-            // Items that carried a subcategory point back at the restored child category.
-            migrationBuilder.Sql(@"
-                UPDATE items i
-                SET ""CategoryId"" = c.""CategoryId""
-                FROM categories c
-                WHERE c.legacy_subcategory_id = i.""SubCategoryId"";
-            ");
-
-            migrationBuilder.Sql(@"
-                ALTER TABLE categories DROP COLUMN legacy_subcategory_id;
-            ");
-
-            // ---------------------------------------------------------------------------
-
-            migrationBuilder.DropTable(
-                name: "brands");
-
-            migrationBuilder.DropTable(
-                name: "item_types");
-
-            migrationBuilder.DropTable(
-                name: "product_config");
-
-            migrationBuilder.DropTable(
-                name: "subcategories");
-
-            migrationBuilder.DropIndex(
-                name: "IX_items_BrandId",
-                table: "items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_items_SubCategoryId",
-                table: "items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_Name",
-                table: "categories");
-
-            migrationBuilder.DropIndex(
-                name: "IX_categories_Status",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "BrandId",
-                table: "items");
-
-            migrationBuilder.DropColumn(
-                name: "SubCategoryId",
-                table: "items");
-
-            migrationBuilder.DropColumn(
-                name: "CreatedAt",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "Status",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "UpdatedAt",
-                table: "categories");
-
-            migrationBuilder.DropColumn(
-                name: "xmin",
-                table: "categories");
-
-            migrationBuilder.RenameColumn(
-                name: "StockNature",
-                table: "items",
-                newName: "ItemType");
-
-            // ParentId itself was re-added at the top of this method, ahead of the reverse
-            // data migration that populates it.
-            migrationBuilder.CreateIndex(
-                name: "IX_categories_ParentId",
-                table: "categories",
-                column: "ParentId");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_categories_categories_ParentId",
-                table: "categories",
-                column: "ParentId",
-                principalTable: "categories",
-                principalColumn: "CategoryId",
-                onDelete: ReferentialAction.Restrict);
-        }
-    }
-}

Backend/ERPCore/Infra/Persistence/Migrations/20260718081219_ini2.cs

@@ -1,22 +0,0 @@
-using Microsoft.EntityFrameworkCore.Migrations;
-
-#nullable disable
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <inheritdoc />
-    public partial class ini2 : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-
-        }
-    }
-}

Backend/ERPCore/Infra/Persistence/Migrations/20260718092655_AddRolesNavPermissions.cs

@@ -1,303 +0,0 @@
-using System;
-using Microsoft.EntityFrameworkCore.Migrations;
-using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
-
-#nullable disable
-
-#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
-
-namespace ERPCore.Infra.Persistence.Migrations
-{
-    /// <inheritdoc />
-    public partial class AddRolesNavPermissions : Migration
-    {
-        /// <inheritdoc />
-        protected override void Up(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.AddColumn<int>(
-                name: "RoleId",
-                table: "users",
-                type: "integer",
-                nullable: true);
-
-            migrationBuilder.CreateTable(
-                name: "nav_items",
-                columns: table => new
-                {
-                    NavItemId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Label = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
-                    Icon = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
-                    Href = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
-                    SortOrder = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active")
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_nav_items", x => x.NavItemId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "roles",
-                columns: table => new
-                {
-                    RoleId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    auth_role_id = table.Column<Guid>(type: "uuid", nullable: false),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Name = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
-                    IsSystemRole = table.Column<bool>(type: "boolean", nullable: false, defaultValue: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active"),
-                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
-                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
-                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_roles", x => x.RoleId);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "sub_nav_items",
-                columns: table => new
-                {
-                    SubNavItemId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    NavItemId = table.Column<int>(type: "integer", nullable: false),
-                    Code = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
-                    Label = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
-                    Icon = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
-                    Href = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: true),
-                    SortOrder = table.Column<int>(type: "integer", nullable: false),
-                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Active")
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_sub_nav_items", x => x.SubNavItemId);
-                    table.ForeignKey(
-                        name: "FK_sub_nav_items_nav_items_NavItemId",
-                        column: x => x.NavItemId,
-                        principalTable: "nav_items",
-                        principalColumn: "NavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "permissions",
-                columns: table => new
-                {
-                    PermissionId = table.Column<int>(type: "integer", nullable: false)
-                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
-                    Code = table.Column<string>(type: "character varying(80)", maxLength: 80, nullable: false),
-                    NavItemId = table.Column<int>(type: "integer", nullable: true),
-                    SubNavItemId = table.Column<int>(type: "integer", nullable: true)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_permissions", x => x.PermissionId);
-                    table.ForeignKey(
-                        name: "FK_permissions_nav_items_NavItemId",
-                        column: x => x.NavItemId,
-                        principalTable: "nav_items",
-                        principalColumn: "NavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_permissions_sub_nav_items_SubNavItemId",
-                        column: x => x.SubNavItemId,
-                        principalTable: "sub_nav_items",
-                        principalColumn: "SubNavItemId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.CreateTable(
-                name: "role_permissions",
-                columns: table => new
-                {
-                    RoleId = table.Column<int>(type: "integer", nullable: false),
-                    PermissionId = table.Column<int>(type: "integer", nullable: false)
-                },
-                constraints: table =>
-                {
-                    table.PrimaryKey("PK_role_permissions", x => new { x.RoleId, x.PermissionId });
-                    table.ForeignKey(
-                        name: "FK_role_permissions_permissions_PermissionId",
-                        column: x => x.PermissionId,
-                        principalTable: "permissions",
-                        principalColumn: "PermissionId",
-                        onDelete: ReferentialAction.Cascade);
-                    table.ForeignKey(
-                        name: "FK_role_permissions_roles_RoleId",
-                        column: x => x.RoleId,
-                        principalTable: "roles",
-                        principalColumn: "RoleId",
-                        onDelete: ReferentialAction.Cascade);
-                });
-
-            migrationBuilder.InsertData(
-                table: "nav_items",
-                columns: new[] { "NavItemId", "Code", "Href", "Icon", "Label", "SortOrder" },
-                values: new object[,]
-                {
-                    { 1, "dashboard", "/dashboard", null, "Dashboard", 1 },
-                    { 2, "products", "/dashboard/products", null, "Products", 2 },
-                    { 3, "vendors", "/dashboard/vendors", null, "Vendors", 3 },
-                    { 4, "procurement", "/dashboard/procurement", null, "Procurement", 4 },
-                    { 5, "receiving", "/dashboard/receiving/grn", null, "Receiving", 5 },
-                    { 6, "stock", "/dashboard/stock", null, "Stock", 6 },
-                    { 7, "warehouses", "/dashboard/warehouse", null, "Warehouses", 7 },
-                    { 8, "orders", "/dashboard/orders", null, "Orders", 8 },
-                    { 9, "settings", "/dashboard/settings", null, "Settings", 9 },
-                    { 10, "help", "/dashboard/help", null, "Help", 10 }
-                });
-
-            migrationBuilder.UpdateData(
-                table: "users",
-                keyColumn: "UserId",
-                keyValue: 1,
-                column: "RoleId",
-                value: null);
-
-            migrationBuilder.InsertData(
-                table: "permissions",
-                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
-                values: new object[,]
-                {
-                    { 1, "NAV:dashboard", 1, null },
-                    { 2, "NAV:products", 2, null },
-                    { 3, "NAV:vendors", 3, null },
-                    { 4, "NAV:procurement", 4, null },
-                    { 5, "NAV:receiving", 5, null },
-                    { 6, "NAV:stock", 6, null },
-                    { 7, "NAV:warehouses", 7, null },
-                    { 8, "NAV:orders", 8, null },
-                    { 9, "NAV:settings", 9, null },
-                    { 10, "NAV:help", 10, null }
-                });
-
-            migrationBuilder.InsertData(
-                table: "sub_nav_items",
-                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
-                values: new object[,]
-                {
-                    { 1, "products.item", "/dashboard/products", null, "Item", 2, 1 },
-                    { 2, "products.category", "/dashboard/products/categories", null, "Category", 2, 2 },
-                    { 3, "products.brand", "/dashboard/products/brands", null, "Brand", 2, 3 },
-                    { 4, "products.item-type", "/dashboard/products/item-types", null, "Item Type", 2, 4 },
-                    { 5, "products.uom", "/dashboard/products/uoms", null, "UOM", 2, 5 },
-                    { 6, "products.configuration", "/dashboard/products/settings", null, "Configuration", 2, 6 },
-                    { 7, "settings.roles", "/dashboard/settings/roles", null, "Roles", 9, 1 },
-                    { 8, "settings.users", "/dashboard/settings/users", null, "Users", 9, 2 }
-                });
-
-            migrationBuilder.InsertData(
-                table: "permissions",
-                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
-                values: new object[,]
-                {
-                    { 11, "NAV:products.item", null, 1 },
-                    { 12, "NAV:products.category", null, 2 },
-                    { 13, "NAV:products.brand", null, 3 },
-                    { 14, "NAV:products.item-type", null, 4 },
-                    { 15, "NAV:products.uom", null, 5 },
-                    { 16, "NAV:products.configuration", null, 6 },
-                    { 17, "NAV:settings.roles", null, 7 },
-                    { 18, "NAV:settings.users", null, 8 }
-                });
-
-            migrationBuilder.CreateIndex(
-                name: "IX_users_RoleId",
-                table: "users",
-                column: "RoleId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_nav_items_Code",
-                table: "nav_items",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_Code",
-                table: "permissions",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_NavItemId",
-                table: "permissions",
-                column: "NavItemId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_permissions_SubNavItemId",
-                table: "permissions",
-                column: "SubNavItemId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_role_permissions_PermissionId",
-                table: "role_permissions",
-                column: "PermissionId");
-
-            migrationBuilder.CreateIndex(
-                name: "IX_roles_auth_role_id",
-                table: "roles",
-                column: "auth_role_id",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_roles_Code",
-                table: "roles",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_sub_nav_items_Code",
-                table: "sub_nav_items",
-                column: "Code",
-                unique: true);
-
-            migrationBuilder.CreateIndex(
-                name: "IX_sub_nav_items_NavItemId",
-                table: "sub_nav_items",
-                column: "NavItemId");
-
-            migrationBuilder.AddForeignKey(
-                name: "FK_users_roles_RoleId",
-                table: "users",
-                column: "RoleId",
-                principalTable: "roles",
-                principalColumn: "RoleId",
-                onDelete: ReferentialAction.Restrict);
-        }
-
-        /// <inheritdoc />
-        protected override void Down(MigrationBuilder migrationBuilder)
-        {
-            migrationBuilder.DropForeignKey(
-                name: "FK_users_roles_RoleId",
-                table: "users");
-
-            migrationBuilder.DropTable(
-                name: "role_permissions");
-
-            migrationBuilder.DropTable(
-                name: "permissions");
-
-            migrationBuilder.DropTable(
-                name: "roles");
-
-            migrationBuilder.DropTable(
-                name: "sub_nav_items");
-
-            migrationBuilder.DropTable(
-                name: "nav_items");
-
-            migrationBuilder.DropIndex(
-                name: "IX_users_RoleId",
-                table: "users");
-
-            migrationBuilder.DropColumn(
-                name: "RoleId",
-                table: "users");
-        }
-    }
-}

Backend/ERPCore/Migrations/20260811095944_AddItemTypeIsMeasurable.cs

@@ -0,0 +1,29 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddItemTypeIsMeasurable : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "IsMeasurable",
+                table: "item_types",
+                type: "boolean",
+                nullable: false,
+                defaultValue: false);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "IsMeasurable",
+                table: "item_types");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260813091828_warrenty.cs

@@ -0,0 +1,196 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class warrenty : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "Warranty",
+                table: "items",
+                type: "character varying(20)",
+                maxLength: 20,
+                nullable: false,
+                defaultValue: "NonWarranty");
+
+            migrationBuilder.AddColumn<int>(
+                name: "WarrantyPeriodMonths",
+                table: "items",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "grn_line_warranty_numbers",
+                columns: table => new
+                {
+                    GrnLineWarrantyNumberId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    GrnLineId = table.Column<int>(type: "integer", nullable: false),
+                    WarrantyNo = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    WarrantyPeriodMonths = table.Column<int>(type: "integer", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_grn_line_warranty_numbers", x => x.GrnLineWarrantyNumberId);
+                    table.ForeignKey(
+                        name: "FK_grn_line_warranty_numbers_grn_lines_GrnLineId",
+                        column: x => x.GrnLineId,
+                        principalTable: "grn_lines",
+                        principalColumn: "GrnLineId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "sales_returns",
+                columns: table => new
+                {
+                    ReturnId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DocNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: false),
+                    CustomerId = table.Column<int>(type: "integer", nullable: false),
+                    WarehouseId = table.Column<int>(type: "integer", nullable: false),
+                    ReasonCodeId = table.Column<int>(type: "integer", nullable: false),
+                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_returns", x => x.ReturnId);
+                    table.ForeignKey(
+                        name: "FK_sales_returns_customers_CustomerId",
+                        column: x => x.CustomerId,
+                        principalTable: "customers",
+                        principalColumn: "CustomerId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_returns_reason_codes_ReasonCodeId",
+                        column: x => x.ReasonCodeId,
+                        principalTable: "reason_codes",
+                        principalColumn: "ReasonCodeId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_returns_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_returns_warehouses_WarehouseId",
+                        column: x => x.WarehouseId,
+                        principalTable: "warehouses",
+                        principalColumn: "WarehouseId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "sales_return_lines",
+                columns: table => new
+                {
+                    ReturnLineId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    ReturnId = table.Column<int>(type: "integer", nullable: false),
+                    SalesInvoiceLineId = table.Column<int>(type: "integer", nullable: true),
+                    ItemId = table.Column<int>(type: "integer", nullable: false),
+                    Qty = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_return_lines", x => x.ReturnLineId);
+                    table.ForeignKey(
+                        name: "FK_sales_return_lines_items_ItemId",
+                        column: x => x.ItemId,
+                        principalTable: "items",
+                        principalColumn: "ItemId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_return_lines_sales_invoice_lines_SalesInvoiceLineId",
+                        column: x => x.SalesInvoiceLineId,
+                        principalTable: "sales_invoice_lines",
+                        principalColumn: "SalesInvoiceLineId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_return_lines_sales_returns_ReturnId",
+                        column: x => x.ReturnId,
+                        principalTable: "sales_returns",
+                        principalColumn: "ReturnId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_line_warranty_numbers_GrnLineId_WarrantyNo",
+                table: "grn_line_warranty_numbers",
+                columns: new[] { "GrnLineId", "WarrantyNo" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_lines_ItemId",
+                table: "sales_return_lines",
+                column: "ItemId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_lines_ReturnId",
+                table: "sales_return_lines",
+                column: "ReturnId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_return_lines_SalesInvoiceLineId",
+                table: "sales_return_lines",
+                column: "SalesInvoiceLineId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_returns_CreatedBy",
+                table: "sales_returns",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_returns_CustomerId",
+                table: "sales_returns",
+                column: "CustomerId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_returns_DocNo",
+                table: "sales_returns",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_returns_ReasonCodeId",
+                table: "sales_returns",
+                column: "ReasonCodeId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_returns_WarehouseId",
+                table: "sales_returns",
+                column: "WarehouseId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "grn_line_warranty_numbers");
+
+            migrationBuilder.DropTable(
+                name: "sales_return_lines");
+
+            migrationBuilder.DropTable(
+                name: "sales_returns");
+
+            migrationBuilder.DropColumn(
+                name: "Warranty",
+                table: "items");
+
+            migrationBuilder.DropColumn(
+                name: "WarrantyPeriodMonths",
+                table: "items");
+        }
+    }
+}

Backend/ERPCore/Program.cs

@@ -1,21 +1,24 @@
 using System.Text.Json.Serialization;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.Auth.AuthHex;
+using ERPCore.Infra.Gl;
 using ERPCore.Infra.Persistence;
 using ERPCore.Infra.Storage;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories;
 using ERPCore.Repositories.Interfaces;
 using ERPCore.Services;
+using ERPCore.Services.Interfaces;
 using ERPCore.Services.Auth;
 using ERPCore.Services.Hrm;
-using ERPCore.Services.Interfaces;
 using ERPCore.Services.Production;
 using ERPCore.Services.Stock;
 using ERPCore.System.Errors;
 using Microsoft.AspNetCore.Authentication;
 using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Diagnostics;
 using Microsoft.OpenApi;
+using Npgsql;
 using Serilog;
 
 var builder = WebApplication.CreateBuilder(args);
@@ -31,7 +34,10 @@ builder.Services.AddControllers()
 
 // EF Core + PostgreSQL
 builder.Services.AddDbContext<ErpDbContext>(o =>
-    o.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection")));
+{
+    o.UseNpgsql(builder.Configuration.GetConnectionString("DefaultConnection"));
+    o.ConfigureWarnings(w => w.Ignore(RelationalEventId.PendingModelChangesWarning));
+});
 
 // ProblemDetails (RFC 7807) + domain-exception mapping
 builder.Services.AddProblemDetails();
@@ -51,6 +57,15 @@ builder.Services.AddScoped<IAuthUserService, AuthUserService>();
 builder.Services.AddScoped<IAuthRecoveryService, AuthRecoveryService>();
 builder.Services.AddScoped<IAuthAltService, AuthAltService>();
 
+// General Ledger service proxy → external GL microservice (docs/12-GENERAL-LEDGER-INTEGRATION.md)
+builder.Services.AddHttpClient<IGeneralLedgerClient, GeneralLedgerClient>(c =>
+{
+    var baseUrl = builder.Configuration["GeneralLedgerService:BaseUrl"]
+        ?? throw new InvalidOperationException("GeneralLedgerService:BaseUrl is not configured.");
+    c.BaseAddress = new Uri(baseUrl);
+});
+builder.Services.AddScoped<IGeneralLedgerService, GeneralLedgerService>();
+
 // Current-user (audit actor). AuthHex has no sub/nameid → a claims transformation
 // JIT-provisions a local shadow user and injects the local `int` id as `nameid`.
 builder.Services.AddHttpContextAccessor();
@@ -62,11 +77,13 @@ builder.Services.AddScoped<IUnitOfWork, UnitOfWork>();
 builder.Services.AddScoped(typeof(IRepository<>), typeof(Repository<>));
 
 // Master-data services (docs/11 §2)
+builder.Services.AddScoped<ICustomerService, CustomerService>();
 builder.Services.AddScoped<IItemService, ItemService>();
 builder.Services.AddScoped<IUomService, UomService>();
 builder.Services.AddScoped<ICategoryService, CategoryService>();
 builder.Services.AddScoped<IBrandService, BrandService>();
 builder.Services.AddScoped<IItemTypeService, ItemTypeService>();
+//builder.Services.AddScoped<ICompanyProfileService, CompanyProfileService>();
 builder.Services.AddScoped<IProductConfigService, ProductConfigService>();
 builder.Services.AddScoped<IVendorService, VendorService>();
 builder.Services.AddScoped<IWarehouseService, WarehouseService>();
@@ -82,11 +99,24 @@ builder.Services.AddScoped<IRfqService, RfqService>();
 builder.Services.AddScoped<IPurchaseOrderService, PurchaseOrderService>();
 
 // Stock core + goods receipt (docs/11 §4–5)
-builder.Services.AddScoped<IUomConverter, UomConverter>();
+builder.Services.AddScoped<IItemMeasure, ItemMeasure>();
 builder.Services.AddScoped<IFifoCostingService, FifoCostingService>();
 builder.Services.AddScoped<IStockService, StockService>();
 builder.Services.AddScoped<IGrnService, GrnService>();
 
+// Sales (Phase 1)
+builder.Services.AddScoped<ISalesPricingService, SalesPricingService>();
+builder.Services.AddScoped<ISalesDomainService, SalesDomainService>();
+builder.Services.AddScoped<ISalesPostingService, SalesPostingService>();
+builder.Services.AddScoped<ISalesDocumentWorkflowService, SalesDocumentWorkflowService>();
+builder.Services.AddScoped<ISalesMappingService, SalesMappingService>();
+builder.Services.AddScoped<ISalesInvoiceService, SalesInvoiceService>();
+builder.Services.AddScoped<ISalesSlipService, SalesSlipService>();
+builder.Services.AddScoped<IBundleSaleService, BundleSaleService>();
+builder.Services.AddScoped<ISalesPromotionSuggestionService, SalesPromotionSuggestionService>();
+builder.Services.AddScoped<ISalesReportService, SalesReportService>();
+builder.Services.AddScoped<ISalesReturnService, SalesReturnService>();
+
 // Stock transactions + reference data (docs/11 §5–6)
 builder.Services.AddScoped<IStockMutator, StockMutator>();
 builder.Services.AddScoped<IReasonCodeService, ReasonCodeService>();
@@ -161,8 +191,17 @@ var app = builder.Build();
 using (var scope = app.Services.CreateScope())
 {
     var db = scope.ServiceProvider.GetRequiredService<ErpDbContext>();
+   // await EnsureMigrationBaselineAsync(db);
+    await db.Database.MigrateAsync();
+    try
+    {
         await DataSeeder.SeedAsync(db);
     }
+    catch (Exception ex)
+    {
+        throw new InvalidOperationException("Database migration succeeded, but startup seeding failed.", ex);
+    }
+}
 
 app.UseSerilogRequestLogging();
 
@@ -178,3 +217,4 @@ app.UseAuthorization();
 app.MapControllers();
 app.MapHealthChecks("/health");
 app.Run();
+

Backend/ERPCore/Services/BundleSaleService.cs

@@ -0,0 +1,247 @@
+using ERPCore.Domain;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.Services.Stock;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class BundleSaleService : IBundleSaleService
+{
+    private readonly IRepository<BundleSaleTemplate> _templates;
+    private readonly IRepository<BundleSale> _bundles;
+    private readonly IRepository<Customer> _customers;
+    private readonly IRepository<Item> _items;
+    private readonly IRepository<Warehouse> _warehouses;
+    private readonly IRepository<User> _users;
+    private readonly ISalesDomainService _sales;
+    private readonly ISalesPostingService _posting;
+    private readonly ICurrentUser _currentUser;
+    private readonly INumberSequenceService _numbers;
+    private readonly IUnitOfWork _uow;
+
+    public BundleSaleService(
+        IRepository<BundleSale> bundles,
+        IRepository<BundleSaleTemplate> templates,
+        IRepository<Customer> customers,
+        IRepository<Item> items,
+        IRepository<Warehouse> warehouses,
+        IRepository<User> users,
+        ISalesDomainService sales,
+        ISalesPostingService posting,
+        ICurrentUser currentUser,
+        INumberSequenceService numbers,
+        IUnitOfWork uow)
+    {
+        _templates = templates;
+        _bundles = bundles;
+        _customers = customers;
+        _items = items;
+        _warehouses = warehouses;
+        _users = users;
+        _sales = sales;
+        _posting = posting;
+        _currentUser = currentUser;
+        _numbers = numbers;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<BundleSaleTemplateSummaryDto>> ListTemplatesAsync(PageQuery query, CancellationToken ct = default)
+    {
+        IQueryable<BundleSaleTemplate> q = _templates.Query().AsNoTracking().Include(x => x.Lines);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.ILike(x.TemplateCode, $"%{term}%") || EF.Functions.ILike(x.TemplateName, $"%{term}%") || EF.Functions.ILike(x.Description ?? "", $"%{term}%"));
+        }
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(x => x.BundleSaleTemplateId).Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+        return PagedResponse<BundleSaleTemplateSummaryDto>.Create(rows.Select(x => new BundleSaleTemplateSummaryDto(
+            x.BundleSaleTemplateId, x.TemplateCode, x.TemplateName, x.Description, x.Status, x.Lines.Count, x.CreatedAt, x.UpdatedAt)).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<BundleSaleTemplateDto?> GetTemplateAsync(int bundleSaleTemplateId, CancellationToken ct = default)
+    {
+        var template = await _templates.Query().AsNoTracking().Include(x => x.Lines).FirstOrDefaultAsync(x => x.BundleSaleTemplateId == bundleSaleTemplateId, ct);
+        return template is null ? null : new BundleSaleTemplateDto(
+            template.BundleSaleTemplateId,
+            template.TemplateCode,
+            template.TemplateName,
+            template.Description,
+            template.Status,
+            template.CreatedAt,
+            template.UpdatedAt,
+            template.Lines.OrderBy(x => x.SortOrder).Select(x => new BundleSaleTemplateLineDto(
+                x.BundleSaleTemplateLineId, x.ItemId, x.WarehouseId, x.Qty, x.UnitPrice, x.IncludeInBundle, x.SortOrder)).ToList());
+    }
+
+    public async Task<PagedResponse<BundleSaleSummaryDto>> ListAsync(PageQuery query, BundleSaleStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default)
+    {
+        IQueryable<BundleSale> q = _bundles.Query().AsNoTracking().Include(x => x.Lines);
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(x => EF.Functions.ILike(x.BundleNo, $"%{term}%") || EF.Functions.ILike(x.BundleName, $"%{term}%") || EF.Functions.ILike(x.BundleCode, $"%{term}%"));
+        }
+        if (status is not null) q = q.Where(x => x.Status == status);
+        if (customerId is not null) q = q.Where(x => x.CustomerId == customerId);
+        if (warehouseId is not null) q = q.Where(x => x.WarehouseId == warehouseId);
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderByDescending(x => x.BundleSaleId).Skip(query.Skip).Take(query.PageSize).ToListAsync(ct);
+        return PagedResponse<BundleSaleSummaryDto>.Create(rows.Select(MapSummary).ToList(), query.Page, query.PageSize, total);
+    }
+
+    public async Task<BundleSaleDto?> GetAsync(int bundleSaleId, CancellationToken ct = default)
+    {
+        var bundle = await _bundles.Query().AsNoTracking().Include(x => x.Lines).FirstOrDefaultAsync(x => x.BundleSaleId == bundleSaleId, ct);
+        return bundle is null ? null : Map(bundle);
+    }
+
+    public Task<BundleSalePostingCheckDto> CheckPostingAsync(int bundleSaleId, CancellationToken ct = default)
+        => _posting.CheckBundleAsync(bundleSaleId, ct);
+
+    public async Task<BundleSaleDto> CreateAsync(CreateBundleSaleRequest request, CancellationToken ct = default)
+    {
+        await _sales.ValidateSalesHeaderAsync(request.CustomerId, request.WarehouseId, request.CashierUserId, true, ct);
+        var template = await _templates.Query().AsNoTracking().Include(x => x.Lines)
+            .FirstAsync(x => x.BundleSaleTemplateId == request.BundleSaleTemplateId, ct);
+        var bundle = new BundleSale
+        {
+            BundleNo = await _numbers.NextAsync(DocumentTypes.BundleSale, ct),
+            BundleDate = DateTime.UtcNow,
+            CustomerId = request.CustomerId,
+            WarehouseId = request.WarehouseId,
+            CashierUserId = request.CashierUserId,
+            BundleSaleTemplateId = request.BundleSaleTemplateId,
+            BundleName = request.BundleName,
+            BundleCode = string.Empty,
+            Status = BundleSaleStatus.Draft,
+            CreatedAt = DateTime.UtcNow
+        };
+        bundle.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        bundle.Lines = await BuildLinesAsync(template, request.WarehouseId, request.Lines, ct);
+        Recalculate(bundle, request.BundlePrice);
+        bundle.BundleCode = $"{bundle.BundleNo}-B";
+        await _bundles.AddAsync(bundle, ct);
+        bundle.ConcurrencyStamp = 1;
+        await _uow.SaveChangesAsync(ct);
+        return Map(bundle);
+    }
+
+    public async Task<BundleSaleDto> UpdateAsync(int bundleSaleId, UpdateBundleSaleRequest request, CancellationToken ct = default)
+    {
+        var bundle = await _bundles.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.BundleSaleId == bundleSaleId, ct)
+            ?? throw new NotFoundException($"Bundle sale {bundleSaleId} was not found.");
+        if (bundle.Status != BundleSaleStatus.Draft)
+            throw new ConflictException($"Bundle sale {bundleSaleId} is {bundle.Status} and cannot be edited.");
+
+        await _sales.ValidateSalesHeaderAsync(request.CustomerId, request.WarehouseId, request.CashierUserId, true, ct);
+        var template = await _templates.Query().AsNoTracking().Include(x => x.Lines)
+            .FirstAsync(x => x.BundleSaleTemplateId == request.BundleSaleTemplateId, ct);
+        bundle.CustomerId = request.CustomerId;
+        bundle.WarehouseId = request.WarehouseId;
+        bundle.CashierUserId = request.CashierUserId;
+        bundle.BundleSaleTemplateId = request.BundleSaleTemplateId;
+        bundle.BundleName = request.BundleName;
+        bundle.CustomerSnapshotName = await _customers.Query().Where(x => x.CustomerId == request.CustomerId).Select(x => x.DisplayName ?? x.Name).FirstAsync(ct);
+        bundle.Lines.Clear();
+        foreach (var line in await BuildLinesAsync(template, request.WarehouseId, request.Lines, ct)) bundle.Lines.Add(line);
+        Recalculate(bundle, request.BundlePrice);
+        bundle.UpdatedAt = DateTime.UtcNow;
+        bundle.ConcurrencyStamp++;
+        await _uow.SaveChangesAsync(ct);
+        return Map(bundle);
+    }
+
+    public async Task<BundleSaleDto> PostAsync(int bundleSaleId, CancellationToken ct = default)
+        {
+            await _posting.PostBundleAsync(bundleSaleId, ct);
+            var bundle = await _bundles.Query().AsNoTracking().Include(x => x.Lines)
+                .FirstAsync(x => x.BundleSaleId == bundleSaleId, ct);
+            return Map(bundle);
+        }
+
+    public async Task<BundleSaleDto> CancelAsync(int bundleSaleId, CancellationToken ct = default)
+    {
+        var bundle = await _bundles.Query().Include(x => x.Lines).FirstOrDefaultAsync(x => x.BundleSaleId == bundleSaleId, ct)
+            ?? throw new NotFoundException($"Bundle sale {bundleSaleId} was not found.");
+        if (bundle.Status != BundleSaleStatus.Draft)
+            throw new ConflictException($"Bundle sale {bundleSaleId} is {bundle.Status} and cannot be cancelled.");
+        bundle.Status = BundleSaleStatus.Cancelled;
+        bundle.UpdatedAt = DateTime.UtcNow;
+        bundle.ConcurrencyStamp++;
+        await _uow.SaveChangesAsync(ct);
+        return Map(bundle);
+    }
+
+    private async Task<List<BundleSaleLine>> BuildLinesAsync(
+        BundleSaleTemplate template, int warehouseId, IReadOnlyList<CreateBundleSaleTemplateLineRequest> requestLines, CancellationToken ct)
+    {
+        var lines = new List<BundleSaleLine>();
+        var sourceLines = requestLines.Count > 0
+            ? requestLines.OrderBy(x => x.SortOrder).ToList()
+            : template.Lines.OrderBy(x => x.SortOrder).Select(x => new CreateBundleSaleTemplateLineRequest
+            {
+                ItemId = x.ItemId,
+                WarehouseId = x.WarehouseId,
+                Qty = x.Qty,
+                UnitPrice = x.UnitPrice,
+                IncludeInBundle = x.IncludeInBundle,
+                SortOrder = x.SortOrder
+            }).ToList();
+
+        foreach (var r in sourceLines)
+        {
+            if (r.Qty <= 0)
+                throw new DomainException(ErrorCodes.Validation, "Bundle line quantity must be greater than zero.", 422);
+
+            // Bundle sales use the header warehouse as the source of truth for stock and pricing.
+            // Keep any per-line warehouse input from drifting away from the header.
+            var lineWarehouseId = warehouseId;
+
+            var item = await _items.Query().AsNoTracking().FirstAsync(x => x.ItemId == r.ItemId, ct);
+            await _sales.ValidateSalesLineAsync(warehouseId, r.ItemId, lineWarehouseId, r.Qty, 0m, null, ct);
+            var calc = _sales.ComputeLine(r.Qty, 0m, r.UnitPrice, SalesDiscountMode.Amount, 0m, 0m, 0m, 0m, false);
+            lines.Add(new BundleSaleLine
+            {
+                ItemId = r.ItemId,
+                Description = item.Name,
+                Qty = r.Qty,
+                WarehouseId = lineWarehouseId,
+                UnitPrice = r.UnitPrice,
+                LineTotal = calc.LineTotal,
+                IncludeInBundle = r.IncludeInBundle,
+                IsComponent = true,
+                ParentLineId = null
+            });
+        }
+        return lines;
+    }
+
+    private static void Recalculate(BundleSale bundle, decimal bundlePrice)
+    {
+        bundle.ComponentSubtotal = bundle.Lines.Where(x => x.IncludeInBundle).Sum(x => x.LineTotal);
+        bundle.BundlePrice = bundlePrice;
+        bundle.MarginAmount = bundle.BundlePrice - bundle.ComponentSubtotal;
+        bundle.DiscountTotal = Math.Max(0m, bundle.ComponentSubtotal - bundle.BundlePrice);
+        bundle.TaxTotal = 0m;
+        bundle.GrandTotal = bundle.BundlePrice + bundle.TaxTotal;
+    }
+
+    private static BundleSaleSummaryDto MapSummary(BundleSale x) => new(
+        x.BundleSaleId, x.BundleNo, x.BundleDate, x.CustomerId, x.CustomerSnapshotName, x.WarehouseId, x.BundleName, x.BundleCode, x.Status, x.ComponentSubtotal, x.BundlePrice, x.GrandTotal, x.CreatedAt);
+
+    private static BundleSaleDto Map(BundleSale x) => new(
+        x.BundleSaleId, x.BundleNo, x.BundleDate, x.CustomerId, x.CustomerSnapshotName, x.WarehouseId, x.CashierUserId, x.BundleSaleTemplateId,
+        x.BundleName, x.BundleCode, x.Status, x.ComponentSubtotal, x.BundlePrice, x.MarginAmount, x.DiscountTotal, x.TaxTotal, x.GrandTotal,
+        x.CreatedAt, x.UpdatedAt,
+        x.Lines.Select(l => new BundleSaleLineDto(l.BundleSaleLineId, l.ItemId, l.Description, l.Qty, l.WarehouseId, l.UnitPrice, l.LineTotal, l.IncludeInBundle, l.IsComponent, l.ParentLineId)).ToList());
+
+}

Backend/ERPCore/Services/CustomerService.cs

@@ -0,0 +1,168 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Customers;
+using ERPCore.Infra.UoW;
+using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Services;
+
+public sealed class CustomerService : ICustomerService
+{
+    private readonly IRepository<Customer> _customers;
+    private readonly IRepository<Warehouse> _warehouses;
+    private readonly IUnitOfWork _uow;
+
+    public CustomerService(IRepository<Customer> customers, IRepository<Warehouse> warehouses, IUnitOfWork uow)
+    {
+        _customers = customers;
+        _warehouses = warehouses;
+        _uow = uow;
+    }
+
+    public async Task<PagedResponse<CustomerDto>> ListAsync(PageQuery query, EntityStatus? status, CustomerType? customerType, CancellationToken ct = default)
+    {
+        var q = _customers.Query().AsNoTracking();
+        if (!string.IsNullOrWhiteSpace(query.Q))
+        {
+            var term = query.Q.Trim();
+            q = q.Where(c => EF.Functions.ILike(c.Name, $"%{term}%")
+                             || EF.Functions.ILike(c.CustomerCode, $"%{term}%")
+                             || (c.DisplayName != null && EF.Functions.ILike(c.DisplayName, $"%{term}%")));
+        }
+        if (status is not null) q = q.Where(c => c.Status == status);
+        if (customerType is not null) q = q.Where(c => c.CustomerType == customerType);
+
+        var total = await q.CountAsync(ct);
+        var rows = await q.OrderBy(c => c.Name)
+            .Skip(query.Skip).Take(query.PageSize)
+            .Select(c => new CustomerDto(
+                c.CustomerId, c.CustomerCode, c.CustomerType, c.Name, c.DisplayName, c.Phone, c.Email,
+                c.AddressLine1, c.AddressLine2, c.City, c.Country, c.TaxRegistrationNo,
+                c.CreditLimit, c.CreditDays, c.DefaultWarehouseId, c.Status, c.CreatedAt, c.UpdatedAt))
+            .ToListAsync(ct);
+
+        return PagedResponse<CustomerDto>.Create(rows, query.Page, query.PageSize, total);
+    }
+
+    public async Task<ETagged<CustomerDto>?> GetAsync(int customerId, CancellationToken ct = default)
+    {
+        var customer = await _customers.Query().AsNoTracking()
+            .FirstOrDefaultAsync(c => c.CustomerId == customerId, ct);
+        return customer is null ? null : new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task<ETagged<CustomerDto>> CreateAsync(CreateCustomerRequest request, CancellationToken ct = default)
+    {
+        var code = request.CustomerCode.Trim();
+        var name = request.Name.Trim();
+
+        if (await _customers.Query().AnyAsync(c => c.CustomerCode.ToLower() == code.ToLower(), ct))
+            throw new ConflictException($"A customer code '{code}' already exists.");
+
+        if (!string.IsNullOrWhiteSpace(request.Email))
+        {
+            var email = request.Email.Trim();
+            if (await _customers.Query().AnyAsync(c => c.Email != null && c.Email.ToLower() == email.ToLower(), ct))
+                throw new ConflictException($"A customer with email '{email}' already exists.");
+        }
+
+        if (request.DefaultWarehouseId is not null)
+        {
+            var exists = await _warehouses.Query().AnyAsync(w => w.WarehouseId == request.DefaultWarehouseId, ct);
+            if (!exists) throw new NotFoundException($"Warehouse {request.DefaultWarehouseId} was not found.");
+        }
+
+        var customer = new Customer
+        {
+            CustomerCode = code,
+            CustomerType = request.CustomerType,
+            Name = name,
+            DisplayName = Normalize(request.DisplayName),
+            Phone = Normalize(request.Phone),
+            Email = Normalize(request.Email),
+            AddressLine1 = Normalize(request.AddressLine1),
+            AddressLine2 = Normalize(request.AddressLine2),
+            City = Normalize(request.City),
+            Country = Normalize(request.Country),
+            TaxRegistrationNo = Normalize(request.TaxRegistrationNo),
+            CreditLimit = request.CreditLimit,
+            CreditDays = request.CreditDays,
+            DefaultWarehouseId = request.DefaultWarehouseId,
+            Status = EntityStatus.Active,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        await _customers.AddAsync(customer, ct);
+        await _uow.SaveChangesAsync(ct);
+
+        return new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task<ETagged<CustomerDto>> UpdateAsync(int customerId, UpdateCustomerRequest request, uint expectedRowVersion, CancellationToken ct = default)
+    {
+        var customer = await _customers.GetByIdAsync(customerId, ct)
+            ?? throw new NotFoundException($"Customer {customerId} was not found.");
+
+        if (customer.RowVersion != expectedRowVersion)
+            throw new DomainException(ErrorCodes.ConcurrencyConflict, "The customer was modified by another request.", 412);
+
+        var code = request.CustomerCode.Trim();
+        var name = request.Name.Trim();
+
+        if (!string.Equals(customer.CustomerCode, code, StringComparison.Ordinal)
+            && await _customers.Query().AnyAsync(c => c.CustomerCode.ToLower() == code.ToLower() && c.CustomerId != customerId, ct))
+            throw new ConflictException($"A customer code '{code}' already exists.");
+
+        if (!string.Equals(customer.Email, request.Email?.Trim(), StringComparison.OrdinalIgnoreCase)
+            && !string.IsNullOrWhiteSpace(request.Email)
+            && await _customers.Query().AnyAsync(c => c.Email != null && c.Email.ToLower() == request.Email!.Trim().ToLower() && c.CustomerId != customerId, ct))
+            throw new ConflictException($"A customer with email '{request.Email.Trim()}' already exists.");
+
+        if (request.DefaultWarehouseId is not null)
+        {
+            var exists = await _warehouses.Query().AnyAsync(w => w.WarehouseId == request.DefaultWarehouseId, ct);
+            if (!exists) throw new NotFoundException($"Warehouse {request.DefaultWarehouseId} was not found.");
+        }
+
+        customer.CustomerCode = code;
+        customer.CustomerType = request.CustomerType;
+        customer.Name = name;
+        customer.DisplayName = Normalize(request.DisplayName);
+        customer.Phone = Normalize(request.Phone);
+        customer.Email = Normalize(request.Email);
+        customer.AddressLine1 = Normalize(request.AddressLine1);
+        customer.AddressLine2 = Normalize(request.AddressLine2);
+        customer.City = Normalize(request.City);
+        customer.Country = Normalize(request.Country);
+        customer.TaxRegistrationNo = Normalize(request.TaxRegistrationNo);
+        customer.CreditLimit = request.CreditLimit;
+        customer.CreditDays = request.CreditDays;
+        customer.DefaultWarehouseId = request.DefaultWarehouseId;
+        customer.UpdatedAt = DateTime.UtcNow;
+
+        await _uow.SaveChangesAsync(ct);
+        return new ETagged<CustomerDto>(Map(customer), customer.RowVersion);
+    }
+
+    public async Task SetStatusAsync(int customerId, EntityStatus status, CancellationToken ct = default)
+    {
+        var customer = await _customers.GetByIdAsync(customerId, ct)
+            ?? throw new NotFoundException($"Customer {customerId} was not found.");
+
+        customer.Status = status;
+        customer.UpdatedAt = DateTime.UtcNow;
+        await _uow.SaveChangesAsync(ct);
+    }
+
+    private static CustomerDto Map(Customer c) => new(
+        c.CustomerId, c.CustomerCode, c.CustomerType, c.Name, c.DisplayName, c.Phone, c.Email,
+        c.AddressLine1, c.AddressLine2, c.City, c.Country, c.TaxRegistrationNo,
+        c.CreditLimit, c.CreditDays, c.DefaultWarehouseId, c.Status, c.CreatedAt, c.UpdatedAt);
+
+    private static string? Normalize(string? value) => string.IsNullOrWhiteSpace(value) ? null : value.Trim();
+}

Backend/ERPCore/Services/GeneralLedgerService.cs

@@ -0,0 +1,16 @@
+using ERPCore.Infra.Gl;
+using ERPCore.Services.Interfaces;
+
+namespace ERPCore.Services;
+
+/// <inheritdoc cref="IGeneralLedgerService"/>
+public sealed class GeneralLedgerService : IGeneralLedgerService
+{
+    private readonly IGeneralLedgerClient _client;
+
+    public GeneralLedgerService(IGeneralLedgerClient client) => _client = client;
+
+    public Task<GeneralLedgerResponse> ForwardAsync(
+        HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
+        => _client.SendAsync(method, path, queryString, contentType, body, ct);
+}

Backend/ERPCore/Services/GrnService.cs

@@ -28,14 +28,12 @@ public sealed class GrnService : IGrnService
     private readonly IRepository<PurchaseOrder> _pos;
     private readonly IRepository<PoLine> _poLines;
     private readonly IRepository<Item> _items;
-    private readonly IRepository<Uom> _uoms;
     private readonly IRepository<Warehouse> _warehouses;
     private readonly IRepository<Bin> _bins;
     private readonly IRepository<Vendor> _vendors;
     private readonly IRepository<Batch> _batches;
     private readonly IRepository<StockLayer> _layers;
     private readonly IRepository<StockLedger> _ledger;
-    private readonly IUomConverter _uomConverter;
     private readonly IFifoCostingService _fifo;
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
@@ -43,23 +41,21 @@ public sealed class GrnService : IGrnService
 
     public GrnService(
         IRepository<Grn> grns, IRepository<PurchaseOrder> pos, IRepository<PoLine> poLines,
-        IRepository<Item> items, IRepository<Uom> uoms, IRepository<Warehouse> warehouses,
+        IRepository<Item> items, IRepository<Warehouse> warehouses,
         IRepository<Bin> bins, IRepository<Vendor> vendors, IRepository<Batch> batches,
-        IRepository<StockLayer> layers, IRepository<StockLedger> ledger, IUomConverter uomConverter,
+        IRepository<StockLayer> layers, IRepository<StockLedger> ledger,
         IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
     {
         _grns = grns;
         _pos = pos;
         _poLines = poLines;
         _items = items;
-        _uoms = uoms;
         _warehouses = warehouses;
         _bins = bins;
         _vendors = vendors;
         _batches = batches;
         _layers = layers;
         _ledger = ledger;
-        _uomConverter = uomConverter;
         _fifo = fifo;
         _numbers = numbers;
         _currentUser = currentUser;
@@ -95,7 +91,7 @@ public sealed class GrnService : IGrnService
     public async Task<GrnDto?> GetAsync(int grnId, CancellationToken ct = default)
     {
         var grn = await _grns.Query().AsNoTracking()
-            .Include(g => g.Lines)
+            .Include(g => g.Lines).ThenInclude(l => l.WarrantyNumbers)
             .FirstOrDefaultAsync(g => g.GrnId == grnId, ct);
         return grn is null ? null : Map(grn);
     }
@@ -133,8 +129,6 @@ public sealed class GrnService : IGrnService
         {
             var item = await _items.Query().AsNoTracking().FirstOrDefaultAsync(i => i.ItemId == input.ItemId, ct)
                 ?? throw new DomainException(ErrorCodes.Validation, $"Item {input.ItemId} does not exist.", 422);
-            if (!await _uoms.Query().AnyAsync(u => u.UomId == input.UomId, ct))
-                throw new DomainException(ErrorCodes.Validation, $"UOM {input.UomId} does not exist.", 422);
             if (input.BinId is not null && !await _bins.Query().AnyAsync(b => b.BinId == input.BinId && b.WarehouseId == request.WarehouseId, ct))
                 throw new DomainException(ErrorCodes.Validation, $"Bin {input.BinId} is not in warehouse {request.WarehouseId}.", 422);
 
@@ -150,6 +144,8 @@ public sealed class GrnService : IGrnService
                 if (poLine.ItemId != input.ItemId)
                     throw new DomainException(ErrorCodes.Validation, $"PO line {input.PoLineId} is for a different item.", 422);
 
+                // Both sides are counts of the item's base UOM — the GRN line no longer carries
+                // a unit of its own — so this comparison and the accrual below are like-for-like.
                 var openQty = poLine.Qty - poLine.QtyReceived;
                 if (input.Qty > openQty * (1 + OverReceiptTolerance))
                     throw new DomainException(ErrorCodes.OverReceiptTolerance,
@@ -169,12 +165,12 @@ public sealed class GrnService : IGrnService
             var vatAmount = Math.Round(receivedValue * input.VatPct / 100m, 4, MidpointRounding.AwayFromZero);
 
             var batch = await ResolveBatchAsync(item, input.Batch, batchCache, ct);
+            var warrantyNumbers = ResolveWarrantyNumbers(item, input.WarrantyNumbers, input.Qty);
 
             lines.Add(new GrnLine
             {
                 PoLineId = input.PoLineId,
                 ItemId = input.ItemId,
-                UomId = input.UomId,
                 BinId = input.BinId,
                 Batch = batch, // navigation so EF fixes up BatchId once the batch is inserted
                 Qty = input.Qty,
@@ -186,7 +182,8 @@ public sealed class GrnService : IGrnService
                 VatAmount = vatAmount,
                 ReceivedValue = receivedValue,
                 LineTotal = receivedValue + vatAmount,
-                HoldStatus = input.HoldStatus
+                HoldStatus = input.HoldStatus,
+                WarrantyNumbers = warrantyNumbers
             });
         }
 
@@ -234,10 +231,11 @@ public sealed class GrnService : IGrnService
         {
             foreach (var line in grn.Lines.OrderBy(l => l.GrnLineId))
             {
-                var item = await _items.Query().AsNoTracking().FirstAsync(i => i.ItemId == line.ItemId, token);
                 // FIFO layer costs at the after-discount net price; VAT is recoverable and never
-                // enters stock value (docs/10 FR-GRN-06, revised).
+                // enters stock value (docs/10 FR-GRN-06, revised). The line quantity is already
-                var (qtyBase, unitCostBase) = await ToBaseAsync(item, line.UomId, line.Qty, line.NetUnitCost, token);
+                // a count of the item's base UOM, so it layers exactly as entered.
+                var qtyBase = line.Qty;
+                var unitCostBase = line.NetUnitCost;
 
                 var layer = await _fifo.CreateInboundLayerAsync(
                     line.ItemId, grn.WarehouseId, line.BatchId, null, line.GrnLineId,
@@ -346,13 +344,28 @@ public sealed class GrnService : IGrnService
     }
 
     /// <summary>
-    /// Delegates to the shared <see cref="IUomConverter"/>. This was a private method here
+    /// A warranty-tracked item requires exactly one warranty number per received unit —
-    /// until manufacturing needed the same conversion for stage stock inputs; behaviour is
+    /// same shape of rule as <see cref="ResolveBatchAsync"/> for batch tracking. The coverage
-    /// identical, so receive costing is unchanged.
+    /// period is not entered at receipt; it is snapshotted from <see cref="Item.WarrantyPeriodMonths"/>,
+    /// which the item must have been given at creation (<see cref="ItemService"/> enforces that).
     /// </summary>
-    private Task<(decimal QtyBase, decimal UnitCostBase)> ToBaseAsync(
+    private static List<GrnLineWarrantyNumber> ResolveWarrantyNumbers(Item item, List<string>? numbers, decimal qty)
-        Item item, int uomId, decimal qty, decimal unitCostPerUom, CancellationToken ct)
+    {
-        => _uomConverter.ToBaseAsync(item, uomId, qty, unitCostPerUom, ct);
+        if (item.Warranty != Warranty.Warranty) return new List<GrnLineWarrantyNumber>();
+        if (item.WarrantyPeriodMonths is null)
+            throw new DomainException(
+                ErrorCodes.Validation, $"Item {item.Sku} is under warranty but has no warranty period configured.", 422);
+
+        var trimmed = (numbers ?? new List<string>()).Select(n => n.Trim()).Where(n => n.Length > 0).ToList();
+        if (trimmed.Count != qty)
+            throw new DomainException(
+                ErrorCodes.Validation,
+                $"Item {item.Sku} is under warranty; provide exactly {qty} warranty number(s), got {trimmed.Count}.", 422);
+        if (trimmed.Distinct(StringComparer.OrdinalIgnoreCase).Count() != trimmed.Count)
+            throw new DomainException(ErrorCodes.Validation, $"Warranty numbers for item {item.Sku} must be unique.", 422);
+
+        return trimmed.Select(n => new GrnLineWarrantyNumber { WarrantyNo = n, WarrantyPeriodMonths = item.WarrantyPeriodMonths.Value }).ToList();
+    }
 
     private async Task UpdatePoStatusAsync(int? poId, CancellationToken ct)
     {
@@ -392,8 +405,9 @@ public sealed class GrnService : IGrnService
     private static GrnDto Map(Grn g) => new(
         g.GrnId, g.DocNo, g.PoId, g.VendorId, g.WarehouseId, g.Status, g.CreatedBy, g.CreatedAt, g.PostedAt,
         g.Lines.OrderBy(l => l.GrnLineId).Select(l => new GrnLineDto(
-            l.GrnLineId, l.PoLineId, l.ItemId, l.UomId, l.BinId, l.Qty, l.UnitCost, l.PoUnitPrice,
+            l.GrnLineId, l.PoLineId, l.ItemId, l.BinId, l.Qty, l.UnitCost, l.PoUnitPrice,
             l.DiscountPct, l.NetUnitCost, l.VatPct, l.VatAmount, l.ReceivedValue, l.LineTotal,
             l.PoUnitPrice is null ? 0m : Math.Round((l.UnitCost - l.PoUnitPrice.Value) * l.Qty, 4, MidpointRounding.AwayFromZero),
-            l.HoldStatus, l.BatchId)).ToList());
+            l.HoldStatus, l.BatchId,
+            l.WarrantyNumbers.Select(w => new GrnLineWarrantyNumberDto(w.WarrantyNo, w.WarrantyPeriodMonths)).ToList())).ToList());
 }

Backend/ERPCore/Services/Interfaces/IBundleSaleService.cs

@@ -0,0 +1,19 @@
+using ERPCore.Common.Http;
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+
+namespace ERPCore.Services.Interfaces;
+
+public interface IBundleSaleService
+{
+    Task<PagedResponse<BundleSaleTemplateSummaryDto>> ListTemplatesAsync(PageQuery query, CancellationToken ct = default);
+    Task<BundleSaleTemplateDto?> GetTemplateAsync(int bundleSaleTemplateId, CancellationToken ct = default);
+    Task<PagedResponse<BundleSaleSummaryDto>> ListAsync(PageQuery query, BundleSaleStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default);
+    Task<BundleSaleDto?> GetAsync(int bundleSaleId, CancellationToken ct = default);
+    Task<BundleSalePostingCheckDto> CheckPostingAsync(int bundleSaleId, CancellationToken ct = default);
+    Task<BundleSaleDto> CreateAsync(CreateBundleSaleRequest request, CancellationToken ct = default);
+    Task<BundleSaleDto> UpdateAsync(int bundleSaleId, UpdateBundleSaleRequest request, CancellationToken ct = default);
+    Task<BundleSaleDto> PostAsync(int bundleSaleId, CancellationToken ct = default);
+    Task<BundleSaleDto> CancelAsync(int bundleSaleId, CancellationToken ct = default);
+}