feat: add purchase invoice batch print page and related components

- Implemented PurchaseInvoiceBatchPrintPage for printing purchase invoices.
- Created InvoicePrintHeader and InvoicePrintFooter components for invoice layout.
- Added invoice layout presets for different styles (Classic, Compact, Modern).
- Developed PurchaseInvoicePaymentDialog for handling payments against invoices.
- Introduced API mocks for company profile and invoice template configuration.
- Added validation functions for company profile and purchase invoices.
- Defined types for company profile, invoice template configuration, and purchase invoices.

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

@@ -29,6 +29,14 @@ public sealed class BundleSalesController : ApiControllerBase
         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(

Backend/ERPCore/Controllers/GrnsController.cs

@@ -12,7 +12,10 @@ 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]

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

@@ -24,6 +24,19 @@ public sealed class ProductionRunsController : ApiControllerBase
         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)]

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

@@ -10,8 +10,13 @@ namespace ERPCore.Controllers;
 public sealed class SalesInvoicesController : ApiControllerBase
 {
     private readonly ISalesInvoiceService _invoices;
+    private readonly ISalesInvoicePaymentService _payments;
 
-    public SalesInvoicesController(ISalesInvoiceService invoices) => _invoices = invoices;
+    public SalesInvoicesController(ISalesInvoiceService invoices, ISalesInvoicePaymentService payments)
+    {
+        _invoices = invoices;
+        _payments = payments;
+    }
 
     [HttpGet]
     [ProducesResponseType(typeof(PagedResponse<SalesInvoiceSummaryDto>), StatusCodes.Status200OK)]
@@ -70,4 +75,23 @@ public sealed class SalesInvoicesController : ApiControllerBase
     [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/Domain/DocumentTypes.cs

@@ -10,6 +10,7 @@ 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";
@@ -20,5 +21,9 @@ public static class DocumentTypes
     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/BundleSale.cs

@@ -29,5 +29,11 @@ public class BundleSale
     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/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/Item.cs

@@ -44,11 +44,12 @@ public class Item
     public string? TaxClass { get; set; }
 
     /// <summary>
-    /// Optional fixed selling price used by Sales only. <c>null</c> means "use stock value"
+    /// Optional selling price range and flat price used by Sales only.
-    /// (the item is sold at its FIFO stock cost at sale time); a value is the fixed sale price.
+    /// <c>null</c> values mean the field is not set. These values never enter costing/GRN/FIFO.
-    /// Never enters costing/GRN/FIFO (docs/10 Part C.1, C.9).
     /// </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

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/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
+/// rejected with <c>CONFIG_DISABLED</c>. <see cref="ItemTypesEnabled"/> is advisory only
-/// <b>advisory only</b> — items carry no item-type reference (see <see cref="ItemType"/>),
+/// - items carry no item-type reference (see <see cref="ItemType"/>), so there is nothing
-/// so there is nothing on a write to reject; the frontend honours it by hiding the
+/// on a write to reject; the frontend honours it by hiding the variant builder.
-/// builder's type section. Reads are never gated, so existing data stays visible after a
+/// <see cref="SellingPricesEnabled"/>, <see cref="SerialNumbersEnabled"/>,
-/// flag is switched off.
+/// <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/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/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

@@ -29,6 +29,14 @@ public class SalesInvoice
     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; }
 
@@ -38,4 +46,5 @@ public class SalesInvoice
     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/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

@@ -28,5 +28,11 @@ public class SalesReturn
 
     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/SalesSlip.cs

@@ -27,6 +27,10 @@ public class SalesSlip
     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; }
 

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/Enums/PurchaseInvoiceStatus.cs

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

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/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
+/// <c>false</c> and silently switch everything off. Nullable makes the requirement actually
-/// actually bind — an omitted flag is a 400, not an accidental disable.
+/// 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/Grn/GrnDtos.cs

