@agridea/suibi-module 0.1.0-preview.9159a63 → 0.1.0-preview.ae6b6f9

package/dist/types/app/nutrient-cycle/field-cultivation/{field-cultivation-list.component.d.ts → field-cultivation-list/field-cultivation-list.component.d.ts}

@@ -1,4 +1,4 @@
-import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from './field-cultivation.types';
+import { FieldCultivationDetailEntry, FieldCultivationDetailMode } from '../field-cultivation.types';
 export declare class FieldCultivationListComponent {
     private readonly masterData;
     private readonly i18n;

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

@@ -0,0 +1,29 @@
+import { FieldCultivationTab } from '../../../core/navigation/navigation.service';
+import { CropHarvestTableKind } from '../crop-harvest-table/crop-harvest-table.config';
+import { FieldCultivationArableLand, FieldCultivationCropHarvest, FieldCultivationData, FieldCultivationFodderCropland, FieldCultivationSpecial } from '../field-cultivation.types';
+export declare class FieldCultivationMasterDetailComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    constructor();
+    readonly fieldCultivation: import("@angular/core").Signal<FieldCultivationData>;
+    readonly fodderCroplandRows: import("@angular/core").Signal<FieldCultivationFodderCropland[]>;
+    readonly arableLandRows: import("@angular/core").Signal<FieldCultivationArableLand[]>;
+    readonly specialRows: import("@angular/core").Signal<FieldCultivationSpecial[]>;
+    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>;
+    onTabChange(index: number): void;
+    onGeneralChange(value: FieldCultivationData): void;
+    /** Persists one crop-harvest table's rows (fed / dispensed harvests of the general tab). */
+    onCropHarvestRowsChange(kind: CropHarvestTableKind, rows: FieldCultivationCropHarvest[]): void;
+    /** Persists the fodder-cropland rows produced by the inline table (edit / add / delete). */
+    onFodderCroplandRowsChange(rows: FieldCultivationFodderCropland[]): void;
+    /** Persists the arable-land rows produced by the inline table (edit / add / delete). */
+    onArableRowsChange(rows: FieldCultivationArableLand[]): void;
+    /** Persists the special-crops rows produced by the inline table (edit / add / delete). */
+    onSpecialRowsChange(rows: FieldCultivationSpecial[]): void;
+    private patchRows;
+    private patchFieldCultivation;
+    private parseTab;
+}

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

