feat: add production navigation permissions and produced items page

- Created a new migration to add navigation items and permissions for the production section.
- Implemented the Produced Items page with filtering options for date range, templates, warehouses, and status.
- Integrated API calls to fetch produced items, templates, and warehouses.
- Added UI components for displaying produced items in a table format with relevant details.

Backend/ERPCore/Services/Interfaces/IProductionRunService.cs

@@ -18,6 +18,15 @@ public interface IProductionRunService
 
     Task<ETagged<RunGraphDto>?> GetAsync(int runId, CancellationToken ct = default);
 
+    /// <summary>
+    /// Produced-items report (FR-MFG-13): one row per run that has produced something,
+    /// terminal-output quantities and roll-up cost, plus a summary total over every
+    /// filtered row. No pagination — bounded by the filters like the Sales reports.
+    /// </summary>
+    Task<ProducedListResponseDto> ListProducedAsync(
+        DateOnly? from, DateOnly? to, int? templateId, int? warehouseId, ProductionRunStatus? status,
+        CancellationToken ct = default);
+
     /// <summary>
     /// Instantiates a template (FR-MFG-08): copies every stage, input, output and edge,
     /// scales all quantities by <c>targetQty / terminalOutputQtyPerBatch</c>, issues a

Backend/ERPCore/Services/Production/ProductionRunService.cs

@@ -124,6 +124,75 @@ public sealed class ProductionRunService : IProductionRunService
         return PagedResponse<RunSummaryDto>.Create(items, query.Page, query.PageSize, total);
     }
 
+    public async Task<ProducedListResponseDto> ListProducedAsync(
+        DateOnly? from, DateOnly? to, int? templateId, int? warehouseId, ProductionRunStatus? status,
+        CancellationToken ct = default)
+    {
+        var q = _runs.Query().AsNoTracking()
+            // FR-MFG-05 (ProductionGraphValidator) guarantees exactly one item-bearing
+            // output per run, always the terminal one — a row exists once that output has
+            // actually produced something.
+            .Where(r => r.Stages.Any(s => s.Outputs.Any(o => o.ItemId != null && o.ProducedQty > 0)));
+
+        if (from is not null) q = q.Where(r => r.CreatedAt >= from.Value.ToDateTime(TimeOnly.MinValue));
+        if (to is not null) q = q.Where(r => r.CreatedAt < to.Value.AddDays(1).ToDateTime(TimeOnly.MinValue));
+        if (templateId is not null) q = q.Where(r => r.TemplateId == templateId);
+        if (warehouseId is not null) q = q.Where(r => r.WarehouseId == warehouseId);
+        if (status is not null) q = q.Where(r => r.Status == status);
+
+        // Projected to an anonymous type first, then mapped client-side — EF Core 10 cannot
+        // translate a record constructor call inside a projection alongside aggregates (same
+        // failure mode noted in ListAsync above).
+        var rows = await q
+            .OrderByDescending(r => r.RunId)
+            .Select(r => new
+            {
+                r.RunId,
+                r.DocNo,
+                r.Status,
+                r.TemplateId,
+                TemplateName = r.Template!.Name,
+                r.WarehouseId,
+                WarehouseName = r.Warehouse!.Name,
+                Output = r.Stages.SelectMany(s => s.Outputs)
+                    .Where(o => o.ItemId != null)
+                    .Select(o => new { o.ItemId, ItemName = o.Item!.Name, o.ProducedQty, o.ScrappedQty })
+                    .First(),
+                ConsumedValue = r.Stages.SelectMany(s => s.Inputs).Sum(i => i.ConsumedValue),
+                ReturnedValue = r.Stages.SelectMany(s => s.Inputs).Sum(i => i.ReturnedValue),
+                r.CreatedAt,
+                r.CompletedAt
+            })
+            .ToListAsync(ct);
+
+        var items = rows.Select(r =>
+        {
+            var good = r.Output.ProducedQty - r.Output.ScrappedQty;
+            // Same formula PostReceiptAsync uses to cost the finished layer at approve
+            // (FR-MFG-13): pool / good qty, 6dp. TotalCost carries the pool exactly rather
+            // than good * unitCost, which drifts from it past ~100 units (see the ledgerValue
+            // rounding note in PostReceiptAsync).
+            var pool = r.ConsumedValue - r.ReturnedValue;
+            var unitCost = good > 0 ? Math.Round(pool / good, 6, MidpointRounding.AwayFromZero) : 0m;
+            return new ProducedLineDto(
+                r.RunId, r.DocNo, r.Status, r.TemplateId, r.TemplateName,
+                r.WarehouseId, r.WarehouseName,
+                r.Output.ItemId!.Value, r.Output.ItemName,
+                r.Output.ProducedQty, r.Output.ScrappedQty, good,
+                unitCost, pool,
+                r.CreatedAt, r.CompletedAt);
+        }).ToList();
+
+        var summary = new ProducedSummaryDto(
+            items.Count,
+            items.Sum(i => i.ProducedQty),
+            items.Sum(i => i.ScrappedQty),
+            items.Sum(i => i.GoodQty),
+            items.Sum(i => i.TotalCost));
+
+        return new ProducedListResponseDto(items, summary);
+    }
+
     public async Task<ETagged<RunGraphDto>?> GetAsync(int runId, CancellationToken ct = default)
     {
         var run = await LoadGraphQuery().AsNoTracking().FirstOrDefaultAsync(r => r.RunId == runId, ct);