@@ -16,23 +16,30 @@ public sealed record GrnLineDto(
 
 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

Backend/ERPCore/Dtos/Items/ItemDtos.cs

@@ -10,7 +10,7 @@ public sealed record ItemListItemDto(
     int ItemId, string Sku, string Name, int CategoryId, int? SubCategoryId, int? BrandId,
     int BaseUomId, int? DefaultVendorId, StockNature StockNature, TrackingMode TrackingMode,
     Warranty Warranty, int? WarrantyPeriodMonths,
-    string? TaxClass, decimal? SalePrice,
+    string? TaxClass, decimal? SellingMinPrice, decimal? SellingMaxPrice, decimal? SellingFlatPrice,
     decimal? ContentQty, MeasureUnit? ContentUnit,
     decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
     EntityStatus Status);
@@ -31,7 +31,7 @@ public sealed record ItemDetailDto(
     int? SubCategoryId, int? BrandId, int BaseUomId, int? DefaultVendorId,
     StockNature StockNature, TrackingMode TrackingMode,
     Warranty Warranty, int? WarrantyPeriodMonths,
-    string? TaxClass, decimal? SalePrice,
+    string? TaxClass, decimal? SellingMinPrice, decimal? SellingMaxPrice, decimal? SellingFlatPrice,
     decimal? ContentQty, MeasureUnit? ContentUnit,
     decimal? ContentBaseQty, MeasureUnit? ContentBaseUnit,
     EntityStatus Status, IReadOnlyList<ItemReorderDto> Reorder,
@@ -66,7 +66,9 @@ public sealed class CreateItemRequest
     public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
-    [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingMinPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingMaxPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingFlatPrice { get; set; }
 
     /// <summary>
     /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null
@@ -96,7 +98,9 @@ public sealed class UpdateItemRequest
     public int? WarrantyPeriodMonths { get; set; }
     [StringLength(20)] public string? TaxClass { get; set; }
     /// <summary>Optional fixed sale price (Sales only). Null ⇒ sell at stock/FIFO value.</summary>
-    [Range(0, double.MaxValue)] public decimal? SalePrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingMinPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingMaxPrice { get; set; }
+    [Range(0, double.MaxValue)] public decimal? SellingFlatPrice { get; set; }
 
     /// <summary>
     /// How much one pack holds. Supply with <see cref="ContentUnit"/> or leave both null

Backend/ERPCore/Dtos/Notifications/NotificationConfigDtos.cs

@@ -0,0 +1,29 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ERPCore.Dtos.Notifications;
+
+public sealed record NotificationModuleConfigDto(
+    string ModuleKey,
+    string Label,
+    string Description,
+    bool EmailEnabled,
+    bool SmsEnabled,
+    bool InAppEnabled);
+
+public sealed record NotificationConfigDto(
+    IReadOnlyList<NotificationModuleConfigDto> Modules,
+    DateTime? UpdatedAt,
+    int? UpdatedBy);
+
+public sealed class UpdateNotificationModuleRequest
+{
+    [Required, StringLength(100)] public string ModuleKey { get; set; } = string.Empty;
+    [Required] public bool? EmailEnabled { get; set; }
+    [Required] public bool? SmsEnabled { get; set; }
+    [Required] public bool? InAppEnabled { get; set; }
+}
+
+public sealed class UpdateNotificationConfigRequest
+{
+    [Required, MinLength(0)] public List<UpdateNotificationModuleRequest> Modules { get; set; } = new();
+}

Backend/ERPCore/Dtos/Procurement/PurchaseInvoiceDtos.cs

@@ -0,0 +1,50 @@
+using System.ComponentModel.DataAnnotations;
+using ERPCore.Domain.Enums;
+
+namespace ERPCore.Dtos.Procurement;
+
+public sealed record PurchaseInvoiceLineDto(
+    int PurchaseInvoiceLineId, int GrnId, string GrnDocNo, DateTime GrnPostedAt,
+    decimal Subtotal, decimal VatTotal, decimal LineTotal);
+
+public sealed record PurchaseInvoiceTotalsDto(
+    decimal Subtotal, decimal VatTotal, decimal GrandTotal, decimal PaidAmount, decimal BalanceAmount);
+
+public sealed record PurchaseInvoiceDto(
+    int PurchaseInvoiceId, string DocNo, string VendorInvoiceNo, DateTime VendorInvoiceDate,
+    int VendorId, string VendorSnapshotName, string? VendorSnapshotTaxNo,
+    PurchaseInvoiceStatus Status, int GrnCount, int CreatedBy, DateTime CreatedAt, DateTime? UpdatedAt,
+    string? GlJournalNo, DateTime? GlPostedAt,
+    PurchaseInvoiceTotalsDto Totals, IReadOnlyList<PurchaseInvoiceLineDto> Lines);
+
+public sealed record PurchaseInvoiceSummaryDto(
+    int PurchaseInvoiceId, string DocNo, string VendorInvoiceNo, DateTime VendorInvoiceDate,
+    int VendorId, string VendorSnapshotName, PurchaseInvoiceStatus Status, int GrnCount,
+    PurchaseInvoiceTotalsDto Totals, DateTime CreatedAt, string? GlJournalNo);
+
+public sealed record PurchaseInvoicePaymentDto(
+    int PurchaseInvoicePaymentId, int PurchaseInvoiceId, decimal Amount, DateTime PaymentDate,
+    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt);
+
+public sealed class CreatePurchaseInvoicePaymentRequest
+{
+    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
+    [Required] public long GlBankAccountId { get; set; }
+    [StringLength(100)] public string? Reference { get; set; }
+}
+
+public sealed class CreatePurchaseInvoiceRequest
+{
+    [Required] public int VendorId { get; set; }
+    [Required, StringLength(50)] public string VendorInvoiceNo { get; set; } = string.Empty;
+    [Required] public DateTime VendorInvoiceDate { get; set; }
+    [Required, MinLength(1)] public List<int> GrnIds { get; set; } = new();
+}
+
+public sealed class UpdatePurchaseInvoiceRequest
+{
+    [Required] public int VendorId { get; set; }
+    [Required, StringLength(50)] public string VendorInvoiceNo { get; set; } = string.Empty;
+    [Required] public DateTime VendorInvoiceDate { get; set; }
+    [Required, MinLength(1)] public List<int> GrnIds { get; set; } = new();
+}

Backend/ERPCore/Dtos/Procurement/PurchaseReturnDtos.cs

@@ -9,12 +9,13 @@ public sealed record PurchaseReturnLineDto(int ReturnLineId, int? GrnLineId, int
 
 public sealed record PurchaseReturnDto(
     int ReturnId, string DocNo, int VendorId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, IReadOnlyList<PurchaseReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+    int CreatedBy, DateTime CreatedAt, string? GlJournalNo, DateTime? GlPostedAt,
+    IReadOnlyList<PurchaseReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
 
 /// <summary>Row shape for <c>GET /purchase-returns</c> — no lines/ledgerRefs (those need a per-row query).</summary>
 public sealed record PurchaseReturnSummaryDto(
     int ReturnId, string DocNo, int VendorId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, int LineCount);
+    int CreatedBy, DateTime CreatedAt, int LineCount, string? GlJournalNo);
 
 // Requests ----------------------------------------------------------------------
 

Backend/ERPCore/Dtos/Production/RunDtos.cs

@@ -70,6 +70,35 @@ public sealed record RunEventDto(
     int EventId, int? RunStageId, RunStageEventType EventType, string? Note,
     JsonElement? Payload, int UserId, DateTime CreatedAt);
 
+/// <summary>
+/// One row of the produced-items report (<c>GET /production-runs/produced</c>) — the
+/// terminal output of a run that has produced something, costed the same way
+/// <c>PostReceiptAsync</c> costs the finished layer at approve (FR-MFG-13):
+/// <c>unitCost = (Σ ConsumedValue − Σ ReturnedValue) / (ProducedQty − ScrappedQty)</c>.
+/// One row per run — server validation (<see cref="ProductionGraphValidator"/> via
+/// FR-MFG-05) guarantees exactly one item-bearing output per run, always the terminal
+/// one, so run and produced line coincide 1:1.
+/// <para><c>UnitCost</c>/<c>TotalCost</c> are final only once <c>Status</c> is
+/// <c>Completed</c> — a leftover return can still shrink the pool between the terminal
+/// stage's Done and its Approve, same caveat as <see cref="CostPoolDto"/>.</para>
+/// </summary>
+public sealed record ProducedLineDto(
+    int RunId, string DocNo, ProductionRunStatus Status,
+    int TemplateId, string TemplateName,
+    int WarehouseId, string WarehouseName,
+    int ItemId, string ItemName,
+    decimal ProducedQty, decimal ScrappedQty, decimal GoodQty,
+    decimal UnitCost, decimal TotalCost,
+    DateTime CreatedAt, DateTime? CompletedAt);
+
+/// <summary>Aggregate footer for the produced-items report — totals over every row the filter
+/// matched, not just the current page (there is no pagination here, matching the Sales report
+/// convention of flat, filter-bounded rows).</summary>
+public sealed record ProducedSummaryDto(
+    int RunCount, decimal TotalProducedQty, decimal TotalScrappedQty, decimal TotalGoodQty, decimal TotalCost);
+
+public sealed record ProducedListResponseDto(IReadOnlyList<ProducedLineDto> Items, ProducedSummaryDto Summary);
+
 /// <summary>Full run graph (docs/30 §D.2 <c>GET /production-runs/{id}</c>).</summary>
 public sealed record RunGraphDto(
     int RunId, string DocNo, int TemplateId, string TemplateName,
@@ -99,8 +128,10 @@ public sealed class CreateRunRequest
 }
 
 /// <summary>
-/// Per-run scaling override (FR-MFG-08). Only accepted while the stage has not started
+/// Per-run scaling override (FR-MFG-08). Accepted before the stage starts, and — for a Stock
-/// (<c>409 STAGE_NOT_EDITABLE</c>).
+/// input only — while it is running too: raising <see cref="StageQuantityLine.PlannedQty"/>
+/// draws the extra amount from FIFO, lowering it returns the excess (<c>409
+/// STAGE_NOT_EDITABLE</c> for every other status).
 /// </summary>
 public sealed class UpdateStageQuantitiesRequest
 {
@@ -116,4 +147,11 @@ public sealed class StageQuantityLine
 
     [Range(0.0001, double.MaxValue)]
     public decimal PlannedQty { get; set; }
+
+    /// <summary>
+    /// Required only when this line lowers a running Stock input below what it has already
+    /// consumed — the excess is returned to stock the same way <c>ReturnLeftoverAsync</c>
+    /// does, and that always needs a reason (FR-MFG-14). Ignored otherwise.
+    /// </summary>
+    public int? ReasonCodeId { get; set; }
 }

Backend/ERPCore/Dtos/Sales/BundleSaleDtos.cs

@@ -51,7 +51,6 @@ public sealed class CreateBundleSaleTemplateLineRequest
 
 public sealed class CreateBundleSaleTemplateRequest
 {
-    [Required] public string TemplateCode { get; set; } = string.Empty;
     [Required] public string TemplateName { get; set; } = string.Empty;
     public string? Description { get; set; }
     [Required, MinLength(1)] public List<CreateBundleSaleTemplateLineRequest> Lines { get; set; } = new();

Backend/ERPCore/Dtos/Sales/SalesDayEndDtos.cs

@@ -0,0 +1,51 @@
+using System.ComponentModel.DataAnnotations;
+
+namespace ERPCore.Dtos.Sales;
+
+// Responses -----------------------------------------------------------------------
+
+/// <summary>Qty/revenue sold for one item across a closed (or about-to-close) day, for the day-end report.
+/// Merges sales-slip and bundle-sale lines for the same item into one row.</summary>
+public sealed record SalesDayEndItemLineDto(int ItemId, string Sku, string Name, decimal Qty, decimal Revenue);
+
+/// <summary>Read-only visibility into that cashier's Sales Invoices for the date — informational
+/// only, appended to <see cref="SalesDayEndDto"/> and <see cref="SalesDayEndPreviewDto"/>.
+/// Invoices post their own GL entry on Confirm (SalesPostingService.PostInvoiceAsync) and have no
+/// DayEndId, so they're never locked against a close: these fields are computed live from current
+/// data on every read, unlike the frozen Slip/Bundle totals alongside them.</summary>
+public sealed record SalesDayEndInvoiceSummaryDto(
+    int InvoiceCount, decimal InvoiceSubtotal, decimal InvoiceDiscountTotal, decimal InvoiceTaxTotal,
+    decimal InvoiceGrandTotal, IReadOnlyList<string> InvoiceNumbers);
+
+public sealed record SalesDayEndDto(
+    int SalesDayEndId, string DocNo, int CashierUserId, DateOnly BusinessDate,
+    int SlipCount, int BundleCount, decimal Subtotal, decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal,
+    decimal CostOfGoodsSold, string? GlJournalNo, DateTime? GlPostedAt, int ClosedBy, DateTime ClosedAt,
+    IReadOnlyList<string> SlipNumbers, IReadOnlyList<string> BundleNumbers, IReadOnlyList<SalesDayEndItemLineDto> ItemBreakdown,
+    SalesDayEndInvoiceSummaryDto Invoices);
+
+public sealed record SalesDayEndSummaryDto(
+    int SalesDayEndId, string DocNo, int CashierUserId, DateOnly BusinessDate,
+    int SlipCount, int BundleCount, decimal GrandTotal, string? GlJournalNo, DateTime ClosedAt);
+
+/// <summary>What closing right now would include — call before <c>POST /sales-day-end</c> so the
+/// cashier can see the day's totals, and any still-Draft slips/bundles blocking the close.</summary>
+public sealed record SalesDayEndPreviewDto(
+    int CashierUserId, DateOnly BusinessDate, bool AlreadyClosed,
+    int SlipCount, int BundleCount, decimal Subtotal, decimal DiscountTotal, decimal TaxTotal, decimal GrandTotal,
+    IReadOnlyList<string> SlipNumbers, IReadOnlyList<string> BundleNumbers,
+    IReadOnlyList<DraftSlipBlockingCloseDto> DraftSlipsBlockingClose,
+    IReadOnlyList<DraftBundleBlockingCloseDto> DraftBundleSalesBlockingClose,
+    SalesDayEndInvoiceSummaryDto Invoices);
+
+public sealed record DraftSlipBlockingCloseDto(int SalesSlipId, string SlipNo, decimal GrandTotal);
+public sealed record DraftBundleBlockingCloseDto(int BundleSaleId, string BundleNo, decimal GrandTotal);
+
+// Requests ------------------------------------------------------------------------
+
+public sealed class CreateSalesDayEndRequest
+{
+    [Required] public int CashierUserId { get; set; }
+    /// <summary>Defaults to today (UTC) when omitted.</summary>
+    public DateOnly? BusinessDate { get; set; }
+}

Backend/ERPCore/Dtos/Sales/SalesInvoiceDtos.cs

@@ -17,12 +17,24 @@ public sealed record SalesInvoiceDto(
     int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
     string CustomerSnapshotName, string? CustomerSnapshotTaxNo, int WarehouseId,
     SalesInvoiceType InvoiceType, SalesInvoiceStatus Status, int CreatedBy, DateTime CreatedAt,
-    DateTime? UpdatedAt, SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
+    DateTime? UpdatedAt, string? GlJournalNo, DateTime? GlPostedAt,
+    SalesInvoiceTotalsDto Totals, IReadOnlyList<SalesInvoiceLineDto> Lines);
 
 public sealed record SalesInvoiceSummaryDto(
     int SalesInvoiceId, string InvoiceNo, DateTime InvoiceDate, int CustomerId,
     string CustomerSnapshotName, int WarehouseId, SalesInvoiceType InvoiceType,
-    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt);
+    SalesInvoiceStatus Status, SalesInvoiceTotalsDto Totals, DateTime CreatedAt, string? GlJournalNo);
+
+public sealed record SalesInvoicePaymentDto(
+    int SalesInvoicePaymentId, int SalesInvoiceId, decimal Amount, DateTime PaymentDate,
+    long GlBankAccountId, string BankAccountName, string? Reference, string? GlJournalNo, DateTime CreatedAt);
+
+public sealed class CreateSalesInvoicePaymentRequest
+{
+    [Range(0.01, double.MaxValue)] public decimal Amount { get; set; }
+    [Required] public long GlBankAccountId { get; set; }
+    [StringLength(100)] public string? Reference { get; set; }
+}
 
 public sealed record SalesInvoicePostingIssueDto(
     int SalesInvoiceLineId, int ItemId, string ItemSku, string ItemName, int WarehouseId,

Backend/ERPCore/Dtos/Sales/SalesPromotionSuggestionDtos.cs

@@ -4,7 +4,7 @@ public sealed record SalesFreeIssueRewardOptionDto(
     int ItemId,
     string Sku,
     string Name,
-    decimal? SalePrice);
+    decimal? SellingFlatPrice);
 
 public sealed record SalesFreeIssueSuggestionLineDto(
     int SalesSlipLineId,

Backend/ERPCore/Dtos/Sales/SalesReturnDtos.cs

@@ -9,12 +9,13 @@ public sealed record SalesReturnLineDto(int ReturnLineId, int? SalesInvoiceLineI
 
 public sealed record SalesReturnDto(
     int ReturnId, string DocNo, int CustomerId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, IReadOnlyList<SalesReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+    int CreatedBy, DateTime CreatedAt, string? GlJournalNo, DateTime? GlPostedAt,
+    IReadOnlyList<SalesReturnLineDto> Lines, IReadOnlyList<int> LedgerRefs);
 
 /// <summary>Row shape for <c>GET /sales-returns</c> — no lines/ledgerRefs (those need a per-row query).</summary>
 public sealed record SalesReturnSummaryDto(
     int ReturnId, string DocNo, int CustomerId, int WarehouseId, int ReasonCodeId, ReturnStatus Status,
-    int CreatedBy, DateTime CreatedAt, int LineCount, decimal TotalQty);
+    int CreatedBy, DateTime CreatedAt, int LineCount, decimal TotalQty, string? GlJournalNo);
 
 /// <summary>
 /// Remaining returnable qty for one sales invoice line — the invoiced qty minus

Backend/ERPCore/Dtos/Stock/AdjustmentDtos.cs

@@ -9,12 +9,13 @@ public sealed record AdjustmentLineDto(int AdjLineId, int ItemId, int? BinId, in
 
 public sealed record AdjustmentDto(
     int AdjustmentId, string DocNo, int WarehouseId, int ReasonCodeId, AdjustmentStatus Status,
-    int CreatedBy, DateTime CreatedAt, IReadOnlyList<AdjustmentLineDto> Lines, IReadOnlyList<int> LedgerRefs);
+    int CreatedBy, DateTime CreatedAt, string? GlJournalNo, DateTime? GlPostedAt,
+    IReadOnlyList<AdjustmentLineDto> Lines, IReadOnlyList<int> LedgerRefs);
 
 /// <summary>Row shape for <c>GET /stock-adjustments</c> — no lines/ledgerRefs (those need a per-row query).</summary>
 public sealed record AdjustmentSummaryDto(
     int AdjustmentId, string DocNo, int WarehouseId, int ReasonCodeId, AdjustmentStatus Status,
-    int CreatedBy, DateTime CreatedAt, int LineCount);
+    int CreatedBy, DateTime CreatedAt, int LineCount, string? GlJournalNo);
 
 // Requests ----------------------------------------------------------------------
 

Backend/ERPCore/Dtos/Stock/CountDtos.cs

@@ -16,7 +16,7 @@ public sealed record CountSummaryDto(
     int CountId, string DocNo, int WarehouseId, CountType CountType, CountStatus Status,
     int CreatedBy, DateTime CreatedAt, int LineCount);
 
-public sealed record CountPostResultDto(int CountId, CountStatus Status, int? AdjustmentId, IReadOnlyList<int> LedgerRefs);
+public sealed record CountPostResultDto(int CountId, CountStatus Status, int? AdjustmentId, string? GlJournalNo, IReadOnlyList<int> LedgerRefs);
 
 // Requests ----------------------------------------------------------------------
 

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

@@ -16,12 +16,14 @@ public sealed class GrnConfiguration : IEntityTypeConfiguration<Grn>
 
         builder.Property(g => g.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(g => g.CreatedAt).IsRequired();
+        builder.Property(g => g.GlJournalNo).HasMaxLength(30);
         builder.Property(g => g.RowVersion).IsRowVersion();
 
         builder.HasOne(g => g.PurchaseOrder).WithMany().HasForeignKey(g => g.PoId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(g => g.Vendor).WithMany().HasForeignKey(g => g.VendorId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(g => g.Warehouse).WithMany().HasForeignKey(g => g.WarehouseId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(g => g.Creator).WithMany().HasForeignKey(g => g.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(g => g.PurchaseInvoice).WithMany().HasForeignKey(g => g.PurchaseInvoiceId).OnDelete(DeleteBehavior.Restrict);
 
         builder.HasIndex(g => g.Status);
         builder.HasIndex(g => g.PoId);

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

@@ -20,7 +20,9 @@ public sealed class ItemConfiguration : IEntityTypeConfiguration<Item>
         builder.Property(i => i.TaxClass).HasMaxLength(20);
 
         // Sales-only fixed selling price; nullable (null ⇒ sell at stock/FIFO value).
-        builder.Property(i => i.SalePrice).HasPrecision(18, 4);
+        builder.Property(i => i.SellingMinPrice).HasPrecision(18, 4);
+        builder.Property(i => i.SellingMaxPrice).HasPrecision(18, 4);
+        builder.Property(i => i.SellingFlatPrice).HasPrecision(18, 4);
 
         // Optional content size (how much one stocked pack holds). All four are nullable
         // together: null ⇒ the item has no measurable content. The base pair is derived

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

@@ -39,7 +39,8 @@ public sealed class NavItemConfiguration : IEntityTypeConfiguration<NavItem>
             new NavItem { NavItemId = 10, Code = "help", Label = "Help", Href = "/dashboard/help", SortOrder = 10 },
             new NavItem { NavItemId = 11, Code = "ledgers", Label = "Ledgers", Href = "/dashboard/ledgers", SortOrder = 11 },
             new NavItem { NavItemId = 12, Code = "accounts", Label = "Accounts", Href = "/dashboard/accounts", SortOrder = 12 },
-            new NavItem { NavItemId = 13, Code = "sales", Label = "Sales", Href = "/dashboard/sales", SortOrder = 13 }
+            new NavItem { NavItemId = 13, Code = "sales", Label = "Sales", Href = "/dashboard/sales", SortOrder = 13 },
+            new NavItem { NavItemId = 14, Code = "production", Label = "Production", Href = "/dashboard/production", SortOrder = 14 }
         );
     }
 }

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

@@ -0,0 +1,29 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class NotificationConfigConfiguration : IEntityTypeConfiguration<NotificationConfig>
+{
+    public void Configure(EntityTypeBuilder<NotificationConfig> builder)
+    {
+        builder.ToTable("notification_config", t =>
+            t.HasCheckConstraint("ck_notification_config_singleton", $"\"NotificationConfigId\" = {NotificationConfig.SingletonId}"));
+
+        builder.HasKey(c => c.NotificationConfigId);
+        builder.Property(c => c.NotificationConfigId).ValueGeneratedNever();
+
+        builder.Property(c => c.RowVersion).IsRowVersion();
+
+        builder.HasMany(c => c.Modules)
+            .WithOne(m => m.NotificationConfig)
+            .HasForeignKey(m => m.NotificationConfigId)
+            .OnDelete(DeleteBehavior.Cascade);
+
+        builder.HasOne(c => c.UpdatedByUser)
+            .WithMany()
+            .HasForeignKey(c => c.UpdatedBy)
+            .OnDelete(DeleteBehavior.Restrict);
+    }
+}

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

@@ -0,0 +1,21 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class NotificationConfigModuleConfiguration : IEntityTypeConfiguration<NotificationConfigModule>
+{
+    public void Configure(EntityTypeBuilder<NotificationConfigModule> builder)
+    {
+        builder.ToTable("notification_config_modules");
+        builder.HasKey(m => m.NotificationConfigModuleId);
+
+        builder.Property(m => m.ModuleKey).IsRequired().HasMaxLength(100);
+        builder.HasIndex(m => m.ModuleKey).IsUnique();
+
+        builder.Property(m => m.EmailEnabled).IsRequired().HasDefaultValue(false);
+        builder.Property(m => m.SmsEnabled).IsRequired().HasDefaultValue(false);
+        builder.Property(m => m.InAppEnabled).IsRequired().HasDefaultValue(false);
+    }
+}

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

@@ -61,7 +61,12 @@ public sealed class PermissionConfiguration : IEntityTypeConfiguration<Permissio
             new Permission { PermissionId = 26, Code = "NAV:accounts.bank-accounts", SubNavItemId = 15 },
             new Permission { PermissionId = 32, Code = "NAV:accounts", NavItemId = 12 },
             new Permission { PermissionId = 33, Code = "NAV:accounts.cheque-books", SubNavItemId = 21 },
-            new Permission { PermissionId = 34, Code = "NAV:accounts.received-cheques", SubNavItemId = 22 }
+            new Permission { PermissionId = 34, Code = "NAV:accounts.received-cheques", SubNavItemId = 22 },
+            new Permission { PermissionId = 35, Code = "NAV:production", NavItemId = 14 },
+            new Permission { PermissionId = 36, Code = "NAV:production.templates", SubNavItemId = 27 },
+            new Permission { PermissionId = 37, Code = "NAV:production.runs", SubNavItemId = 25 },
+            new Permission { PermissionId = 38, Code = "NAV:production.produced", SubNavItemId = 26 },
+            new Permission { PermissionId = 39, Code = "NAV:procurement.purchase-invoices", SubNavItemId = 28 }
         );
     }
 }

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

@@ -25,6 +25,10 @@ public sealed class ProductConfigConfiguration : IEntityTypeConfiguration<Produc
         builder.Property(c => c.SubcategoriesEnabled).IsRequired().HasDefaultValue(true);
         builder.Property(c => c.BrandsEnabled).IsRequired().HasDefaultValue(true);
         builder.Property(c => c.ItemTypesEnabled).IsRequired().HasDefaultValue(true);
+        builder.Property(c => c.SellingPricesEnabled).IsRequired().HasDefaultValue(true);
+        builder.Property(c => c.SerialNumbersEnabled).IsRequired().HasDefaultValue(true);
+        builder.Property(c => c.BatchListsEnabled).IsRequired().HasDefaultValue(true);
+        builder.Property(c => c.WarrantyPeriodsEnabled).IsRequired().HasDefaultValue(true);
 
         // PostgreSQL xmin system column as the optimistic concurrency token (ETag).
         builder.Property(c => c.RowVersion).IsRowVersion();

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

@@ -0,0 +1,97 @@
+using ERPCore.Domain.Entities;
+using ERPCore.Domain.Enums;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class PurchaseInvoiceConfiguration : IEntityTypeConfiguration<PurchaseInvoice>
+{
+    public void Configure(EntityTypeBuilder<PurchaseInvoice> builder)
+    {
+        builder.ToTable("purchase_invoices");
+        builder.HasKey(x => x.PurchaseInvoiceId);
+
+        builder.Property(x => x.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(x => x.DocNo).IsUnique();
+
+        builder.Property(x => x.VendorInvoiceNo).IsRequired().HasMaxLength(50);
+        builder.Property(x => x.VendorInvoiceDate).IsRequired();
+        // A vendor invoice number is only meaningful per-vendor; the service also excludes
+        // Cancelled invoices from the duplicate check, so this composite index is a coarse
+        // backstop (it does not distinguish Cancelled rows) rather than the sole enforcement.
+        builder.HasIndex(x => new { x.VendorId, x.VendorInvoiceNo });
+
+        builder.HasOne(x => x.Vendor)
+            .WithMany()
+            .HasForeignKey(x => x.VendorId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.Property(x => x.VendorSnapshotName).IsRequired().HasMaxLength(200);
+        builder.Property(x => x.VendorSnapshotTaxNo).HasMaxLength(50);
+
+        builder.Property(x => x.Status)
+            .HasConversion<string>().HasMaxLength(20).IsRequired()
+            .HasDefaultValue(PurchaseInvoiceStatus.Draft);
+
+        foreach (var p in new[] { nameof(PurchaseInvoice.Subtotal), nameof(PurchaseInvoice.VatTotal), nameof(PurchaseInvoice.GrandTotal), nameof(PurchaseInvoice.PaidAmount), nameof(PurchaseInvoice.BalanceAmount) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+        builder.Property(x => x.GlJournalNo).HasMaxLength(30);
+
+        builder.HasOne(x => x.Creator).WithMany().HasForeignKey(x => x.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+        builder.Property(x => x.CreatedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasIndex(x => x.Status);
+        builder.HasIndex(x => x.VendorId);
+
+        builder.HasMany(x => x.Lines)
+            .WithOne(x => x.PurchaseInvoice)
+            .HasForeignKey(x => x.PurchaseInvoiceId)
+            .OnDelete(DeleteBehavior.Cascade);
+    }
+}
+
+public sealed class PurchaseInvoiceLineConfiguration : IEntityTypeConfiguration<PurchaseInvoiceLine>
+{
+    public void Configure(EntityTypeBuilder<PurchaseInvoiceLine> builder)
+    {
+        builder.ToTable("purchase_invoice_lines");
+        builder.HasKey(x => x.PurchaseInvoiceLineId);
+
+        builder.Property(x => x.Subtotal).HasPrecision(18, 4);
+        builder.Property(x => x.VatTotal).HasPrecision(18, 4);
+        builder.Property(x => x.LineTotal).HasPrecision(18, 4);
+
+        builder.HasOne(x => x.Grn)
+            .WithMany()
+            .HasForeignKey(x => x.GrnId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        // A GRN can be consolidated onto at most one active line at a time — cancelling the
+        // invoice removes its lines and frees the GRN (PurchaseInvoiceService.CancelAsync), so
+        // this stays enforceable rather than blocking a later re-invoice of the same GRN.
+        builder.HasIndex(x => x.GrnId).IsUnique();
+    }
+}
+
+public sealed class PurchaseInvoicePaymentConfiguration : IEntityTypeConfiguration<PurchaseInvoicePayment>
+{
+    public void Configure(EntityTypeBuilder<PurchaseInvoicePayment> builder)
+    {
+        builder.ToTable("purchase_invoice_payments");
+        builder.HasKey(p => p.PurchaseInvoicePaymentId);
+
+        builder.Property(p => p.Amount).HasPrecision(18, 4);
+        builder.Property(p => p.PaymentDate).IsRequired();
+        builder.Property(p => p.BankAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(p => p.Reference).HasMaxLength(100);
+        builder.Property(p => p.GlJournalNo).HasMaxLength(30);
+        builder.Property(p => p.CreatedAt).IsRequired();
+
+        builder.HasOne(p => p.PurchaseInvoice).WithMany(x => x.Payments).HasForeignKey(p => p.PurchaseInvoiceId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(p => p.Creator).WithMany().HasForeignKey(p => p.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(p => p.PurchaseInvoiceId);
+    }
+}

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

@@ -16,6 +16,7 @@ public sealed class PurchaseReturnConfiguration : IEntityTypeConfiguration<Purch
 
         builder.Property(r => r.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(r => r.CreatedAt).IsRequired();
+        builder.Property(r => r.GlJournalNo).HasMaxLength(30);
 
         builder.HasOne(r => r.Vendor).WithMany().HasForeignKey(r => r.VendorId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(r => r.Warehouse).WithMany().HasForeignKey(r => r.WarehouseId).OnDelete(DeleteBehavior.Restrict);

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

@@ -0,0 +1,44 @@
+using ERPCore.Domain.Entities;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Metadata.Builders;
+
+namespace ERPCore.Infra.Persistence.Configurations;
+
+public sealed class SalesDayEndConfiguration : IEntityTypeConfiguration<SalesDayEnd>
+{
+    public void Configure(EntityTypeBuilder<SalesDayEnd> builder)
+    {
+        builder.ToTable("sales_day_ends");
+        builder.HasKey(x => x.SalesDayEndId);
+
+        builder.Property(x => x.DocNo).IsRequired().HasMaxLength(30);
+        builder.HasIndex(x => x.DocNo).IsUnique();
+
+        builder.Property(x => x.BusinessDate).IsRequired();
+
+        foreach (var p in new[] { nameof(SalesDayEnd.Subtotal), nameof(SalesDayEnd.DiscountTotal), nameof(SalesDayEnd.TaxTotal), nameof(SalesDayEnd.GrandTotal), nameof(SalesDayEnd.CostOfGoodsSold) })
+            builder.Property<decimal>(p).HasPrecision(18, 4);
+        builder.Property(x => x.BundleCount).HasDefaultValue(0);
+
+        builder.Property(x => x.GlJournalNo).HasMaxLength(30);
+        builder.Property(x => x.ClosedAt).IsRequired();
+        builder.Property(x => x.RowVersion).IsRowVersion();
+
+        builder.HasOne(x => x.CashierUser).WithMany().HasForeignKey(x => x.CashierUserId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(x => x.ClosedByUser).WithMany().HasForeignKey(x => x.ClosedBy).OnDelete(DeleteBehavior.Restrict);
+
+        // A cashier can only close a given business date once (CloseAsync replays this
+        // row idempotently on a second call instead of erroring — see SalesDayEndService).
+        builder.HasIndex(x => new { x.CashierUserId, x.BusinessDate }).IsUnique();
+
+        builder.HasMany(x => x.Slips)
+            .WithOne(x => x.DayEnd)
+            .HasForeignKey(x => x.DayEndId)
+            .OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasMany(x => x.BundleSales)
+            .WithOne(x => x.DayEnd)
+            .HasForeignKey(x => x.DayEndId)
+            .OnDelete(DeleteBehavior.Restrict);
+    }
+}

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

@@ -40,6 +40,7 @@ public sealed class SalesInvoiceConfiguration : IEntityTypeConfiguration<SalesIn
 
         foreach (var p in new[] { nameof(SalesInvoice.Subtotal), nameof(SalesInvoice.DiscountTotal), nameof(SalesInvoice.TaxTotal), nameof(SalesInvoice.GrandTotal), nameof(SalesInvoice.RoundOff), nameof(SalesInvoice.NetPayable), nameof(SalesInvoice.PaidAmount), nameof(SalesInvoice.BalanceAmount) })
             builder.Property<decimal>(p).HasPrecision(18, 4);
+        builder.Property(x => x.GlJournalNo).HasMaxLength(30);
 
         builder.Property(x => x.CreatedAt).IsRequired();
         builder.Property(x => x.RowVersion).IsRowVersion();
@@ -54,6 +55,27 @@ public sealed class SalesInvoiceConfiguration : IEntityTypeConfiguration<SalesIn
     }
 }
 
+public sealed class SalesInvoicePaymentConfiguration : IEntityTypeConfiguration<SalesInvoicePayment>
+{
+    public void Configure(EntityTypeBuilder<SalesInvoicePayment> builder)
+    {
+        builder.ToTable("sales_invoice_payments");
+        builder.HasKey(p => p.SalesInvoicePaymentId);
+
+        builder.Property(p => p.Amount).HasPrecision(18, 4);
+        builder.Property(p => p.PaymentDate).IsRequired();
+        builder.Property(p => p.BankAccountName).IsRequired().HasMaxLength(200);
+        builder.Property(p => p.Reference).HasMaxLength(100);
+        builder.Property(p => p.GlJournalNo).HasMaxLength(30);
+        builder.Property(p => p.CreatedAt).IsRequired();
+
+        builder.HasOne(p => p.SalesInvoice).WithMany(x => x.Payments).HasForeignKey(p => p.SalesInvoiceId).OnDelete(DeleteBehavior.Restrict);
+        builder.HasOne(p => p.Creator).WithMany().HasForeignKey(p => p.CreatedBy).OnDelete(DeleteBehavior.Restrict);
+
+        builder.HasIndex(p => p.SalesInvoiceId);
+    }
+}
+
 public sealed class SalesInvoiceLineConfiguration : IEntityTypeConfiguration<SalesInvoiceLine>
 {
     public void Configure(EntityTypeBuilder<SalesInvoiceLine> builder)

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

@@ -16,6 +16,7 @@ public sealed class SalesReturnConfiguration : IEntityTypeConfiguration<SalesRet
 
         builder.Property(r => r.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(r => r.CreatedAt).IsRequired();
+        builder.Property(r => r.GlJournalNo).HasMaxLength(30);
 
         builder.HasOne(r => r.Customer).WithMany().HasForeignKey(r => r.CustomerId).OnDelete(DeleteBehavior.Restrict);
         builder.HasOne(r => r.Warehouse).WithMany().HasForeignKey(r => r.WarehouseId).OnDelete(DeleteBehavior.Restrict);

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

@@ -16,6 +16,7 @@ public sealed class StockAdjustmentConfiguration : IEntityTypeConfiguration<Stoc
 
         builder.Property(a => a.Status).HasConversion<string>().HasMaxLength(20).IsRequired();
         builder.Property(a => a.CreatedAt).IsRequired();
+        builder.Property(a => a.GlJournalNo).HasMaxLength(30);
         builder.Property(a => a.RowVersion).IsRowVersion();
 
         builder.HasOne(a => a.Warehouse).WithMany().HasForeignKey(a => a.WarehouseId).OnDelete(DeleteBehavior.Restrict);

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

@@ -33,6 +33,7 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 6, NavItemId = 2, Code = "products.configuration", Label = "Configuration", Href = "/dashboard/products/settings", SortOrder = 6 },
             new SubNavItem { SubNavItemId = 7, NavItemId = 9, Code = "settings.roles", Label = "Roles", Href = "/dashboard/settings/roles", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 8, NavItemId = 9, Code = "settings.users", Label = "Users", Href = "/dashboard/settings/users", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 24, NavItemId = 9, Code = "settings.notification-config", Label = "Notification Config", Href = "/dashboard/settings/notification-config", SortOrder = 3 },
             new SubNavItem { SubNavItemId = 23, NavItemId = 13, Code = "sales.bundle-sales", Label = "Bundle Sales", Href = "/dashboard/sales/bundles", SortOrder = 1 },
             // Procurement (NavItemId 4) children — mirror the hub page order.
             // IDs 17-20 (not 9-12): 9-12 were already claimed by the Ledgers sub-items below;
@@ -41,6 +42,7 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             new SubNavItem { SubNavItemId = 18, NavItemId = 4, Code = "procurement.rfqs", Label = "RFQs", Href = "/dashboard/procurement/rfqs", SortOrder = 2 },
             new SubNavItem { SubNavItemId = 19, NavItemId = 4, Code = "procurement.purchase-orders", Label = "Purchase Orders", Href = "/dashboard/procurement/purchase-orders", SortOrder = 3 },
             new SubNavItem { SubNavItemId = 20, NavItemId = 4, Code = "procurement.purchase-returns", Label = "Purchase Returns", Href = "/dashboard/procurement/purchase-returns", SortOrder = 4 },
+            new SubNavItem { SubNavItemId = 28, NavItemId = 4, Code = "procurement.purchase-invoices", Label = "Purchase Invoices", Href = "/dashboard/procurement/purchase-invoices", SortOrder = 5 },
             new SubNavItem { SubNavItemId = 9, NavItemId = 11, Code = "ledgers.trial-balance", Label = "Trial Balance", Href = "/dashboard/ledgers/trial-balance", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 10, NavItemId = 11, Code = "ledgers.balance-sheet", Label = "Balance Sheet", Href = "/dashboard/ledgers/balance-sheet", SortOrder = 2 },
             new SubNavItem { SubNavItemId = 11, NavItemId = 11, Code = "ledgers.general-ledger", Label = "General Ledger", Href = "/dashboard/ledgers/general-ledger", SortOrder = 3 },
@@ -53,7 +55,15 @@ public sealed class SubNavItemConfiguration : IEntityTypeConfiguration<SubNavIte
             // doesn't silently lose it just because the section it lives under changed.
             new SubNavItem { SubNavItemId = 15, NavItemId = 12, Code = "accounts.bank-accounts", Label = "Cash / Bank Accounts", Href = "/dashboard/accounts/bank-accounts", SortOrder = 1 },
             new SubNavItem { SubNavItemId = 21, NavItemId = 12, Code = "accounts.cheque-books", Label = "Cheque Books", Href = "/dashboard/accounts/cheque-books", SortOrder = 2 },
-            new SubNavItem { SubNavItemId = 22, NavItemId = 12, Code = "accounts.received-cheques", Label = "Received Cheques", Href = "/dashboard/accounts/received-cheques", SortOrder = 3 }
+            new SubNavItem { SubNavItemId = 22, NavItemId = 12, Code = "accounts.received-cheques", Label = "Received Cheques", Href = "/dashboard/accounts/received-cheques", SortOrder = 3 },
+            // Production (NavItemId 14) children — mirror the sidebar order (AppSidebar.tsx).
+            // ID 27 (not 24): 24 collides with settings.notification-config above — that ID was
+            // reused by mistake in migration 20260820100345, which upserts row 24 to become the
+            // notification-config item and silently overwrites this one. See migration
+            // FixProductionTemplatesSubNavItemIdConflict for the data repair.
+            new SubNavItem { SubNavItemId = 27, NavItemId = 14, Code = "production.templates", Label = "Templates", Href = "/dashboard/production/templates", SortOrder = 1 },
+            new SubNavItem { SubNavItemId = 25, NavItemId = 14, Code = "production.runs", Label = "Runs", Href = "/dashboard/production/runs", SortOrder = 2 },
+            new SubNavItem { SubNavItemId = 26, NavItemId = 14, Code = "production.produced", Label = "Produced", Href = "/dashboard/production/produced", SortOrder = 3 }
         );
     }
 }

Backend/ERPCore/Infra/Persistence/DataSeeder.cs

@@ -43,8 +43,9 @@ public static class DataSeeder
     {
         var dirty = await SeedReasonCodesAsync(db, ct);
         dirty |= await SeedItemTypesAsync(db, ct);
-       // dirty |= await SeedCompanyProfileAsync(db, ct);
+        // dirty |= await SeedCompanyProfileAsync(db, ct);
         dirty |= await SeedProductConfigAsync(db, ct);
+        dirty |= await SeedNotificationConfigAsync(db, ct);
         dirty |= await SeedSalesMastersAsync(db, ct);
         dirty |= await SeedSalesStockAsync(db, ct);
         dirty |= await SeedSalesAsync(db, ct);
@@ -100,7 +101,22 @@ public static class DataSeeder
             ConfigId = ProductConfig.SingletonId,
             SubcategoriesEnabled = true,
             BrandsEnabled = true,
-            ItemTypesEnabled = true
+            ItemTypesEnabled = true,
+            SellingPricesEnabled = true,
+            SerialNumbersEnabled = true,
+            BatchListsEnabled = true,
+            WarrantyPeriodsEnabled = true
+        });
+        return true;
+    }
+
+    private static async Task<bool> SeedNotificationConfigAsync(ErpDbContext db, CancellationToken ct)
+    {
+        if (await db.NotificationConfig.AnyAsync(c => c.NotificationConfigId == NotificationConfig.SingletonId, ct)) return false;
+
+        db.NotificationConfig.Add(new NotificationConfig
+        {
+            NotificationConfigId = NotificationConfig.SingletonId
         });
         return true;
     }
@@ -182,7 +198,7 @@ public static class DataSeeder
             WarehouseId = warehouse.WarehouseId,
             QtyReceived = 100m,
             QtyRemaining = 100m,
-            UnitCost = item.SalePrice.GetValueOrDefault() > 0m ? item.SalePrice.GetValueOrDefault() / 2m : 25m,
+            UnitCost = item.SellingFlatPrice.GetValueOrDefault() > 0m ? item.SellingFlatPrice.GetValueOrDefault() / 2m : 25m,
             ReceiptDate = DateTime.UtcNow.AddDays(-7)
         });
         db.StockLayers.Add(new StockLayer
@@ -191,7 +207,7 @@ public static class DataSeeder
             WarehouseId = warehouse.WarehouseId,
             QtyReceived = 5m,
             QtyRemaining = 5m,
-            UnitCost = secondItem.SalePrice.GetValueOrDefault() > 0m ? secondItem.SalePrice.GetValueOrDefault() / 2m : 15m,
+            UnitCost = secondItem.SellingFlatPrice.GetValueOrDefault() > 0m ? secondItem.SellingFlatPrice.GetValueOrDefault() / 2m : 15m,
             ReceiptDate = DateTime.UtcNow.AddDays(-6)
         });
         return true;
@@ -278,7 +294,7 @@ public static class DataSeeder
                 BaseUomId = uom.UomId,
                 StockNature = StockNature.Stocked,
                 TrackingMode = TrackingMode.None,
-                SalePrice = 100m,
+                SellingFlatPrice = 100m,
                 Status = EntityStatus.Active,
                 CreatedAt = now
             },
@@ -292,7 +308,7 @@ public static class DataSeeder
                 BaseUomId = uom.UomId,
                 StockNature = StockNature.Stocked,
                 TrackingMode = TrackingMode.None,
-                SalePrice = 50m,
+                SellingFlatPrice = 50m,
                 ContentQty = 500m,
                 ContentUnit = MeasureUnit.Ml,
                 ContentBaseQty = 500m,
@@ -445,7 +461,7 @@ public static class DataSeeder
                     ItemId = items[0].ItemId,
                     WarehouseId = warehouse.WarehouseId,
                     Qty = 1m,
-                    UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                    UnitPrice = items[0].SellingFlatPrice.GetValueOrDefault(),
                     IncludeInBundle = true,
                     SortOrder = 1
                 },
@@ -454,7 +470,7 @@ public static class DataSeeder
                     ItemId = items[1].ItemId,
                     WarehouseId = warehouse.WarehouseId,
                     Qty = 1m,
-                    UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                    UnitPrice = items[1].SellingFlatPrice.GetValueOrDefault(),
                     IncludeInBundle = true,
                     SortOrder = 2
                 }
@@ -478,10 +494,10 @@ public static class DataSeeder
                 BundleName = "Demo Bundle Draft",
                 BundleCode = "BND-DEMO-001",
                 Status = BundleSaleStatus.Draft,
-                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                ComponentSubtotal = items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault(),
                 BundlePrice = 0m,
-                MarginAmount = -(items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()),
+                MarginAmount = -(items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault()),
-                DiscountTotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                DiscountTotal = items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault(),
                 TaxTotal = 0m,
                 GrandTotal = 0m,
                 CreatedAt = now.AddDays(-2),
@@ -493,8 +509,8 @@ public static class DataSeeder
                         Description = items[0].Name,
                         Qty = 1m,
                         WarehouseId = warehouse.WarehouseId,
-                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        UnitPrice = items[0].SellingFlatPrice.GetValueOrDefault(),
-                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SellingFlatPrice.GetValueOrDefault(),
                         IncludeInBundle = true,
                         IsComponent = true
                     },
@@ -504,8 +520,8 @@ public static class DataSeeder
                         Description = items[1].Name,
                         Qty = 1m,
                         WarehouseId = warehouse.WarehouseId,
-                        UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                        UnitPrice = items[1].SellingFlatPrice.GetValueOrDefault(),
-                        LineTotal = items[1].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[1].SellingFlatPrice.GetValueOrDefault(),
                         IncludeInBundle = true,
                         IsComponent = true
                     }
@@ -523,12 +539,12 @@ public static class DataSeeder
                 BundleName = "Demo Bundle Posted",
                 BundleCode = "BND-DEMO-001",
                 Status = BundleSaleStatus.Posted,
-                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault(),
+                ComponentSubtotal = items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault(),
-                BundlePrice = (items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()) - 10m,
+                BundlePrice = (items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault()) - 10m,
                 MarginAmount = -10m,
                 DiscountTotal = 10m,
                 TaxTotal = 0m,
-                GrandTotal = (items[0].SalePrice.GetValueOrDefault() + items[1].SalePrice.GetValueOrDefault()) - 10m,
+                GrandTotal = (items[0].SellingFlatPrice.GetValueOrDefault() + items[1].SellingFlatPrice.GetValueOrDefault()) - 10m,
                 CreatedAt = now.AddDays(-1),
                 UpdatedAt = now.AddHours(-2),
                 Lines =
@@ -539,8 +555,8 @@ public static class DataSeeder
                         Description = items[0].Name,
                         Qty = 1m,
                         WarehouseId = warehouse.WarehouseId,
-                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        UnitPrice = items[0].SellingFlatPrice.GetValueOrDefault(),
-                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SellingFlatPrice.GetValueOrDefault(),
                         IncludeInBundle = true,
                         IsComponent = true
                     },
@@ -550,8 +566,8 @@ public static class DataSeeder
                         Description = items[1].Name,
                         Qty = 1m,
                         WarehouseId = warehouse.WarehouseId,
-                        UnitPrice = items[1].SalePrice.GetValueOrDefault(),
+                        UnitPrice = items[1].SellingFlatPrice.GetValueOrDefault(),
-                        LineTotal = items[1].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[1].SellingFlatPrice.GetValueOrDefault(),
                         IncludeInBundle = true,
                         IsComponent = true
                     }