@@ -18,6 +18,7 @@ export interface FieldCultivationBaseEntry {
 export interface FieldCultivationFodderCropland extends FieldCultivationBaseEntry {
     fieldName?: string | null;
     calculateYieldThroughFodderBalance?: boolean;
+    requirementCorrection?: FieldCultivationRequirementCorrection[];
 }
 export interface FieldCultivationArableLand extends FieldCultivationBaseEntry {
     hasLongTermYieldDivergence?: boolean;

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

@@ -0,0 +1,28 @@
+import { FieldCultivationFodderCropland } from '../field-cultivation.types';
+/**
+ * FodderCroplandTableComponent — thin wrapper around InlineTableComponent for the
+ * "Surface fourragère" tab: entries are edited directly in the table (no detail pane).
+ *
+ * Rows without a selected crop (freshly added) exist only in the local `uiRows`
+ * state and are emitted upstream once a crop is picked, so no empty rows ever
+ * reach the data store (fodder `uiRows` pattern). The rowTransform clears the
+ * yield whenever it is not user-editable for the row.
+ */
+export declare class FodderCroplandTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationFodderCropland[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationFodderCropland[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
+    /** Rows as last edited locally (may contain not-yet-committed empty rows); null = follow data. */
+    private readonly uiRows;
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    constructor();
+    onRowsChange(rows: Record<string, unknown>[]): void;
+    /**
+     * 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. 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>;
+}

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

@@ -0,0 +1,16 @@
+/**
+ * Column and section configuration for the fodder-cropland inline table
+ * ("Surface fourragère" tab).
+ *
+ * Replaces the former list + JSONForms detail pane: entries are edited directly
+ * in the table. `userSpecificPlantName` and `fieldName` stay in the data model
+ * (filled by imports/API) but are no longer editable in the UI.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/**
+ * Yield is user-editable only when the selected crop permits yield input AND the
+ * yield is not calculated through the fodder balance — mirrors the former
+ * `fieldCultivation_shouldShowYieldInput` constraint of the detail form.
+ */
+export declare function yieldNotEditable(row: Record<string, unknown>): boolean;
+export declare const FODDER_CROPLAND_TABLE_CONFIG: InlineTableConfig;

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

@@ -1,4 +1,9 @@
-export * from './field-cultivation-list.component';
-export * from './field-cultivation-detail.component';
-export * from './field-cultivation-master-detail.component';
+export * from './field-cultivation-list/field-cultivation-list.component';
+export * from './field-cultivation-detail/field-cultivation-detail.component';
+export * from './field-cultivation-general/field-cultivation-general.component';
+export * from './field-cultivation-master-detail/field-cultivation-master-detail.component';
+export * from './crop-harvest-table/crop-harvest-table.component';
+export * from './fodder-cropland-table/fodder-cropland-table.component';
+export * from './arable-land-table/arable-land-table.component';
+export * from './special-crops-table/special-crops-table.component';
 export * from './field-cultivation.types';

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

@@ -0,0 +1,29 @@
+import { FieldCultivationSpecial } from '../field-cultivation.types';
+/**
+ * SpecialCropsTableComponent — thin wrapper around InlineTableComponent for the
+ * "Cultures spéciales" tab: one table for the whole CULT_SPECIAL category.
+ *
+ * Rows without a selected crop (freshly added) exist only in the local `uiRows`
+ * state and are emitted upstream once a crop is picked, so no empty rows ever
+ * reach the data store (fodder `uiRows` pattern).
+ */
+export declare class SpecialCropsTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FieldCultivationSpecial[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldCultivationSpecial[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
+    /** Rows as last edited locally (may contain not-yet-committed empty rows); null = follow data. */
+    private readonly uiRows;
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    constructor();
+    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 %),
+     *  - 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.
+     */
+    readonly enforceSpecialCropRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * Column and section configuration for the special-crops inline table
+ * ("Cultures spéciales" tab).
+ *
+ * ONE table for the whole CULT_SPECIAL category: the crop dropdown reuses the
+ * `agronomicCropCategorySpecial` code list, which is already filtered on
+ * cultivationCategory === 'CULT_SPECIAL'. Nutrient columns live in the row's
+ * `requirementCorrection[]` sub-array: Nmin is the N2 slot in kg, the three
+ * corrections are the P2O5/K2O/Mg slots in %.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+/** Nmin maps to the N2 requirement-correction slot, always expressed in kg. */
+export declare const NMIN_FORMULA = "N2";
+export declare const NMIN_UNIT = "kg";
+/** Correction slots managed by the table, always expressed in % (100 % = no correction). */
+export declare const CORRECTION_FORMULAS: readonly ["P2O5", "K2O", "Mg"];
+export declare const CORRECTION_UNIT = "%";
+export declare const CORRECTION_DEFAULT = 100;
+/** Code list feeding the crop dropdown — the whole CULT_SPECIAL category. */
+export declare const SPECIAL_CROPS_CODE_LIST = "agronomicCropCategorySpecial";
+/** Crop ids permitted in the table — every CULT_SPECIAL entry of the master data. */
+export declare const SPECIAL_CROPS_IDS: Set<string>;
+/** Looks up a crop entry in the table's code list. */
+export declare function specialCropEntry(id: unknown): Record<string, unknown> | undefined;
+/**
+ * Nutrient columns are read-only unless the selected crop has the
+ * `isPermittedForRequirementCorrection` flag: without it, the pre-filled Nmin and
+ * correction values are fixed defaults from master data and must not be user-editable.
+ */
+export declare function nutrientColumnsLocked(crop: Record<string, unknown> | undefined): boolean;
+/**
+ * Applies the crop's defaults to the requirement-correction slots.
+ * - If the crop does NOT permit requirement corrections (or none is selected): the
+ *   managed slots are removed entirely — nothing is editable and nothing is sent to the API.
+ * - If the crop DOES permit them: the managed slots are pre-filled from the crop's
+ *   master-data `requirement` (N2 in kg; P2O5/K2O/Mg in %) and stay user-editable.
+ */
+export declare function applyCropDefaults(row: Record<string, unknown>, crop: Record<string, unknown> | undefined): Record<string, unknown>;
+/**
+ * Normalizes the managed requirement-correction slots on every edit: fixed units
+ * (N2 → kg, corrections → %) and removal of managed entries left without a quantity
+ * (the API rejects present-but-null quantities).
+ */
+export declare function normalizeManagedCorrections(row: Record<string, unknown>): Record<string, unknown>;
+/**
+ * Shared column definitions for the requirement-correction sub-array (Nmin + P2O5/K2O/Mg),
+ * reusable across fodder, arable and special tables. `lockRow` disables editing per row.
+ */
+export declare function requirementCorrectionColumns(lockRow: (row: Record<string, unknown>) => boolean): InlineTableConfig['columns'];
+export declare const SPECIAL_CROPS_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-spreading/fertiliser-table/fertiliser-table.component.d.ts

@@ -1,3 +1,4 @@
+import { InlineColumnDef } from '../../../components/inline-table/inline-table.types';
 import { FieldSpreadingFertiliserEntry } from '../field-spreading.types';
 /**
  * FertiliserTableComponent — thin wrapper around InlineTableComponent.
@@ -17,17 +18,25 @@ import { FieldSpreadingFertiliserEntry } from '../field-spreading.types';
  *   3. The generic InlineTableComponent requires no changes.
  */
 export declare class FertiliserTableComponent {
+    private readonly i18n;
     readonly entries: import("@angular/core").InputSignal<FieldSpreadingFertiliserEntry[]>;
     readonly entriesChange: import("@angular/core").OutputEmitterRef<FieldSpreadingFertiliserEntry[]>;
+    /** Row index to highlight after a validation-error deep-link (forwarded to the table). */
+    readonly highlightRowIndex: import("@angular/core").InputSignal<number | null>;
     /** Column/section config exposed to the template (constant — no signal needed). */
     protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
     /** Cast typed entries to the generic Record[] expected by InlineTableComponent. */
     readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
-    /** Cast the generic output back to the typed FieldSpreadingFertiliserEntry[]. */
+    /** Cast the generic output back to the typed FieldSpreadingFertiliserEntry[], stripping any
+     *  ingredient with a 0 quantity so it never reaches the final JSON. */
     onRowsChange(rows: Record<string, unknown>[]): void;
     /**
      * Row transform for auto-populating nutrient columns when a product is selected.
      *
+     * Also imposes `transactionUnit = 'kg'` on every edit (not just product changes) so
+     * stale/imported rows with a different or null unit get corrected once touched —
+     * `createRow` already defaults new rows to 'kg', this is only a safety net.
+     *
      * Defined as an arrow-function property so `this` is never needed and the function
      * can be passed as a value to InlineTableComponent without losing its context.
      *
@@ -35,4 +44,12 @@ export declare class FertiliserTableComponent {
      * edits pass through unchanged.
      */
     readonly autoPopulateNutrients: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+    /**
+     * Per-cell validation for the nutrient % columns: each value capped at 100 %
+     * and the sum of the four ingredients capped at 100 % per row.
+     * The inline table bypasses JSONForms/AJV, so these rules (mirroring the
+     * `maximum` / `proportionSum` keywords in schema.json) must be surfaced
+     * visually here — the global validation panel alone is not visible while typing.
+     */
+    readonly nutrientCellError: (row: Record<string, unknown>, col: InlineColumnDef) => string | null;
 }

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

@@ -5,6 +5,8 @@ export declare class FieldSpreadingComponent {
     private readonly navigationSvc;
     private readonly i18n;
     constructor();
+    /** Fertiliser row to highlight (set by validation deep-links, cleared by the next one). */
+    readonly highlightedFertiliserIndex: import("@angular/core").WritableSignal<number | null>;
     readonly schema: import("@angular/core").Signal<JsonSchema>;
     readonly localizedGeneralUi: import("@angular/core").Signal<import("@jsonforms/core").UISchemaElement>;
     readonly renderers: {

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

@@ -23,6 +23,7 @@ export interface FieldSpreadingIngredient {
     unit?: string | null;
 }
 export interface FieldSpreadingFertiliserEntry {
+    descriptor?: string | null;
     fertiliserProductCategory?: string | null;
     quantity?: number | null;
     transactionUnit?: string | null;

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

@@ -0,0 +1,8 @@
+import { FieldSpreadingIngredient } from './field-spreading.types';
+/**
+ * Ensures all ingredients are present in the output, converting `null` quantities to `0`
+ * to satisfy API requirements while still filtering out explicitly zeroed entries.
+ */
+export declare function stripZeroQuantityIngredients<T extends {
+    ingredient?: FieldSpreadingIngredient[];
+}>(entries: T[]): T[];

package/dist/types/app/nutrient-cycle/field-spreading/recycling-table/recycling-table.component.d.ts

@@ -6,9 +6,10 @@ import { FieldSpreadingRecyclingEntry } from '../field-spreading.types';
  *   1. Provides `RECYCLING_TABLE_CONFIG` (the column/section "uischema").
  *   2. Bridges typed `FieldSpreadingRecyclingEntry[]` to/from the generic
  *      `Record<string, unknown>[]` API of InlineTableComponent.
- *
- * Unlike FertiliserTableComponent, no `rowTransform` is needed here — recycling
- * products have no auto-population logic; all nutrient values are entered manually.
+ *   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) — they are separate mappings, NOT a concatenation of
+ *      one into the other (kg/kg would be wrong for solid products).
  */
 export declare class RecyclingTableComponent {
     readonly entries: import("@angular/core").InputSignal<FieldSpreadingRecyclingEntry[]>;
@@ -17,6 +18,14 @@ export declare class RecyclingTableComponent {
     protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
     /** Cast typed entries to generic Record[] for InlineTableComponent. */
     readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
-    /** Cast generic output back to typed FieldSpreadingRecyclingEntry[]. */
+    /** Cast generic output back to typed FieldSpreadingRecyclingEntry[], stripping any
+     *  ingredient with a 0 quantity so it never reaches the final JSON. */
     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.
+     */
+    readonly deriveUnits: (_changedKey: string, _newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
 }

package/dist/types/app/nutrient-cycle/field-spreading/recycling-table/recycling-table.config.d.ts

@@ -4,13 +4,14 @@
  * This is the "uischema" for the Recycling fertilisers tab.
  * The structure mirrors fertiliser-table.config.ts — only the columns differ:
  *   - Product field: typeOfManureRecyclingProduct (different code list)
- *   - Nutrient columns: Ntot, NSol, P₂O₅, K₂O, Mg expressed in kg/unit (not %)
+ *   - Nutrient columns: Ntot, Nlos, P₂O₅, K₂O, Mg expressed in kg/unit (not %)
  *     — 5 nutrients vs 4 for mineral fertilisers, no auto-population on product select.
  *
  * To adapt again for a new domain, copy this file and adjust columns + i18n keys.
  */
 import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
-/** Nutrient formulas tracked per recycling entry, in display order. */
-export declare const RECYCLING_NUTRIENT_COLUMNS: readonly ["Ntot", "NSol", "P2O5", "K2O", "Mg"];
+/** Nutrient formulas tracked per recycling entry, in display order. 'Nlos' = soluble nitrogen (matches the
+ *  `molecularFormula` enum from assets/master-data/substances.json — NOT 'NSol', which the API rejects). */
+export declare const RECYCLING_NUTRIENT_COLUMNS: readonly ["Ntot", "Nlos", "P2O5", "K2O", "Mg"];
 export type RecyclingNutrientFormula = (typeof RECYCLING_NUTRIENT_COLUMNS)[number];
 export declare const RECYCLING_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/field-spreading/recycling-table/recycling-transaction-unit.util.d.ts

@@ -0,0 +1,4 @@
+/** Derives the mandatory transaction unit ('kg' or 'm3') from the product's matterState. */
+export declare function deriveRecyclingTransactionUnit(productCode: string | null | undefined): string | null;
+/** Derives the mandatory ingredient unit ('kg/t' or 'kg/m3') from the product's matterState. */
+export declare function deriveRecyclingIngredientUnit(productCode: string | null | undefined): string | null;

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

@@ -0,0 +1,25 @@
+import { FodderCropFromNonFodderCropland, FodderDispense, FodderSupply, FodderTableRow } from '../fodder.types';
+export declare class FodderMasterDetailComponent {
+    private readonly dataSvc;
+    private readonly navigationSvc;
+    constructor();
+    readonly supplyRows: import("@angular/core").Signal<FodderSupply[]>;
+    readonly dispenseRows: import("@angular/core").Signal<FodderDispense[]>;
+    readonly nonFodderCroplandRows: import("@angular/core").Signal<FodderCropFromNonFodderCropland[]>;
+    readonly proportionStorageLoss: import("@angular/core").Signal<number | undefined>;
+    readonly totalBalanceErrorMargin: import("@angular/core").Signal<number | undefined>;
+    /** Rows in the order last produced by the table (local UI order); null = follow the data. */
+    private readonly uiRows;
+    /** Data-derived merged list: supply block, then dispense, then non-fodder cropland. */
+    private readonly dataRows;
+    /** Rows shown in the table. The local UI order wins so that adding a row or changing its
+     *  type never reshuffles the list under the user's hands. */
+    readonly rows: import("@angular/core").Signal<FodderTableRow[]>;
+    /** Persists the edited rows (split back into their three collections) while keeping the
+     *  emitted order as the local UI order. */
+    onRowsChange(rows: FodderTableRow[]): void;
+    onScalarInput(field: 'proportionStorageLoss' | 'totalBalanceErrorMargin', event: Event): void;
+    scalarInputValue(value: number | undefined): string;
+    private cloneFodder;
+    private cloneTrading;
+}

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

@@ -0,0 +1,26 @@
+import { FodderTableRow } from '../fodder.types';
+/**
+ * FodderTableComponent — thin wrapper around InlineTableComponent for the merged fodder table
+ * (supply / dispense / non-fodder cropland in one table, distinguished per row via `rowKind`).
+ * The config provides the columns; the rowTransform imposes the fixed units (transactionUnit
+ * 'kg', dry-matter ingredient T/S in '%') and keeps the product compatible with the row kind.
+ */
+export declare class FodderTableComponent {
+    readonly entries: import("@angular/core").InputSignal<FodderTableRow[]>;
+    readonly entriesChange: import("@angular/core").OutputEmitterRef<FodderTableRow[]>;
+    /** Column/section config (constant — no signal needed). */
+    protected readonly config: import("../../../components/inline-table/inline-table.types").InlineTableConfig;
+    /** Cast typed entries to the generic Record[] expected by InlineTableComponent. */
+    readonly rowsForTable: import("@angular/core").Signal<Record<string, unknown>[]>;
+    onRowsChange(rows: Record<string, unknown>[]): void;
+    /**
+     * Domain rules applied on every edit:
+     *  - `rowKind` change: normalize unknown/cleared values to 'supply' and clear the product
+     *    when it is not permitted for the new kind.
+     *  - Product change: pre-fill the dry matter share (T/S %) with the product's
+     *    `standardDryMatterContent` (stays editable afterwards; null when none is defined).
+     *  - Units are fixed, never user-entered: quantity is always transacted in kg and the only
+     *    permitted ingredient is dry matter (T/S) expressed in % — re-appended when missing.
+     */
+    readonly enforceFodderRules: (changedKey: string, newValue: unknown, row: Record<string, unknown>) => Record<string, unknown>;
+}

package/dist/types/app/nutrient-cycle/fodder/fodder-table/fodder-table.config.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Column and section configuration for the single fodder inline table.
+ *
+ * The three former mode tabs (supply / dispense / non-fodder cropland) are merged into one
+ * table: each row picks its kind via the `rowKind` select column, and the product dropdown
+ * is narrowed per row to the products permitted for that kind.
+ */
+import type { InlineTableConfig } from '../../../components/inline-table/inline-table.types';
+export declare const FODDER_TABLE_CONFIG: InlineTableConfig;

package/dist/types/app/nutrient-cycle/fodder/fodder.types.d.ts

@@ -25,3 +25,10 @@ export interface FodderData {
     proportionStorageLoss?: number;
     totalBalanceErrorMargin?: number;
 }
+/** UI-only discriminator telling which fodder collection a table row belongs to. */
+export type FodderRowKind = 'supply' | 'dispense' | 'non_fodder_cropland';
+/** Row shape used by the inline fodder table: a trading entry tagged with its row kind.
+ *  `rowKind` is stripped again when the rows are written back to the data model. */
+export type FodderTableRow = FodderTradingEntry & {
+    rowKind: FodderRowKind;
+};

package/dist/types/app/nutrient-cycle/fodder/index.d.ts

@@ -1,4 +1,3 @@
-export * from './fodder-list.component';
-export * from './fodder-detail.component';
-export * from './fodder-master-detail.component';
+export * from './fodder-table/fodder-table.component';
+export * from './fodder-master-detail/fodder-master-detail.component';
 export * from './fodder.types';

package/dist/types/app/nutrient-cycle/fodder/ingredient.util.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Dry matter (Trockensubstanz, T/S) is the only ingredient formula permitted for fodder
+ * entries (see `fodderMolecularFormula` in code-lists.ts) and its only allowed unit is '%'
+ * (assets/master-data/substances.json → S.1007.1). Both are imposed, never user-picked.
+ */
+export declare const FODDER_INGREDIENT_FORMULA = "T/S";
+export declare const FODDER_INGREDIENT_UNIT = "%";
+export declare function deriveFodderIngredientUnit(): string;

package/dist/types/app/nutrient-cycle/storage/index.d.ts

@@ -1,4 +1,4 @@
-export * from './storage-list.component';
-export * from './storage-detail.component';
-export * from './storage-master-detail.component';
+export * from './storage-list/storage-list.component';
+export * from './storage-detail/storage-detail.component';
+export * from './storage-master-detail/storage-master-detail.component';
 export * from './storage.types';

package/dist/types/app/nutrient-cycle/storage/{storage-detail.component.d.ts → storage-detail/storage-detail.component.d.ts}

@@ -1,5 +1,5 @@
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
-import { ManurePitEntry, SlurryTankEntry, StorageEntryType } from './storage.types';
+import { ManurePitEntry, SlurryTankEntry, StorageEntryType } from '../storage.types';
 export declare class StorageDetailComponent {
     private readonly i18n;
     readonly type: import("@angular/core").InputSignal<StorageEntryType>;
@@ -17,7 +17,7 @@ export declare class StorageDetailComponent {
     readonly jsonFormsData: import("@angular/core").Signal<(({
         descriptor?: string;
         cover?: number | null;
-        manureFromAnimalStockStored?: import("./storage.types").ManureFromAnimalStockStored[];
+        manureFromAnimalStockStored?: import("..").ManureFromAnimalStockStored[];
     } | {
         descriptor?: string;
         volumeInM3?: number | null;
@@ -25,6 +25,6 @@ export declare class StorageDetailComponent {
         cover?: number | null;
         mixingFrequency?: number | null;
         manureDerivation?: string[];
-    }) & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    }) & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     onDataChange(event: unknown): void;
 }

package/dist/types/app/nutrient-cycle/storage/{storage-general.component.d.ts → storage-general/storage-general.component.d.ts}

@@ -1,5 +1,5 @@
 import { JsonSchema, UISchemaElement } from '@jsonforms/core';
-import { StorageNormalized } from './storage.types';
+import { StorageNormalized } from '../storage.types';
 type StorageSection = 'manure' | 'slurry' | 'slurryFacilityToggle' | 'general';
 export declare class StorageGeneralComponent {
     private readonly i18n;
@@ -17,13 +17,13 @@ export declare class StorageGeneralComponent {
         stableStrawLitter: number | null;
         manureSupplyProportionStored: number | null;
         createFacilitySpecificManureProduct: boolean;
-    } & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | ({
+    } & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | ({
         createFacilitySpecificSlurryProduct: boolean;
-    } & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | ({
+    } & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | ({
         slurrySupplyProportionStored: number | null;
         slurryTankQuantity: number | null;
         dilutionRatio: number | null;
-    } & import("../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
+    } & import("../../../core/schemas/ui-helper-registry").UiHelperDefinitions) | null>;
     onDataChange(event: unknown): void;
 }
 export {};

package/dist/types/app/nutrient-cycle/storage/{storage-list.component.d.ts → storage-list/storage-list.component.d.ts}

@@ -1,10 +1,11 @@
-import { ManurePitEntry, SlurryTankEntry, StorageEntryType } from './storage.types';
+import { ManurePitEntry, SlurryTankEntry, StorageEntryType } from '../storage.types';
 export declare class StorageListComponent {
     private readonly i18n;
     private readonly masterData;
     readonly rows: import("@angular/core").InputSignal<(ManurePitEntry | SlurryTankEntry)[]>;
     readonly selectedIndex: import("@angular/core").InputSignal<number | null>;
     readonly type: import("@angular/core").InputSignal<StorageEntryType>;
+    readonly errorIndices: import("@angular/core").InputSignal<ReadonlySet<number>>;
     readonly select: import("@angular/core").OutputEmitterRef<number>;
     readonly add: import("@angular/core").OutputEmitterRef<void>;
     readonly delete: import("@angular/core").OutputEmitterRef<number>;
@@ -12,6 +13,8 @@ export declare class StorageListComponent {
     readonly headerName: import("@angular/core").Signal<string>;
     readonly headerMeta: import("@angular/core").Signal<string>;
     resolveName(row: ManurePitEntry | SlurryTankEntry, index: number): string;
+    rowHasError(index: number): boolean;
+    rowErrorLabel(): string;
     resolveMeta(row: ManurePitEntry | SlurryTankEntry): string;
     emptyLabel(): string;
     emptyHintLabel(): string;

package/dist/types/app/nutrient-cycle/storage/{storage-master-detail.component.d.ts → storage-master-detail/storage-master-detail.component.d.ts}

@@ -1,8 +1,9 @@
-import { StorageTab } from '../../core/navigation/navigation.service';
-import { ManurePitEntry, SlurryTankEntry, StorageEntryType, StorageNormalized } from './storage.types';
+import { StorageTab } from '../../../core/navigation/navigation.service';
+import { ManurePitEntry, SlurryTankEntry, StorageEntryType, StorageNormalized } from '../storage.types';
 export declare class StorageMasterDetailComponent {
     private readonly dataSvc;
     private readonly navigationSvc;
+    private readonly globalValidation;
     constructor();
     readonly storage: import("@angular/core").Signal<StorageNormalized>;
     readonly manurePitRows: import("@angular/core").Signal<ManurePitEntry[]>;
@@ -11,6 +12,8 @@ export declare class StorageMasterDetailComponent {
     readonly selectedIndex: import("@angular/core").WritableSignal<number | null>;
     readonly manureFacilitySpecificEnabled: import("@angular/core").Signal<boolean>;
     readonly slurryFacilitySpecificEnabled: import("@angular/core").Signal<boolean>;
+    readonly manurePitErrorIndices: import("@angular/core").Signal<Set<number>>;
+    readonly slurryTankErrorIndices: import("@angular/core").Signal<Set<number>>;
     readonly detailOpen: import("@angular/core").Signal<boolean>;
     readonly detailType: import("@angular/core").Signal<StorageEntryType>;
     readonly currentDetail: import("@angular/core").Signal<ManurePitEntry | SlurryTankEntry | null>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agridea/suibi-module",
-  "version": "0.1.0-preview.9159a63",
+  "version": "0.1.0-preview.ae6b6f9",
   "scripts": {
     "ng": "ng",
     "start": "ng serve",