@agridea/suibi-module 0.1.0-preview.01100f9 → 0.1.0-preview.0808fe0

package/dist/elements/browser/version.txt

@@ -1 +1 @@
-0.1.0-preview.01100f9 01100f9
+0.1.0-preview.0808fe0 0808fe0

package/dist/elements/browser/wc-global-utilities.css

@@ -1 +1 @@
-.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}
+.cdk-overlay-container{position:fixed;inset:0;z-index:1200;pointer-events:none}.cdk-overlay-container:empty{display:none}.cdk-global-overlay-wrapper{position:fixed;inset:0;display:flex;align-items:flex-start;justify-content:center;pointer-events:none}.cdk-overlay-connected-position-bounding-box{position:absolute;z-index:1200;display:flex;flex-direction:column;min-width:1px;min-height:1px}.cdk-overlay-pane{position:absolute;pointer-events:auto;box-sizing:border-box;z-index:1200}.cdk-overlay-backdrop{position:fixed;inset:0;z-index:1199;pointer-events:auto}.cdk-overlay-transparent-backdrop{background:transparent}.cdk-overlay-dark-backdrop{background:#00000052}.mat-mdc-select-panel.mdc-menu-surface{background:#fff;--mdc-theme-surface: #fff;--mdc-menu-container-color: #fff;--mat-select-panel-background-color: #fff;box-shadow:0 4px 16px #00000040;border-radius:4px;outline:0;opacity:1!important;filter:none!important}.mat-mdc-option.mdc-list-item{height:auto;min-height:48px}.mat-mdc-option .mdc-list-item__primary-text{white-space:normal;overflow:visible;text-overflow:clip;line-height:1.35}

package/dist/types/app/components/data-preview/data-preview.component.d.ts

@@ -3,9 +3,231 @@ import { PlanningBalanceService } from '../../core/planning/planning-balance.ser
 export declare class DataPreviewComponent {
     private readonly host;
     private readonly emitter;
+    private readonly clipboard;
     readonly planning: PlanningBalanceService;
     readonly naebi: NaebiDataService;
     readonly metadataPreview: import("@angular/core").Signal<import("../../../public-api").SuibiDataEventMetadata>;
+    /** Exact payload that runPlanning will POST (same builder as the real request). */
+    readonly apiPayload: import("@angular/core").Signal<{
+        nutrientCycle: {
+            animalStock: {
+                order: string;
+                animalCategoryPRIF: number;
+                selfReportedLivestock: {
+                    averageQuantity: number;
+                };
+                durationCorrectionQuantity: number;
+                durationCorrectionDays: number;
+                utilisation: number;
+                formOfDetention: {
+                    hasGrazing: boolean;
+                    pasture: {
+                        days: number;
+                        hoursPerDay: number;
+                    };
+                    stall: {
+                        stableSystem: string;
+                        stableVentilationType: number;
+                        hasStableDeepLitter: boolean;
+                        hasStableManureBeltDrying: boolean;
+                        stableManureRemovalFrequency: number;
+                        stableWaterSupply: number;
+                        hasStableManureAndSlurryProduction: boolean;
+                        hasStableFeedingStationElevated: boolean;
+                        hasStableFloorSlopedUrineDrainage: boolean;
+                        hasYard: boolean;
+                    };
+                };
+                hasImpexDerivedExcretion: boolean;
+                hasLinearCorrectionDerivedExcretion: boolean;
+                feeding: {
+                    fodderConsumption: number;
+                    concentratedFeedstuffConsumption: number;
+                    concentratedFeedStuffConsumption: number;
+                    winterFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                    summerFeeding: {
+                        feedingRoutine: {
+                            typeOfFeedstuffProduct: string;
+                            transactionUnit: string;
+                            quantity: number;
+                        }[];
+                        dailyConcentratedFeedstuff: {
+                            quantity: number;
+                        };
+                    };
+                };
+            }[];
+            storage: {
+                stableStrawLitter: number;
+                slurrySupplyProportionStored: number;
+                createFacilitySpecificManureProduct: boolean;
+                createFacilitySpecificSlurryProduct: boolean;
+                slurryTankQuantity: number;
+                dilutionRatio: number;
+                manurePit: never[];
+                slurryTank: {
+                    descriptor: string;
+                    volumeInM3: number;
+                    depthInM: number;
+                    cover: number;
+                    mixingFrequency: number;
+                    manureDerivation: string[];
+                }[];
+            };
+            farmManureTrading: {
+                supply: never[];
+                dispense: {
+                    quantity: number;
+                    typeOfManureRecyclingProduct: string;
+                    transactionUnit: string;
+                    manureDerivation: {
+                        zoologicalAnimal: string;
+                        percentageAllocation: number;
+                    }[];
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            fieldSpreading: {
+                soilPh: number;
+                slurry: {
+                    quantity: number;
+                    dilutionRatio: number;
+                    otherApplicationTechnologies: {
+                        applicationTechnologyType: number;
+                        proportionOfArea: number;
+                    }[];
+                    applicationDuringWarmDays: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                    proportionAppliedAfter6PM: number;
+                    dragHoseAreaSize: number;
+                };
+                manure: {
+                    applicationIncorporationTime: number;
+                    proportionAppliedSummerMonths: number;
+                    proportionAppliedOtherMonths: number;
+                };
+                fertiliser: {
+                    descriptor: string;
+                    fertiliserProductCategory: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+                recycling: {
+                    typeOfManureRecyclingProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        molecularFormula: string;
+                        quantity: number;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            lifetimePerformance: {
+                milkProductionReport: number;
+            };
+            fodder: {
+                trading: {
+                    supply: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: {
+                            quantity: number;
+                            molecularFormula: string;
+                            unit: string;
+                        }[];
+                    }[];
+                    dispense: {
+                        typeOfFeedstuffProduct: string;
+                        quantity: number;
+                        transactionUnit: string;
+                        ingredient: never[];
+                    }[];
+                };
+                cropFromNonFodderCropland: {
+                    typeOfFeedstuffProduct: string;
+                    quantity: number;
+                    transactionUnit: string;
+                    ingredient: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+                proportionStorageLoss: number;
+                totalBalanceErrorMargin: number;
+            };
+            fieldCultivation: {
+                buildingZoneAreaSize: number;
+                outdoorVegetableMainCropAreaSize: number;
+                indoorVegetableMainCropAreaSize: number;
+                feedingOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                dispenseOfCropHarvest: {
+                    agronomicCropCategory: string;
+                    effectiveYield: number;
+                }[];
+                fodderCropland: ({
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    calculateYieldThroughFodderBalance: boolean;
+                    yieldPerSquareMeasure?: undefined;
+                } | {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    calculateYieldThroughFodderBalance?: undefined;
+                })[];
+                arableLand: {
+                    agronomicCropCategory: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    yieldPerSquareMeasure: number;
+                    hasLongTermYieldDivergence: boolean;
+                }[];
+                special: {
+                    agronomicCropCategory: string;
+                    userSpecificPlantName: string;
+                    isMainCrop: boolean;
+                    areaSize: number;
+                    requirementCorrection: {
+                        quantity: number;
+                        molecularFormula: string;
+                        unit: string;
+                    }[];
+                }[];
+            };
+            generateReport: boolean;
+        };
+        calculationVersion: {
+            version: string;
+        };
+    }>;
     setPlanningEndpoint(value: string | null): void;
     emitData(): void;
+    copyJson(getValue: () => unknown): void;
 }

package/dist/types/app/components/inline-table/inline-table.component.d.ts

@@ -1,6 +1,6 @@
 import { MatCheckboxChange } from '@angular/material/checkbox';
 import { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/code-lists';
-import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
+import { InlineColumnDef, InlineTableConfig, InlineCellErrorResolver } from './inline-table.types';
 /**
  * InlineTableComponent — generic inline-editable table for array-of-objects data.
  *
@@ -27,6 +27,8 @@ import { InlineColumnDef, InlineTableConfig } from './inline-table.types';
  */
 export declare class InlineTableComponent {
     private readonly i18n;
+    private readonly host;
+    constructor();
     /** Table configuration — columns, labels, and the row factory. Acts as the "uischema". */
     readonly config: import("@angular/core").InputSignal<InlineTableConfig>;
     /** Current array of row objects. Each key maps to a column's `key` or sub-array path. */
@@ -39,17 +41,35 @@ export declare class InlineTableComponent {
     /**
      * Optional business-logic transform applied after every cell edit — before emission.
      *
-     * Signature: `(changedKey, newValue, updatedRow) => transformedRow`
+     * Signature: `(changedKey, newValue, updatedRow, previousRow) => transformedRow`
      *
      * - `changedKey`: the `InlineColumnDef.key` of the edited column.
      * - `newValue`: the raw new value (string, number, or null).
      * - `updatedRow`: the row object already reflecting the edit.
+     * - `previousRow`: the row as it was before the edit — needed when the side-effect
+     *   depends on the replaced value (e.g. converting a quantity on a unit switch).
      * - Return the row (possibly further mutated) that should be stored.
      *
      * Use this for cross-field side-effects such as pre-populating nutrient % columns
      * when a product is selected.  For forms without such logic, omit this input.
      */
-    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>) | null>;
+    readonly rowTransform: import("@angular/core").InputSignal<((changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>) | null>;
+    /**
+     * Optional per-cell validation resolver — returns a translated error message
+     * shown under the cell (cell turns red via `mat-form-field-invalid`), or `null`
+     * when valid. Inline tables bypass JSONForms/AJV, so business rules that must
+     * be visible while typing (e.g. percentage caps) are surfaced through this hook.
+     */
+    readonly cellError: import("@angular/core").InputSignal<InlineCellErrorResolver | null>;
+    /**
+     * Index of the row to visually highlight (e.g. after a validation-error deep-link).
+     * Also triggers a scrollIntoView so the row is on screen.
+     */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
+    /** Resolves the per-cell error message via the optional `cellError` input (null = valid). */
+    errorForCell(row: Record<string, unknown>, col: InlineColumnDef): string | null;
+    /** True when any column of the row reports an error — drives the row-level red tint. */
+    rowHasError(row: Record<string, unknown>): boolean;
     /** Extracts a px value from a grid-format width string (e.g. 'minmax(120px, 1fr)' → '120px'). */
     colMinWidth(width?: string): string;
     /** Total table width = sum of all column px values + 40px for the delete column. */
@@ -125,7 +145,9 @@ export declare class InlineTableComponent {
     addSubEntry(rowIdx: number, col: InlineColumnDef): void;
     removeSubEntry(rowIdx: number, col: InlineColumnDef, subIdx: number): void;
     onSubEntryKeyChange(rowIdx: number, col: InlineColumnDef, subIdx: number, value: unknown): void;
-    /** Commits on every keystroke (not on blur) — same rationale as `onNumberChange`. */
+    /** Commits on every keystroke (not on blur) — same rationale as `onNumberChange`.
+     *  When `expectedTotal` is set, the value is clamped to the remaining share so the
+     *  sum can never exceed it; smaller intermediate keystrokes still go through. */
     onSubEntryValueChange(rowIdx: number, col: InlineColumnDef, subIdx: number, event: Event): void;
     /** Writes the sub-entry array back to the row, runs rowTransform, emits rowsChange. */
     private updateSubEntries;

package/dist/types/app/components/inline-table/inline-table.types.d.ts

@@ -19,6 +19,14 @@ import type { BaseCodeListEntry } from '../../jsonforms/shared/option-sources/co
  *  'subrows' renders an expandable editor for a nested list of key/percentage
  *  pairs (e.g. manureDerivation[]) — see `InlineSubrowsConfig`. */
 export type InlineCellType = 'select' | 'number' | 'text' | 'readonly' | 'checkbox' | 'subrows';
+/**
+ * Per-cell validation resolver — returns a translated error message to display
+ * under the cell, or `null` when the cell is valid. Passed as the `cellError`
+ * input of InlineTableComponent for domain tables that bypass JSONForms/AJV
+ * (inline tables are not schema-validated, so business rules like percentage
+ * caps must be surfaced visually through this hook).
+ */
+export type InlineCellErrorResolver = (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
 /**
  * Configuration for a `type: 'subrows'` column — an expandable editor for a nested
  * array of `{ key, value }` entries (e.g. manureDerivation: zoologicalAnimal +
@@ -47,7 +55,8 @@ export interface InlineSubrowsConfig {
     collapseLabelKey: string;
     /** i18n key for the total indicator label. */
     totalLabelKey: string;
-    /** Expected sum of the value fields (e.g. 100) — the indicator turns green on match. */
+    /** Expected sum of the value fields (e.g. 100) — the indicator turns green on exact
+     *  match (no more, no less) and entered values are clamped so the sum never exceeds it. */
     expectedTotal?: number;
     /** Min for the value number input (default 0). */
     valueMin?: number;

package/dist/types/app/core/navigation/navigation.service.d.ts

@@ -58,6 +58,11 @@ export declare class NavigationService {
         type: StorageEntryType;
         index: number;
     } | null>;
+    /** Selected field spreading row context (category/tab + row index) — used by validation deep-links */
+    readonly selectedFieldSpreadingDetail: import("@angular/core").WritableSignal<{
+        category: FieldSpreadingCategory;
+        index: number;
+    } | null>;
     /** True if currently viewing animal stock detail (not list) */
     readonly isAnimalStockDetailView: import("@angular/core").Signal<boolean>;
     /** True if currently on animal stock page (list or detail) */
@@ -81,6 +86,8 @@ export declare class NavigationService {
     navigateToFodderDetail(mode: FodderMode, index: number, category?: FodderCategory): void;
     navigateToFodderList(): void;
     navigateToFieldSpreading(category?: FieldSpreadingCategory): void;
+    /** Deep-link to a specific row of a field spreading tab (e.g. from a validation error). */
+    navigateToFieldSpreadingDetail(category: FieldSpreadingCategory, index: number): void;
     navigateToFieldCultivationDetail(tab: Exclude<FieldCultivationTab, 'general'>, index: number): void;
     navigateToFieldCultivationList(tab?: FieldCultivationTab): void;
     navigateToStorageDetail(type: StorageEntryType, index: number): void;

package/dist/types/app/core/planning/planning-balance.service.d.ts

@@ -33,6 +33,14 @@ export declare class PlanningBalanceService {
     };
     readonly selectedEndpoint: import("@angular/core").Signal<PlanningEndpoint>;
     setSelectedEndpoint(endpoint: PlanningEndpoint): void;
+    /**
+     * Builds the exact payload posted to the planning API: calculationVersion stamped from
+     * the current metadata, `nutrientCycle.generateReport` forced to true (the PDF report
+     * must always be requested on submission), empty ingredient/routine slots stripped,
+     * null optional fields and host-only fields removed, custom display units converted
+     * to base units.
+     */
+    buildApiPayload(data: NaebiData): NaebiData;
     /** Fire a new planning-balance request with the current NAEBI data payload. */
     runPlanning(data: NaebiData, endpoint?: PlanningEndpoint): void;
 }

package/dist/types/app/core/utils/custom-unit.util.d.ts

@@ -0,0 +1,38 @@
+export interface CustomUnit {
+    /** Unit code stored on the row (e.g. 'ha', 't', 'dt'). */
+    code: string;
+    /** API base unit this custom unit converts to (e.g. 'm2', 'kg'). */
+    baseUnit: string;
+    /** Multiplier from the custom unit to its base unit (1 ha = 10'000 m2 → 10000). */
+    factor: number;
+    descriptor?: Record<string, unknown>;
+}
+export declare const CUSTOM_UNITS: readonly CustomUnit[];
+/** True when the unit code is a custom display unit (not an API base unit). */
+export declare function isCustomUnit(unit: unknown): boolean;
+/** Base unit a quantity can be converted to: the custom unit's `baseUnit`, or the unit
+ *  itself when it already is a base (or unknown) unit. */
+export declare function baseUnitOf(unit: string | null | undefined): string | null | undefined;
+/** Custom units convertible to the given base unit (e.g. 'kg' → [t, dt]). */
+export declare function customUnitsForBaseUnit(baseUnit: string): CustomUnit[];
+/**
+ * Builds a filter (compatible with the inline table's `optionsFilter`) keeping only the
+ * units compatible with the given context base unit — i.e. the base unit itself plus its
+ * custom units. Pass a nullable base (e.g. derived from a product's matterState): `null`
+ * keeps the full list (nothing derived yet).
+ *
+ * Works on any entry shape exposing `id` (and `baseUnit` for custom units).
+ */
+export declare function unitOptionsForBaseUnit<T extends {
+    id: string | number;
+}>(contextBaseUnit: string | null | undefined): (entry: T) => boolean;
+/** Converts a quantity expressed in a custom unit to its base unit; pass-through for
+ *  base/unknown units and null quantities. */
+export declare function convertToBaseUnit(quantity: number | null | undefined, unit: string | null | undefined): {
+    quantity: number | null | undefined;
+    unit: string | null | undefined;
+};
+/** Converts a quantity between two units sharing the same base unit (kg ↔ t ↔ dt,
+ *  m2 ↔ ha). Returns the quantity unchanged when either unit is missing or the units
+ *  are incompatible (different base units). */
+export declare function convertQuantityBetween(quantity: number | null | undefined, fromUnit: string | null | undefined, toUnit: string | null | undefined): number | null | undefined;

package/dist/types/app/core/utils/object.util.d.ts

@@ -22,15 +22,6 @@ export declare function deepEqual(a: unknown, b: unknown): boolean;
  * @returns A deep copy of the value
  */
 export declare function deepClone<T>(value: T): T;
-/**
- * Recursively drops `ingredient[]` entries whose `quantity` is null/undefined.
- *
- * Inline tables (fertiliser/recycling) pre-populate every nutrient slot in `ingredient[]`
- * so the UI always shows all formula columns, but slots the user never fills in stay as
- * `{ molecularFormula, quantity: null, unit }`. The calculation API rejects any ingredient
- * entry that's present but incomplete, so submitted payloads must omit those still-empty
- * slots entirely rather than send them with a null quantity.
- */
 export declare function stripIncompleteIngredients<T>(value: T): T;
 /**
  * Sanitizes the planning payload: the calculation API (OpenAPI, no `nullable: true`
@@ -43,6 +34,11 @@ export declare function stripIncompleteIngredients<T>(value: T): T;
  *   feedingOfCropHarvest, dispenseOfCropHarvest): any null property is dropped
  *   (fieldName, userSpecificPlantName, yieldPerSquareMeasure, effectiveYield, …)
  * - `nutrientCycle.fodder.trading.<collection>[].quantity`: null → dropped
+ * - `nutrientCycle.animalStock[].feeding.(winter|summer)Feeding`: never-filled routine
+ *   slots (`{}` rows pre-created by the inline tables) and null fields are dropped;
+ *   a season — and `feeding` itself — is removed when nothing filled-in remains
+ * - `nutrientCycle.fieldSpreading`: null fields dropped (`soilPh`, `slurry.*`,
+ *   `manure.*`); `slurry`/`manure` removed when nothing filled-in remains
  */
 export declare function sanitizePlanningPayload(data: NaebiDataLike): NaebiDataLike;
 /** Structural type so object.util stays free of a NaebiData import (circular-safe). */

package/dist/types/app/core/validation/ajv-custom.d.ts

@@ -9,6 +9,7 @@ import Ajv from 'ajv';
  *
  * Custom keywords:
  * - `permittedStableSystem`: Validates stable system against animal category constraints
+ * - `proportionSum`: Validates the sum of one numeric field across array items
  *
  * @param options - Additional AJV options to merge with defaults
  */

package/dist/types/app/core/validation/capabilities.d.ts

@@ -16,3 +16,9 @@ export declare function derivePermittedStableSystems(animalCategoryPRIF: number
  * Maps animalCategoryPRIF -> array of permitted stableSystem enum strings.
  */
 export declare const PERMITTED_STABLE_SYSTEMS: Record<number, string[]>;
+/**
+ * Pre-computed map of non-zero per-category minimum yields (yieldPerSquareMeasure).
+ * Only 8 of the 314 crop categories declare a minimum > 0 (e.g. cereals, peas);
+ * all others fall back to the schema-level `minimum: 0`.
+ */
+export declare const CROP_MINIMUM_YIELD_PER_SQUARE_MEASURE: Record<string, number>;

package/dist/types/app/core/validation/global-validation.service.d.ts

@@ -25,6 +25,8 @@ export interface EnrichedValidationError extends ErrorObject {
     targetFodderCategory?: FodderCategory;
     /** Category tab inside field spreading */
     targetFieldSpreadingCategory?: FieldSpreadingCategory;
+    /** Row index inside a field spreading tab (fertiliser/recycling) */
+    targetFieldSpreadingIndex?: number;
     /** Category tab inside field cultivation */
     targetFieldCultivationTab?: FieldCultivationTab;
     /** Field cultivation detail index */

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading-table/farm-manure-trading-table.component.d.ts

@@ -9,10 +9,10 @@ type TradingRow = FarmManureTradingSupply | FarmManureTradingDispense;
  *   1. Provides the per-mode column/section config (the "uischema").
  *   2. Bridges typed `FarmManureTradingSupply[]`/`Dispense[]` to/from the generic
  *      `Record<string, unknown>[]` API of InlineTableComponent.
- *   3. Supplies `deriveUnits` as a `rowTransform` — `transactionUnit` ('kg'/'m3') and
- *      every ingredient's `unit` ('kg/t'/'kg/m3') are fully derived from the selected
- *      product's matterState (never user-entered) — two independent mappings, NOT a
- *      concatenation of one into the other.
+ *   3. Supplies `deriveUnits` as a `rowTransform` — the base `transactionUnit` ('kg'/'m3')
+ *      and every ingredient's `unit` ('kg/t'/'kg/m3') are derived from the selected
+ *      product's matterState; the user may switch to a custom unit sharing the same base
+ *      (t, dt for kg), which converts the entered quantity on the fly.
  */
 export declare class FarmManureTradingTableComponent {
     readonly mode: import("@angular/core").InputSignal<FarmManureTradingMode>;
@@ -24,11 +24,12 @@ export declare class FarmManureTradingTableComponent {
     /** Cast generic output back to typed trading rows. */
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
-     * Row transform re-deriving `transactionUnit` and every ingredient's `unit` from the
-     * product's matterState on each edit — runs unconditionally (not just when
-     * `typeOfManureRecyclingProduct` changes) so an edit made before the product is picked
-     * still resolves once it is.
+     * Row transform deriving the ingredient units from the product's matterState on each
+     * edit, and handling `transactionUnit`:
+     *  - product change (or missing unit on legacy rows): reset to the derived base unit,
+     *  - unit switch: convert the entered quantity from the previous to the new unit
+     *    (both share the same base), so the transacted amount is preserved.
      */
-    readonly deriveUnits: (_changedKey: string, _newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly deriveUnits: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }
 export {};

package/dist/types/app/nutrient-cycle/farm-manure-trading/farm-manure-trading.types.d.ts

@@ -10,6 +10,8 @@ export interface ManureDerivation {
 export interface FarmManureTradingSupply {
     quantity?: number;
     typeOfManureRecyclingProduct?: string;
+    /** Host-only free text: persisted in the emitted dossier, stripped before API calls. */
+    productDesignation?: string;
     transactionUnit?: string;
     manureDerivation?: ManureDerivation[];
     ingredient?: ManureIngredient[];
@@ -17,6 +19,8 @@ export interface FarmManureTradingSupply {
 export interface FarmManureTradingDispense {
     quantity?: number;
     typeOfManureRecyclingProduct?: string;
+    /** Host-only free text: persisted in the emitted dossier, stripped before API calls. */
+    productDesignation?: string;
     transactionUnit?: string;
     manureDerivation?: ManureDerivation[];
     ingredient?: ManureIngredient[];

package/dist/types/app/nutrient-cycle/field-cultivation/arable-land-table/arable-land-table.component.d.ts

@@ -15,7 +15,8 @@ export declare class ArableLandTableComponent {
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Crop change: clear yield + divergence when the new crop forbids yield input,
-     * so no stale values linger under the now-disabled cells.
+     * so no stale values linger under the now-disabled cells. Requirement corrections
+     * are special-crops-only (SUIBIL-1143): strip them so they never reach the emitted JSON.
      */
-    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceArableRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/arable-land-table/arable-land-table.config.d.ts

@@ -6,4 +6,6 @@
  * `agronomicCropCategoryArableLand` code list as-is, keeping its existing order.
  */
 import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/** Looks up the row's selected crop in the arable-land code list. */
+export declare function arableCrop(row: Record<string, unknown>): Record<string, unknown> | undefined;
 export declare const ARABLE_LAND_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation-master-detail/field-cultivation-master-detail.component.d.ts

@@ -12,7 +12,7 @@ export declare class FieldCultivationMasterDetailComponent {
     readonly feedingRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
     readonly dispenseRows: import("@angular/core").Signal<FieldCultivationCropHarvest[]>;
     readonly activeTab: import("@angular/core").WritableSignal<FieldCultivationTab>;
-    readonly activeTabIndex: import("@angular/core").Signal<0 | 1 | 2 | 3>;
+    readonly activeTabIndex: import("@angular/core").Signal<1 | 0 | 2 | 3>;
     onTabChange(index: number): void;
     onGeneralChange(value: FieldCultivationData): void;
     /** Persists one crop-harvest table's rows (fed / dispensed harvests of the general tab). */

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation.types.d.ts

@@ -11,8 +11,12 @@ export interface FieldCultivationCropHarvest {
 export interface FieldCultivationBaseEntry {
     agronomicCropCategory?: string | null;
     userSpecificPlantName?: string | null;
-    isMainCrop?: boolean;
+    /** Null for CSC_OUTVG special crops — the main-crop concept does not apply to them. */
+    isMainCrop?: boolean | null;
     areaSize?: number | null;
+    /** Host-only display unit for areaSize ('m2' base, or custom e.g. 'ha') — persisted in
+     *  the dossier, converted to m2 and stripped before the planning POST (docs/custom-units.md). */
+    areaUnit?: string | null;
     yieldPerSquareMeasure?: number | null;
 }
 export interface FieldCultivationFodderCropland extends FieldCultivationBaseEntry {

package/dist/types/app/nutrient-cycle/field-cultivation/field-cultivation.util.d.ts

@@ -1,4 +1,8 @@
 import { FieldCultivationCropHarvest, FieldCultivationData, FieldCultivationDetailEntry, FieldCultivationDetailMode, FieldCultivationRequirementCorrection } from './field-cultivation.types';
+/** Subcategory whose special crops are never a main crop — `isMainCrop` must be null. */
+export declare const OUTDOOR_VEGETABLE_SUBCATEGORY = "CSC_OUTVG";
+/** True when the crop code belongs to the outdoor-vegetable subcategory (CSC_OUTVG). */
+export declare function isOutdoorVegetableCrop(cropCode: unknown): boolean;
 export declare function normalizeRequirementCorrection(source: Partial<FieldCultivationRequirementCorrection> | undefined): FieldCultivationRequirementCorrection;
 export declare function normalizeCropHarvestEntry(source: Partial<FieldCultivationCropHarvest> | undefined): FieldCultivationCropHarvest;
 export declare function normalizeFieldCultivationDetailEntry(mode: FieldCultivationDetailMode, source: Partial<FieldCultivationDetailEntry> | undefined): FieldCultivationDetailEntry;

package/dist/types/app/nutrient-cycle/field-cultivation/fodder-cropland-table/fodder-cropland-table.component.d.ts

@@ -21,7 +21,8 @@ export declare class FodderCroplandTableComponent {
     /**
      * Clears the yield whenever it stops being user-editable for the row (fodder-balance
      * calculation switched on, or new crop without yield input), so no stale value
-     * lingers under the now-disabled cell.
+     * lingers under the now-disabled cell. Requirement corrections are special-crops-only
+     * (SUIBIL-1143): strip them so they never reach the emitted JSON.
      */
-    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceFodderCroplandRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-cultivation/special-crops-table/special-crops-table.component.d.ts

@@ -19,11 +19,11 @@ export declare class SpecialCropsTableComponent {
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Domain rules applied on every edit:
-     *  - units of the managed nutrient slots are fixed (N2 in kg, corrections in %),
+     *  - the unit of the managed nutrient slots is fixed (corrections in %),
      *  - managed slots left empty are dropped (the API rejects null quantities),
-     *  - selecting a crop pre-fills Nmin from its standard N2 requirement and resets the
-     *    corrections to 100 %; clearing the crop (or picking one that forbids corrections)
-     *    removes the managed slots.
+     *  - CSC_OUTVG crops carry `isMainCrop: null` (not a main-crop concept),
+     *  - selecting a crop pre-fills the three corrections (P2O5/K2O/Mg) at 100 %;
+     *    clearing the crop removes the managed slots.
      */
-    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>, previousRow?: Record<string, unknown>) => Record<string, unknown>;
 }