@@ -569,12 +585,12 @@ public static class DataSeeder
                 BundleName = "Demo Bundle Cancelled",
                 BundleCode = "BND-DEMO-001",
                 Status = BundleSaleStatus.Cancelled,
-                ComponentSubtotal = items[0].SalePrice.GetValueOrDefault(),
+                ComponentSubtotal = items[0].SellingFlatPrice.GetValueOrDefault(),
-                BundlePrice = items[0].SalePrice.GetValueOrDefault(),
+                BundlePrice = items[0].SellingFlatPrice.GetValueOrDefault(),
                 MarginAmount = 0m,
                 DiscountTotal = 0m,
                 TaxTotal = 0m,
-                GrandTotal = items[0].SalePrice.GetValueOrDefault(),
+                GrandTotal = items[0].SellingFlatPrice.GetValueOrDefault(),
                 CreatedAt = now,
                 UpdatedAt = now,
                 Lines =
@@ -585,8 +601,8 @@ public static class DataSeeder
                         Description = items[0].Name,
                         Qty = 1m,
                         WarehouseId = secondaryWarehouse.WarehouseId,
-                        UnitPrice = items[0].SalePrice.GetValueOrDefault(),
+                        UnitPrice = items[0].SellingFlatPrice.GetValueOrDefault(),
-                        LineTotal = items[0].SalePrice.GetValueOrDefault(),
+                        LineTotal = items[0].SellingFlatPrice.GetValueOrDefault(),
                         IncludeInBundle = true,
                         IsComponent = true
                     }

