Add backup images for login and background removal

- Added loginerps.png.bak (1134 KB) as a backup for the login image.
- Added whithoutbackground.png.bak (3455 KB) as a backup for the image without background.

.gitignore

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

Backend/ERPCore.Tests/ERPCore.Tests.csproj

@@ -0,0 +1,26 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net10.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <IsPackable>false</IsPackable>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <PackageReference Include="Microsoft.EntityFrameworkCore.InMemory" Version="10.0.9" />
+    <PackageReference Include="coverlet.collector" Version="6.0.4" />
+    <PackageReference Include="Microsoft.NET.Test.Sdk" Version="17.14.1" />
+    <PackageReference Include="xunit" Version="2.9.3" />
+    <PackageReference Include="xunit.runner.visualstudio" Version="3.1.4" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\ERPCore\ERPCore.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <Using Include="Xunit" />
+  </ItemGroup>
+
+</Project>

Backend/ERPCore.Tests/NotificationConfigServiceTests.cs

@@ -0,0 +1,152 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Notifications;
+using ERPCore.Repositories;
+using ERPCore.Services;
+using ERPCore.System.Errors;
+using ERPCore.Tests.TestSupport;
+using Microsoft.EntityFrameworkCore;
+
+namespace ERPCore.Tests;
+
+public class NotificationConfigServiceTests
+{
+    [Fact]
+    public async Task GetAsync_MergesSavedValuesWithDiscoveredModules()
+    {
+        var dbName = Guid.NewGuid().ToString("N");
+        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
+        await NotificationConfigTestSupport.SeedAsync(db, new[]
+        {
+            new NotificationConfigModule
+            {
+                ModuleKey = "sale.create",
+                EmailEnabled = true,
+                SmsEnabled = false,
+                InAppEnabled = true
+            }
+        });
+
+        var service = CreateService(db);
+
+        var result = await service.GetAsync();
+
+        Assert.Equal(7u, result.RowVersion);
+        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "sale.create" && m.EmailEnabled && !m.SmsEnabled && m.InAppEnabled);
+        Assert.Contains(result.Value.Modules, m => m.ModuleKey == "grn.confirmed" && !m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_PersistsEmptyAndMultiChannelSelections()
+    {
+        var dbName = Guid.NewGuid().ToString("N");
+        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
+        await NotificationConfigTestSupport.SeedAsync(db);
+
+        var service = CreateService(db);
+        var catalog = new NotificationModuleCatalog();
+        var request = new ERPCore.Dtos.Notifications.UpdateNotificationConfigRequest
+        {
+            Modules = catalog.GetAll().Select((module, index) => new ERPCore.Dtos.Notifications.UpdateNotificationModuleRequest
+            {
+                ModuleKey = module.Key,
+                EmailEnabled = index == 0,
+                SmsEnabled = index == 1,
+                InAppEnabled = index == 1
+            }).ToList()
+        };
+
+        var updated = await service.UpdateAsync(request, 7);
+
+        Assert.Equal(7u, updated.RowVersion);
+        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[0].Key && m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
+        Assert.Contains(updated.Value.Modules, m => m.ModuleKey == catalog.GetAll()[1].Key && !m.EmailEnabled && m.SmsEnabled && m.InAppEnabled);
+
+        await using var verifyDb = NotificationConfigTestSupport.CreateContext(dbName);
+        var persisted = await verifyDb.NotificationConfigModules.AsNoTracking().ToListAsync();
+        Assert.Contains(persisted, m => m.ModuleKey == catalog.GetAll()[0].Key && m.EmailEnabled && !m.SmsEnabled && !m.InAppEnabled);
+        Assert.Contains(persisted, m => m.ModuleKey == catalog.GetAll()[1].Key && !m.EmailEnabled && m.SmsEnabled && m.InAppEnabled);
+    }
+
+    [Fact]
+    public async Task ResolveEnabledChannelsAsync_ReturnsEmptyWhenNothingEnabled()
+    {
+        var dbName = Guid.NewGuid().ToString("N");
+        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
+        await NotificationConfigTestSupport.SeedAsync(db, new[]
+        {
+            new NotificationConfigModule
+            {
+                ModuleKey = "sale.create",
+                EmailEnabled = false,
+                SmsEnabled = false,
+                InAppEnabled = false
+            }
+        });
+
+        var service = CreateService(db);
+
+        var channels = await service.ResolveEnabledChannelsAsync("sale.create");
+
+        Assert.Empty(channels);
+    }
+
+    [Fact]
+    public async Task ResolveEnabledChannelsAsync_ReturnsMultipleChannels()
+    {
+        var dbName = Guid.NewGuid().ToString("N");
+        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
+        await NotificationConfigTestSupport.SeedAsync(db, new[]
+        {
+            new NotificationConfigModule
+            {
+                ModuleKey = "sale.create",
+                EmailEnabled = true,
+                SmsEnabled = true,
+                InAppEnabled = false
+            }
+        });
+
+        var service = CreateService(db);
+
+        var channels = await service.ResolveEnabledChannelsAsync("sale.create");
+
+        Assert.Equal(new[] { NotificationChannel.Email, NotificationChannel.Sms }, channels);
+    }
+
+    [Fact]
+    public async Task UpdateAsync_MapsConcurrencyFailuresToDomainException()
+    {
+        var dbName = Guid.NewGuid().ToString("N");
+        await using var db = NotificationConfigTestSupport.CreateContext(dbName);
+        await NotificationConfigTestSupport.SeedAsync(db);
+
+        var service = CreateService(db, new ThrowingUnitOfWork());
+        var catalog = new NotificationModuleCatalog();
+        var request = new ERPCore.Dtos.Notifications.UpdateNotificationConfigRequest
+        {
+            Modules = catalog.GetAll().Select(module => new ERPCore.Dtos.Notifications.UpdateNotificationModuleRequest
+            {
+                ModuleKey = module.Key,
+                EmailEnabled = false,
+                SmsEnabled = false,
+                InAppEnabled = false
+            }).ToList()
+        };
+
+        var ex = await Assert.ThrowsAsync<DomainException>(() => service.UpdateAsync(request, 7));
+        Assert.Equal(ErrorCodes.ConcurrencyConflict, ex.Code);
+        Assert.Equal(412, ex.StatusCode);
+    }
+
+    private static NotificationConfigService CreateService(ERPCore.Infra.Persistence.ErpDbContext db, ERPCore.Infra.UoW.IUnitOfWork? uow = null)
+    {
+        var configRepo = new Repository<NotificationConfig>(db);
+        var moduleRepo = new Repository<NotificationConfigModule>(db);
+        return new NotificationConfigService(
+            configRepo,
+            moduleRepo,
+            new NotificationModuleCatalog(),
+            new TestCurrentUser(),
+            uow ?? new ERPCore.Infra.UoW.UnitOfWork(db));
+    }
+}

Backend/ERPCore.Tests/NotificationModuleCatalogTests.cs

@@ -0,0 +1,17 @@
+using ERPCore.Services;
+
+namespace ERPCore.Tests;
+
+public class NotificationModuleCatalogTests
+{
+    [Fact]
+    public void GetAll_ReturnsStableUniqueModuleKeys()
+    {
+        var catalog = new NotificationModuleCatalog();
+
+        Assert.NotEmpty(catalog.GetAll());
+        Assert.Contains(catalog.GetAll(), m => m.Key == "sale.create");
+        Assert.Contains(catalog.GetAll(), m => m.Key == "grn.confirmed");
+        Assert.Equal(catalog.GetAll().Count, catalog.GetAll().Select(m => m.Key).Distinct(StringComparer.OrdinalIgnoreCase).Count());
+    }
+}

Backend/ERPCore.Tests/TestSupport/NotificationConfigTestSupport.cs

@@ -0,0 +1,70 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Infra.Auth;
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Storage;
+
+namespace ERPCore.Tests.TestSupport;
+
+internal sealed class TestCurrentUser : ICurrentUser
+{
+    public string UserId => "system";
+    public int AuditUserId => User.SystemUserId;
+    public bool IsAuthenticated => false;
+}
+
+internal sealed class ThrowingUnitOfWork : ERPCore.Infra.UoW.IUnitOfWork
+{
+    public Task<int> SaveChangesAsync(CancellationToken ct = default)
+        => throw new DbUpdateConcurrencyException("Test concurrency conflict.");
+
+    public Task ExecuteInTransactionAsync(Func<CancellationToken, Task> action, CancellationToken ct = default)
+        => throw new NotSupportedException();
+
+    public Task<T> ExecuteInTransactionAsync<T>(Func<CancellationToken, Task<T>> action, CancellationToken ct = default)
+        => throw new NotSupportedException();
+}
+
+internal static class NotificationConfigTestSupport
+{
+    private static readonly InMemoryDatabaseRoot Root = new();
+
+    public static ErpDbContext CreateContext(string name)
+    {
+        var options = new DbContextOptionsBuilder<ErpDbContext>()
+            .UseInMemoryDatabase(name, Root)
+            .Options;
+
+        return new ErpDbContext(options, new TestCurrentUser());
+    }
+
+    public static async Task SeedAsync(ErpDbContext db, IEnumerable<NotificationConfigModule>? modules = null)
+    {
+        db.Users.Add(new User
+        {
+            UserId = User.SystemUserId,
+            Username = "system",
+            DisplayName = "System"
+        });
+
+        var config = new NotificationConfig
+        {
+            NotificationConfigId = NotificationConfig.SingletonId,
+            UpdatedBy = User.SystemUserId,
+            UpdatedAt = DateTime.UtcNow,
+            RowVersion = 7,
+        };
+
+        if (modules is not null)
+        {
+            foreach (var module in modules)
+            {
+                module.NotificationConfigId = NotificationConfig.SingletonId;
+                config.Modules.Add(module);
+            }
+        }
+
+        db.NotificationConfig.Add(config);
+        await db.SaveChangesAsync();
+    }
+}

Backend/ERPCore/Controllers/BranchConfigController.cs

@@ -0,0 +1,44 @@
+using ERPCore.Dtos.Config;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>
+/// Branch configuration endpoints — the singleton toggle for whether this deployment
+/// requires a branch on Employee/Warehouse records at all.
+/// <para>
+/// <b>Authorization:</b> writes are admitted by the inherited ERP door policy only, same
+/// Phase-1 posture as <see cref="ProductConfigController"/> — any ERP-admitted user can
+/// flip this flag until per-endpoint RBAC lands.
+/// </para>
+/// </summary>
+[Route("api/v1/branch-config")]
+public sealed class BranchConfigController : ApiControllerBase
+{
+    private readonly IBranchConfigService _config;
+
+    public BranchConfigController(IBranchConfigService config) => _config = config;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(BranchConfigDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<BranchConfigDto>> Get(CancellationToken ct)
+    {
+        var result = await _config.GetAsync(ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPut]
+    [ProducesResponseType(typeof(BranchConfigDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<BranchConfigDto>> Update(
+        [FromBody] UpdateBranchConfigRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _config.UpdateAsync(request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+}

Backend/ERPCore/Controllers/BundleSalesController.cs

@@ -0,0 +1,88 @@
+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);
+    }
+
+    [HttpPost("templates")]
+    [ProducesResponseType(typeof(BundleSaleTemplateDto), StatusCodes.Status201Created)]
+    public async Task<ActionResult<BundleSaleTemplateDto>> CreateTemplate([FromBody] CreateBundleSaleTemplateRequest request, CancellationToken ct)
+    {
+        var result = await _bundles.CreateTemplateAsync(request, ct);
+        return Created($"/api/v1/bundle-sales/templates/{result.BundleSaleTemplateId}", 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/DashboardController.cs

@@ -15,6 +15,6 @@ public sealed class DashboardController : ApiControllerBase
     /// <summary>Aggregate counts for stock, GRN, and procurement.</summary>
     [HttpGet("stats")]
     [ProducesResponseType(typeof(DashboardStatsDto), StatusCodes.Status200OK)]
-    public async Task<ActionResult<DashboardStatsDto>> GetStats(CancellationToken ct)
-        => Ok(await _dashboard.GetStatsAsync(ct));
+    public async Task<ActionResult<DashboardStatsDto>> GetStats([FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _dashboard.GetStatsAsync(branchId, ct));
 }

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/GrnsController.cs

@@ -12,15 +12,18 @@ public sealed class GrnsController : ApiControllerBase
 {
     private readonly IGrnService _grns;
 
-    public GrnsController(IGrnService grns) => _grns = grns;
+    public GrnsController(IGrnService grns)
+    {
+        _grns = grns;
+    }
 
     /// <summary>List GRNs, newest first.</summary>
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<GrnSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<GrnSummaryDto>>> List(
         [FromQuery] PageQuery query, [FromQuery] GrnStatus? status, [FromQuery] int? poId,
-        [FromQuery] int? vendorId, [FromQuery] int? warehouseId, CancellationToken ct)
-        => Ok(await _grns.ListAsync(query, status, poId, vendorId, warehouseId, ct));
+        [FromQuery] int? vendorId, [FromQuery] int? warehouseId, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _grns.ListAsync(query, status, poId, vendorId, warehouseId, branchId, ct));
 
     [HttpGet("{grnId:int}")]
     [ProducesResponseType(typeof(GrnDto), StatusCodes.Status200OK)]

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/NotificationConfigController.cs

@@ -0,0 +1,34 @@
+using ERPCore.Dtos.Notifications;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+[Route("api/v1/notification-config")]
+public sealed class NotificationConfigController : ApiControllerBase
+{
+    private readonly INotificationConfigService _config;
+
+    public NotificationConfigController(INotificationConfigService config) => _config = config;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(NotificationConfigDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<NotificationConfigDto>> Get(CancellationToken ct)
+    {
+        var result = await _config.GetAsync(ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPut]
+    [ProducesResponseType(typeof(NotificationConfigDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<NotificationConfigDto>> Update([FromBody] UpdateNotificationConfigRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _config.UpdateAsync(request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+}

Backend/ERPCore/Controllers/ProductionRunsController.cs

@@ -0,0 +1,170 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Production run endpoints (docs/30-BACKEND-PHASE2.md §D.2–D.3).</summary>
+[Route("api/v1/production-runs")]
+public sealed class ProductionRunsController : ApiControllerBase
+{
+    private readonly IProductionRunService _runs;
+
+    public ProductionRunsController(IProductionRunService runs) => _runs = runs;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<RunSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<RunSummaryDto>>> List(
+        [FromQuery] PageQuery query,
+        [FromQuery] ProductionRunStatus? status,
+        [FromQuery] int? templateId,
+        [FromQuery] int? warehouseId,
+        CancellationToken ct)
+        => Ok(await _runs.ListAsync(query, status, templateId, warehouseId, ct));
+
+    /// <summary>Produced-items report (FR-MFG-13): one row per run that has produced
+    /// something, plus a summary total over every filtered row.</summary>
+    [HttpGet("produced")]
+    [ProducesResponseType(typeof(ProducedListResponseDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<ProducedListResponseDto>> ListProduced(
+        [FromQuery] DateOnly? from,
+        [FromQuery] DateOnly? to,
+        [FromQuery] int? templateId,
+        [FromQuery] int? warehouseId,
+        [FromQuery] ProductionRunStatus? status,
+        CancellationToken ct)
+        => Ok(await _runs.ListProducedAsync(from, to, templateId, warehouseId, status, ct));
+
+    [HttpGet("{runId:int}")]
+    [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<RunGraphDto>> GetById(int runId, CancellationToken ct)
+    {
+        var result = await _runs.GetAsync(runId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(RunGraphDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunGraphDto>> Create([FromBody] CreateRunRequest request, CancellationToken ct)
+    {
+        var result = await _runs.CreateAsync(request, ct);
+
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/production-runs/{result.Value.RunId}", result.Value);
+    }
+
+    [HttpPut("{runId:int}/stages/{runStageId:int}/quantities")]
+    [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunStageDto>> UpdateQuantities(
+        int runId, int runStageId, [FromBody] UpdateStageQuantitiesRequest request, CancellationToken ct)
+        => Ok(await _runs.UpdateStageQuantitiesAsync(runId, runStageId, request, ct));
+
+    // --- stage actions (docs/30 §D.3) ---------------------------------------
+    //
+    // Idempotency-Key is accepted on every action to match the Phase-1 contract (docs/11
+    // §1.6) but, as in GrnService.ConfirmAsync, it is not stored. Replay safety comes from
+    // the status guards instead: a double-fire finds the stage already moved on and gets a
+    // 409, which docs/21 §6 tells the client to treat as a silent refetch. Recorded as a
+    // deviation from §D.3's "idempotency-key honored".
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/start")]
+    [ProducesResponseType(typeof(StartStageResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<StartStageResultDto>> Start(
+        int runId, int runStageId,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.StartStageAsync(runId, runStageId, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/complete")]
+    [ProducesResponseType(typeof(RunStageDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<RunStageDto>> Complete(
+        int runId, int runStageId, [FromBody] CompleteStageRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.CompleteStageAsync(runId, runStageId, request, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/approve")]
+    [ProducesResponseType(typeof(ApproveStageResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<ApproveStageResultDto>> Approve(
+        int runId, int runStageId, [FromBody] ApproveStageRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.ApproveStageAsync(runId, runStageId, request ?? new ApproveStageRequest(), ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/transfer")]
+    [ProducesResponseType(typeof(TransferResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TransferResultDto>> Transfer(
+        int runId, int runStageId, [FromBody] TransferRemainderRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.TransferAsync(runId, runStageId, request, ct));
+
+    [HttpPost("{runId:int}/inputs/{runInputId:int}/return-leftover")]
+    [ProducesResponseType(typeof(ReturnLeftoverResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<ReturnLeftoverResultDto>> ReturnLeftover(
+        int runId, int runInputId, [FromBody] ReturnLeftoverRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.ReturnLeftoverAsync(runId, runInputId, request, ct));
+
+    [HttpPost("{runId:int}/stages/{runStageId:int}/reject-intake")]
+    [ProducesResponseType(typeof(RejectIntakeResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<RejectIntakeResultDto>> RejectIntake(
+        int runId, int runStageId, [FromBody] RejectRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.RejectIntakeAsync(runId, runStageId, request ?? new RejectRequest(), ct));
+
+    /// <summary>Terminal reject — resets the whole run for a rework pass (FR-MFG-16).</summary>
+    [HttpPost("{runId:int}/stages/{runStageId:int}/reject")]
+    [ProducesResponseType(typeof(TerminalRejectResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<TerminalRejectResultDto>> Reject(
+        int runId, int runStageId, [FromBody] RejectRequest? request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.RejectTerminalAsync(runId, runStageId, request ?? new RejectRequest(), ct));
+
+    [HttpPost("{runId:int}/cancel")]
+    [ProducesResponseType(typeof(CancelRunResultDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<CancelRunResultDto>> Cancel(
+        int runId, [FromBody] CancelRunRequest request,
+        [FromHeader(Name = "Idempotency-Key")] string? idempotencyKey,
+        CancellationToken ct)
+        => Ok(await _runs.CancelAsync(runId, request, ct));
+}

Backend/ERPCore/Controllers/ProductionTemplatesController.cs

@@ -0,0 +1,73 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Production;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Production template endpoints (docs/30-BACKEND-PHASE2.md §D.1).</summary>
+[Route("api/v1/production-templates")]
+public sealed class ProductionTemplatesController : ApiControllerBase
+{
+    private readonly IProductionTemplateService _templates;
+
+    public ProductionTemplatesController(IProductionTemplateService templates) => _templates = templates;
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<TemplateSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<TemplateSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] EntityStatus? status, CancellationToken ct)
+        => Ok(await _templates.ListAsync(query, status, ct));
+
+    [HttpGet("{templateId:int}")]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<TemplateGraphDto>> GetById(int templateId, CancellationToken ct)
+    {
+        var result = await _templates.GetAsync(templateId, ct);
+        if (result is null) return NotFound();
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TemplateGraphDto>> Create(
+        [FromBody] SaveTemplateRequest request, CancellationToken ct)
+    {
+        var result = await _templates.CreateAsync(request, ct);
+
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/production-templates/{result.Value.TemplateId}", result.Value);
+    }
+
+    [HttpPut("{templateId:int}")]
+    [ProducesResponseType(typeof(TemplateGraphDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<TemplateGraphDto>> Update(
+        int templateId, [FromBody] SaveTemplateRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _templates.UpdateAsync(templateId, request, expected, ct);
+
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPatch("{templateId:int}/status")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> SetStatus(
+        int templateId, [FromBody] UpdateTemplateStatusRequest request, CancellationToken ct)
+    {
+        await _templates.SetStatusAsync(templateId, request.Status, ct);
+        return NoContent();
+    }
+}

Backend/ERPCore/Controllers/PurchaseInvoicesController.cs

@@ -0,0 +1,102 @@
+using ERPCore.Domain.Enums;
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Grn;
+using ERPCore.Dtos.Procurement;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Purchase invoice endpoints — vendor invoices consolidating Confirmed GRNs.</summary>
+[Route("api/v1/purchase-invoices")]
+public sealed class PurchaseInvoicesController : ApiControllerBase
+{
+    private readonly IPurchaseInvoiceService _invoices;
+    private readonly IPurchaseInvoicePaymentService _payments;
+
+    public PurchaseInvoicesController(IPurchaseInvoiceService invoices, IPurchaseInvoicePaymentService payments)
+    {
+        _invoices = invoices;
+        _payments = payments;
+    }
+
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<PurchaseInvoiceSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<PurchaseInvoiceSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] PurchaseInvoiceStatus? status, [FromQuery] int? vendorId, CancellationToken ct)
+        => Ok(await _invoices.ListAsync(query, status, vendorId, ct));
+
+    /// <summary>Confirmed, not-yet-invoiced GRNs for a vendor — candidates for a new/edited invoice.</summary>
+    [HttpGet("eligible-grns")]
+    [ProducesResponseType(typeof(IReadOnlyList<GrnEligibleForInvoiceDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<IReadOnlyList<GrnEligibleForInvoiceDto>>> EligibleGrns([FromQuery] int vendorId, CancellationToken ct)
+        => Ok(await _invoices.ListEligibleGrnsAsync(vendorId, ct));
+
+    [HttpGet("{purchaseInvoiceId:int}")]
+    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<PurchaseInvoiceDto>> GetById(int purchaseInvoiceId, CancellationToken ct)
+    {
+        var result = await _invoices.GetAsync(purchaseInvoiceId, ct);
+        if (result is null) return NotFound();
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost]
+    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status422UnprocessableEntity)]
+    public async Task<ActionResult<PurchaseInvoiceDto>> Create([FromBody] CreatePurchaseInvoiceRequest request, CancellationToken ct)
+    {
+        var result = await _invoices.CreateAsync(request, ct);
+        SetETag(result.RowVersion);
+        return Created($"/api/v1/purchase-invoices/{result.Value.PurchaseInvoiceId}", result.Value);
+    }
+
+    [HttpPut("{purchaseInvoiceId:int}")]
+    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    [ProducesResponseType(StatusCodes.Status412PreconditionFailed)]
+    public async Task<ActionResult<PurchaseInvoiceDto>> Update(int purchaseInvoiceId, [FromBody] UpdatePurchaseInvoiceRequest request, CancellationToken ct)
+    {
+        var expected = RequireIfMatch();
+        var result = await _invoices.UpdateAsync(purchaseInvoiceId, request, expected, ct);
+        SetETag(result.RowVersion);
+        return Ok(result.Value);
+    }
+
+    [HttpPost("{purchaseInvoiceId:int}/post")]
+    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PurchaseInvoiceDto>> Post(int purchaseInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.PostAsync(purchaseInvoiceId, ct));
+
+    [HttpPost("{purchaseInvoiceId:int}/cancel")]
+    [ProducesResponseType(typeof(PurchaseInvoiceDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PurchaseInvoiceDto>> Cancel(int purchaseInvoiceId, CancellationToken ct)
+        => Ok(await _invoices.CancelAsync(purchaseInvoiceId, ct));
+
+    /// <summary>Pay the vendor against this invoice's balance, in full or in installments; posts a real GL journal entry.</summary>
+    [HttpPost("{purchaseInvoiceId:int}/payments")]
+    [ProducesResponseType(typeof(PurchaseInvoicePaymentDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<PurchaseInvoicePaymentDto>> Pay(int purchaseInvoiceId, [FromBody] CreatePurchaseInvoicePaymentRequest request, CancellationToken ct)
+    {
+        var dto = await _payments.PayAsync(purchaseInvoiceId, request, ct);
+        return Created($"/api/v1/purchase-invoices/{purchaseInvoiceId}/payments/{dto.PurchaseInvoicePaymentId}", dto);
+    }
+
+    /// <summary>Payment history for this invoice, newest first.</summary>
+    [HttpGet("{purchaseInvoiceId:int}/payments")]
+    [ProducesResponseType(typeof(IReadOnlyList<PurchaseInvoicePaymentDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<IReadOnlyList<PurchaseInvoicePaymentDto>>> ListPayments(int purchaseInvoiceId, CancellationToken ct)
+        => Ok(await _payments.ListAsync(purchaseInvoiceId, ct));
+}

Backend/ERPCore/Controllers/SalesDayEndController.cs

@@ -0,0 +1,50 @@
+using ERPCore.Dtos.Common;
+using ERPCore.Dtos.Sales;
+using ERPCore.Services.Interfaces;
+using Microsoft.AspNetCore.Mvc;
+
+namespace ERPCore.Controllers;
+
+/// <summary>Cashier day-end close-out — locks a cashier's Posted sales slips for a business
+/// date and posts one consolidated GL journal entry for the day (docs/14 Sales API).</summary>
+[Route("api/v1/sales-day-end")]
+public sealed class SalesDayEndController : ApiControllerBase
+{
+    private readonly ISalesDayEndService _dayEnds;
+
+    public SalesDayEndController(ISalesDayEndService dayEnds) => _dayEnds = dayEnds;
+
+    /// <summary>List day-end closes, newest first.</summary>
+    [HttpGet]
+    [ProducesResponseType(typeof(PagedResponse<SalesDayEndSummaryDto>), StatusCodes.Status200OK)]
+    public async Task<ActionResult<PagedResponse<SalesDayEndSummaryDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] int? cashierUserId, CancellationToken ct)
+        => Ok(await _dayEnds.ListAsync(query, cashierUserId, ct));
+
+    /// <summary>What closing this cashier/date right now would include (or the existing close's totals, if already closed).</summary>
+    [HttpGet("preview")]
+    [ProducesResponseType(typeof(SalesDayEndPreviewDto), StatusCodes.Status200OK)]
+    public async Task<ActionResult<SalesDayEndPreviewDto>> Preview(
+        [FromQuery] int cashierUserId, [FromQuery] DateOnly? businessDate, CancellationToken ct)
+        => Ok(await _dayEnds.PreviewAsync(cashierUserId, businessDate ?? DateOnly.FromDateTime(DateTime.UtcNow), ct));
+
+    [HttpGet("{salesDayEndId:int}")]
+    [ProducesResponseType(typeof(SalesDayEndDto), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<SalesDayEndDto>> GetById(int salesDayEndId, CancellationToken ct)
+    {
+        var dto = await _dayEnds.GetAsync(salesDayEndId, ct);
+        return dto is null ? NotFound() : Ok(dto);
+    }
+
+    /// <summary>Close the day: lock every Posted slip for (CashierUserId, BusinessDate) and post the
+    /// consolidated GL journal entry. Idempotent — closing an already-closed date replays it.</summary>
+    [HttpPost]
+    [ProducesResponseType(typeof(SalesDayEndDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<SalesDayEndDto>> Close([FromBody] CreateSalesDayEndRequest request, CancellationToken ct)
+    {
+        var dto = await _dayEnds.CloseAsync(request, ct);
+        return Created($"/api/v1/sales-day-end/{dto.SalesDayEndId}", dto);
+    }
+}

Backend/ERPCore/Controllers/SalesInvoicesController.cs

@@ -0,0 +1,98 @@
+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;
+    private readonly ISalesInvoicePaymentService _payments;
+
+    public SalesInvoicesController(ISalesInvoiceService invoices, ISalesInvoicePaymentService payments)
+    {
+        _invoices = invoices;
+        _payments = payments;
+    }
+
+    [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,
+        [FromQuery] int? branchId,
+        CancellationToken ct)
+        => Ok(await _invoices.ListAsync(query, status, customerId, warehouseId, branchId, 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));
+
+    /// <summary>Pay the customer's balance against this invoice, in full or in installments; posts a real GL journal entry.</summary>
+    [HttpPost("{salesInvoiceId:int}/payments")]
+    [ProducesResponseType(typeof(SalesInvoicePaymentDto), StatusCodes.Status201Created)]
+    [ProducesResponseType(StatusCodes.Status400BadRequest)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    [ProducesResponseType(StatusCodes.Status409Conflict)]
+    public async Task<ActionResult<SalesInvoicePaymentDto>> Pay(int salesInvoiceId, [FromBody] CreateSalesInvoicePaymentRequest request, CancellationToken ct)
+    {
+        var dto = await _payments.PayAsync(salesInvoiceId, request, ct);
+        return Created($"/api/v1/sales-invoices/{salesInvoiceId}/payments/{dto.SalesInvoicePaymentId}", dto);
+    }
+
+    /// <summary>Payment history for this invoice, newest first.</summary>
+    [HttpGet("{salesInvoiceId:int}/payments")]
+    [ProducesResponseType(typeof(IReadOnlyList<SalesInvoicePaymentDto>), StatusCodes.Status200OK)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<ActionResult<IReadOnlyList<SalesInvoicePaymentDto>>> ListPayments(int salesInvoiceId, CancellationToken ct)
+        => Ok(await _payments.ListAsync(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/Controllers/StockAdjustmentsController.cs

@@ -17,8 +17,8 @@ public sealed class StockAdjustmentsController : ApiControllerBase
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<AdjustmentSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<AdjustmentSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? reasonCodeId, CancellationToken ct)
-        => Ok(await _adjustments.ListAsync(query, warehouseId, reasonCodeId, ct));
+        [FromQuery] PageQuery query, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] int? reasonCodeId, CancellationToken ct)
+        => Ok(await _adjustments.ListAsync(query, warehouseId, branchId, reasonCodeId, ct));
 
     /// <summary>Get one adjustment with its lines and the ledger entries it posted.</summary>
     [HttpGet("{adjustmentId:int}")]

Backend/ERPCore/Controllers/StockController.cs

@@ -28,8 +28,8 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("on-hand/list")]
     [ProducesResponseType(typeof(PagedResponse<StockOnHandDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<StockOnHandDto>>> OnHandList(
-        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _stock.GetOnHandListAsync(itemId, warehouseId, query, ct));
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _stock.GetOnHandListAsync(itemId, warehouseId, branchId, query, ct));
 
     /// <summary>
     /// Immutable movement history. <c>sourceDocType</c>/<c>sourceDocId</c> answer "what did
@@ -39,11 +39,11 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("ledger")]
     [ProducesResponseType(typeof(PagedResponse<StockLedgerRowDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<StockLedgerRowDto>>> Ledger(
-        [FromQuery] int? itemId, [FromQuery] int? warehouseId,
+        [FromQuery] int? itemId, [FromQuery] int? warehouseId, [FromQuery] int? branchId,
         [FromQuery] DateOnly? from, [FromQuery] DateOnly? to,
         [FromQuery] string? sourceDocType, [FromQuery] int? sourceDocId,
         [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _stock.GetLedgerAsync(itemId, warehouseId, from, to, sourceDocType, sourceDocId, query, ct));
+        => Ok(await _stock.GetLedgerAsync(itemId, warehouseId, branchId, from, to, sourceDocType, sourceDocId, query, ct));
 
     [HttpGet("valuation")]
     [ProducesResponseType(typeof(StockValuationDto), StatusCodes.Status200OK)]
@@ -54,8 +54,8 @@ public sealed class StockController : ApiControllerBase
     [HttpGet("reorder-alerts")]
     [ProducesResponseType(typeof(PagedResponse<ReorderAlertDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<ReorderAlertDto>>> ReorderAlerts(
-        [FromQuery] int? warehouseId, [FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _reorder.GetAlertsAsync(warehouseId, query, ct));
+        [FromQuery] int? warehouseId, [FromQuery] int? branchId, [FromQuery] PageQuery query, CancellationToken ct)
+        => Ok(await _reorder.GetAlertsAsync(warehouseId, branchId, query, ct));
 
     /// <summary>Create a draft requisition for an item's suggested reorder quantity.</summary>
     [HttpPost("reorder-alerts/{itemId:int}/requisition")]

Backend/ERPCore/Controllers/StockCountsController.cs

@@ -18,8 +18,8 @@ public sealed class StockCountsController : ApiControllerBase
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<CountSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<CountSummaryDto>>> List(
-        [FromQuery] PageQuery query, [FromQuery] CountStatus? status, [FromQuery] int? warehouseId, CancellationToken ct)
-        => Ok(await _counts.ListAsync(query, status, warehouseId, ct));
+        [FromQuery] PageQuery query, [FromQuery] CountStatus? status, [FromQuery] int? warehouseId, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _counts.ListAsync(query, status, warehouseId, branchId, ct));
 
     [HttpGet("{countId:int}")]
     [ProducesResponseType(typeof(CountDto), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/StockTransfersController.cs

@@ -19,8 +19,8 @@ public sealed class StockTransfersController : ApiControllerBase
     [ProducesResponseType(typeof(PagedResponse<TransferSummaryDto>), StatusCodes.Status200OK)]
     public async Task<ActionResult<PagedResponse<TransferSummaryDto>>> List(
         [FromQuery] PageQuery query, [FromQuery] TransferStatus? status,
-        [FromQuery] int? srcWarehouseId, [FromQuery] int? destWarehouseId, CancellationToken ct)
-        => Ok(await _transfers.ListAsync(query, status, srcWarehouseId, destWarehouseId, ct));
+        [FromQuery] int? srcWarehouseId, [FromQuery] int? destWarehouseId, [FromQuery] int? branchId, CancellationToken ct)
+        => Ok(await _transfers.ListAsync(query, status, srcWarehouseId, destWarehouseId, branchId, ct));
 
     [HttpGet("{transferId:int}")]
     [ProducesResponseType(typeof(TransferDto), StatusCodes.Status200OK)]

Backend/ERPCore/Controllers/UomsController.cs

@@ -1,3 +1,4 @@
+using ERPCore.Domain.Enums;
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Uoms;
 using ERPCore.Services.Interfaces;
@@ -15,8 +16,9 @@ public sealed class UomsController : ApiControllerBase
 
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<UomDto>), StatusCodes.Status200OK)]
-    public async Task<ActionResult<PagedResponse<UomDto>>> List([FromQuery] PageQuery query, CancellationToken ct)
-        => Ok(await _uoms.ListAsync(query, ct));
+    public async Task<ActionResult<PagedResponse<UomDto>>> List(
+        [FromQuery] PageQuery query, [FromQuery] EntityStatus? status, CancellationToken ct)
+        => Ok(await _uoms.ListAsync(query, status, ct));
 
     [HttpPost]
     [ProducesResponseType(typeof(UomDto), StatusCodes.Status201Created)]
@@ -26,4 +28,14 @@ public sealed class UomsController : ApiControllerBase
         var dto = await _uoms.CreateAsync(request, ct);
         return Created($"/api/v1/uoms/{dto.UomId}", dto);
     }
+
+    /// <summary>Deactivate/reactivate. Masters are never hard-deleted (FR-MD-08).</summary>
+    [HttpPatch("{uomId:int}/status")]
+    [ProducesResponseType(StatusCodes.Status204NoContent)]
+    [ProducesResponseType(StatusCodes.Status404NotFound)]
+    public async Task<IActionResult> SetStatus(int uomId, [FromBody] UpdateUomStatusRequest request, CancellationToken ct)
+    {
+        await _uoms.SetStatusAsync(uomId, request.Status, ct);
+        return NoContent();
+    }
 }

Backend/ERPCore/Controllers/UsersController.cs

@@ -1,6 +1,7 @@
 using ERPCore.Dtos.Common;
 using ERPCore.Dtos.Hrm;
 using ERPCore.Dtos.Users;
+using ERPCore.Infra.Auth;
 using ERPCore.Services.Interfaces;
 using Microsoft.AspNetCore.Mvc;
 
@@ -15,11 +16,13 @@ public sealed class UsersController : ApiControllerBase
 {
     private readonly IUserManagementService _users;
     private readonly IEmployeeUserLinkService _links;
+    private readonly ICurrentUser _currentUser;
 
-    public UsersController(IUserManagementService users, IEmployeeUserLinkService links)
+    public UsersController(IUserManagementService users, IEmployeeUserLinkService links, ICurrentUser currentUser)
     {
         _users = users;
         _links = links;
+        _currentUser = currentUser;
     }
 
     /// <summary>Advisory forward-direction lookup: does a Staff record already exist with this email? (docs/12-BACKEND-HRM.md A.5)</summary>
@@ -53,7 +56,7 @@ public sealed class UsersController : ApiControllerBase
     [ProducesResponseType(StatusCodes.Status409Conflict)]
     public async Task<ActionResult<ManagedUserDto>> Create([FromBody] CreateUserRequest request, CancellationToken ct)
     {
-        var result = await _users.CreateAsync(request, ct);
+        var result = await _users.CreateAsync(request, _currentUser.AuditUserId, ct);
         return Created($"/api/v1/users/{result.UserId}", result);
     }
 

Backend/ERPCore/Domain/DocumentTypes.cs

@@ -10,8 +10,20 @@ public static class DocumentTypes
     public const string Rfq = "RFQ";
     public const string PurchaseOrder = "PO";
     public const string Grn = "GRN";
+    public const string PurchaseInvoice = "PINV";
     public const string Transfer = "TRF";
     public const string Adjustment = "ADJ";
     public const string Count = "CNT";
     public const string PurchaseReturn = "PRET";
+
+    /// <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 BundleSaleTemplate = "TPL";
+    public const string SalesReturn = "SRET";
+
+    /// <summary>Cashier day-end close-out (Sales) — <c>DEND-2026-00001</c>.</summary>
+    public const string SalesDayEnd = "DEND";
 }

Backend/ERPCore/Domain/Entities/Branch.cs

@@ -3,16 +3,19 @@ using ERPCore.Domain.Enums;
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Branch/location master (FR-HR-MD-01) — multi-branch readiness. Referenced
-/// optionally by <see cref="Employee.BranchId"/> and <see cref="PayrollRun.BranchId"/>.
+/// Branch/location master (FR-HR-MD-01) — multi-branch readiness. Required by
+/// <see cref="Employee.BranchId"/>, optionally referenced by <see cref="PayrollRun.BranchId"/>.
 /// Deactivated, not deleted, when referenced. Model: docs/12-BACKEND-HRM.md Part C.1.
 /// </summary>
 public class Branch
 {
     public int BranchId { get; set; }
+
+    /// <summary>Server-generated on create ("BR-001", "BR-002", ...) — never accepted from the client.</summary>
     public string Code { get; set; } = string.Empty;
     public string Name { get; set; } = string.Empty;
     public string? Address { get; set; }
+    public string? PhoneNumber { get; set; }
     public EntityStatus Status { get; set; } = EntityStatus.Active;
 
     public DateTime CreatedAt { get; set; }

Backend/ERPCore/Domain/Entities/BranchConfig.cs

@@ -0,0 +1,27 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Branch configuration — a singleton row (single-tenant, docs/00-CORE §1) gating whether
+/// this deployment uses branches at all. When <see cref="BranchingEnabled"/> is off, the
+/// Employee/Warehouse create forms stop asking for a branch and every new record is
+/// silently assigned to the deployment's one default branch instead — schema-wise
+/// <c>Employee.BranchId</c>/<c>Warehouse.BranchId</c> stay <c>NOT NULL</c> either way, only
+/// the UI/UX requirement toggles. See <see cref="Services.BranchConfigService.ResolveBranchIdAsync"/>.
+/// </summary>
+public class BranchConfig
+{
+    /// <summary>Always 1 - the singleton row's id.</summary>
+    public const int SingletonId = 1;
+
+    public int ConfigId { get; set; }
+
+    public bool BranchingEnabled { get; set; } = true;
+
+    public DateTime? UpdatedAt { get; set; }
+
+    public int? UpdatedBy { get; set; }
+    public User? UpdatedByUser { get; set; }
+
+    /// <summary>PostgreSQL xmin-backed optimistic concurrency token (ETag source).</summary>
+    public uint RowVersion { get; set; }
+}

Backend/ERPCore/Domain/Entities/BundleSale.cs

@@ -0,0 +1,39 @@
+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; }
+
+    /// <summary>Set once this bundle's business date is closed by <see cref="SalesDayEnd"/> — a
+    /// closed bundle sale is frozen (no further edits). Same role as <see cref="SalesSlip.DayEndId"/>;
+    /// a bundle sale is a cashier document exactly like a sales slip, just priced as a set.</summary>
+    public int? DayEndId { get; set; }
+    public SalesDayEnd? DayEnd { 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/Employee.cs

@@ -50,7 +50,7 @@ public class Employee
     public Designation? Designation { get; set; }
     public int EmploymentTypeId { get; set; }
     public EmploymentType? EmploymentType { get; set; }
-    public int? BranchId { get; set; }
+    public int BranchId { get; set; }
     public Branch? Branch { get; set; }
     public int WorkShiftId { get; set; }
     public WorkShift? WorkShift { get; set; }

Backend/ERPCore/Domain/Entities/Grn.cs

@@ -30,6 +30,16 @@ public class Grn
     public DateTime CreatedAt { get; set; }
     public DateTime? PostedAt { get; set; }
 
+    /// <summary>Journal number of the real GL journal entry posted for this GRN's receipt (set on confirm).</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+
+    /// <summary>The Purchase Invoice this GRN has been consolidated into, if any (null until
+    /// invoiced). Vendor settlement is tracked on the invoice, not per-GRN — see
+    /// <see cref="PurchaseInvoice"/>.</summary>
+    public int? PurchaseInvoiceId { get; set; }
+    public PurchaseInvoice? PurchaseInvoice { get; set; }
+
     /// <summary>PostgreSQL xmin-backed optimistic concurrency token.</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,14 +38,46 @@ 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>
-    /// Optional fixed selling price used by Sales only. <c>null</c> means "use stock value"
-    /// (the item is sold at its FIFO stock cost at sale time); a value is the fixed sale price.
-    /// Never enters costing/GRN/FIFO (docs/10 Part C.1, C.9).
+    /// Optional selling price range and flat price used by Sales only.
+    /// <c>null</c> values mean the field is not set. These values never enter costing/GRN/FIFO.
     /// </summary>
-    public decimal? SalePrice { get; set; }
+    public decimal? SellingMinPrice { get; set; }
+    public decimal? SellingMaxPrice { get; set; }
+    public decimal? SellingFlatPrice { 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;
 
@@ -50,5 +88,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
-/// to feed the frontend's item-builder dropdown via <c>GET /item-types</c>. The chosen
+/// nothing: there is no value table and no join to <see cref="Item"/>. 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/NotificationConfig.cs

@@ -0,0 +1,19 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Notification configuration (new settings module) - singleton root row.
+/// </summary>
+public class NotificationConfig
+{
+    public const int SingletonId = 1;
+
+    public int NotificationConfigId { get; set; }
+
+    public DateTime? UpdatedAt { get; set; }
+    public int? UpdatedBy { get; set; }
+    public User? UpdatedByUser { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<NotificationConfigModule> Modules { get; set; } = new List<NotificationConfigModule>();
+}

Backend/ERPCore/Domain/Entities/NotificationConfigModule.cs

@@ -0,0 +1,14 @@
+namespace ERPCore.Domain.Entities;
+
+public class NotificationConfigModule
+{
+    public int NotificationConfigModuleId { get; set; }
+
+    public int NotificationConfigId { get; set; }
+    public NotificationConfig? NotificationConfig { get; set; }
+
+    public string ModuleKey { get; set; } = string.Empty;
+    public bool EmailEnabled { get; set; }
+    public bool SmsEnabled { get; set; }
+    public bool InAppEnabled { 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/ProductConfig.cs

@@ -1,22 +1,24 @@
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Product configuration (FR-MD-11) — a <b>singleton row</b> (single-tenant, docs/00-CORE §1)
+/// Product configuration (FR-MD-11) - a singleton row (single-tenant, docs/00-CORE §1)
 /// gating optional product master-data features.
 /// <para>
 /// <see cref="SubcategoriesEnabled"/> and <see cref="BrandsEnabled"/> are enforced
 /// server-side: an Item write carrying a subcategory/brand while the flag is off is
-/// rejected with <c>CONFIG_DISABLED</c>. <see cref="ItemTypesEnabled"/> is
-/// <b>advisory only</b> — items carry no item-type reference (see <see cref="ItemType"/>),
-/// so there is nothing on a write to reject; the frontend honours it by hiding the
-/// builder's type section. Reads are never gated, so existing data stays visible after a
-/// flag is switched off.
+/// rejected with <c>CONFIG_DISABLED</c>. <see cref="ItemTypesEnabled"/> is advisory only
+/// - items carry no item-type reference (see <see cref="ItemType"/>), so there is nothing
+/// on a write to reject; the frontend honours it by hiding the variant builder.
+/// <see cref="SellingPricesEnabled"/>, <see cref="SerialNumbersEnabled"/>,
+/// <see cref="BatchListsEnabled"/> and <see cref="WarrantyPeriodsEnabled"/> are enforced
+/// on item writes and drive the create/edit screens. Reads are never gated, so existing
+/// data stays visible after a flag is switched off.
 /// </para>
 /// Model: docs/10-BACKEND-PHASE1.md Part C.1.
 /// </summary>
 public class ProductConfig
 {
-    /// <summary>Always 1 — the singleton row's id.</summary>
+    /// <summary>Always 1 - the singleton row's id.</summary>
     public const int SingletonId = 1;
 
     public int ConfigId { get; set; }
@@ -24,6 +26,10 @@ public class ProductConfig
     public bool SubcategoriesEnabled { get; set; } = true;
     public bool BrandsEnabled { get; set; } = true;
     public bool ItemTypesEnabled { get; set; } = true;
+    public bool SellingPricesEnabled { get; set; } = true;
+    public bool SerialNumbersEnabled { get; set; } = true;
+    public bool BatchListsEnabled { get; set; } = true;
+    public bool WarrantyPeriodsEnabled { get; set; } = true;
 
     public DateTime? UpdatedAt { get; set; }
 

Backend/ERPCore/Domain/Entities/ProductionRun.cs

@@ -0,0 +1,59 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One execution instance of a template (FR-MFG-08), numbered <c>PRD-2026-00001</c>.
+/// Every stage, input, output and edge is <b>copied</b> from the template at creation
+/// with quantities scaled by <see cref="ScaleFactor"/>, so a completed run stays
+/// readable even if the template is later edited (FR-MFG-06).
+/// <para>The run's <b>cost pool</b> is derived, never stored:
+/// <c>Σ RunStageInput.ConsumedValue − Σ RunStageInput.ReturnedValue</c>. The terminal
+/// approve divides it by the good quantity to cost the finished layer, then closes it
+/// (FR-MFG-13, <c>409 RUN_COST_CLOSED</c>).</para>
+/// Mutable aggregate with a <see cref="RowVersion"/> token. Model: docs/30 Part C.
+/// </summary>
+public class ProductionRun
+{
+    public int RunId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    /// <summary>Stock inputs are consumed from, and the finished good received into, this warehouse.</summary>
+    public int WarehouseId { get; set; }
+    public Warehouse? Warehouse { get; set; }
+
+    /// <summary>Optional destination bin for the finished goods. Reaches the ledger only — stock layers carry no bin.</summary>
+    public int? OutputBinId { get; set; }
+    public Bin? OutputBin { get; set; }
+
+    /// <summary>Target quantity of the finished item; drives <see cref="ScaleFactor"/>.</summary>
+    public decimal TargetQty { get; set; }
+
+    /// <summary><c>TargetQty / terminalOutput.QtyPerBatch</c>, applied to every copied quantity.</summary>
+    public decimal ScaleFactor { get; set; }
+
+    public ProductionRunStatus Status { get; set; } = ProductionRunStatus.InProgress;
+
+    /// <summary>Incremented by each terminal reject (FR-MFG-16); prior figures live in the event history.</summary>
+    public int ReworkCount { get; set; }
+
+    public int? CancelReasonCodeId { get; set; }
+    public ReasonCode? CancelReason { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+
+    /// <summary>Set by the terminal approve only. A cancelled run leaves this null.</summary>
+    public DateTime? CompletedAt { get; set; }
+
+    public uint RowVersion { get; set; }
+
+    public ICollection<RunStage> Stages { get; set; } = new List<RunStage>();
+    public ICollection<RunEdge> Edges { get; set; } = new List<RunEdge>();
+    public ICollection<RunStageEvent> Events { get; set; } = new List<RunStageEvent>();
+}

Backend/ERPCore/Domain/Entities/ProductionTemplate.cs

@@ -0,0 +1,43 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A reusable production-line definition — the stage graph designed on the canvas
+/// (FR-MFG-01). Never hard-deleted once referenced by a run; deactivated instead
+/// (FR-MD-08 posture). Editing is locked while any run of it is InProgress
+/// (FR-MFG-06, <c>409 TEMPLATE_IN_USE</c>) — edit-lock replaces versioning, which is
+/// why runs copy display fields at creation. Mutable aggregate with a
+/// <see cref="RowVersion"/> token. Model: docs/30 Part C.
+/// </summary>
+public class ProductionTemplate
+{
+    public int TemplateId { get; set; }
+    public string Code { get; set; } = string.Empty;
+    public string Name { get; set; } = string.Empty;
+    public string? Description { get; set; }
+
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+
+    /// <summary>
+    /// Canvas-only annotations (grouping boxes and divider lines) as a jsonb array, stored
+    /// verbatim and never interpreted server-side.
+    /// </summary>
+    /// <remarks>
+    /// Not in docs/30 Part C — added because the builder canvas already draws these and
+    /// without somewhere to keep them a save would silently discard the user's layout notes.
+    /// They carry no graph semantics: no ports, no edges, and the validator never sees them.
+    /// Nullable so a template that has none stores nothing rather than an empty array.
+    /// </remarks>
+    public string? Annotations { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+    public uint RowVersion { get; set; }
+
+    public ICollection<TemplateStage> Stages { get; set; } = new List<TemplateStage>();
+    public ICollection<StageEdge> Edges { get; set; } = new List<StageEdge>();
+    public ICollection<ProductionRun> Runs { get; set; } = new List<ProductionRun>();
+}

Backend/ERPCore/Domain/Entities/PurchaseInvoice.cs

@@ -0,0 +1,50 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Vendor invoice consolidating one or more Confirmed GRNs for the same vendor
+/// (each linked GRN becomes one <see cref="PurchaseInvoiceLine"/>, not re-itemized).
+/// Draft is editable (GRNs can be re-selected); Posted reclassifies the GRN clearing
+/// balance to Accounts Payable (see PurchaseInvoiceService.PostAsync); vendor payments
+/// are then recorded against this aggregate rather than against the individual GRNs.
+/// </summary>
+public class PurchaseInvoice
+{
+    public int PurchaseInvoiceId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public string VendorInvoiceNo { get; set; } = string.Empty;
+    public DateTime VendorInvoiceDate { get; set; }
+
+    public int VendorId { get; set; }
+    public Vendor? Vendor { get; set; }
+
+    public string VendorSnapshotName { get; set; } = string.Empty;
+    public string? VendorSnapshotTaxNo { get; set; }
+
+    public PurchaseInvoiceStatus Status { get; set; } = PurchaseInvoiceStatus.Draft;
+
+    public decimal Subtotal { get; set; }
+    public decimal VatTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+    public decimal PaidAmount { get; set; }
+    public decimal BalanceAmount { get; set; }
+
+    /// <summary>Journal number of the AP-recognition GL journal entry posted when this
+    /// invoice is Posted (Debit GRN Clearing / Credit Accounts Payable) — see
+    /// PurchaseInvoiceService.PostAsync.</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { 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<PurchaseInvoiceLine> Lines { get; set; } = new List<PurchaseInvoiceLine>();
+    public ICollection<PurchaseInvoicePayment> Payments { get; set; } = new List<PurchaseInvoicePayment>();
+}

Backend/ERPCore/Domain/Entities/PurchaseInvoiceLine.cs

@@ -0,0 +1,21 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One row per consolidated GRN on a <see cref="PurchaseInvoice"/> — a straight
+/// consolidation of that GRN's line totals, not a re-itemization (docs: Purchase
+/// Invoice consolidates GRNs, it does not re-enter item lines).
+/// </summary>
+public class PurchaseInvoiceLine
+{
+    public int PurchaseInvoiceLineId { get; set; }
+
+    public int PurchaseInvoiceId { get; set; }
+    public PurchaseInvoice? PurchaseInvoice { get; set; }
+
+    public int GrnId { get; set; }
+    public Grn? Grn { get; set; }
+
+    public decimal Subtotal { get; set; }
+    public decimal VatTotal { get; set; }
+    public decimal LineTotal { get; set; }
+}

Backend/ERPCore/Domain/Entities/PurchaseInvoicePayment.cs

@@ -0,0 +1,32 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A vendor payment made against a Posted purchase invoice's balance (installments
+/// allowed — see PurchaseInvoicePaymentService.PayAsync). Posts its own real GL
+/// journal entry (Debit Accounts Payable / Credit the selected bank-or-cash account)
+/// before being recorded here.
+/// </summary>
+public class PurchaseInvoicePayment
+{
+    public int PurchaseInvoicePaymentId { get; set; }
+
+    public int PurchaseInvoiceId { get; set; }
+    public PurchaseInvoice? PurchaseInvoice { get; set; }
+
+    public decimal Amount { get; set; }
+    public DateTime PaymentDate { get; set; }
+
+    /// <summary>GL's numeric id for the bank/cash account the payment was made from.</summary>
+    public long GlBankAccountId { get; set; }
+    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
+    public string BankAccountName { get; set; } = string.Empty;
+
+    public string? Reference { get; set; }
+
+    /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
+    public string? GlJournalNo { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+    public DateTime CreatedAt { get; set; }
+}

Backend/ERPCore/Domain/Entities/PurchaseReturn.cs

@@ -28,5 +28,12 @@ public class PurchaseReturn
 
     public DateTime CreatedAt { get; set; }
 
+    /// <summary>Journal number of the real GL journal entry posted for this return (set on create — it auto-posts).
+    /// Reverses the Inventory/Clearing lines a Grn posts — <see cref="PurchaseReturnLine"/> carries no unit
+    /// price/VAT of its own, so it can't reverse a VAT-recoverable line the way a real credit note would.</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+
     public ICollection<PurchaseReturnLine> Lines { get; set; } = new List<PurchaseReturnLine>();
 }
+

Backend/ERPCore/Domain/Entities/RunEdge.cs

@@ -0,0 +1,28 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A parent → child arrow copied from the template's <see cref="StageEdge"/> set at run
+/// creation.
+/// <para><b>Addition to docs/30 Part C (recorded).</b> The doc's entity model has no run
+/// edge table, but the run graph needs its own copy: deriving edges at read time through
+/// <c>RunStage.TemplateStageId → STAGE_EDGE</c> would let a later template edit silently
+/// rewrite completed-run history — the exact thing FR-MFG-06 exists to prevent — and
+/// breaks outright once that link is nulled by a stage deletion.</para>
+/// <para>Used for the run canvas, child-readiness evaluation and reject-intake's
+/// "delivering parents". Note that <b>WIP delivery is routed by
+/// <c>RunStageInput.FromRunOutputId</c>, not by these edges</b> — an edge is display and
+/// validation only.</para>
+/// </summary>
+public class RunEdge
+{
+    public int RunEdgeId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    public int ParentRunStageId { get; set; }
+    public RunStage? ParentRunStage { get; set; }
+
+    public int ChildRunStageId { get; set; }
+    public RunStage? ChildRunStage { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStage.cs

@@ -0,0 +1,59 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One stage of a run — a copy of a <see cref="TemplateStage"/> taken at run creation
+/// (FR-MFG-06), carrying its own live status and actual timings. Model: docs/30 Part C.
+/// <para><b>Whether this stage is terminal is derived</b>, never stored: a stage is
+/// terminal when it has no outbound <see cref="RunEdge"/>. Storing it would let it
+/// drift from the edge set.</para>
+/// </summary>
+public class RunStage
+{
+    public int RunStageId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    /// <summary>
+    /// Provenance link back to the template stage. <b>Nullable</b>: a template PUT may
+    /// delete a stage while completed/cancelled runs still reference it (the edit-lock
+    /// only blocks edits during InProgress runs), so the FK is <c>SET NULL</c> rather
+    /// than blocking the edit forever. Everything needed to display a historical run is
+    /// copied below, which is exactly what FR-MFG-06 anticipates.
+    /// </summary>
+    public int? TemplateStageId { get; set; }
+    public TemplateStage? TemplateStage { get; set; }
+
+    // --- copied from the template at run creation (FR-MFG-06) ---
+    public string Name { get; set; } = string.Empty;
+    public string? RoleLabel { get; set; }
+    public int EstimatedMinutes { get; set; }
+    public decimal PosX { get; set; }
+    public decimal PosY { get; set; }
+
+    public ProductionStageStatus Status { get; set; } = ProductionStageStatus.Waiting;
+
+    /// <summary>Stamped at start; preserved across a reject-intake rework so the original start stands (FR-MFG-19).</summary>
+    public DateTime? ActualStartAt { get; set; }
+    public DateTime? ActualEndAt { get; set; }
+
+    /// <summary>Copied from the template stage; definitions survive a rework.</summary>
+    public string FieldDefs { get; set; } = "[]";
+
+    /// <summary>Captured at complete as a jsonb object; cleared by a terminal reject so required fields are re-answered.</summary>
+    public string? FieldValues { get; set; }
+
+    /// <summary>
+    /// Concurrency token. Stage actions re-read the stage inside their transaction and
+    /// let this xmin check serialize concurrent requests — it is what stops two
+    /// simultaneous terminal approves from both reading <c>Done</c> and posting two
+    /// receipts. See the idempotency note in <c>ProductionRunService</c>.
+    /// </summary>
+    public uint RowVersion { get; set; }
+
+    public ICollection<RunStageInput> Inputs { get; set; } = new List<RunStageInput>();
+    public ICollection<RunStageOutput> Outputs { get; set; } = new List<RunStageOutput>();
+    public ICollection<RunStageEvent> Events { get; set; } = new List<RunStageEvent>();
+}

Backend/ERPCore/Domain/Entities/RunStageEvent.cs

@@ -0,0 +1,40 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// Immutable history of everything that happened to a run (docs/30 Part C). Written by
+/// every mutating action and never updated or deleted, so a run's story — including the
+/// figures discarded by each rework — survives in full.
+/// <para><b>Addition to docs/30 Part C (recorded):</b> <see cref="RunId"/>. The doc hangs
+/// events off the stage only, which leaves run-level events (cancel, terminal reject)
+/// with no home and forces the detail timeline to join through stages. Keeping both
+/// links makes <see cref="RunStageId"/> optional and the timeline a single query.</para>
+/// </summary>
+public class RunStageEvent
+{
+    public int EventId { get; set; }
+
+    public int RunId { get; set; }
+    public ProductionRun? Run { get; set; }
+
+    /// <summary>Null for run-level events (Cancel).</summary>
+    public int? RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    public RunStageEventType EventType { get; set; }
+
+    public string? Note { get; set; }
+
+    /// <summary>
+    /// Event-specific detail as jsonb — consumed layers on a Start, pulled-back
+    /// quantities on a RejectIntake, the full pre-rework snapshot on a TerminalReject.
+    /// Pre-serialized string, written only through <c>ProductionJson</c>.
+    /// </summary>
+    public string? Payload { get; set; }
+
+    public int UserId { get; set; }
+    public User? User { get; set; }
+
+    public DateTime CreatedAt { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStageInput.cs

@@ -0,0 +1,59 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One input line of a run stage — a copy of a <see cref="StageInput"/> with its
+/// quantity scaled at creation, plus the live consumption/delivery figures.
+/// Model: docs/30 Part C.
+/// <para><b>Stock inputs</b> accumulate <see cref="ConsumedQty"/>/<see cref="ConsumedValue"/>
+/// at each start and <see cref="ReturnedQty"/>/<see cref="ReturnedValue"/> on leftover
+/// return or run cancel. Those four columns are the whole cost pool
+/// (<c>Σ consumed − Σ returned</c>) and are deliberately <b>not</b> reset by a terminal
+/// reject — already-consumed material stays in the pool (FR-MFG-16).</para>
+/// <para><b>Upstream inputs</b> accumulate <see cref="DeliveredQty"/> as parent stages
+/// transfer WIP in. The stage becomes Ready only when every upstream input has
+/// <c>DeliveredQty &gt;= PlannedQty</c> (FR-MFG-09, an all-parents join).</para>
+/// </summary>
+public class RunStageInput
+{
+    public int RunInputId { get; set; }
+
+    public int RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    public StageInputSource Source { get; set; }
+
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    /// <summary>The parent output feeding this input. This — not <see cref="RunEdge"/> — is what routes a transfer.</summary>
+    public int? FromRunOutputId { get; set; }
+    public RunStageOutput? FromRunOutput { get; set; }
+
+    /// <summary>Copied from the template input: what <see cref="PlannedQty"/> is expressed in.</summary>
+    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>). 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>
+    /// Stock inputs only, in the item's <b>base</b> UOM. A start consumes
+    /// <c>max(0, PlannedQty − ConsumedQty)</c> and adds to these, so a rework restart
+    /// with an unchanged planned quantity consumes nothing and one with a raised planned
+    /// quantity consumes only the delta (FR-MFG-16).
+    /// </summary>
+    public decimal ConsumedQty { get; set; }
+    public decimal ConsumedValue { get; set; }
+
+    /// <summary>Upstream inputs only: accumulated by parent transfers.</summary>
+    public decimal DeliveredQty { get; set; }
+
+    /// <summary>Leftover returns (FR-MFG-14) and cancel returns (FR-MFG-17), at the consumed weighted cost.</summary>
+    public decimal ReturnedQty { get; set; }
+    public decimal ReturnedValue { get; set; }
+}

Backend/ERPCore/Domain/Entities/RunStageOutput.cs

@@ -0,0 +1,50 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One output line of a run stage — a copy of a <see cref="StageOutput"/> with its
+/// quantity scaled at creation, plus the live produced/scrapped/transferred figures.
+/// Model: docs/30 Part C.
+/// <para><b>Available to transfer is derived, never stored:</b>
+/// <c>ProducedQty − ScrappedQty − TransferredQty</c>. Every transfer path checks it and
+/// raises <c>422 TRANSFER_EXCEEDS_AVAILABLE</c> (FR-MFG-12).</para>
+/// <para>Scrap cost is <b>absorbed</b> into the run cost pool as normal yield loss — no
+/// write-off ledger entry is posted (FR-MFG-11).</para>
+/// </summary>
+public class RunStageOutput
+{
+    public int RunOutputId { get; set; }
+
+    public int RunStageId { get; set; }
+    public RunStage? RunStage { get; set; }
+
+    /// <summary>Null on intermediate (WIP) outputs; set on the terminal output — the finished good.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    /// <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. 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>
+    public decimal ProducedQty { get; set; }
+
+    public decimal ScrappedQty { get; set; }
+
+    /// <summary>Mandatory when <see cref="ScrappedQty"/> &gt; 0, context <c>Production</c> (FR-MFG-11).</summary>
+    public int? ScrapReasonCodeId { get; set; }
+    public ReasonCode? ScrapReason { get; set; }
+
+    /// <summary>Total WIP handed to children so far, across approve and any later partial transfers.</summary>
+    public decimal TransferredQty { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesDayEnd.cs

@@ -0,0 +1,46 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A cashier's end-of-day close-out. Aggregates every <see cref="SalesSlip"/> the
+/// cashier posted on <see cref="BusinessDate"/>, freezes them against this record
+/// (<see cref="SalesSlip.DayEndId"/>) so a slip can only ever belong to one day-end,
+/// and posts one consolidated GL journal entry for the day's revenue/tax/COGS —
+/// the sales-side equivalent of how <see cref="Grn"/> posts per receipt. Unique per
+/// (CashierUserId, BusinessDate): closing twice replays the existing record instead
+/// of creating a second one (same idempotent-replay pattern as Grn.ConfirmAsync).
+/// </summary>
+public class SalesDayEnd
+{
+    public int SalesDayEndId { get; set; }
+    public string DocNo { get; set; } = string.Empty;
+
+    public int CashierUserId { get; set; }
+    public User? CashierUser { get; set; }
+
+    /// <summary>The calendar date being closed (matched against each slip's <see cref="SalesSlip.SlipDate"/>, UTC).</summary>
+    public DateOnly BusinessDate { get; set; }
+
+    public int SlipCount { get; set; }
+    public int BundleCount { get; set; }
+    public decimal Subtotal { get; set; }
+    public decimal DiscountTotal { get; set; }
+    public decimal TaxTotal { get; set; }
+    public decimal GrandTotal { get; set; }
+
+    /// <summary>Sum of the FIFO cost consumed for these slips (from <see cref="StockLedger"/>), for the COGS GL lines.</summary>
+    public decimal CostOfGoodsSold { get; set; }
+
+    /// <summary>Journal number of the real GL journal entry posted for this close (null when there was nothing to post).</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+
+    public int ClosedBy { get; set; }
+    public User? ClosedByUser { get; set; }
+    public DateTime ClosedAt { get; set; }
+
+    /// <summary>PostgreSQL xmin-backed optimistic concurrency token.</summary>
+    public uint RowVersion { get; set; }
+
+    public ICollection<SalesSlip> Slips { get; set; } = new List<SalesSlip>();
+    public ICollection<BundleSale> BundleSales { get; set; } = new List<BundleSale>();
+}

Backend/ERPCore/Domain/Entities/SalesInvoice.cs

@@ -0,0 +1,50 @@
+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; }
+
+    /// <summary>Journal number of the revenue-recognition GL journal entry posted when this
+    /// invoice is Posted (Debit Accounts Receivable / Credit Sales Revenue + Tax, plus COGS —
+    /// see SalesPostingService.PostInvoiceAsync). Unlike a SalesSlip, an invoice posts its own
+    /// GL entry immediately rather than waiting for Sales Day End, since invoices aren't a
+    /// cashier document and don't go through that close-out.</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { 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>();
+    public ICollection<SalesInvoicePayment> Payments { get; set; } = new List<SalesInvoicePayment>();
+}

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/SalesInvoicePayment.cs

@@ -0,0 +1,32 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A customer payment made against a Posted sales invoice's balance (installments
+/// allowed — see SalesInvoicePaymentService.PayAsync). Posts its own real GL journal
+/// entry (Debit the selected bank-or-cash account / Credit Accounts Receivable) before
+/// being recorded here — the mirror image of <see cref="PurchaseInvoicePayment"/>.
+/// </summary>
+public class SalesInvoicePayment
+{
+    public int SalesInvoicePaymentId { get; set; }
+
+    public int SalesInvoiceId { get; set; }
+    public SalesInvoice? SalesInvoice { get; set; }
+
+    public decimal Amount { get; set; }
+    public DateTime PaymentDate { get; set; }
+
+    /// <summary>GL's numeric id for the bank/cash account the payment was received into.</summary>
+    public long GlBankAccountId { get; set; }
+    /// <summary>Snapshot of the account's display name at payment time (GL account lists have no local FK).</summary>
+    public string BankAccountName { get; set; } = string.Empty;
+
+    public string? Reference { get; set; }
+
+    /// <summary>Journal number of the real GL journal entry this payment posted.</summary>
+    public string? GlJournalNo { get; set; }
+
+    public int CreatedBy { get; set; }
+    public User? Creator { get; set; }
+    public DateTime CreatedAt { get; set; }
+}

Backend/ERPCore/Domain/Entities/SalesReturn.cs

@@ -0,0 +1,38 @@
+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; }
+
+    /// <summary>Journal number of the real GL journal entry posted for this return (set on create — it auto-posts).
+    /// Reverses Inventory/COGS only — <see cref="SalesReturnLine"/> carries no unit price, so revenue/tax aren't
+    /// reversed here (they'd need a per-line price this document doesn't capture).</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { 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,40 @@
+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; }
+
+    /// <summary>Set once this slip's business date is closed by <see cref="SalesDayEnd"/> — a closed slip is frozen (no further edits).</summary>
+    public int? DayEndId { get; set; }
+    public SalesDayEnd? DayEnd { 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/StageEdge.cs

@@ -0,0 +1,21 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A parent → child arrow on the template canvas. The edge set must form a DAG with
+/// at least one entry stage and exactly one terminal stage; that is enforced in
+/// <c>ProductionGraphValidator</c> on every save, not by the database (FR-MFG-02).
+/// Model: docs/30 Part C.
+/// </summary>
+public class StageEdge
+{
+    public int EdgeId { get; set; }
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    public int ParentStageId { get; set; }
+    public TemplateStage? ParentStage { get; set; }
+
+    public int ChildStageId { get; set; }
+    public TemplateStage? ChildStage { get; set; }
+}

Backend/ERPCore/Domain/Entities/StageInput.cs

@@ -0,0 +1,44 @@
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One line of a stage's input formula (FR-MFG-04). Exactly one of the two source
+/// shapes applies, enforced by <c>ProductionGraphValidator</c>:
+/// <list type="bullet">
+/// <item><see cref="StageInputSource.Stock"/> — <see cref="ItemId"/> set,
+/// <see cref="FromOutputId"/> null. FIFO-consumed from the run warehouse at stage
+/// start. Allowed on <i>any</i> stage, e.g. packaging added late.</item>
+/// <item><see cref="StageInputSource.Upstream"/> — <see cref="FromOutputId"/> set to
+/// an output of a <b>direct parent</b> stage, <see cref="ItemId"/> null. Flows as
+/// internal WIP and never touches stock or the ledger.</item>
+/// </list>
+/// Model: docs/30 Part C.
+/// </summary>
+public class StageInput
+{
+    public int InputId { get; set; }
+
+    public int StageId { get; set; }
+    public TemplateStage? Stage { get; set; }
+
+    public StageInputSource Source { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Stock; null when Upstream.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    /// <summary>Required when <see cref="Source"/> is Upstream; must belong to a direct parent.</summary>
+    public int? FromOutputId { get; set; }
+    public StageOutput? FromOutput { get; set; }
+
+    /// <summary>
+    /// 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

@@ -0,0 +1,33 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// A named quantity produced by a stage (FR-MFG-05). Intermediate outputs are
+/// <b>internal WIP only</b> — <see cref="ItemId"/> is null, no stock and no ledger row
+/// is ever written for them. The terminal stage is the exception: it has exactly one
+/// output and that output <b>must</b> reference a real Item (the finished good), which
+/// is what the production receipt creates a layer for. Model: docs/30 Part C.
+/// </summary>
+public class StageOutput
+{
+    public int OutputId { get; set; }
+
+    public int StageId { get; set; }
+    public TemplateStage? Stage { get; set; }
+
+    /// <summary>Null on intermediate stages; required on the terminal stage.</summary>
+    public int? ItemId { get; set; }
+    public Item? Item { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    /// <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/StockAdjustment.cs

@@ -27,5 +27,10 @@ public class StockAdjustment
     public DateTime CreatedAt { get; set; }
     public uint RowVersion { get; set; }
 
+    /// <summary>Journal number of the real GL journal entry posted for this adjustment (set on create — it
+    /// auto-posts). Increases and decreases post separately (never netted) so gains/losses stay visible.</summary>
+    public string? GlJournalNo { get; set; }
+    public DateTime? GlPostedAt { get; set; }
+
     public ICollection<StockAdjustmentLine> Lines { get; set; } = new List<StockAdjustmentLine>();
 }

Backend/ERPCore/Domain/Entities/TemplateStage.cs

@@ -0,0 +1,36 @@
+namespace ERPCore.Domain.Entities;
+
+/// <summary>
+/// One box on the template canvas (FR-MFG-03): a named step with a role label, an
+/// estimated duration, a formula (<see cref="Inputs"/> + <see cref="Outputs"/>) and
+/// custom field definitions. Model: docs/30 Part C.
+/// </summary>
+public class TemplateStage
+{
+    public int StageId { get; set; }
+
+    public int TemplateId { get; set; }
+    public ProductionTemplate? Template { get; set; }
+
+    public string Name { get; set; } = string.Empty;
+
+    /// <summary>Free text (e.g. "QA"). Informational only this phase — never enforced (FR-X-01).</summary>
+    public string? RoleLabel { get; set; }
+
+    public int EstimatedMinutes { get; set; }
+
+    /// <summary>Canvas coordinates — stored verbatim, never interpreted server-side (FR-MFG-03).</summary>
+    public decimal PosX { get; set; }
+    public decimal PosY { get; set; }
+
+    /// <summary>
+    /// Custom field definitions as jsonb: <c>[{ key, label, type, options?, required }]</c>
+    /// (FR-MFG-07). Held as a pre-serialized string, matching the <c>AuditLog.ChangeSet</c>
+    /// precedent; always written through <c>ProductionJson</c> so the column can only ever
+    /// hold canonical JSON.
+    /// </summary>
+    public string FieldDefs { get; set; } = "[]";
+
+    public ICollection<StageInput> Inputs { get; set; } = new List<StageInput>();
+    public ICollection<StageOutput> Outputs { get; set; } = new List<StageOutput>();
+}

Backend/ERPCore/Domain/Entities/Uom.cs

@@ -1,11 +1,19 @@
+using ERPCore.Domain.Enums;
+
 namespace ERPCore.Domain.Entities;
 
 /// <summary>
-/// Unit of Measure (FR-MD-02). Referenced as an item's base UOM and as the
-/// endpoints of a <see cref="UomConversion"/>. Model: docs/10-BACKEND-PHASE1.md Part C.1.
+/// Unit of Measure (FR-MD-02). A flat lookup, used as an item's base UOM — the pack every
+/// 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
 {
     public int UomId { get; set; }
     public string Name { get; set; } = string.Empty;
+    public EntityStatus Status { get; set; } = EntityStatus.Active;
+
+    public DateTime CreatedAt { get; set; }
+    public DateTime? UpdatedAt { get; set; }
 }

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/Entities/Warehouse.cs

@@ -9,6 +9,8 @@ public class Warehouse
     public int WarehouseId { get; set; }
     public string Code { get; set; } = string.Empty;
     public string Name { get; set; } = string.Empty;
+    public int BranchId { get; set; }
+    public Branch? Branch { get; set; }
 
     public ICollection<Bin> Bins { get; set; } = new List<Bin>();
 }

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/CustomFieldType.cs

@@ -0,0 +1,16 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Input type of a stage custom field (FR-MFG-07; docs/30 §D.5 <c>fieldType</c>).
+/// Lives inside the <c>field_defs</c> jsonb rather than a column, but is modelled as an
+/// enum so a bad value is rejected at the DTO boundary instead of reaching the database.
+/// <see cref="Select"/> is the only type that reads <c>options</c>.
+/// </summary>
+public enum CustomFieldType
+{
+    Text,
+    Number,
+    Checkbox,
+    Date,
+    Select
+}

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/ProductionRunStatus.cs

@@ -0,0 +1,14 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Lifecycle of a production run (docs/30 §B.4, §D.5). A run is created
+/// <see cref="InProgress"/> and reaches exactly one final state: it completes at the
+/// terminal stage's approve (production receipt, FR-MFG-13) or is cancelled with a
+/// stock return (FR-MFG-17). Stored as a string.
+/// </summary>
+public enum ProductionRunStatus
+{
+    InProgress,
+    Completed,
+    Cancelled
+}

Backend/ERPCore/Domain/Enums/ProductionStageStatus.cs

@@ -0,0 +1,22 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Status of one stage within a production run (docs/30 §B.4, §D.5).
+/// <code>
+/// Waiting ──(all upstream inputs fully delivered)──▶ Ready
+/// Ready ──start (FIFO-consume Stock inputs)──▶ InProgress
+/// InProgress ──complete (produced/scrap/fields)──▶ Done
+/// Done ──approve──▶ Approved   (non-terminal: WIP transfers out; terminal: receipt)
+/// </code>
+/// Rejection is not a resting state (FR-MFG-15/16): a reject immediately produces a
+/// rework transition back into this set and is recorded as a
+/// <see cref="RunStageEventType"/> instead. Stored as a string.
+/// </summary>
+public enum ProductionStageStatus
+{
+    Waiting,
+    Ready,
+    InProgress,
+    Done,
+    Approved
+}

Backend/ERPCore/Domain/Enums/PurchaseInvoiceStatus.cs

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

Backend/ERPCore/Domain/Enums/ReasonContext.cs

@@ -5,5 +5,8 @@ public enum ReasonContext
 {
     Adjustment,
     Return,
-    Count
+    Count,
+
+    /// <summary>Manufacturing: scrap, leftover return, run cancel (docs/30 §A.2).</summary>
+    Production
 }

Backend/ERPCore/Domain/Enums/RunStageEventType.cs

@@ -0,0 +1,20 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Kind of entry in a run's immutable history (docs/30 Part C, <c>RUN_STAGE_EVENT</c>).
+/// Every mutating action on a run writes exactly one event carrying who/when plus a
+/// jsonb payload; <see cref="TerminalReject"/> additionally snapshots the whole run's
+/// figures for the rework pass being discarded (FR-MFG-16). Stored as a string.
+/// </summary>
+public enum RunStageEventType
+{
+    Start,
+    Complete,
+    Approve,
+    Transfer,
+    RejectIntake,
+    TerminalReject,
+    LeftoverReturn,
+    Cancel,
+    QuantityEdit
+}

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/StageInputSource.cs

@@ -0,0 +1,14 @@
+namespace ERPCore.Domain.Enums;
+
+/// <summary>
+/// Where a stage input's material comes from (FR-MFG-04; docs/30 §D.5).
+/// <see cref="Stock"/> inputs reference an Item and are FIFO-consumed from the run
+/// warehouse when the stage starts. <see cref="Upstream"/> inputs reference a direct
+/// parent stage's output and flow as internal WIP — they never touch the ledger.
+/// Stored as a string.
+/// </summary>
+public enum StageInputSource
+{
+    Stock,
+    Upstream
+}

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/Domain/LedgerSourceTypes.cs

@@ -0,0 +1,34 @@
+namespace ERPCore.Domain;
+
+/// <summary>
+/// Additional <c>STOCK_LEDGER.source_doc_type</c> values for manufacturing movements
+/// (docs/30 §A.2). <c>source_doc_id</c> is always the <c>run_id</c>, so
+/// <c>LIKE 'PRD%'</c> traces every stock movement a run caused.
+/// </summary>
+/// <remarks>
+/// <para><b>Deviation from docs/30 §A.2 (recorded).</b> The doc proposes the long names
+/// <c>ProductionIssue</c>/<c>ProductionReceipt</c>/<c>ProductionReturn</c>/
+/// <c>ProductionCancelReturn</c>, but both <c>stock_ledger.SourceDocType</c> and
+/// <c>journal_entry_stubs.SourceDocType</c> are <c>varchar(10)</c> and every existing
+/// value is a short prefix (<c>GRN</c>, <c>TRF</c>, <c>ADJ</c>, <c>PRET</c>). Widening
+/// those columns would be a second Phase-1 schema change beyond the single deviation
+/// §A.1 declares (NFR-08), so the short codes below extend the existing convention
+/// instead. docs/30 §A.2 and §D.5 are amended to match.</para>
+/// <para>These are <b>not</b> <see cref="DocumentTypes"/> entries — production issues no
+/// document per movement. The run's own document number uses
+/// <see cref="DocumentTypes.Production"/> (<c>PRD-2026-00001</c>).</para>
+/// </remarks>
+public static class LedgerSourceTypes
+{
+    /// <summary>Stock consumed by a stage start (FR-MFG-10). Outbound.</summary>
+    public const string ProductionIssue = "PRDI";
+
+    /// <summary>Finished goods received at the terminal approve (FR-MFG-13). Inbound.</summary>
+    public const string ProductionReceipt = "PRDR";
+
+    /// <summary>Unconsumed material returned before receipt (FR-MFG-14). Inbound.</summary>
+    public const string ProductionReturn = "PRDL";
+
+    /// <summary>Net consumed stock returned when a run is cancelled (FR-MFG-17). Inbound.</summary>
+    public const string ProductionCancelReturn = "PRDC";
+}

Backend/ERPCore/Domain/Notifications/Modules/NotificationModules.cs

@@ -0,0 +1,34 @@
+namespace ERPCore.Domain.Notifications.Modules;
+
+[NotificationModule("sale.create", "Sale Created", "Raised when a sales document is created.", 10)]
+public sealed class SaleCreateNotificationModule;
+
+[NotificationModule("sale.posted", "Sale Posted", "Raised when a sales document is posted.", 20)]
+public sealed class SalePostedNotificationModule;
+
+[NotificationModule("grn.created", "GRN Created", "Raised when a goods receipt note is created.", 30)]
+public sealed class GrnCreatedNotificationModule;
+
+[NotificationModule("grn.confirmed", "GRN Confirmed", "Raised when a goods receipt note is confirmed.", 40)]
+public sealed class GrnConfirmedNotificationModule;
+
+[NotificationModule("purchase.order.created", "Purchase Order Created", "Raised when a purchase order is created.", 50)]
+public sealed class PurchaseOrderCreatedNotificationModule;
+
+[NotificationModule("purchase.order.approved", "Purchase Order Approved", "Raised when a purchase order is approved.", 60)]
+public sealed class PurchaseOrderApprovedNotificationModule;
+
+[NotificationModule("purchase.return.created", "Purchase Return Created", "Raised when a purchase return is created.", 70)]
+public sealed class PurchaseReturnCreatedNotificationModule;
+
+[NotificationModule("stock.adjustment.created", "Stock Adjustment Created", "Raised when a stock adjustment is created.", 80)]
+public sealed class StockAdjustmentCreatedNotificationModule;
+
+[NotificationModule("stock.transfer.created", "Stock Transfer Created", "Raised when a stock transfer is created.", 90)]
+public sealed class StockTransferCreatedNotificationModule;
+
+[NotificationModule("item.created", "Item Created", "Raised when an item master record is created.", 100)]
+public sealed class ItemCreatedNotificationModule;
+
+[NotificationModule("item.updated", "Item Updated", "Raised when an item master record is updated.", 110)]
+public sealed class ItemUpdatedNotificationModule;

Backend/ERPCore/Domain/Notifications/NotificationChannel.cs

@@ -0,0 +1,8 @@
+namespace ERPCore.Domain.Notifications;
+
+public enum NotificationChannel
+{
+    Email,
+    Sms,
+    InApp
+}

Backend/ERPCore/Domain/Notifications/NotificationModuleAttribute.cs

@@ -0,0 +1,18 @@
+namespace ERPCore.Domain.Notifications;
+
+[AttributeUsage(AttributeTargets.Class, AllowMultiple = false, Inherited = false)]
+public sealed class NotificationModuleAttribute : Attribute
+{
+    public string Key { get; }
+    public string Label { get; }
+    public string Description { get; }
+    public int SortOrder { get; }
+
+    public NotificationModuleAttribute(string key, string label, string description, int sortOrder)
+    {
+        Key = key;
+        Label = label;
+        Description = description;
+        SortOrder = sortOrder;
+    }
+}

Backend/ERPCore/Domain/Notifications/NotificationModuleDefinition.cs

@@ -0,0 +1,7 @@
+namespace ERPCore.Domain.Notifications;
+
+public sealed record NotificationModuleDefinition(
+    string Key,
+    string Label,
+    string Description,
+    int SortOrder);

Backend/ERPCore/Dtos/Config/BranchConfigDtos.cs

@@ -0,0 +1,20 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ERPCore.Dtos.Config;
+
+/// <summary>Branch configuration resource — the singleton toggle for whether this deployment
+/// requires a branch on Employee/Warehouse records at all.</summary>
+public sealed record BranchConfigDto(bool BranchingEnabled, DateTime? UpdatedAt, int? UpdatedBy);
+
+/// <summary>
+/// Full replacement of the flag. <c>UpdatedBy</c> is derived from the token, never posted.
+/// <para>
+/// <see cref="BranchingEnabled"/> is <see cref="bool"/>? deliberately: <c>[Required]</c> on a
+/// non-nullable bool is a no-op, so an omitted flag would otherwise silently bind to
+/// <c>false</c>. Nullable makes the requirement actually bind — an omitted flag is a 400.
+/// </para>
+/// </summary>
+public sealed class UpdateBranchConfigRequest
+{
+    [Required] public bool? BranchingEnabled { get; set; }
+}

Backend/ERPCore/Dtos/Config/ProductConfigDtos.cs

@@ -4,10 +4,14 @@ namespace ERPCore.Dtos.Config;
 
 /// <summary>
 /// Product configuration resource (docs/11-BACKEND-PHASE1.md §2.8). Singleton.
-/// <see cref="ItemTypesEnabled"/> is advisory (frontend-honoured) — see the entity docs.
+/// <see cref="ItemTypesEnabled"/> is advisory (frontend-honoured) - see the entity docs.
+/// <see cref="SellingPricesEnabled"/>, <see cref="SerialNumbersEnabled"/>,
+/// <see cref="BatchListsEnabled"/> and <see cref="WarrantyPeriodsEnabled"/> are enforced
+/// when items are written.
 /// </summary>
 public sealed record ProductConfigDto(
     bool SubcategoriesEnabled, bool BrandsEnabled, bool ItemTypesEnabled,
+    bool SellingPricesEnabled, bool SerialNumbersEnabled, bool BatchListsEnabled, bool WarrantyPeriodsEnabled,
     DateTime? UpdatedAt, int? UpdatedBy);
 
 /// <summary>
@@ -15,8 +19,8 @@ public sealed record ProductConfigDto(
 /// <para>
 /// The flags are <see cref="bool"/>? deliberately: <c>[Required]</c> on a non-nullable bool
 /// is a no-op (it always has a value), so a body of <c>{}</c> would bind every flag to
-/// <c>false</c> and silently switch all three features off. Nullable makes the requirement
-/// actually bind — an omitted flag is a 400, not an accidental disable.
+/// <c>false</c> and silently switch everything off. Nullable makes the requirement actually
+/// bind - an omitted flag is a 400, not an accidental disable.
 /// </para>
 /// </summary>
 public sealed class UpdateProductConfigRequest
@@ -24,4 +28,8 @@ public sealed class UpdateProductConfigRequest
     [Required] public bool? SubcategoriesEnabled { get; set; }
     [Required] public bool? BrandsEnabled { get; set; }
     [Required] public bool? ItemTypesEnabled { get; set; }
+    [Required] public bool? SellingPricesEnabled { get; set; }
+    [Required] public bool? SerialNumbersEnabled { get; set; }
+    [Required] public bool? BatchListsEnabled { get; set; }
+    [Required] public bool? WarrantyPeriodsEnabled { get; set; }
 }

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,32 +5,41 @@ 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,
-    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, IReadOnlyList<GrnLineDto> Lines);
+    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, string? GlJournalNo,
+    int? PurchaseInvoiceId, string? PurchaseInvoiceNo, IReadOnlyList<GrnLineDto> Lines);
 
 /// <summary>Row shape for <c>GET /grns</c> — line count instead of the lines themselves.</summary>
 public sealed record GrnSummaryDto(
     int GrnId, string DocNo, int? PoId, int VendorId, int WarehouseId, GrnStatus Status,
-    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, int LineCount);
+    int CreatedBy, DateTime CreatedAt, DateTime? PostedAt, int LineCount,
+    int? PurchaseInvoiceId, string? PurchaseInvoiceNo);
 
 public sealed record CreatedLayerDto(
     int LayerId, int ItemId, int WarehouseId, int? BatchId,
     decimal QtyReceived, decimal QtyRemaining, decimal UnitCost, DateTime ReceiptDate);
 
 public sealed record GrnConfirmResultDto(
-    int GrnId, GrnStatus Status, DateTime PostedAt,
+    int GrnId, GrnStatus Status, DateTime PostedAt, string GlJournalNo,
     IReadOnlyList<CreatedLayerDto> CreatedLayers, IReadOnlyList<int> LedgerRefs, PurchaseOrderStatus? PoStatus);
 
 public sealed record ReleaseLineResultDto(int GrnLineId, HoldStatus HoldStatus);
 
+/// <summary>A Confirmed, not-yet-invoiced GRN eligible to be consolidated onto a Purchase Invoice.</summary>
+public sealed record GrnEligibleForInvoiceDto(
+    int GrnId, string DocNo, DateTime PostedAt, int WarehouseId,
+    int LineCount, decimal Subtotal, decimal VatTotal, decimal GrandTotal);
+
 // Requests ----------------------------------------------------------------------
 
 public sealed class BatchInput
@@ -44,7 +53,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 +67,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/Hrm/EmployeeDtos.cs

@@ -6,7 +6,7 @@ namespace ERPCore.Dtos.Hrm;
 public sealed record EmployeeListItemDto(
     int EmployeeId, string EmployeeCode, string FullName, string? Email,
     int DepartmentId, string? DepartmentName, int DesignationId, string? DesignationName,
-    int EmploymentTypeId, string? EmploymentTypeName, int? BranchId, string? BranchName,
+    int EmploymentTypeId, string? EmploymentTypeName, int BranchId, string? BranchName,
     EmployeeStatus Status, bool HasUserLink, DateTime HireDate);
 
 public sealed record EmployeeDetailDto(
@@ -16,7 +16,7 @@ public sealed record EmployeeDetailDto(
     string? City, string? PostalCode, string? Country,
     string? EmergencyContactName, string? EmergencyContactRelationship, string? EmergencyContactPhone,
     DateTime HireDate, DateTime? ConfirmationDate, DateTime? LastWorkingDate,
-    int DepartmentId, int DesignationId, int EmploymentTypeId, int? BranchId, int WorkShiftId,
+    int DepartmentId, int DesignationId, int EmploymentTypeId, int BranchId, int WorkShiftId,
     int? ReportingManagerId, string? EpfNumber, string? EtfNumber, string? TaxIdentificationNumber,
     int? UserId, EmployeeStatus Status, DateTime CreatedAt, DateTime? UpdatedAt);
 
@@ -45,7 +45,7 @@ public sealed class CreateEmployeeRequest
     [Required] public int DepartmentId { get; set; }
     [Required] public int DesignationId { get; set; }
     [Required] public int EmploymentTypeId { get; set; }
-    public int? BranchId { get; set; }
+    [Required] public int BranchId { get; set; }
     [Required] public int WorkShiftId { get; set; }
     public int? ReportingManagerId { get; set; }
 
@@ -82,7 +82,7 @@ public sealed class UpdateEmployeeRequest
     [Required] public int DepartmentId { get; set; }
     [Required] public int DesignationId { get; set; }
     [Required] public int EmploymentTypeId { get; set; }
-    public int? BranchId { get; set; }
+    [Required] public int BranchId { get; set; }
     [Required] public int WorkShiftId { get; set; }
     public int? ReportingManagerId { get; set; }