@adcops/autocore-react 3.3.83 → 3.3.85

package/src/components/ams/AssetEditDialog.tsx

@@ -0,0 +1,800 @@
+/*
+ * <AssetEditDialog> — modal for editing an existing asset.
+ *
+ * Two tabs:
+ *   1. "Asset" — role, nameplate (custom fields), and per-axis
+ *      sub_locations matrix. Posts via `ams.update_asset`.
+ *   2. "Calibration" — performed_by, expires_at, cert_ref, notes, and
+ *      the calibration values (flat or per-axis). Enabled only when
+ *      `asset.current_calibration_id` is non-null. Posts via
+ *      `ams.update_calibration` (server enforces "current only"). Tab
+ *      is hidden entirely for assets that never had a calibration —
+ *      "+ Calibration" on <AssetDetailView> is the path to add one.
+ *
+ * The server treats `asset_id`, `asset_type`, `serial`, and
+ * `install_date` as immutable; the read-only header strip mirrors
+ * that. Status stays out of this dialog because the Retire button on
+ * <AssetDetailView> already owns that transition.
+ *
+ * Save commits the Asset tab first, then (if a calibration is loaded)
+ * the Calibration tab. Either failure surfaces inline and stops; the
+ * dialog stays open so the operator can fix the input and retry.
+ *
+ * Sibling <CalibrationEntryDialog> still covers add-new-calibration
+ * and the in-place edit launched from the History table's pencil
+ * icon — this dialog overlaps the latter on purpose, since operators
+ * naturally expect calibration metadata to live alongside the asset
+ * they're editing.
+ */
+
+import React, { useContext, useEffect, useMemo, useState } from 'react';
+import { Button } from 'primereact/button';
+import { Calendar } from 'primereact/calendar';
+import { Dialog } from 'primereact/dialog';
+import { Dropdown } from 'primereact/dropdown';
+import { InputText } from 'primereact/inputtext';
+import { InputTextarea } from 'primereact/inputtextarea';
+import { TabPanel, TabView } from 'primereact/tabview';
+import { EventEmitterContext } from '../../core/EventEmitterContext';
+import { MessageType } from '../../hub/CommandMessage';
+import { useAms, type AmsRole } from './AmsProvider';
+
+// Sentinel: keeps the Role dropdown consistent with the Add dialog's
+// "Other..." escape hatch so operators can move an asset to a custom
+// role that isn't declared in project.json.
+const ROLE_OTHER = '__other__';
+
+interface SchemaField {
+    name: string;
+    type: string;
+    units?: string;
+    label?: string;
+    description?: string;
+    required?: boolean;
+}
+
+interface SubLocationsSchema {
+    label?: string;
+    key_label?: string;
+    keys: string[];
+    fields: SchemaField[];
+    calibration_fields?: SchemaField[];
+}
+
+export interface AssetEditDialogProps {
+    visible: boolean;
+    /** Full asset record as returned by `ams.read_asset`. The dialog
+     *  pre-seeds every editable input from this; on submit it pins
+     *  asset_id from here onto the update_asset call. */
+    asset: any | null;
+    onHide: () => void;
+    /** Fires after a successful update so the parent can refresh. */
+    onSaved?: () => void;
+}
+
+function fieldsFor(schemas: any, assetType: string): SchemaField[] {
+    const arr = schemas?.[assetType]?.fields;
+    return Array.isArray(arr) ? arr as SchemaField[] : [];
+}
+
+function subLocationsFor(schemas: any, assetType: string): SubLocationsSchema | null {
+    const sl = schemas?.[assetType]?.sub_locations;
+    if (!sl || !Array.isArray(sl.keys) || !Array.isArray(sl.fields)) return null;
+    return sl as SubLocationsSchema;
+}
+
+/** Flat top-level calibration_fields declared on the asset_type, if any.
+ *  Empty array when the type uses the per-axis form or declares no
+ *  calibration values at all. */
+function calibrationFieldsFor(schemas: any, assetType: string): SchemaField[] {
+    const arr = schemas?.[assetType]?.calibration_fields;
+    return Array.isArray(arr) ? arr as SchemaField[] : [];
+}
+
+/** Per-axis calibration_fields declared on the asset_type's
+ *  sub_locations schema, if any. The asset_type uses *one* of:
+ *  flat top-level `calibration_fields`, or per-axis
+ *  `sub_locations.calibration_fields`. We render whichever is
+ *  non-empty (top-level wins on collision since
+ *  CalibrationEntryDialog handles them the same way). */
+function perAxisCalibrationFieldsFor(
+    sub: SubLocationsSchema | null,
+): SchemaField[] {
+    return (sub?.calibration_fields ?? []) as SchemaField[];
+}
+
+/** Coerce a per-cell string back to the field's declared type.
+ *  Mirrors the Add dialog's helper so empty strings drop out, numbers
+ *  come back as JSON numbers, bools as bools. */
+function coerceField(field: SchemaField, raw: string): any {
+    if (raw === undefined || raw === '') return undefined;
+    switch (field.type) {
+        case 'f32': case 'f64':
+        case 'i8': case 'i16': case 'i32': case 'i64':
+        case 'u8': case 'u16': case 'u32': case 'u64': {
+            const n = Number(raw);
+            return Number.isFinite(n) ? n : undefined;
+        }
+        case 'bool':
+            return raw === 'true' || raw === '1';
+        default:
+            return raw;
+    }
+}
+
+/** Default a field's input from whatever's in the asset's custom blob.
+ *  Numbers / bools serialize back to strings for the text inputs to
+ *  consume; missing values become "". */
+function seedFromCustom(custom: Record<string, any> | undefined, name: string): string {
+    if (!custom) return '';
+    const v = custom[name];
+    if (v === undefined || v === null) return '';
+    return String(v);
+}
+
+export const AssetEditDialog: React.FC<AssetEditDialogProps> = ({
+    visible, asset, onHide, onSaved,
+}) => {
+    const { schemas, roles, readCalibration } = useAms();
+    const { invoke } = useContext(EventEmitterContext);
+
+    const assetType = asset?.asset_type ?? '';
+    const fields = useMemo(() => fieldsFor(schemas, assetType), [schemas, assetType]);
+    const subLocationsSchema = useMemo(
+        () => subLocationsFor(schemas, assetType), [schemas, assetType],
+    );
+    const calibrationFields = useMemo(
+        () => calibrationFieldsFor(schemas, assetType), [schemas, assetType],
+    );
+    const perAxisCalibrationFields = useMemo(
+        () => perAxisCalibrationFieldsFor(subLocationsSchema), [subLocationsSchema],
+    );
+    /** Asset has per-axis calibration if its sub_locations schema
+     *  declares calibration_fields. Otherwise it's flat (or has no
+     *  cal values at all). Mirrors the rule CalibrationEntryDialog
+     *  uses to pick its UI mode. */
+    const isPerAxisCalibration = perAxisCalibrationFields.length > 0;
+    const hasAnyCalibrationFields =
+        isPerAxisCalibration || calibrationFields.length > 0;
+    const rolesForType: AmsRole[] = useMemo(
+        () => (assetType ? roles[assetType] ?? [] : []),
+        [assetType, roles],
+    );
+    const typeHasRoles = rolesForType.length > 0;
+
+    const roleDropdownOptions = useMemo(() => {
+        const opts = rolesForType.map(r => ({
+            label: r.label ?? r.location, value: r.location,
+        }));
+        opts.push({ label: 'Other (advanced — type a custom role)', value: ROLE_OTHER });
+        return opts;
+    }, [rolesForType]);
+
+    // Form state — kept local to the dialog so editing one asset
+    // doesn't leak into the next open. Seeded inside the `visible`
+    // effect below.
+    const [roleSelection, setRoleSelection] = useState<string>('');
+    const [location, setLocation] = useState<string>('');
+    const [customFields, setCustomFields] =
+        useState<Record<string, string>>({});
+    const [subLocationFields, setSubLocationFields] =
+        useState<Record<string, Record<string, string>>>({});
+    const [submitting, setSubmitting] = useState(false);
+    const [error, setError] = useState<string | null>(null);
+
+    // Active tab. Defaults to the Asset tab on open. Stored in state
+    // so a parent re-render doesn't reset it while the operator is
+    // mid-edit on the Calibration tab.
+    const [activeTab, setActiveTab] = useState<number>(0);
+
+    // ── Calibration tab state ────────────────────────────────────────
+    // Loaded from `ams.read_calibration` when the dialog opens and the
+    // asset has a current calibration. `null` means "no current cal —
+    // tab is hidden." The operator can edit the meta fields and the
+    // values; on Save we POST `ams.update_calibration` with the
+    // current cal_id pinned. The server enforces that this matches
+    // the asset's current_calibration_id, so the tab only ever edits
+    // the cal currently in effect — older history is frozen.
+    const [calRecord, setCalRecord] = useState<any | null>(null);
+    const [calPerformedBy, setCalPerformedBy] = useState<string>('');
+    const [calExpiresAt, setCalExpiresAt] = useState<Date | null>(null);
+    const [calCertRef, setCalCertRef] = useState<string>('');
+    const [calNotes, setCalNotes] = useState<string>('');
+    /** Flat-schema cal values, e.g. `{ scale: 9.81, offset: 0 }`. */
+    const [calValues, setCalValues] = useState<Record<string, string>>({});
+    /** Per-axis cal matrix, `{ fx: { scale: "9.81", offset: "0" }, ... }`. */
+    const [calPerAxisValues, setCalPerAxisValues] =
+        useState<Record<string, Record<string, string>>>({});
+
+    // Seed every input from the asset when the dialog opens. Re-seeds
+    // on every open so editing one asset, cancelling, then opening
+    // another doesn't carry the previous values forward.
+    useEffect(() => {
+        if (!visible || !asset) return;
+        setError(null);
+        setSubmitting(false);
+        setActiveTab(0);
+
+        // Role: pick the dropdown option when the asset's location
+        // matches a declared role; otherwise route into ROLE_OTHER so
+        // the operator can keep the current custom string.
+        const loc = typeof asset.location === 'string' ? asset.location : '';
+        const declaredHit = rolesForType.find(r => r.location === loc);
+        if (loc === '') {
+            setRoleSelection('');
+            setLocation('');
+        } else if (declaredHit) {
+            setRoleSelection(loc);
+            setLocation(loc);
+        } else {
+            setRoleSelection(ROLE_OTHER);
+            setLocation(loc);
+        }
+
+        // Nameplate: stringify each declared field's current value.
+        const seededCustom: Record<string, string> = {};
+        for (const f of fields) {
+            seededCustom[f.name] = seedFromCustom(asset.custom, f.name);
+        }
+        setCustomFields(seededCustom);
+
+        // Per-axis matrix: same treatment, walking each declared key
+        // and each declared field.
+        const seededSub: Record<string, Record<string, string>> = {};
+        if (subLocationsSchema) {
+            const subSrc = (asset.sub_locations && typeof asset.sub_locations === 'object')
+                ? asset.sub_locations as Record<string, any> : {};
+            for (const key of subLocationsSchema.keys) {
+                const row = (subSrc[key] && typeof subSrc[key] === 'object')
+                    ? subSrc[key] as Record<string, any> : {};
+                const seededRow: Record<string, string> = {};
+                for (const f of subLocationsSchema.fields) {
+                    const v = row[f.name];
+                    seededRow[f.name] = (v === undefined || v === null) ? '' : String(v);
+                }
+                seededSub[key] = seededRow;
+            }
+        }
+        setSubLocationFields(seededSub);
+
+        // ── Calibration tab: load the current cal record (if any)
+        //    and seed every input from it. Wiped between opens by the
+        //    initial setters below — handles "asset has no cal" and
+        //    "edit a different asset" cleanly without leftover state.
+        setCalRecord(null);
+        setCalPerformedBy('');
+        setCalExpiresAt(null);
+        setCalCertRef('');
+        setCalNotes('');
+        setCalValues({});
+        setCalPerAxisValues({});
+
+        const calId = typeof asset.current_calibration_id === 'string'
+            ? asset.current_calibration_id : '';
+        if (!calId) return;
+
+        let cancelled = false;
+        (async () => {
+            const rec = await readCalibration(asset.asset_id, calId);
+            if (cancelled || !rec) return;
+            setCalRecord(rec);
+            setCalPerformedBy(typeof rec.performed_by === 'string' ? rec.performed_by : '');
+            setCalCertRef(typeof rec.cert_ref === 'string' ? rec.cert_ref : '');
+            setCalNotes(typeof rec.notes === 'string' ? rec.notes : '');
+            setCalExpiresAt(rec.expires_at ? new Date(rec.expires_at) : null);
+
+            // Cal values come in the same shape we render. For a
+            // per-axis schema, we expect `values.<key>.<field>`; for
+            // a flat schema, `values.<field>` directly.
+            const values = (rec.values && typeof rec.values === 'object')
+                ? rec.values as Record<string, any> : {};
+            if (isPerAxisCalibration && subLocationsSchema) {
+                const seededPa: Record<string, Record<string, string>> = {};
+                for (const key of subLocationsSchema.keys) {
+                    const row = (values[key] && typeof values[key] === 'object')
+                        ? values[key] as Record<string, any> : {};
+                    const r: Record<string, string> = {};
+                    for (const f of perAxisCalibrationFields) {
+                        const v = row[f.name];
+                        r[f.name] = (v === undefined || v === null) ? '' : String(v);
+                    }
+                    seededPa[key] = r;
+                }
+                setCalPerAxisValues(seededPa);
+            } else {
+                const seededFlat: Record<string, string> = {};
+                for (const f of calibrationFields) {
+                    const v = values[f.name];
+                    seededFlat[f.name] = (v === undefined || v === null) ? '' : String(v);
+                }
+                setCalValues(seededFlat);
+            }
+        })();
+        return () => { cancelled = true; };
+    }, [
+        visible, asset, fields, subLocationsSchema, rolesForType,
+        calibrationFields, perAxisCalibrationFields, isPerAxisCalibration,
+        readCalibration,
+    ]);
+
+    const onRoleChange = (value: string) => {
+        if (value === ROLE_OTHER) {
+            setRoleSelection(ROLE_OTHER);
+            // Keep whatever string is currently in `location` so the
+            // operator can tweak it rather than retyping.
+        } else {
+            setRoleSelection(value);
+            setLocation(value);
+        }
+    };
+
+    const onSubmit = async () => {
+        if (!asset?.asset_id) return;
+        setSubmitting(true);
+        setError(null);
+
+        // Build `custom` from the current input map, coercing each
+        // value back to its declared JSON type. Empty inputs drop out
+        // so the asset.json doesn't carry empty strings that the
+        // placeholder resolver would treat as "missing".
+        const custom: Record<string, any> = {};
+        for (const field of fields) {
+            const raw = customFields[field.name];
+            const coerced = coerceField(field, raw ?? '');
+            if (coerced !== undefined) custom[field.name] = coerced;
+        }
+
+        // Per-axis matrix: only included when the asset_type declares
+        // a keyed-fields schema. Empty cells drop out per-axis; the
+        // server re-validates with a per-key, per-field problem list
+        // and we surface that error inline if anything's wrong.
+        let subLocations: Record<string, Record<string, any>> | undefined;
+        if (subLocationsSchema) {
+            subLocations = {};
+            for (const key of subLocationsSchema.keys) {
+                const row: Record<string, any> = {};
+                for (const field of subLocationsSchema.fields) {
+                    const raw = subLocationFields[key]?.[field.name] ?? '';
+                    const coerced = coerceField(field, raw);
+                    if (coerced !== undefined) row[field.name] = coerced;
+                }
+                subLocations[key] = row;
+            }
+        }
+
+        const payload: any = {
+            asset_id: asset.asset_id,
+            location,
+            custom,
+        };
+        if (subLocations) payload.sub_locations = subLocations;
+
+        try {
+            const resp: any = await invoke(
+                'ams.update_asset' as any, MessageType.Request, payload,
+            );
+            if (!resp?.success) {
+                setError(resp?.error_message ?? 'update_asset failed');
+                return;
+            }
+
+            // If a calibration is loaded, save it too. Sequential is
+            // intentional — if the asset update succeeded but cal
+            // failed, the operator should retry the cal alone rather
+            // than re-submit the asset. The server enforces "cal_id
+            // must equal current_calibration_id", which guards against
+            // a stale dialog editing a cal that's since been replaced.
+            if (calRecord) {
+                const calPayload: any = {
+                    asset_id: asset.asset_id,
+                    cal_id:   calRecord.cal_id,
+                    performed_by: calPerformedBy,
+                    expires_at:   calExpiresAt ? calExpiresAt.toISOString() : null,
+                    cert_ref:     calCertRef,
+                    notes:        calNotes,
+                    values:       calValuesPayload(),
+                };
+                const calResp: any = await invoke(
+                    'ams.update_calibration' as any, MessageType.Request, calPayload,
+                );
+                if (!calResp?.success) {
+                    setError(calResp?.error_message ?? 'update_calibration failed');
+                    // Switch the operator to the Calibration tab so
+                    // they see the inputs that the error refers to.
+                    setActiveTab(1);
+                    return;
+                }
+            }
+
+            onSaved?.();
+            onHide();
+        } catch (e: any) {
+            setError(String(e?.message ?? e));
+        } finally {
+            setSubmitting(false);
+        }
+    };
+
+    /** Build the `values` field for `ams.update_calibration`. Picks
+     *  the per-axis matrix or the flat map based on the asset_type's
+     *  schema; cells with empty input drop out so the on-disk record
+     *  doesn't accumulate empty strings. */
+    const calValuesPayload = (): any => {
+        if (isPerAxisCalibration && subLocationsSchema) {
+            const out: Record<string, Record<string, any>> = {};
+            for (const key of subLocationsSchema.keys) {
+                const row: Record<string, any> = {};
+                for (const f of perAxisCalibrationFields) {
+                    const raw = calPerAxisValues[key]?.[f.name] ?? '';
+                    const coerced = coerceField(f, raw);
+                    if (coerced !== undefined) row[f.name] = coerced;
+                }
+                out[key] = row;
+            }
+            return out;
+        }
+        const out: Record<string, any> = {};
+        for (const f of calibrationFields) {
+            const raw = calValues[f.name];
+            const coerced = coerceField(f, raw ?? '');
+            if (coerced !== undefined) out[f.name] = coerced;
+        }
+        return out;
+    };
+
+    // Gate Save on the same required-field rules the Add dialog uses,
+    // applied to the *current* (possibly edited) values. The server
+    // re-validates and we surface its error if anything slips through.
+    const saveDisabled =
+        !asset?.asset_id ||
+        submitting ||
+        (typeHasRoles && (
+            roleSelection === '' ||
+            (roleSelection === ROLE_OTHER && !location.trim())
+        )) ||
+        fields.some(f =>
+            f.required && !(customFields[f.name]?.toString().trim()),
+        ) ||
+        (subLocationsSchema?.keys.some(key =>
+            subLocationsSchema.fields.some(field =>
+                field.required &&
+                !(subLocationFields[key]?.[field.name]?.toString().trim()),
+            ),
+        ) ?? false);
+
+    if (!asset) return null;
+    const typeLabel = schemas[assetType]?.label ?? assetType;
+
+    return (
+        <Dialog
+            header={`Edit Asset — ${asset.asset_id}`}
+            visible={visible}
+            style={{ width: '32rem' }}
+            onHide={() => { if (!submitting) onHide(); }}
+            footer={
+                <>
+                    <Button label="Cancel" severity="secondary"
+                        onClick={onHide} disabled={submitting} />
+                    <Button label="Save" icon="pi pi-check"
+                        onClick={onSubmit} loading={submitting}
+                        disabled={saveDisabled} />
+                </>
+            }
+        >
+            {/* Read-only context strip — type, serial, install_date.
+                The server treats these as immutable; surfacing them
+                here keeps the operator oriented without inviting an
+                edit that would silently no-op. */}
+            <div style={{ display: 'grid',
+                          gridTemplateColumns: 'auto 1fr',
+                          gap: '0.25rem 1rem',
+                          fontSize: '0.875rem',
+                          color: 'var(--text-secondary-color)',
+                          marginBottom: '0.75rem' }}>
+                <span>Type</span>          <span>{typeLabel}</span>
+                <span>Serial</span>        <span>{asset.serial || <em>(none)</em>}</span>
+                {asset.install_date && (
+                    <>
+                        <span>Installed</span>
+                        <span>{new Date(asset.install_date).toLocaleString()}</span>
+                    </>
+                )}
+            </div>
+
+            <TabView activeIndex={activeTab} onTabChange={(e) => setActiveTab(e.index)}>
+                <TabPanel header="Asset">
+            <div style={{ display: 'grid',
+                          gridTemplateColumns: 'auto 1fr',
+                          gap: '0.5rem 1rem',
+                          alignItems: 'center' }}>
+                {/* Role field. Asset types referenced only by_id_field
+                    (no by_location asset_ref) come back with an empty
+                    role list — we hide the row entirely so the operator
+                    doesn't try to set a role that no test method or
+                    module will pick up. */}
+                {typeHasRoles && (
+                    <>
+                        <label>Role *</label>
+                        <Dropdown
+                            value={roleSelection}
+                            options={roleDropdownOptions}
+                            onChange={(e) => onRoleChange(e.value)}
+                            placeholder="Choose where this asset is mounted"
+                        />
+                        {roleSelection === ROLE_OTHER && (
+                            <>
+                                <label>Custom role</label>
+                                <InputText
+                                    value={location}
+                                    placeholder="e.g. tsdr_secondary"
+                                    onChange={(e) => setLocation(e.target.value)}
+                                />
+                            </>
+                        )}
+                    </>
+                )}
+
+                {/* Schema-declared nameplate fields. */}
+                {fields.map(field => {
+                    const label = field.label ?? field.name;
+                    const fullLabel = field.units
+                        ? `${label} [${field.units}]${field.required ? ' *' : ''}`
+                        : `${label}${field.required ? ' *' : ''}`;
+                    const isNum = field.type !== 'string' && field.type !== 'bool';
+                    return (
+                        <React.Fragment key={field.name}>
+                            <label title={field.description ?? undefined}>
+                                {fullLabel}
+                            </label>
+                            {field.type === 'bool' ? (
+                                <Dropdown
+                                    value={customFields[field.name] ?? ''}
+                                    options={[
+                                        { label: 'true',  value: 'true' },
+                                        { label: 'false', value: 'false' },
+                                    ]}
+                                    onChange={(e) => setCustomFields(s => ({
+                                        ...s, [field.name]: e.value,
+                                    }))}
+                                    placeholder="—"
+                                />
+                            ) : (
+                                <InputText
+                                    value={customFields[field.name] ?? ''}
+                                    keyfilter={isNum ? 'num' : undefined}
+                                    placeholder={field.description ?? undefined}
+                                    onChange={(e) => setCustomFields(s => ({
+                                        ...s, [field.name]: e.target.value,
+                                    }))}
+                                />
+                            )}
+                        </React.Fragment>
+                    );
+                })}
+            </div>
+
+            {/* Per-axis matrix (multi-axis transducer types etc.) */}
+            {subLocationsSchema && (
+                <div style={{ marginTop: '1.5rem' }}>
+                    <h4 style={{ margin: '0 0 0.5rem 0' }}>
+                        {subLocationsSchema.label ?? 'Sub-locations'}
+                    </h4>
+                    <div style={{ overflowX: 'auto' }}>
+                        <table style={{ width: '100%', borderCollapse: 'collapse',
+                                        fontSize: '0.875rem' }}>
+                            <thead>
+                                <tr>
+                                    <th style={{ textAlign: 'left', padding: '0.25rem 0.5rem',
+                                                 borderBottom: '1px solid var(--surface-border)' }}>
+                                        {subLocationsSchema.key_label ?? 'Key'}
+                                    </th>
+                                    {subLocationsSchema.fields.map(f => (
+                                        <th key={f.name}
+                                            title={f.description ?? undefined}
+                                            style={{ textAlign: 'left',
+                                                     padding: '0.25rem 0.5rem',
+                                                     borderBottom: '1px solid var(--surface-border)' }}>
+                                            {(f.label ?? f.name)}
+                                            {f.units ? ` [${f.units}]` : ''}
+                                            {f.required ? ' *' : ''}
+                                        </th>
+                                    ))}
+                                </tr>
+                            </thead>
+                            <tbody>
+                                {subLocationsSchema.keys.map(key => (
+                                    <tr key={key}>
+                                        <td style={{ padding: '0.25rem 0.5rem', fontWeight: 600 }}>
+                                            {key}
+                                        </td>
+                                        {subLocationsSchema.fields.map(field => {
+                                            const cellValue =
+                                                subLocationFields[key]?.[field.name] ?? '';
+                                            const isNum =
+                                                field.type !== 'string' && field.type !== 'bool';
+                                            return (
+                                                <td key={field.name}
+                                                    style={{ padding: '0.25rem 0.5rem' }}>
+                                                    <InputText
+                                                        value={cellValue}
+                                                        keyfilter={isNum ? 'num' : undefined}
+                                                        onChange={(e) => {
+                                                            const v = e.target.value;
+                                                            setSubLocationFields(s => ({
+                                                                ...s,
+                                                                [key]: {
+                                                                    ...(s[key] ?? {}),
+                                                                    [field.name]: v,
+                                                                },
+                                                            }));
+                                                        }}
+                                                        style={{ width: '100%' }}
+                                                    />
+                                                </td>
+                                            );
+                                        })}
+                                    </tr>
+                                ))}
+                            </tbody>
+                        </table>
+                    </div>
+                </div>
+            )}
+                </TabPanel>
+
+                {/* Calibration tab — present only when the asset has
+                    a current calibration. We hide the tab entirely
+                    rather than showing it disabled because operators
+                    asked for the affordance to be visually obvious
+                    when it's available, not a permanent grey tease
+                    of "you can't edit this yet". Adding a first cal
+                    flows through `+ Calibration` on the parent. */}
+                {calRecord && (
+                    <TabPanel header={`Calibration (${calRecord.cal_id})`}>
+                        {/* Meta fields — performed_by, expires_at,
+                            cert_ref, notes. Same shape as the entry
+                            dialog so operators see consistent inputs
+                            either way they reach the cal form. */}
+                        <div style={{ display: 'grid',
+                                      gridTemplateColumns: 'auto 1fr',
+                                      gap: '0.5rem 1rem',
+                                      alignItems: 'center' }}>
+                            <label>Performed by</label>
+                            <InputText value={calPerformedBy}
+                                onChange={(e) => setCalPerformedBy(e.target.value)} />
+
+                            <label>Expires at</label>
+                            <Calendar value={calExpiresAt}
+                                onChange={(e) => setCalExpiresAt((e.value as Date) ?? null)}
+                                showIcon dateFormat="yy-mm-dd" />
+
+                            <label>Certificate ref</label>
+                            <InputText value={calCertRef}
+                                onChange={(e) => setCalCertRef(e.target.value)}
+                                placeholder="e.g. ADC-CAL-2026-1043"
+                            />
+
+                            <label>Notes</label>
+                            <InputTextarea value={calNotes} rows={3}
+                                onChange={(e) => setCalNotes(e.target.value)}
+                                autoResize />
+                        </div>
+
+                        {/* Cal values. Per-axis when the schema
+                            declares them; otherwise the flat field
+                            list. Skipped entirely when the asset_type
+                            declares no calibration_fields — the meta
+                            fields above still let the operator fix
+                            cert_ref / notes / expiry on a values-less
+                            calibration. */}
+                        {hasAnyCalibrationFields && (
+                            <div style={{ marginTop: '1rem' }}>
+                                <h4 style={{ margin: '0 0 0.5rem 0' }}>
+                                    {isPerAxisCalibration
+                                        ? (subLocationsSchema?.label ?? 'Per-axis calibration')
+                                        : 'Calibration values'}
+                                </h4>
+                                {isPerAxisCalibration && subLocationsSchema ? (
+                                    <div style={{ overflowX: 'auto' }}>
+                                        <table style={{ width: '100%', borderCollapse: 'collapse',
+                                                        fontSize: '0.875rem' }}>
+                                            <thead>
+                                                <tr>
+                                                    <th style={{ textAlign: 'left',
+                                                                 padding: '0.25rem 0.5rem',
+                                                                 borderBottom: '1px solid var(--surface-border)' }}>
+                                                        {subLocationsSchema.key_label ?? 'Key'}
+                                                    </th>
+                                                    {perAxisCalibrationFields.map(f => (
+                                                        <th key={f.name}
+                                                            title={f.description ?? undefined}
+                                                            style={{ textAlign: 'left',
+                                                                     padding: '0.25rem 0.5rem',
+                                                                     borderBottom: '1px solid var(--surface-border)' }}>
+                                                            {(f.label ?? f.name)}
+                                                            {f.units ? ` [${f.units}]` : ''}
+                                                            {f.required ? ' *' : ''}
+                                                        </th>
+                                                    ))}
+                                                </tr>
+                                            </thead>
+                                            <tbody>
+                                                {subLocationsSchema.keys.map(key => (
+                                                    <tr key={key}>
+                                                        <td style={{ padding: '0.25rem 0.5rem', fontWeight: 600 }}>
+                                                            {key}
+                                                        </td>
+                                                        {perAxisCalibrationFields.map(field => {
+                                                            const cellValue =
+                                                                calPerAxisValues[key]?.[field.name] ?? '';
+                                                            const isNum =
+                                                                field.type !== 'string' && field.type !== 'bool';
+                                                            return (
+                                                                <td key={field.name}
+                                                                    style={{ padding: '0.25rem 0.5rem' }}>
+                                                                    <InputText
+                                                                        value={cellValue}
+                                                                        keyfilter={isNum ? 'num' : undefined}
+                                                                        onChange={(e) => {
+                                                                            const v = e.target.value;
+                                                                            setCalPerAxisValues(s => ({
+                                                                                ...s,
+                                                                                [key]: {
+                                                                                    ...(s[key] ?? {}),
+                                                                                    [field.name]: v,
+                                                                                },
+                                                                            }));
+                                                                        }}
+                                                                        style={{ width: '100%' }}
+                                                                    />
+                                                                </td>
+                                                            );
+                                                        })}
+                                                    </tr>
+                                                ))}
+                                            </tbody>
+                                        </table>
+                                    </div>
+                                ) : (
+                                    <div style={{ display: 'grid',
+                                                  gridTemplateColumns: 'auto 1fr',
+                                                  gap: '0.5rem 1rem',
+                                                  alignItems: 'center' }}>
+                                        {calibrationFields.map(field => {
+                                            const label = field.label ?? field.name;
+                                            const fullLabel = field.units
+                                                ? `${label} [${field.units}]${field.required ? ' *' : ''}`
+                                                : `${label}${field.required ? ' *' : ''}`;
+                                            const isNum = field.type !== 'string'
+                                                       && field.type !== 'bool';
+                                            return (
+                                                <React.Fragment key={field.name}>
+                                                    <label title={field.description ?? undefined}>
+                                                        {fullLabel}
+                                                    </label>
+                                                    <InputText
+                                                        value={calValues[field.name] ?? ''}
+                                                        keyfilter={isNum ? 'num' : undefined}
+                                                        onChange={(e) => setCalValues(s => ({
+                                                            ...s, [field.name]: e.target.value,
+                                                        }))}
+                                                    />
+                                                </React.Fragment>
+                                            );
+                                        })}
+                                    </div>
+                                )}
+                            </div>
+                        )}
+                    </TabPanel>
+                )}
+            </TabView>
+
+            {error && (
+                <div style={{ marginTop: '1rem', color: '#ef4444' }}>
+                    {error}
+                </div>
+            )}
+        </Dialog>
+    );
+};