Backend/ERPCore/Infra/Persistence/ErpDbContext.cs

@@ -38,6 +38,9 @@ public class ErpDbContext : DbContext
     
     /// <summary>Singleton row (FR-MD-11).</summary>
     public DbSet<ProductConfig> ProductConfig => Set<ProductConfig>();
+    /// <summary>Singleton row for notification delivery preferences.</summary>
+    public DbSet<NotificationConfig> NotificationConfig => Set<NotificationConfig>();
+    public DbSet<NotificationConfigModule> NotificationConfigModules => Set<NotificationConfigModule>();
 
     // --- Cross-cutting (docs/10 Part C.7) ---
     public DbSet<User> Users => Set<User>();
@@ -64,6 +67,11 @@ public class ErpDbContext : DbContext
     public DbSet<Grn> Grns => Set<Grn>();
     public DbSet<GrnLine> GrnLines => Set<GrnLine>();
 
+    // --- Purchase Invoices (vendor invoices consolidating Confirmed GRNs) ---
+    public DbSet<PurchaseInvoice> PurchaseInvoices => Set<PurchaseInvoice>();
+    public DbSet<PurchaseInvoiceLine> PurchaseInvoiceLines => Set<PurchaseInvoiceLine>();
+    public DbSet<PurchaseInvoicePayment> PurchaseInvoicePayments => Set<PurchaseInvoicePayment>();
+
     // --- Batch / Serial (docs/10 Part C.4) ---
     public DbSet<Batch> Batches => Set<Batch>();
     public DbSet<Serial> Serials => Set<Serial>();
@@ -87,8 +95,10 @@ public class ErpDbContext : DbContext
     // --- Sales (Phase 1) ---
     public DbSet<SalesInvoice> SalesInvoices => Set<SalesInvoice>();
     public DbSet<SalesInvoiceLine> SalesInvoiceLines => Set<SalesInvoiceLine>();
+    public DbSet<SalesInvoicePayment> SalesInvoicePayments => Set<SalesInvoicePayment>();
     public DbSet<SalesSlip> SalesSlips => Set<SalesSlip>();
     public DbSet<SalesSlipLine> SalesSlipLines => Set<SalesSlipLine>();
+    public DbSet<SalesDayEnd> SalesDayEnds => Set<SalesDayEnd>();
     public DbSet<BundleSaleTemplate> BundleSaleTemplates => Set<BundleSaleTemplate>();
     public DbSet<BundleSaleTemplateLine> BundleSaleTemplateLines => Set<BundleSaleTemplateLine>();
     public DbSet<BundleSale> BundleSales => Set<BundleSale>();

Backend/ERPCore/Migrations/20260812091117_AddGrnGlPostingAndPayments.cs

@@ -0,0 +1,113 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddGrnGlPostingAndPayments : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<decimal>(
+                name: "BalanceAmount",
+                table: "grns",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<string>(
+                name: "GlJournalNo",
+                table: "grns",
+                type: "character varying(30)",
+                maxLength: 30,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "GlPostedAt",
+                table: "grns",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "PaidAmount",
+                table: "grns",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.CreateTable(
+                name: "grn_payments",
+                columns: table => new
+                {
+                    GrnPaymentId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    GrnId = table.Column<int>(type: "integer", nullable: false),
+                    Amount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaymentDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    GlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    BankAccountName = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    Reference = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_grn_payments", x => x.GrnPaymentId);
+                    table.ForeignKey(
+                        name: "FK_grn_payments_grns_GrnId",
+                        column: x => x.GrnId,
+                        principalTable: "grns",
+                        principalColumn: "GrnId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_grn_payments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_payments_CreatedBy",
+                table: "grn_payments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_payments_GrnId",
+                table: "grn_payments",
+                column: "GrnId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "grn_payments");
+
+            migrationBuilder.DropColumn(
+                name: "BalanceAmount",
+                table: "grns");
+
+            migrationBuilder.DropColumn(
+                name: "GlJournalNo",
+                table: "grns");
+
+            migrationBuilder.DropColumn(
+                name: "GlPostedAt",
+                table: "grns");
+
+            migrationBuilder.DropColumn(
+                name: "PaidAmount",
+                table: "grns");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260813091828_warrenty.cs

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

Backend/ERPCore/Migrations/20260816130723_AddSalesDayEnd.cs

@@ -0,0 +1,109 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSalesDayEnd : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "DayEndId",
+                table: "sales_slips",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "sales_day_ends",
+                columns: table => new
+                {
+                    SalesDayEndId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DocNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: false),
+                    CashierUserId = table.Column<int>(type: "integer", nullable: false),
+                    BusinessDate = table.Column<DateOnly>(type: "date", nullable: false),
+                    SlipCount = table.Column<int>(type: "integer", nullable: false),
+                    Subtotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    DiscountTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    TaxTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    GrandTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    CostOfGoodsSold = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    GlPostedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    ClosedBy = table.Column<int>(type: "integer", nullable: false),
+                    ClosedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_day_ends", x => x.SalesDayEndId);
+                    table.ForeignKey(
+                        name: "FK_sales_day_ends_users_CashierUserId",
+                        column: x => x.CashierUserId,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_day_ends_users_ClosedBy",
+                        column: x => x.ClosedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_slips_DayEndId",
+                table: "sales_slips",
+                column: "DayEndId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_day_ends_CashierUserId_BusinessDate",
+                table: "sales_day_ends",
+                columns: new[] { "CashierUserId", "BusinessDate" },
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_day_ends_ClosedBy",
+                table: "sales_day_ends",
+                column: "ClosedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_day_ends_DocNo",
+                table: "sales_day_ends",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_sales_slips_sales_day_ends_DayEndId",
+                table: "sales_slips",
+                column: "DayEndId",
+                principalTable: "sales_day_ends",
+                principalColumn: "SalesDayEndId",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_sales_slips_sales_day_ends_DayEndId",
+                table: "sales_slips");
+
+            migrationBuilder.DropTable(
+                name: "sales_day_ends");
+
+            migrationBuilder.DropIndex(
+                name: "IX_sales_slips_DayEndId",
+                table: "sales_slips");
+
+            migrationBuilder.DropColumn(
+                name: "DayEndId",
+                table: "sales_slips");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260816133305_AddReturnGlPosting.cs

@@ -0,0 +1,61 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddReturnGlPosting : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "GlJournalNo",
+                table: "sales_returns",
+                type: "character varying(30)",
+                maxLength: 30,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "GlPostedAt",
+                table: "sales_returns",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.AddColumn<string>(
+                name: "GlJournalNo",
+                table: "purchase_returns",
+                type: "character varying(30)",
+                maxLength: 30,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "GlPostedAt",
+                table: "purchase_returns",
+                type: "timestamp with time zone",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "GlJournalNo",
+                table: "sales_returns");
+
+            migrationBuilder.DropColumn(
+                name: "GlPostedAt",
+                table: "sales_returns");
+
+            migrationBuilder.DropColumn(
+                name: "GlJournalNo",
+                table: "purchase_returns");
+
+            migrationBuilder.DropColumn(
+                name: "GlPostedAt",
+                table: "purchase_returns");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260816142234_AddAdjustmentGlPosting.cs

@@ -0,0 +1,40 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddAdjustmentGlPosting : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "GlJournalNo",
+                table: "stock_adjustments",
+                type: "character varying(30)",
+                maxLength: 30,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "GlPostedAt",
+                table: "stock_adjustments",
+                type: "timestamp with time zone",
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "GlJournalNo",
+                table: "stock_adjustments");
+
+            migrationBuilder.DropColumn(
+                name: "GlPostedAt",
+                table: "stock_adjustments");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260816151344_AddBundleSaleToDayEnd.cs

@@ -0,0 +1,60 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddBundleSaleToDayEnd : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<int>(
+                name: "BundleCount",
+                table: "sales_day_ends",
+                type: "integer",
+                nullable: false,
+                defaultValue: 0);
+
+            migrationBuilder.AddColumn<int>(
+                name: "DayEndId",
+                table: "bundle_sales",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_bundle_sales_DayEndId",
+                table: "bundle_sales",
+                column: "DayEndId");
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_bundle_sales_sales_day_ends_DayEndId",
+                table: "bundle_sales",
+                column: "DayEndId",
+                principalTable: "sales_day_ends",
+                principalColumn: "SalesDayEndId",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_bundle_sales_sales_day_ends_DayEndId",
+                table: "bundle_sales");
+
+            migrationBuilder.DropIndex(
+                name: "IX_bundle_sales_DayEndId",
+                table: "bundle_sales");
+
+            migrationBuilder.DropColumn(
+                name: "BundleCount",
+                table: "sales_day_ends");
+
+            migrationBuilder.DropColumn(
+                name: "DayEndId",
+                table: "bundle_sales");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260816174034_AddSalesInvoicePayments.cs

@@ -0,0 +1,87 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddSalesInvoicePayments : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<string>(
+                name: "GlJournalNo",
+                table: "sales_invoices",
+                type: "character varying(30)",
+                maxLength: 30,
+                nullable: true);
+
+            migrationBuilder.AddColumn<DateTime>(
+                name: "GlPostedAt",
+                table: "sales_invoices",
+                type: "timestamp with time zone",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "sales_invoice_payments",
+                columns: table => new
+                {
+                    SalesInvoicePaymentId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    SalesInvoiceId = table.Column<int>(type: "integer", nullable: false),
+                    Amount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaymentDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    GlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    BankAccountName = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    Reference = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_sales_invoice_payments", x => x.SalesInvoicePaymentId);
+                    table.ForeignKey(
+                        name: "FK_sales_invoice_payments_sales_invoices_SalesInvoiceId",
+                        column: x => x.SalesInvoiceId,
+                        principalTable: "sales_invoices",
+                        principalColumn: "SalesInvoiceId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_sales_invoice_payments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_invoice_payments_CreatedBy",
+                table: "sales_invoice_payments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_sales_invoice_payments_SalesInvoiceId",
+                table: "sales_invoice_payments",
+                column: "SalesInvoiceId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "sales_invoice_payments");
+
+            migrationBuilder.DropColumn(
+                name: "GlJournalNo",
+                table: "sales_invoices");
+
+            migrationBuilder.DropColumn(
+                name: "GlPostedAt",
+                table: "sales_invoices");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260818090139_AddProductionNavPermissions.cs

@@ -0,0 +1,90 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+#pragma warning disable CA1814 // Prefer jagged arrays over multidimensional
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddProductionNavPermissions : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.InsertData(
+                table: "nav_items",
+                columns: new[] { "NavItemId", "Code", "Href", "Icon", "Label", "SortOrder" },
+                values: new object[] { 14, "production", "/dashboard/production", null, "Production", 14 });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[] { 35, "NAV:production", 14, null });
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[,]
+                {
+                    { 24, "production.templates", "/dashboard/production/templates", null, "Templates", 14, 1 },
+                    { 25, "production.runs", "/dashboard/production/runs", null, "Runs", 14, 2 },
+                    { 26, "production.produced", "/dashboard/production/produced", null, "Produced", 14, 3 }
+                });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[,]
+                {
+                    { 36, "NAV:production.templates", null, 24 },
+                    { 37, "NAV:production.runs", null, 25 },
+                    { 38, "NAV:production.produced", null, 26 }
+                });
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 35);
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 36);
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 37);
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 38);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 24);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 25);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 26);
+
+            migrationBuilder.DeleteData(
+                table: "nav_items",
+                keyColumn: "NavItemId",
+                keyValue: 14);
+        }
+    }
+}

Backend/ERPCore/Migrations/20260820083810_itemModel.cs

@@ -0,0 +1,52 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class itemModel : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "SalePrice",
+                table: "items",
+                newName: "SellingMinPrice");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "SellingFlatPrice",
+                table: "items",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: true);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "SellingMaxPrice",
+                table: "items",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SellingFlatPrice",
+                table: "items");
+
+            migrationBuilder.DropColumn(
+                name: "SellingMaxPrice",
+                table: "items");
+
+            migrationBuilder.RenameColumn(
+                name: "SellingMinPrice",
+                table: "items",
+                newName: "SalePrice");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260820100345_AddNotificationConfigModulePreferences.cs

@@ -0,0 +1,103 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddNotificationConfigModulePreferences : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.CreateTable(
+                name: "notification_config",
+                columns: table => new
+                {
+                    NotificationConfigId = table.Column<int>(type: "integer", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    UpdatedBy = table.Column<int>(type: "integer", nullable: true),
+                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_notification_config", x => x.NotificationConfigId);
+                    table.CheckConstraint("ck_notification_config_singleton", "\"NotificationConfigId\" = 1");
+                    table.ForeignKey(
+                        name: "FK_notification_config_users_UpdatedBy",
+                        column: x => x.UpdatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "notification_config_modules",
+                columns: table => new
+                {
+                    NotificationConfigModuleId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    NotificationConfigId = table.Column<int>(type: "integer", nullable: false),
+                    ModuleKey = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: false),
+                    EmailEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: false),
+                    SmsEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: false),
+                    InAppEnabled = table.Column<bool>(type: "boolean", nullable: false, defaultValue: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_notification_config_modules", x => x.NotificationConfigModuleId);
+                    table.ForeignKey(
+                        name: "FK_notification_config_modules_notification_config_Notificatio~",
+                        column: x => x.NotificationConfigId,
+                        principalTable: "notification_config",
+                        principalColumn: "NotificationConfigId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.Sql("""
+                INSERT INTO sub_nav_items ("SubNavItemId", "NavItemId", "Code", "Href", "Icon", "Label", "SortOrder")
+                VALUES (24, 9, 'settings.notification-config', '/dashboard/settings/notification-config', NULL, 'Notification Config', 3)
+                ON CONFLICT ("SubNavItemId") DO UPDATE
+                SET "NavItemId" = EXCLUDED."NavItemId",
+                    "Code" = EXCLUDED."Code",
+                    "Href" = EXCLUDED."Href",
+                    "Icon" = EXCLUDED."Icon",
+                    "Label" = EXCLUDED."Label",
+                    "SortOrder" = EXCLUDED."SortOrder";
+                """);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_notification_config_UpdatedBy",
+                table: "notification_config",
+                column: "UpdatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_notification_config_modules_ModuleKey",
+                table: "notification_config_modules",
+                column: "ModuleKey",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_notification_config_modules_NotificationConfigId",
+                table: "notification_config_modules",
+                column: "NotificationConfigId");
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "notification_config_modules");
+
+            migrationBuilder.DropTable(
+                name: "notification_config");
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 24);
+        }
+    }
+}

Backend/ERPCore/Migrations/20260820120000_UpdateItemSellingPrices.cs

@@ -0,0 +1,49 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    public partial class UpdateItemSellingPrices : Migration
+    {
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.RenameColumn(
+                name: "SalePrice",
+                table: "items",
+                newName: "SellingFlatPrice");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "SellingMinPrice",
+                table: "items",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: true);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "SellingMaxPrice",
+                table: "items",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: true);
+        }
+
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "SellingMinPrice",
+                table: "items");
+
+            migrationBuilder.DropColumn(
+                name: "SellingMaxPrice",
+                table: "items");
+
+            migrationBuilder.RenameColumn(
+                name: "SellingFlatPrice",
+                table: "items",
+                newName: "SalePrice");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260820125724_AddProductConfigFeatureFlags.cs

@@ -0,0 +1,62 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddProductConfigFeatureFlags : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.AddColumn<bool>(
+                name: "BatchListsEnabled",
+                table: "product_config",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "SellingPricesEnabled",
+                table: "product_config",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "SerialNumbersEnabled",
+                table: "product_config",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+
+            migrationBuilder.AddColumn<bool>(
+                name: "WarrantyPeriodsEnabled",
+                table: "product_config",
+                type: "boolean",
+                nullable: false,
+                defaultValue: true);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropColumn(
+                name: "BatchListsEnabled",
+                table: "product_config");
+
+            migrationBuilder.DropColumn(
+                name: "SellingPricesEnabled",
+                table: "product_config");
+
+            migrationBuilder.DropColumn(
+                name: "SerialNumbersEnabled",
+                table: "product_config");
+
+            migrationBuilder.DropColumn(
+                name: "WarrantyPeriodsEnabled",
+                table: "product_config");
+        }
+    }
+}

Backend/ERPCore/Migrations/20260825000000_FixProductionTemplatesSubNavItemIdConflict.Designer.cs

@@ -0,0 +1,24 @@
+// <auto-generated />
+using ERPCore.Infra.Persistence;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Infrastructure;
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    [DbContext(typeof(ErpDbContext))]
+    [Migration("20260825000000_FixProductionTemplatesSubNavItemIdConflict")]
+    partial class FixProductionTemplatesSubNavItemIdConflict
+    {
+        /// <inheritdoc />
+        protected override void BuildTargetModel(ModelBuilder modelBuilder)
+        {
+            // This migration only repairs seed row data via raw SQL — no entity/column shape
+            // changes — so it does not redeclare the full model here. The single source of
+            // truth for scaffolding future migrations is ErpDbContextModelSnapshot.cs, which
+            // already reflects this fix (production.templates seeded at SubNavItemId 27).
+        }
+    }
+}

Backend/ERPCore/Migrations/20260825000000_FixProductionTemplatesSubNavItemIdConflict.cs

@@ -0,0 +1,46 @@
+using Microsoft.EntityFrameworkCore.Migrations;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <summary>
+    /// Repairs a collision baked into migration history: 20260818090139_AddProductionNavPermissions
+    /// inserted "production.templates" as sub_nav_items row 24, then
+    /// 20260820100345_AddNotificationConfigModulePreferences reused the same literal id 24 for
+    /// "settings.notification-config" via a raw-SQL <c>INSERT ... ON CONFLICT ("SubNavItemId") DO
+    /// UPDATE</c>, silently overwriting the production.templates row instead of inserting a new
+    /// one. Row 24 now correctly holds notification-config; this migration re-creates the lost
+    /// production.templates row under a fresh id (27, matching the corrected seed data in
+    /// SubNavItemConfiguration/PermissionConfiguration) and repoints the NAV:production.templates
+    /// permission (id 36) at it.
+    /// </summary>
+    public partial class FixProductionTemplatesSubNavItemIdConflict : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                INSERT INTO sub_nav_items ("SubNavItemId", "NavItemId", "Code", "Href", "Icon", "Label", "SortOrder")
+                VALUES (27, 14, 'production.templates', '/dashboard/production/templates', NULL, 'Templates', 1)
+                ON CONFLICT ("SubNavItemId") DO NOTHING;
+                """);
+
+            migrationBuilder.Sql("""
+                UPDATE permissions SET "SubNavItemId" = 27 WHERE "PermissionId" = 36;
+                """);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.Sql("""
+                UPDATE permissions SET "SubNavItemId" = 24 WHERE "PermissionId" = 36;
+                """);
+
+            migrationBuilder.Sql("""
+                DELETE FROM sub_nav_items WHERE "SubNavItemId" = 27;
+                """);
+        }
+    }
+}

Backend/ERPCore/Migrations/20260831060800_AddPurchaseInvoices.cs

@@ -0,0 +1,303 @@
+using System;
+using Microsoft.EntityFrameworkCore.Migrations;
+using Npgsql.EntityFrameworkCore.PostgreSQL.Metadata;
+
+#nullable disable
+
+namespace ERPCore.Migrations
+{
+    /// <inheritdoc />
+    public partial class AddPurchaseInvoices : Migration
+    {
+        /// <inheritdoc />
+        protected override void Up(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropTable(
+                name: "grn_payments");
+
+            migrationBuilder.DropColumn(
+                name: "BalanceAmount",
+                table: "grns");
+
+            migrationBuilder.DropColumn(
+                name: "PaidAmount",
+                table: "grns");
+
+            migrationBuilder.AddColumn<int>(
+                name: "PurchaseInvoiceId",
+                table: "grns",
+                type: "integer",
+                nullable: true);
+
+            migrationBuilder.CreateTable(
+                name: "purchase_invoices",
+                columns: table => new
+                {
+                    PurchaseInvoiceId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    DocNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: false),
+                    VendorInvoiceNo = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: false),
+                    VendorInvoiceDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    VendorId = table.Column<int>(type: "integer", nullable: false),
+                    VendorSnapshotName = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    VendorSnapshotTaxNo = table.Column<string>(type: "character varying(50)", maxLength: 50, nullable: true),
+                    Status = table.Column<string>(type: "character varying(20)", maxLength: 20, nullable: false, defaultValue: "Draft"),
+                    Subtotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    VatTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    GrandTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaidAmount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    BalanceAmount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    GlPostedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    UpdatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: true),
+                    xmin = table.Column<uint>(type: "xid", rowVersion: true, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_purchase_invoices", x => x.PurchaseInvoiceId);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoices_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoices_vendors_VendorId",
+                        column: x => x.VendorId,
+                        principalTable: "vendors",
+                        principalColumn: "VendorId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "purchase_invoice_lines",
+                columns: table => new
+                {
+                    PurchaseInvoiceLineId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    PurchaseInvoiceId = table.Column<int>(type: "integer", nullable: false),
+                    GrnId = table.Column<int>(type: "integer", nullable: false),
+                    Subtotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    VatTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    LineTotal = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_purchase_invoice_lines", x => x.PurchaseInvoiceLineId);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoice_lines_grns_GrnId",
+                        column: x => x.GrnId,
+                        principalTable: "grns",
+                        principalColumn: "GrnId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoice_lines_purchase_invoices_PurchaseInvoiceId",
+                        column: x => x.PurchaseInvoiceId,
+                        principalTable: "purchase_invoices",
+                        principalColumn: "PurchaseInvoiceId",
+                        onDelete: ReferentialAction.Cascade);
+                });
+
+            migrationBuilder.CreateTable(
+                name: "purchase_invoice_payments",
+                columns: table => new
+                {
+                    PurchaseInvoicePaymentId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    PurchaseInvoiceId = table.Column<int>(type: "integer", nullable: false),
+                    Amount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    PaymentDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    GlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    BankAccountName = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    Reference = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_purchase_invoice_payments", x => x.PurchaseInvoicePaymentId);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoice_payments_purchase_invoices_PurchaseInvoice~",
+                        column: x => x.PurchaseInvoiceId,
+                        principalTable: "purchase_invoices",
+                        principalColumn: "PurchaseInvoiceId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_purchase_invoice_payments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.InsertData(
+                table: "sub_nav_items",
+                columns: new[] { "SubNavItemId", "Code", "Href", "Icon", "Label", "NavItemId", "SortOrder" },
+                values: new object[] { 28, "procurement.purchase-invoices", "/dashboard/procurement/purchase-invoices", null, "Purchase Invoices", 4, 5 });
+
+            migrationBuilder.InsertData(
+                table: "permissions",
+                columns: new[] { "PermissionId", "Code", "NavItemId", "SubNavItemId" },
+                values: new object[] { 39, "NAV:procurement.purchase-invoices", null, 28 });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grns_PurchaseInvoiceId",
+                table: "grns",
+                column: "PurchaseInvoiceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoice_lines_GrnId",
+                table: "purchase_invoice_lines",
+                column: "GrnId",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoice_lines_PurchaseInvoiceId",
+                table: "purchase_invoice_lines",
+                column: "PurchaseInvoiceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoice_payments_CreatedBy",
+                table: "purchase_invoice_payments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoice_payments_PurchaseInvoiceId",
+                table: "purchase_invoice_payments",
+                column: "PurchaseInvoiceId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoices_CreatedBy",
+                table: "purchase_invoices",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoices_DocNo",
+                table: "purchase_invoices",
+                column: "DocNo",
+                unique: true);
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoices_Status",
+                table: "purchase_invoices",
+                column: "Status");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoices_VendorId",
+                table: "purchase_invoices",
+                column: "VendorId");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_purchase_invoices_VendorId_VendorInvoiceNo",
+                table: "purchase_invoices",
+                columns: new[] { "VendorId", "VendorInvoiceNo" });
+
+            migrationBuilder.AddForeignKey(
+                name: "FK_grns_purchase_invoices_PurchaseInvoiceId",
+                table: "grns",
+                column: "PurchaseInvoiceId",
+                principalTable: "purchase_invoices",
+                principalColumn: "PurchaseInvoiceId",
+                onDelete: ReferentialAction.Restrict);
+        }
+
+        /// <inheritdoc />
+        protected override void Down(MigrationBuilder migrationBuilder)
+        {
+            migrationBuilder.DropForeignKey(
+                name: "FK_grns_purchase_invoices_PurchaseInvoiceId",
+                table: "grns");
+
+            migrationBuilder.DropTable(
+                name: "purchase_invoice_lines");
+
+            migrationBuilder.DropTable(
+                name: "purchase_invoice_payments");
+
+            migrationBuilder.DropTable(
+                name: "purchase_invoices");
+
+            migrationBuilder.DropIndex(
+                name: "IX_grns_PurchaseInvoiceId",
+                table: "grns");
+
+            migrationBuilder.DeleteData(
+                table: "permissions",
+                keyColumn: "PermissionId",
+                keyValue: 39);
+
+            migrationBuilder.DeleteData(
+                table: "sub_nav_items",
+                keyColumn: "SubNavItemId",
+                keyValue: 28);
+
+            migrationBuilder.DropColumn(
+                name: "PurchaseInvoiceId",
+                table: "grns");
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "BalanceAmount",
+                table: "grns",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.AddColumn<decimal>(
+                name: "PaidAmount",
+                table: "grns",
+                type: "numeric(18,4)",
+                precision: 18,
+                scale: 4,
+                nullable: false,
+                defaultValue: 0m);
+
+            migrationBuilder.CreateTable(
+                name: "grn_payments",
+                columns: table => new
+                {
+                    GrnPaymentId = table.Column<int>(type: "integer", nullable: false)
+                        .Annotation("Npgsql:ValueGenerationStrategy", NpgsqlValueGenerationStrategy.IdentityByDefaultColumn),
+                    CreatedBy = table.Column<int>(type: "integer", nullable: false),
+                    GrnId = table.Column<int>(type: "integer", nullable: false),
+                    Amount = table.Column<decimal>(type: "numeric(18,4)", precision: 18, scale: 4, nullable: false),
+                    BankAccountName = table.Column<string>(type: "character varying(200)", maxLength: 200, nullable: false),
+                    CreatedAt = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    GlBankAccountId = table.Column<long>(type: "bigint", nullable: false),
+                    GlJournalNo = table.Column<string>(type: "character varying(30)", maxLength: 30, nullable: true),
+                    PaymentDate = table.Column<DateTime>(type: "timestamp with time zone", nullable: false),
+                    Reference = table.Column<string>(type: "character varying(100)", maxLength: 100, nullable: true)
+                },
+                constraints: table =>
+                {
+                    table.PrimaryKey("PK_grn_payments", x => x.GrnPaymentId);
+                    table.ForeignKey(
+                        name: "FK_grn_payments_grns_GrnId",
+                        column: x => x.GrnId,
+                        principalTable: "grns",
+                        principalColumn: "GrnId",
+                        onDelete: ReferentialAction.Restrict);
+                    table.ForeignKey(
+                        name: "FK_grn_payments_users_CreatedBy",
+                        column: x => x.CreatedBy,
+                        principalTable: "users",
+                        principalColumn: "UserId",
+                        onDelete: ReferentialAction.Restrict);
+                });
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_payments_CreatedBy",
+                table: "grn_payments",
+                column: "CreatedBy");
+
+            migrationBuilder.CreateIndex(
+                name: "IX_grn_payments_GrnId",
+                table: "grn_payments",
+                column: "GrnId");
+        }
+    }
+}

Backend/ERPCore/Program.cs

@@ -85,6 +85,8 @@ builder.Services.AddScoped<IBrandService, BrandService>();
 builder.Services.AddScoped<IItemTypeService, ItemTypeService>();
 //builder.Services.AddScoped<ICompanyProfileService, CompanyProfileService>();
 builder.Services.AddScoped<IProductConfigService, ProductConfigService>();
+builder.Services.AddSingleton<INotificationModuleCatalog, NotificationModuleCatalog>();
+builder.Services.AddScoped<INotificationConfigService, NotificationConfigService>();
 builder.Services.AddScoped<IVendorService, VendorService>();
 builder.Services.AddScoped<IWarehouseService, WarehouseService>();
 
@@ -104,6 +106,10 @@ builder.Services.AddScoped<IFifoCostingService, FifoCostingService>();
 builder.Services.AddScoped<IStockService, StockService>();
 builder.Services.AddScoped<IGrnService, GrnService>();
 
+// Purchase invoices (vendor invoices consolidating Confirmed GRNs)
+builder.Services.AddScoped<IPurchaseInvoiceService, PurchaseInvoiceService>();
+builder.Services.AddScoped<IPurchaseInvoicePaymentService, PurchaseInvoicePaymentService>();
+
 // Sales (Phase 1)
 builder.Services.AddScoped<ISalesPricingService, SalesPricingService>();
 builder.Services.AddScoped<ISalesDomainService, SalesDomainService>();
@@ -111,11 +117,13 @@ builder.Services.AddScoped<ISalesPostingService, SalesPostingService>();
 builder.Services.AddScoped<ISalesDocumentWorkflowService, SalesDocumentWorkflowService>();
 builder.Services.AddScoped<ISalesMappingService, SalesMappingService>();
 builder.Services.AddScoped<ISalesInvoiceService, SalesInvoiceService>();
+builder.Services.AddScoped<ISalesInvoicePaymentService, SalesInvoicePaymentService>();
 builder.Services.AddScoped<ISalesSlipService, SalesSlipService>();
 builder.Services.AddScoped<IBundleSaleService, BundleSaleService>();
 builder.Services.AddScoped<ISalesPromotionSuggestionService, SalesPromotionSuggestionService>();
 builder.Services.AddScoped<ISalesReportService, SalesReportService>();
 builder.Services.AddScoped<ISalesReturnService, SalesReturnService>();
+builder.Services.AddScoped<ISalesDayEndService, SalesDayEndService>();
 
 // Stock transactions + reference data (docs/11 §5–6)
 builder.Services.AddScoped<IStockMutator, StockMutator>();

Backend/ERPCore/Services/AdjustmentService.cs

@@ -6,6 +6,7 @@ using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 using Microsoft.EntityFrameworkCore;
@@ -16,7 +17,10 @@ namespace ERPCore.Services;
 /// Stock-adjustment service — the highest-risk feature (02-SECURITY C.5). Auto-posts
 /// with a mandatory reason code and user stamp. Line application (FIFO consume on a
 /// decrease, layer create on an increase) + ledger posting is delegated to
-/// <see cref="IStockMutator"/>. Runs in a single UoW transaction (NFR-02/05).
+/// <see cref="IStockMutator"/>. Runs in a single UoW transaction (NFR-02/05). Also posts
+/// a real GL journal entry — increases and decreases post as separate Inventory/Gain and
+/// Loss/Inventory lines respectively (never netted against each other), so a count that's
+/// simultaneously over on one item and under on another shows both, not a false net.
 /// </summary>
 public sealed class AdjustmentService : IAdjustmentService
 {
@@ -29,11 +33,16 @@ public sealed class AdjustmentService : IAdjustmentService
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly IUnitOfWork _uow;
+    private readonly IGeneralLedgerService _gl;
+    private readonly string _glInventoryAccountCode;
+    private readonly string _glGainAccountCode;
+    private readonly string _glLossAccountCode;
 
     public AdjustmentService(
         IRepository<StockAdjustment> adjustments, IRepository<Warehouse> warehouses, IRepository<Item> items,
         IRepository<ReasonCode> reasonCodes, IRepository<StockLedger> ledger, IStockMutator mutator,
-        INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
+        INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow,
+        IGeneralLedgerService gl, IConfiguration configuration)
     {
         _adjustments = adjustments;
         _warehouses = warehouses;
@@ -44,6 +53,45 @@ public sealed class AdjustmentService : IAdjustmentService
         _numbers = numbers;
         _currentUser = currentUser;
         _uow = uow;
+        _gl = gl;
+        _glInventoryAccountCode = configuration["Adjustment:GlInventoryAccountCode"] ?? string.Empty;
+        _glGainAccountCode = configuration["Adjustment:GlGainAccountCode"] ?? string.Empty;
+        _glLossAccountCode = configuration["Adjustment:GlLossAccountCode"] ?? string.Empty;
+    }
+
+    /// <summary>Builds and posts the GL journal for a <see cref="StockAdjustment"/>'s stock movement.
+    /// <see cref="CountService"/>'s variance posting mirrors this exact logic for the same reason
+    /// (it creates a <see cref="StockAdjustment"/> through the same <see cref="IStockMutator"/> call).</summary>
+    private async Task<string?> PostAdjustmentJournalAsync(
+        string docNo, DateTime now, IReadOnlyList<StockLedger> refs, CancellationToken ct)
+    {
+        var gain = refs.Where(r => r.Direction == Direction.In).Sum(r => r.Value);
+        var loss = refs.Where(r => r.Direction == Direction.Out).Sum(r => r.Value);
+        if (gain <= 0 && loss <= 0) return null;
+
+        var period = await _gl.GetPeriodByDateAsync(DateOnly.FromDateTime(now), ct);
+        var lines = new List<GlJournalEntryLineRequest>();
+        if (gain > 0)
+        {
+            lines.Add(new GlJournalEntryLineRequest(_glInventoryAccountCode, gain, 0m, $"Adjustment {docNo} — stock increase"));
+            lines.Add(new GlJournalEntryLineRequest(_glGainAccountCode, 0m, gain, $"Adjustment {docNo} — inventory gain"));
+        }
+        if (loss > 0)
+        {
+            lines.Add(new GlJournalEntryLineRequest(_glLossAccountCode, loss, 0m, $"Adjustment {docNo} — inventory loss"));
+            lines.Add(new GlJournalEntryLineRequest(_glInventoryAccountCode, 0m, loss, $"Adjustment {docNo} — stock decrease"));
+        }
+
+        var result = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+        {
+            PeriodId = period.PeriodId,
+            EntryDate = DateOnly.FromDateTime(now),
+            SourceModule = "ADJUSTMENT",
+            Reference = docNo,
+            Narration = $"Stock adjustment {docNo}",
+            Lines = lines
+        }, ct);
+        return result.JournalNo;
     }
 
     public async Task<PagedResponse<AdjustmentSummaryDto>> ListAsync(
@@ -64,7 +112,7 @@ public sealed class AdjustmentService : IAdjustmentService
             .Skip(query.Skip).Take(query.PageSize)
             .Select(a => new AdjustmentSummaryDto(
                 a.AdjustmentId, a.DocNo, a.WarehouseId, a.ReasonCodeId, a.Status,
-                a.CreatedBy, a.CreatedAt, a.Lines.Count))
+                a.CreatedBy, a.CreatedAt, a.Lines.Count, a.GlJournalNo))
             .ToListAsync(ct);
 
         return PagedResponse<AdjustmentSummaryDto>.Create(rows, query.Page, query.PageSize, total);
@@ -136,6 +184,10 @@ public sealed class AdjustmentService : IAdjustmentService
             await _uow.SaveChangesAsync(token); // flush so AdjustmentId is a valid ledger sourceDocId
 
             var refs = await _mutator.ApplyAsync(request.WarehouseId, DocumentTypes.Adjustment, entity.AdjustmentId, now, deltas, token);
+
+            entity.GlJournalNo = await PostAdjustmentJournalAsync(docNo, now, refs, token);
+            if (entity.GlJournalNo is not null) entity.GlPostedAt = now;
+
             return (entity, refs);
         }, ct);
 
@@ -144,6 +196,7 @@ public sealed class AdjustmentService : IAdjustmentService
 
     private static AdjustmentDto ToDto(StockAdjustment a, IReadOnlyList<int> ledgerRefs) => new(
         a.AdjustmentId, a.DocNo, a.WarehouseId, a.ReasonCodeId, a.Status, a.CreatedBy, a.CreatedAt,
+        a.GlJournalNo, a.GlPostedAt,
         a.Lines.OrderBy(l => l.AdjLineId)
             .Select(l => new AdjustmentLineDto(l.AdjLineId, l.ItemId, l.BinId, l.BatchId, l.QtyDelta)).ToList(),
         ledgerRefs);

Backend/ERPCore/Services/BundleSaleService.cs

@@ -17,6 +17,7 @@ public sealed class BundleSaleService : IBundleSaleService
 {
     private readonly IRepository<BundleSaleTemplate> _templates;
     private readonly IRepository<BundleSale> _bundles;
+    private readonly IRepository<SalesDayEnd> _dayEnds;
     private readonly IRepository<Customer> _customers;
     private readonly IRepository<Item> _items;
     private readonly IRepository<Warehouse> _warehouses;
@@ -30,6 +31,7 @@ public sealed class BundleSaleService : IBundleSaleService
     public BundleSaleService(
         IRepository<BundleSale> bundles,
         IRepository<BundleSaleTemplate> templates,
+        IRepository<SalesDayEnd> dayEnds,
         IRepository<Customer> customers,
         IRepository<Item> items,
         IRepository<Warehouse> warehouses,
@@ -42,6 +44,7 @@ public sealed class BundleSaleService : IBundleSaleService
     {
         _templates = templates;
         _bundles = bundles;
+        _dayEnds = dayEnds;
         _customers = customers;
         _items = items;
         _warehouses = warehouses;
@@ -82,6 +85,45 @@ public sealed class BundleSaleService : IBundleSaleService
                 x.BundleSaleTemplateLineId, x.ItemId, x.WarehouseId, x.Qty, x.UnitPrice, x.IncludeInBundle, x.SortOrder)).ToList());
     }
 
+    public async Task<BundleSaleTemplateDto> CreateTemplateAsync(CreateBundleSaleTemplateRequest request, CancellationToken ct = default)
+    {
+        var template = new BundleSaleTemplate
+        {
+            TemplateCode = await _numbers.NextAsync(DocumentTypes.BundleSaleTemplate, ct),
+            TemplateName = request.TemplateName,
+            Description = request.Description,
+            Status = EntityStatus.Active,
+            CreatedAt = DateTime.UtcNow
+        };
+
+        foreach (var line in request.Lines)
+        {
+            if (!await _items.Query().AsNoTracking().AnyAsync(x => x.ItemId == line.ItemId, ct))
+                throw new NotFoundException($"Item {line.ItemId} was not found.");
+            if (!await _warehouses.Query().AsNoTracking().AnyAsync(x => x.WarehouseId == line.WarehouseId, ct))
+                throw new NotFoundException($"Warehouse {line.WarehouseId} was not found.");
+
+            template.Lines.Add(new BundleSaleTemplateLine
+            {
+                ItemId = line.ItemId,
+                WarehouseId = line.WarehouseId,
+                Qty = line.Qty,
+                UnitPrice = line.UnitPrice,
+                IncludeInBundle = line.IncludeInBundle,
+                SortOrder = line.SortOrder
+            });
+        }
+
+        await _templates.AddAsync(template, ct);
+        await _uow.SaveChangesAsync(ct);
+
+        return new BundleSaleTemplateDto(
+            template.BundleSaleTemplateId, template.TemplateCode, template.TemplateName, template.Description,
+            template.Status, template.CreatedAt, template.UpdatedAt,
+            template.Lines.OrderBy(x => x.SortOrder).Select(x => new BundleSaleTemplateLineDto(
+                x.BundleSaleTemplateLineId, x.ItemId, x.WarehouseId, x.Qty, x.UnitPrice, x.IncludeInBundle, x.SortOrder)).ToList());
+    }
+
     public async Task<PagedResponse<BundleSaleSummaryDto>> ListAsync(PageQuery query, BundleSaleStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default)
     {
         IQueryable<BundleSale> q = _bundles.Query().AsNoTracking().Include(x => x.Lines);
@@ -110,6 +152,15 @@ public sealed class BundleSaleService : IBundleSaleService
     public async Task<BundleSaleDto> CreateAsync(CreateBundleSaleRequest request, CancellationToken ct = default)
     {
         await _sales.ValidateSalesHeaderAsync(request.CustomerId, request.WarehouseId, request.CashierUserId, true, ct);
+
+        // Same guard as SalesSlipService.CreateAsync — a bundle sale is a cashier document
+        // exactly like a sales slip, so it's blocked by the same closed day (docs/14 Sales Day End).
+        var today = DateOnly.FromDateTime(DateTime.UtcNow);
+        var alreadyClosed = await _dayEnds.Query().AsNoTracking()
+            .AnyAsync(x => x.CashierUserId == request.CashierUserId && x.BusinessDate == today, ct);
+        if (alreadyClosed)
+            throw new ConflictException($"Cashier {request.CashierUserId} already closed today's ({today:yyyy-MM-dd}) sales — day-end has been posted.");
+
         var template = await _templates.Query().AsNoTracking().Include(x => x.Lines)
             .FirstAsync(x => x.BundleSaleTemplateId == request.BundleSaleTemplateId, ct);
         var bundle = new BundleSale

Backend/ERPCore/Services/CountService.cs

@@ -6,6 +6,7 @@ using ERPCore.Dtos.Stock;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 using Microsoft.EntityFrameworkCore;
@@ -16,7 +17,9 @@ namespace ERPCore.Services;
 /// Stock-count service (FR-STK-08). Create snapshots system quantities (immutable,
 /// 02-SECURITY C.7); posting emits a variance <see cref="StockAdjustment"/> via the
 /// shared <see cref="IStockMutator"/> (a variance is an adjustment in disguise, C.7)
-/// and closes the count — all in one UoW transaction.
+/// and closes the count — all in one UoW transaction. GL posting for that variance
+/// mirrors <see cref="AdjustmentService"/>'s (same account config, same gain/loss
+/// split) since it's the exact same kind of document under the hood.
 /// </summary>
 public sealed class CountService : ICountService
 {
@@ -32,11 +35,16 @@ public sealed class CountService : ICountService
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly IUnitOfWork _uow;
+    private readonly IGeneralLedgerService _gl;
+    private readonly string _glInventoryAccountCode;
+    private readonly string _glGainAccountCode;
+    private readonly string _glLossAccountCode;
 
     public CountService(
         IRepository<StockCount> counts, IRepository<StockAdjustment> adjustments, IRepository<Warehouse> warehouses,
         IRepository<Item> items, IRepository<ReasonCode> reasonCodes, IFifoCostingService fifo, IStockMutator mutator,
-        INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
+        INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow,
+        IGeneralLedgerService gl, IConfiguration configuration)
     {
         _counts = counts;
         _adjustments = adjustments;
@@ -48,6 +56,44 @@ public sealed class CountService : ICountService
         _numbers = numbers;
         _currentUser = currentUser;
         _uow = uow;
+        _gl = gl;
+        _glInventoryAccountCode = configuration["Adjustment:GlInventoryAccountCode"] ?? string.Empty;
+        _glGainAccountCode = configuration["Adjustment:GlGainAccountCode"] ?? string.Empty;
+        _glLossAccountCode = configuration["Adjustment:GlLossAccountCode"] ?? string.Empty;
+    }
+
+    /// <summary>Same logic as <c>AdjustmentService</c>'s private method of the same name — see there for why
+    /// gains/losses post as separate lines instead of a net.</summary>
+    private async Task<string?> PostAdjustmentJournalAsync(
+        string docNo, DateTime now, IReadOnlyList<StockLedger> refs, CancellationToken ct)
+    {
+        var gain = refs.Where(r => r.Direction == Direction.In).Sum(r => r.Value);
+        var loss = refs.Where(r => r.Direction == Direction.Out).Sum(r => r.Value);
+        if (gain <= 0 && loss <= 0) return null;
+
+        var period = await _gl.GetPeriodByDateAsync(DateOnly.FromDateTime(now), ct);
+        var lines = new List<GlJournalEntryLineRequest>();
+        if (gain > 0)
+        {
+            lines.Add(new GlJournalEntryLineRequest(_glInventoryAccountCode, gain, 0m, $"Adjustment {docNo} — stock increase"));
+            lines.Add(new GlJournalEntryLineRequest(_glGainAccountCode, 0m, gain, $"Adjustment {docNo} — inventory gain"));
+        }
+        if (loss > 0)
+        {
+            lines.Add(new GlJournalEntryLineRequest(_glLossAccountCode, loss, 0m, $"Adjustment {docNo} — inventory loss"));
+            lines.Add(new GlJournalEntryLineRequest(_glInventoryAccountCode, 0m, loss, $"Adjustment {docNo} — stock decrease"));
+        }
+
+        var result = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+        {
+            PeriodId = period.PeriodId,
+            EntryDate = DateOnly.FromDateTime(now),
+            SourceModule = "ADJUSTMENT",
+            Reference = docNo,
+            Narration = $"Stock adjustment {docNo}",
+            Lines = lines
+        }, ct);
+        return result.JournalNo;
     }
 
     public async Task<PagedResponse<CountSummaryDto>> ListAsync(
@@ -160,7 +206,7 @@ public sealed class CountService : ICountService
         {
             count.Status = CountStatus.Posted;
             await _uow.SaveChangesAsync(ct);
-            return new CountPostResultDto(count.CountId, count.Status, null, Array.Empty<int>());
+            return new CountPostResultDto(count.CountId, count.Status, null, null, Array.Empty<int>());
         }
 
         var reason = await _reasonCodes.Query().AsNoTracking()
@@ -168,7 +214,7 @@ public sealed class CountService : ICountService
             ?? throw new DomainException(ErrorCodes.Validation, $"Reason code '{VarianceReasonCode}' (Count Variance) is not configured.", 422);
 
         var now = DateTime.UtcNow;
-        var (adjustmentId, ledgerEntries) = await _uow.ExecuteInTransactionAsync(async token =>
+        var (adjustmentId, glJournalNo, ledgerEntries) = await _uow.ExecuteInTransactionAsync(async token =>
         {
             var docNo = await _numbers.NextAsync(DocumentTypes.Adjustment, token);
             var adjustment = new StockAdjustment
@@ -191,12 +237,15 @@ public sealed class CountService : ICountService
 
             var refs = await _mutator.ApplyAsync(count.WarehouseId, DocumentTypes.Adjustment, adjustment.AdjustmentId, now, deltas, token);
 
+            adjustment.GlJournalNo = await PostAdjustmentJournalAsync(docNo, now, refs, token);
+            if (adjustment.GlJournalNo is not null) adjustment.GlPostedAt = now;
+
             count.Status = CountStatus.Posted;
-            return (adjustment.AdjustmentId, refs);
+            return (adjustment.AdjustmentId, adjustment.GlJournalNo, refs);
         }, ct);
 
         // Map ledger ids after commit so they are populated.
-        return new CountPostResultDto(count.CountId, count.Status, adjustmentId, ledgerEntries.Select(r => r.LedgerId).ToList());
+        return new CountPostResultDto(count.CountId, count.Status, adjustmentId, glJournalNo, ledgerEntries.Select(r => r.LedgerId).ToList());
     }
 
     private static CountDto Map(StockCount c) => new(

Backend/ERPCore/Services/GeneralLedgerService.cs

@@ -1,11 +1,21 @@
+using System.Text;
+using System.Text.Json;
 using ERPCore.Infra.Gl;
+using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
+using ERPCore.System.Errors;
 
 namespace ERPCore.Services;
 
 /// <inheritdoc cref="IGeneralLedgerService"/>
 public sealed class GeneralLedgerService : IGeneralLedgerService
 {
+    private static readonly JsonSerializerOptions JsonOptions = new()
+    {
+        PropertyNamingPolicy = JsonNamingPolicy.CamelCase,
+        PropertyNameCaseInsensitive = true
+    };
+
     private readonly IGeneralLedgerClient _client;
 
     public GeneralLedgerService(IGeneralLedgerClient client) => _client = client;
@@ -13,4 +23,89 @@ public sealed class GeneralLedgerService : IGeneralLedgerService
     public Task<GeneralLedgerResponse> ForwardAsync(
         HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct)
         => _client.SendAsync(method, path, queryString, contentType, body, ct);
+
+    public async Task<GlJournalEntryResult> PostJournalEntryAsync(GlJournalEntryRequest request, CancellationToken ct)
+    {
+        using var body = new MemoryStream(JsonSerializer.SerializeToUtf8Bytes(request, JsonOptions));
+        var response = await _client.SendAsync(HttpMethod.Post, "journal-entries", null, "application/json", body, ct);
+        var data = ParseSuccess<GlJournalEntryData>(response);
+        return new GlJournalEntryResult(data.JournalNo, data.IsPosted);
+    }
+
+    public async Task<GlPeriod> GetPeriodByDateAsync(DateOnly date, CancellationToken ct)
+    {
+        var response = await _client.SendAsync(
+            HttpMethod.Get, "fiscal-years/periods/by-date", $"?date={date:yyyy-MM-dd}", null, null, ct);
+        var data = ParseSuccess<GlPeriodData>(response);
+        return new GlPeriod(data.PeriodId, data.FiscalYearId);
+    }
+
+    public async Task<IReadOnlyList<GlBankAccount>> ListBankAccountsAsync(CancellationToken ct)
+    {
+        var response = await _client.SendAsync(HttpMethod.Get, "bank-accounts", "?accountType=Both", null, null, ct);
+        var data = ParseSuccess<List<GlBankAccountData>>(response);
+        return data.Select(a => new GlBankAccount(
+            a.AccountType, a.AccountId, a.AccountName, a.BankName,
+            a.CashAccountTypeName, a.AccountNumber, a.GlAccountId, a.GlAccountCode, a.CurrencyCode)).ToList();
+    }
+
+    /// <summary>
+    /// Parses GL's <c>ApiResponse</c> envelope (case-insensitively, since GL's success bodies are
+    /// camelCase and its error bodies are PascalCase — docs/12 §4) and throws
+    /// <see cref="DomainException"/> if the call didn't succeed.
+    /// </summary>
+    private static T ParseSuccess<T>(GeneralLedgerResponse response)
+    {
+        GlEnvelope<T>? envelope;
+        try
+        {
+            envelope = JsonSerializer.Deserialize<GlEnvelope<T>>(response.Body, JsonOptions);
+        }
+        catch (JsonException)
+        {
+            envelope = null;
+        }
+
+        if (response.StatusCode is < 200 or >= 300 || envelope is null || !envelope.Success || envelope.Data is null)
+        {
+            var message = envelope?.Message ?? "The General Ledger service rejected the request.";
+            var status = response.StatusCode is >= 400 and < 500 ? response.StatusCode : 502;
+            throw new DomainException(ErrorCodes.GlRequestFailed, message, status);
+        }
+
+        return envelope.Data;
+    }
+
+    private sealed class GlEnvelope<T>
+    {
+        public int StatusCode { get; set; }
+        public bool Success { get; set; }
+        public string? Message { get; set; }
+        public T? Data { get; set; }
+    }
+
+    private sealed class GlJournalEntryData
+    {
+        public string JournalNo { get; set; } = string.Empty;
+        public bool IsPosted { get; set; }
+    }
+
+    private sealed class GlPeriodData
+    {
+        public int PeriodId { get; set; }
+        public int FiscalYearId { get; set; }
+    }
+
+    private sealed class GlBankAccountData
+    {
+        public string AccountType { get; set; } = string.Empty;
+        public long AccountId { get; set; }
+        public string AccountName { get; set; } = string.Empty;
+        public string? BankName { get; set; }
+        public string? CashAccountTypeName { get; set; }
+        public string? AccountNumber { get; set; }
+        public long GlAccountId { get; set; }
+        public string GlAccountCode { get; set; } = string.Empty;
+        public string CurrencyCode { get; set; } = string.Empty;
+    }
 }

Backend/ERPCore/Services/Gl/GlModels.cs

@@ -0,0 +1,27 @@
+namespace ERPCore.Services.Gl;
+
+/// <summary>
+/// Purpose-built request/response shapes for the specific GL endpoints ERPCore's GRN
+/// module calls directly (journal-entries, period lookup, bank-account listing) — not
+/// a full model of GL's contract (docs/12-GENERAL-LEDGER-INTEGRATION.md §5/§6: typed
+/// DTOs are added only for the flow that actually needs them).
+/// </summary>
+public sealed record GlJournalEntryLineRequest(string AccountCode, decimal DebitAmount, decimal CreditAmount, string? Memo = null);
+
+public sealed class GlJournalEntryRequest
+{
+    public int PeriodId { get; set; }
+    public DateOnly EntryDate { get; set; }
+    public string? SourceModule { get; set; }
+    public string? Reference { get; set; }
+    public string? Narration { get; set; }
+    public List<GlJournalEntryLineRequest> Lines { get; set; } = new();
+}
+
+public sealed record GlJournalEntryResult(string JournalNo, bool IsPosted);
+
+public sealed record GlPeriod(int PeriodId, int FiscalYearId);
+
+public sealed record GlBankAccount(
+    string AccountType, long AccountId, string AccountName, string? BankName,
+    string? CashAccountTypeName, string? AccountNumber, long GlAccountId, string GlAccountCode, string CurrencyCode);

Backend/ERPCore/Services/GrnService.cs

@@ -6,6 +6,7 @@ using ERPCore.Dtos.Grn;
 using ERPCore.Infra.Auth;
 using ERPCore.Infra.UoW;
 using ERPCore.Repositories.Interfaces;
+using ERPCore.Services.Gl;
 using ERPCore.Services.Interfaces;
 using ERPCore.System.Errors;
 using Microsoft.EntityFrameworkCore;
@@ -38,13 +39,18 @@ public sealed class GrnService : IGrnService
     private readonly INumberSequenceService _numbers;
     private readonly ICurrentUser _currentUser;
     private readonly IUnitOfWork _uow;
+    private readonly IGeneralLedgerService _gl;
+    private readonly string _glInventoryAccountCode;
+    private readonly string _glVatRecoverableAccountCode;
+    private readonly string _glClearingAccountCode;
 
     public GrnService(
         IRepository<Grn> grns, IRepository<PurchaseOrder> pos, IRepository<PoLine> poLines,
         IRepository<Item> items, IRepository<Warehouse> warehouses,
         IRepository<Bin> bins, IRepository<Vendor> vendors, IRepository<Batch> batches,
         IRepository<StockLayer> layers, IRepository<StockLedger> ledger,
-        IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow)
+        IFifoCostingService fifo, INumberSequenceService numbers, ICurrentUser currentUser, IUnitOfWork uow,
+        IGeneralLedgerService gl, IConfiguration configuration)
     {
         _grns = grns;
         _pos = pos;
@@ -60,6 +66,10 @@ public sealed class GrnService : IGrnService
         _numbers = numbers;
         _currentUser = currentUser;
         _uow = uow;
+        _gl = gl;
+        _glInventoryAccountCode = configuration["Grn:GlInventoryAccountCode"] ?? string.Empty;
+        _glVatRecoverableAccountCode = configuration["Grn:GlVatRecoverableAccountCode"] ?? string.Empty;
+        _glClearingAccountCode = configuration["Grn:GlClearingAccountCode"] ?? string.Empty;
     }
 
     public async Task<PagedResponse<GrnSummaryDto>> ListAsync(
@@ -82,7 +92,8 @@ public sealed class GrnService : IGrnService
             .Skip(query.Skip).Take(query.PageSize)
             .Select(g => new GrnSummaryDto(
                 g.GrnId, g.DocNo, g.PoId, g.VendorId, g.WarehouseId, g.Status,
-                g.CreatedBy, g.CreatedAt, g.PostedAt, g.Lines.Count))
+                g.CreatedBy, g.CreatedAt, g.PostedAt, g.Lines.Count,
+                g.PurchaseInvoiceId, g.PurchaseInvoice != null ? g.PurchaseInvoice.DocNo : null))
             .ToListAsync(ct);
 
         return PagedResponse<GrnSummaryDto>.Create(rows, query.Page, query.PageSize, total);
@@ -92,6 +103,7 @@ public sealed class GrnService : IGrnService
     {
         var grn = await _grns.Query().AsNoTracking()
             .Include(g => g.Lines).ThenInclude(l => l.WarrantyNumbers)
+            .Include(g => g.PurchaseInvoice)
             .FirstOrDefaultAsync(g => g.GrnId == grnId, ct);
         return grn is null ? null : Map(grn);
     }
@@ -260,15 +272,45 @@ public sealed class GrnService : IGrnService
                 }
             }
 
+            // Post the real GL journal entry for this receipt before committing — if GL
+            // rejects it or is unreachable, the exception propagates out of this callback
+            // and the whole transaction (FIFO layers, stock ledger, PO accrual) rolls back
+            // with it, so inventory and the ledger never diverge (user-approved "fails
+            // atomically" behavior; residual risk if GL posts but the local commit still
+            // fails afterward is accepted for this phase, see the integration plan).
+            var period = await _gl.GetPeriodByDateAsync(DateOnly.FromDateTime(now), token);
+            var glLines = new List<GlJournalEntryLineRequest>();
+            decimal totalPayable = 0m;
+            foreach (var line in grn.Lines.OrderBy(l => l.GrnLineId))
+            {
+                glLines.Add(new GlJournalEntryLineRequest(_glInventoryAccountCode, line.ReceivedValue, 0m, $"GRN {grn.DocNo} line {line.GrnLineId}"));
+                if (line.VatAmount > 0)
+                    glLines.Add(new GlJournalEntryLineRequest(_glVatRecoverableAccountCode, line.VatAmount, 0m, $"GRN {grn.DocNo} line {line.GrnLineId} VAT"));
+                totalPayable += line.LineTotal;
+            }
+            glLines.Add(new GlJournalEntryLineRequest(_glClearingAccountCode, 0m, totalPayable, $"GRN {grn.DocNo} received"));
+
+            var posted = await _gl.PostJournalEntryAsync(new GlJournalEntryRequest
+            {
+                PeriodId = period.PeriodId,
+                EntryDate = DateOnly.FromDateTime(now),
+                SourceModule = "GRN",
+                Reference = grn.DocNo,
+                Narration = $"Goods received - GRN {grn.DocNo}",
+                Lines = glLines
+            }, token);
+
             grn.Status = GrnStatus.Confirmed;
             grn.PostedAt = now;
+            grn.GlJournalNo = posted.JournalNo;
+            grn.GlPostedAt = now;
 
             await UpdatePoStatusAsync(grn.PoId, token);
             return 0;
         }, ct);
 
         return new GrnConfirmResultDto(
-            grn.GrnId, grn.Status, now,
+            grn.GrnId, grn.Status, now, grn.GlJournalNo ?? string.Empty,
             createdLayers.Select(ToCreatedLayer).ToList(),
             ledgerRefs.Select(l => l.LedgerId).ToList(),
             await GetPoStatusAsync(grn.PoId, ct));
@@ -395,7 +437,7 @@ public sealed class GrnService : IGrnService
             .Select(l => l.LedgerId).ToListAsync(ct);
 
         return new GrnConfirmResultDto(
-            grn.GrnId, grn.Status, grn.PostedAt ?? grn.CreatedAt,
+            grn.GrnId, grn.Status, grn.PostedAt ?? grn.CreatedAt, grn.GlJournalNo ?? string.Empty,
             layers.Select(ToCreatedLayer).ToList(), ledgerRefs, await GetPoStatusAsync(grn.PoId, ct));
     }
 
@@ -404,6 +446,7 @@ public sealed class GrnService : IGrnService
 
     private static GrnDto Map(Grn g) => new(
         g.GrnId, g.DocNo, g.PoId, g.VendorId, g.WarehouseId, g.Status, g.CreatedBy, g.CreatedAt, g.PostedAt,
+        g.GlJournalNo, g.PurchaseInvoiceId, g.PurchaseInvoice?.DocNo,
         g.Lines.OrderBy(l => l.GrnLineId).Select(l => new GrnLineDto(
             l.GrnLineId, l.PoLineId, l.ItemId, l.BinId, l.Qty, l.UnitCost, l.PoUnitPrice,
             l.DiscountPct, l.NetUnitCost, l.VatPct, l.VatAmount, l.ReceivedValue, l.LineTotal,

Backend/ERPCore/Services/Interfaces/IBundleSaleService.cs

@@ -9,6 +9,7 @@ public interface IBundleSaleService
 {
     Task<PagedResponse<BundleSaleTemplateSummaryDto>> ListTemplatesAsync(PageQuery query, CancellationToken ct = default);
     Task<BundleSaleTemplateDto?> GetTemplateAsync(int bundleSaleTemplateId, CancellationToken ct = default);
+    Task<BundleSaleTemplateDto> CreateTemplateAsync(CreateBundleSaleTemplateRequest request, CancellationToken ct = default);
     Task<PagedResponse<BundleSaleSummaryDto>> ListAsync(PageQuery query, BundleSaleStatus? status, int? customerId, int? warehouseId, CancellationToken ct = default);
     Task<BundleSaleDto?> GetAsync(int bundleSaleId, CancellationToken ct = default);
     Task<BundleSalePostingCheckDto> CheckPostingAsync(int bundleSaleId, CancellationToken ct = default);

Backend/ERPCore/Services/Interfaces/IGeneralLedgerService.cs

@@ -1,16 +1,27 @@
 using ERPCore.Infra.Gl;
+using ERPCore.Services.Gl;
 
 namespace ERPCore.Services.Interfaces;
 
 /// <summary>
 /// Single entry point into the external General Ledger service — the one function
 /// used both by <see cref="ERPCore.Controllers.GeneralLedgerController"/> (frontend
-/// requests, forwarded verbatim) and, once wired, other ERPCore services that need to
+/// requests, forwarded verbatim) and by other ERPCore services that post directly to
-/// post directly to GL (e.g. GRN confirm, adjustments — docs/12-GENERAL-LEDGER-INTEGRATION.md).
+/// GL (docs/12-GENERAL-LEDGER-INTEGRATION.md §5/§6). <see cref="ForwardAsync"/> stays a
-/// No business logic lives here yet; this pass only connects the transport.
+/// byte-for-byte passthrough; the three typed methods below are the first internal
+/// callers (GRN receipt + payment posting) and model only what those flows need.
 /// </summary>
 public interface IGeneralLedgerService
 {
     Task<GeneralLedgerResponse> ForwardAsync(
         HttpMethod method, string path, string? queryString, string? contentType, Stream? body, CancellationToken ct);
+
+    /// <summary>Creates and posts a balanced journal entry. Throws <see cref="ERPCore.System.Errors.DomainException"/> on rejection/unreachability.</summary>
+    Task<GlJournalEntryResult> PostJournalEntryAsync(GlJournalEntryRequest request, CancellationToken ct);
+
+    /// <summary>Resolves the accounting period covering <paramref name="date"/>.</summary>
+    Task<GlPeriod> GetPeriodByDateAsync(DateOnly date, CancellationToken ct);
+
+    /// <summary>Lists GL's cash and bank accounts (default: both types).</summary>
+    Task<IReadOnlyList<GlBankAccount>> ListBankAccountsAsync(CancellationToken ct);
 }