// ══════════════════════════════════════════════════════════════
// Active frontend — uses atomic REST endpoints (apiPost/apiPatch/apiDelete).
// ══════════════════════════════════════════════════════════════

// ─── P-02: lazy vendor-lib loader ────────────────────────────
// The four vendor libs (jsbarcode, qrcode, chart, html5-qrcode) total
// ~660 KB raw / ~195 KB gzip. Loading them as eager <script defer> tags
// in index.html still costs parse+compile time on every page load, even
// for phones that never open the camera or print labels.
//
// Strategy (fallback per the audit's punch-list — full async wiring of
// every callsite was scoped down): inject them *after* DOMContentLoaded
// when the browser is idle. Critical-path JS (login, dashboard render,
// scan log replay) doesn't depend on these libs, so deferring them
// doesn't change any user-visible flow except on a *very* fresh first
// load when a user instantly taps the camera FAB before idle fires —
// the loader synchronously promotes to active loading in that case.
const _loadedScripts = new Map();
function loadScript(src) {
  if (_loadedScripts.has(src)) return _loadedScripts.get(src);
  const p = new Promise((resolve, reject) => {
    const s = document.createElement('script');
    s.src = src;
    s.async = false;
    s.onload = resolve;
    s.onerror = () => reject(new Error('Failed to load ' + src));
    document.head.appendChild(s);
  });
  _loadedScripts.set(src, p);
  return p;
}
let _vendorLibsReady = null;
function loadVendorLibs() {
  if (_vendorLibsReady) return _vendorLibsReady;
  _vendorLibsReady = Promise.all([
    loadScript('/lib/jsbarcode.min.js'),
    loadScript('/lib/qrcode.min.js'),
    loadScript('/lib/chart.min.js'),
    loadScript('/lib/html5-qrcode.min.js')
  ]);
  return _vendorLibsReady;
}
// Kick off the idle preload once the DOM is ready. Never blocks the main
// render path. Falls back to setTimeout on browsers without
// requestIdleCallback.
function _kickIdleVendorPreload() {
  const ric = window.requestIdleCallback || ((cb) => setTimeout(cb, 200));
  ric(() => {
    loadVendorLibs().catch((err) => console.warn('Vendor lib preload failed:', err));
  });
}
if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', _kickIdleVendorPreload, { once: true });
} else {
  _kickIdleVendorPreload();
}

// ─── I18N ────────────────────────────────────────────────────
let currentLang = localStorage.getItem('mp-lang') || 'de';
const LOCALE_MAP = { en: 'en-GB', de: 'de-DE', pt: 'pt-BR' };
// Kilogramm in der Sprache des Benutzers. `toFixed` liefert immer einen Punkt,
// und "13.650 kg" liest sich auf Deutsch als dreizehntausend statt als 13,65.
const fmtKg = (v, d) => Number(v).toLocaleString(LOCALE_MAP[currentLang] || 'de-DE', { minimumFractionDigits: d, maximumFractionDigits: d });
function loc() {
  return LOCALE_MAP[currentLang];
}
function fmtDt(d) {
  if (!(d instanceof Date)) d = new Date(d);
  const dd = String(d.getDate()).padStart(2, '0'),
    mm = String(d.getMonth() + 1).padStart(2, '0'),
    yy = String(d.getFullYear()).slice(-2);
  return dd + '.' + mm + '.' + yy;
}
function fmtDtTime(d) {
  if (!(d instanceof Date)) d = new Date(d);
  return fmtDt(d) + ' ' + String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0');
}
function fmtDtShort(d) {
  if (!(d instanceof Date)) d = new Date(d);
  return String(d.getDate()).padStart(2, '0') + '.' + String(d.getMonth() + 1).padStart(2, '0');
}
function isoWeekNumber(d) {
  if (!(d instanceof Date)) d = new Date(d);
  const tmp = new Date(Date.UTC(d.getFullYear(), d.getMonth(), d.getDate()));
  tmp.setUTCDate(tmp.getUTCDate() + 4 - (tmp.getUTCDay() || 7));
  const yearStart = new Date(Date.UTC(tmp.getUTCFullYear(), 0, 1));
  return Math.ceil(((tmp - yearStart) / 864e5 + 1) / 7);
}
function t(key, params) {
  const str = (LANG[currentLang] && LANG[currentLang][key]) || (LANG['en'] && LANG['en'][key]) || key;
  if (!params) return str;
  return str.replace(/\{(\w+)\}/g, (_, k) => (params[k] !== undefined ? params[k] : '{' + k + '}'));
}
function tp(key, n) {
  return t(key + (n === 1 ? '.one' : '.other'), { n });
}
function setLang(lang) {
  currentLang = lang;
  localStorage.setItem('mp-lang', lang);
  document.getElementById('lang-sel').value = lang;
  // P-03: lazy-load the new locale on switch. The first switch fetches the
  // file; subsequent switches reuse the cached translations.
  loadLang(lang)
    .then(() => {
      translatePage();
      refresh();
      renderUsbSetup();
      renderUsbKey();
    })
    .catch((err) => console.error('Locale load failed:', err));
}
function translatePage() {
  document.querySelectorAll('[data-i18n]').forEach((el) => {
    el.textContent = t(el.dataset.i18n);
  });
  document.querySelectorAll('[data-i18n-placeholder]').forEach((el) => {
    el.placeholder = t(el.dataset.i18nPlaceholder);
  });
  document.querySelectorAll('[data-i18n-title]').forEach((el) => {
    el.title = t(el.dataset.i18nTitle);
  });
  document.querySelectorAll('[data-i18n-html]').forEach((el) => {
    el.innerHTML = t(el.dataset.i18nHtml);
  });
  document.querySelectorAll('[data-i18n-aria-label]').forEach((el) => {
    el.setAttribute('aria-label', t(el.dataset.i18nAriaLabel));
  });
  document.documentElement.lang = currentLang;
}
// P-03: i18n strings live in /lang/<code>.js. Loaded on demand by `loadLang`
// (kicked off at startup with the user's current locale, and again whenever
// `setLang` switches locales). Bundling all three locales in app.js used to
// add ~174 KB raw / ~52 KB gzip to every page load — now only the active
// locale's bytes are fetched and parsed. Other locales are pulled lazily
// the first time the user picks them.
//
// `window.LANG` is populated by each lang/<code>.js file (each file does
// `window.LANG['<code>'] = { ... }`). The `LANG` reference below is just
// a stable handle for `t()` / `tp()` / `translatePage()` — it points at the
// same object, so once a locale file has loaded its strings are visible
// here without any additional plumbing.
const LANG = (window.LANG = window.LANG || {});
const _langPromises = new Map();
function loadLang(code) {
  if (LANG[code]) return Promise.resolve();
  let p = _langPromises.get(code);
  if (p) return p;
  // ?v=2 is a one-time cache-buster. /lang/*.js was served
  // "max-age=31536000, immutable" against an unversioned URL, so any client that
  // had fetched a locale kept it for a year and never saw newly added keys —
  // t() then printed the raw key. The header is now max-age=300, but a client
  // already holding the immutable copy would never ask again; a different URL is
  // the only thing that reaches it. Future string changes need no bump.
  p = loadScript('/lang/' + code + '.js?v=2');
  _langPromises.set(code, p);
  return p;
}

// ─── CONSTANTS ───────────────────────────────────────────────
// USED gibt es nur auf dem Telefon und auf dem gedruckten Etikett: gebucht wird
// ein REMOVE mit dem Grund "spawn" (siehe verbrauchtScan).
const ACTIONS = ['ADD', 'MOVE', 'MOVE_BATCH', 'REMOVE', 'HARVEST', 'CONTAM', 'USED'];
// The colour a zone falls back to when its row carries none, the shade the role
// picker suggests, and the default in the new-zone form — one table instead of
// the three separate literals these used to be, which is how the KPI strip and
// the zone editor came to disagree about what "fruiting" looks like.
//
// Must stay equal to ZONE_SEED_COLOR in db.js; test/zonenfarben.test.js holds
// the two together, because nothing else would notice them drifting apart.
const ZONE_ROLE_COLOR = {
  spawn: '#926bb6',
  incubation: '#4d829b',
  fruiting: '#438871',
  contaminated: '#ef4444'
};
let ZONES = [],
  ALL_RACKS = [],
  LOCS = [],
  RACK_ZONE = {},
  // id -> full zone object. Built once per applyData / zone edit so callers
  // that need .role / .color / etc. can do an O(1) lookup instead of zones.find().
  // Hot path: dashboard contam-rate (renderOverviewKPIs) iterated all scan-log
  // entries x zones.find() = O(scanLog * zones).
  ZONE_BY_ID = {};
// batchId -> batch. Same reasoning as ZONE_BY_ID: the dashboard resolved a batch
// per task row with batches.find(), which is every row x every batch of string
// comparison on every render, every 30s poll and every tab tap.
//
// Revalidated on length rather than rebuilt at each write site: createBatch and
// createGrainBatch push optimistically and splice back on failure, so a map built
// only in applyData would miss a just-created batch until the next sync. Length is
// the only thing those paths change, and a push-then-splice rollback moves it
// twice, so both directions self-correct.
let _batchById = new Map();
function batchById(id) {
  if (_batchById.size !== batches.length) _batchById = new Map(batches.map((b) => [b.batchId, b]));
  return _batchById.get(id);
}
const toZone = (loc) => {
  if (!loc) return loc;
  if (RACK_ZONE[loc]) return RACK_ZONE[loc];
  if (ZONES.includes(loc)) return loc;
  const z = ZONES.find((z) => loc.startsWith(z + '_'));
  return z || loc;
};
// ABBR removed — kuerzel comes from mushroomStrains (Pilzsorten) now.
// Fallback ramp for species with no entry in SP_REAL below.
const SP_COLORS = [
  '#e11d48',
  '#0284c7',
  '#059669',
  '#d97706',
  '#7c3aed',
  '#0d9488',
  '#ea580c',
  '#db2777',
  '#0891b2',
  '#65a30d'
];
// Species colours approximate what the mushroom actually looks like, so the dot
// is recognisable instead of decorative. Keyed on the species name with any
// " (KUERZEL)" suffix stripped — batches carry both "Blue Oyster" and
// "Blue Oyster (BO)", which the old raw-string key treated as two species and
// coloured differently.
//
// Realism is bent where it would cost legibility: Shiitake, Chestnut, Pioppino
// and Maitake are all brown in life, which at a 10px dot is four of the same
// colour. They are spread across hue and roughly 25 / 40 / 65 / 85 lightness so
// no two read alike — chestnut pushed orange, pioppino cooled to olive, maitake
// taken fully grey. Phoenix is nudged toward salmon so it parts from King Oyster
// tan, and Pearl Oyster to blue-grey so it parts from Maitake.
const SP_REAL = {
  'pink oyster': '#E8618C',
  'blue oyster': '#4A7FB5',
  'yellow oyster': '#E8B92E',
  cordyceps: '#E8701A',
  chestnut: '#C8721F',
  reishi: '#8E2B20',
  shiitake: '#4A2E18',
  pioppino: '#6E6046',
  'king oyster': '#C8A275',
  'phoenix oyster': '#D9A08A',
  'phoenix oyster mushroom': '#D9A08A',
  maitake: '#A9A49B',
  'pearl oyster': '#8FA3B0',
  'lions mane': '#EDE7DA',
  "lion's mane": '#EDE7DA',
  'black pearl king oyster': '#2B2F36'
};
let REF_GROUPS = [];
// ZPL label dimensions in dots, populated from /api/data labelDims
// (server reads LABEL_WIDTH_DOTS / LABEL_HEIGHT_DOTS env). Default
// 400×240 = 50×30mm at 203dpi (Zebra GK420d small label).
const labelDims = { widthDots: 400, heightDots: 240 };
// Whether the harvest feed reports releases, from /api/data harvestRelease.
// Default off, so a server that does not send the flag hides the field rather
// than offering one that goes nowhere.
const harvestRelease = { on: false };
const KNOWN_ZONE_I18N = {
  SPAWN: 'dash.zoneSpawn',
  INC: 'dash.zoneInc',
  TENT1: 'dash.zoneTent1',
  TENT2: 'dash.zoneTent2',
  TENT3: 'dash.zoneTent3',
  CONTAM: 'dash.zoneContam'
};
// The English names db.js seeds these zones with. Only a zone still carrying
// its seed name is translated; one renamed in Settings → Zones shows the name
// it was given, or "Großes Zelt" comes back as "Zelt 1".
const KNOWN_ZONE_SEED_NAME = {
  SPAWN: 'Spawn Run',
  INC: 'Incubation',
  TENT1: 'Tent 1',
  TENT2: 'Tent 2',
  TENT3: 'Tent 3',
  CONTAM: 'Contamination'
};
function zoneI18nKey(z) {
  const key = KNOWN_ZONE_I18N[z.id];
  return key && (!z.name || z.name === KNOWN_ZONE_SEED_NAME[z.id]) ? key : null;
}
function zoneDisplayName(id) {
  if (!id) return id;
  const z = zones.find((x) => x.id === id);
  if (z) {
    const key = zoneI18nKey(z);
    return key ? t(key) : z.name;
  }
  if (KNOWN_ZONE_I18N[id]) return t(KNOWN_ZONE_I18N[id]);
  // Try as rack ID: find parent zone and return "ZoneName / rackSuffix"
  for (const zone of zones) {
    const rack = zone.racks.find((r) => r.id === id);
    if (rack) return (zone.name || zone.id) + '/' + (id.slice(zone.id.length + 1) || id);
  }
  return id;
}
function rebuildZoneConstants() {
  ZONES = zones.map((z) => z.id);
  ALL_RACKS = zones.flatMap((z) => z.racks.map((r) => r.id));
  LOCS = [...ZONES, ...ALL_RACKS];
  RACK_ZONE = {};
  ZONE_BY_ID = {};
  zones.forEach((z) => {
    ZONE_BY_ID[z.id] = z;
    z.racks.forEach((r) => {
      RACK_ZONE[r.id] = z.id;
    });
  });
  ZONE_LABELS = {};
  ZONE_COLORS = {};
  zones.forEach((z) => {
    ZONE_LABELS[z.id] = zoneI18nKey(z) || z.name;
    ZONE_COLORS[z.id] = z.color;
  });
  locColor = { ...ZONE_COLORS };
  // Actions + Quantities stay as text barcodes; Zones + Racks use numeric barcodes
  REF_GROUPS = [
    {
      g: 'Actions',
      items: ['ADD', 'MOVE', 'MOVE_BATCH', 'REMOVE', 'HARVEST', 'CONTAM'].map((a) => ({ val: a, label: a }))
    }
  ];
  REF_GROUPS.push({
    g: 'Zones',
    items: ZONES.map((z) => {
      const bc = barcodeByEntity.get('zone:' + z);
      return { val: bc ? String(bc) : z, label: z };
    })
  });
  zones
    .filter((z) => z.racks.length > 0)
    .forEach((z) => {
      const rIds = z.racks.map((r) => r.id);
      for (let i = 0; i < rIds.length; i += 5) {
        const chunk = rIds.slice(i, i + 5);
        const label = z.name + ' Racks ' + (i + 1) + '–' + (i + chunk.length);
        REF_GROUPS.push({
          g: label,
          items: chunk.map((r) => {
            const bc = barcodeByEntity.get('rack:' + r);
            return { val: bc ? String(bc) : r, label: r };
          })
        });
      }
    });
}

// ─── DATA ────────────────────────────────────────────────────
let mushroomStrains = [],
  // Die Stämme je Pilzsorte (v87) — das Vokabular zum Stamm-Feld, siehe STÄMME.
  staemme = [],
  batches = [],
  scanLog = [],
  movements = [],
  manualTasks = [],
  experiments = [],
  workPackages = [], // Arbeitspakete des Vorhabens, siehe ARBEITSPAKETE
  projectNotes = [],
  projectDocs = null, // Vorhaben-Texte, erst beim Öffnen eines Reiters geladen
  projectDocsStamp = null,
  harvests = [],
  blockNotes = [], // gute Blöcke und Notizen je Block, siehe BLOCKBUCH
  cultures = [],
  inventory = {},
  teamMembers = [],
  caldav = {},
  duckdns = {},
  zones = [],
  suppliers = [],
  pickupLocations = [],
  weekRhythm = {},
  rhythmTasks = [],
  recurringTasks = [];
// Numeric barcode registry: Map<number, {type, id}> and reverse Map<string, number>
let barcodeRegistry = new Map(),
  barcodeByEntity = new Map();
let appUsers = [];
let calEvSelectedAssignees = [];
let calTaskSelectedAssignees = [];
let scan = { action: null, from: null, to: null, count: 0, harvestBag: null };
let confirmCb = null,
  noteId = null,
  saving = false,
  lastHash = '';
const spMap = {};
// "Blue Oyster (BO)" and "Blue Oyster" must land on the same key, or the same
// mushroom gets two colours — which is what happened, since batches store both.
function _spKey(s) {
  return String(s || '')
    .replace(/\s*\([^)]*\)\s*$/, '')
    .trim()
    .toLowerCase();
}
// Anything outside SP_REAL is coloured from a hash of its own name, so it is at
// least STABLE. The previous code indexed the ramp by insertion order
// (SP_COLORS[Object.keys(spMap).length % …]), so a species took whatever colour
// was next when it happened to be drawn first — different per card, different
// after a reload.
function _spHashColor(k) {
  let h = 0;
  for (let i = 0; i < k.length; i++) h = (h * 31 + k.charCodeAt(i)) >>> 0;
  return SP_COLORS[h % SP_COLORS.length];
}
const spColor = (s) => {
  const k = _spKey(s);
  if (!k) return '#888888';
  if (!spMap[k]) spMap[k] = SP_REAL[k] || _spHashColor(k);
  return spMap[k];
};
const spDot = (s) => `<span class="sp-dot" style="background:${spColor(s)}"></span>`;

// ─── HTML ESCAPING ──────────────────────────────────────────
function esc(s) {
  if (s == null) return '';
  return String(s)
    .replace(/&/g, '&amp;')
    .replace(/</g, '&lt;')
    .replace(/>/g, '&gt;')
    .replace(/"/g, '&quot;')
    .replace(/'/g, '&#39;');
}
// Parse a user-entered decimal that may use a German comma as the decimal
// separator ("1,5" → 1.5, "1.234,5" → 1234.5). The app's default language is
// German and the quantity inputs are type=text inputmode=decimal, so mobile
// keyboards offer a comma — plain parseFloat('847,5') silently returns 847.
// Returns NaN for unparseable input; callers apply `|| 0` / Number.isFinite
// exactly as before.
function parseDecimal(v) {
  if (v == null) return NaN;
  let s = String(v).trim();
  if (s.includes(',')) s = s.replace(/\./g, '').replace(',', '.');
  return parseFloat(s);
}
// Record a scan entry's server-side id once its POST resolves. If the user
// undid the entry before the POST landed (no _serverId yet → the undo set
// _undoPending), delete the now-known row so it doesn't resurface on the next
// sync.
function setEntryServerId(entry, id) {
  if (!entry || !id) return;
  entry._serverId = id;
  if (entry._undoPending) apiDelete('/api/scan-log/' + id);
}
// Undo an entry the server has never seen because it is still in the service
// worker's offline queue. A DELETE would 404 — the only way to honour the undo
// is to drop it from the queue before it replays.
function dropQueuedScanEntry(entry) {
  if (!entry || !entry.client_uuid) return false;
  if (!('serviceWorker' in navigator) || !navigator.serviceWorker.controller) return false;
  navigator.serviceWorker.controller.postMessage({ type: 'drop-queued-scan', clientUuid: entry.client_uuid });
  return true;
}
function safeHref(url) {
  if (!url) return '';
  const u = String(url).trim();
  return /^https?:\/\//i.test(u) ? esc(u) : '';
}
function safeColor(c, fallback) {
  if (!c) return fallback || '#16a34a';
  return /^#[0-9a-fA-F]{3,8}$/.test(c) ? c : fallback || '#16a34a';
}

// ─── AUTH ────────────────────────────────────────────────────
let currentUser = null;
let ovPeriod = localStorage.getItem('mp-ov-period') || 'week';
async function authFetch(url, opts) {
  const r = await fetch(url, opts);
  if (r.status === 401) {
    window.location.href = '/login.html';
    throw new Error('unauthorized');
  }
  return r;
}
function _apiCall(method, path, body) {
  _mutating++;
  setSyncStatus('busy', 'Saving...');
  const opts = { method, headers: {} };
  if (body) {
    opts.headers['Content-Type'] = 'application/json';
    opts.body = JSON.stringify(body);
  }
  return authFetch(path, opts)
    .then((r) => {
      return r
        .json()
        .catch(() => ({}))
        .then((d) => {
          _mutating--;
          if (!r.ok) {
            const msg = d.error || 'HTTP ' + r.status;
            setSyncStatus('err', msg);
            return d.error ? d : { error: msg };
          }
          if (_mutating === 0) setSyncStatus('ok', 'Saved · gerade eben');
          return d;
        });
    })
    .catch((e) => {
      _mutating--;
      setSyncStatus('err', 'Save error: ' + (e.message || 'check server'));
      console.error('API error:', method, path, e);
      return { error: e.message || 'Network error' };
    });
}
function apiPost(path, body) {
  return _apiCall('POST', path, body);
}
function apiPatch(path, body) {
  return _apiCall('PATCH', path, body);
}
function apiPut(path, body) {
  return _apiCall('PUT', path, body);
}
function apiDelete(path) {
  return _apiCall('DELETE', path);
}
// Lightweight GET for reads — doesn't toggle the mutating/sync indicator.
async function apiGet(path) {
  const r = await authFetch(path);
  if (!r.ok) {
    const d = await r.json().catch(() => ({}));
    throw new Error(d.error || 'HTTP ' + r.status);
  }
  return r.json();
}
async function invDelta(mat, deltaKg, type, ref) {
  return apiPost('/api/inventory/delta', { mat, deltaKg, type, ref });
}
async function invDeltas(deltas) {
  for (const d of deltas) await invDelta(d.mat, d.deltaKg, d.type, d.ref);
}
async function invSetAbsolute(mat, value, type, ref) {
  return apiPost('/api/inventory/set', { mat, value, type, ref });
}
async function saveInvConfig() {
  return apiPost('/api/inventory/config', {
    thresholds: inventory.thresholds,
    avgComposition: inventory.avgComposition
  });
}
async function loadCurrentUser() {
  try {
    const r = await authFetch('/api/auth/me');
    currentUser = await r.json();
    // Die Kachel-Reihenfolge hängt am Benutzer; vorher galt die ohne Namen.
    syncWkTileOrderUp();
    applyWkTileOrder();
  } catch (e) {
    if (e.message !== 'unauthorized') console.error('Auth check failed:', e);
  }
  showServerTab();
  showMcpTab();
  showCameraTab();
  showAdminNav();
  loadUsbBackup();
}
function showAdminNav() {
  const btn = document.getElementById('n-settings');
  if (btn && currentUser && currentUser.role === 'admin') btn.style.display = '';
}

// MCP, camera and server are admin-only sub-tabs, and every sub-tab now carries
// two buttons: one in the strip, one in the sidebar list. Reveal them together —
// a half-shown pair is a sub-tab reachable from one layout but not the other.
function showAdminSubTab(sub) {
  if (!currentUser || currentUser.role !== 'admin') return;
  for (const id of ['st-settings-' + sub, 'sn-settings-' + sub]) {
    const btn = document.getElementById(id);
    if (btn) btn.style.display = '';
  }
}

// ─── SYNC ────────────────────────────────────────────────────
// Die Antwort auf /api/data, oder ein Fehler, wenn es keine Daten sind.
//
// Ohne Server antwortet nicht der Browser mit einem Fehler, sondern der Service
// Worker mit einem 503 und {error:'offline'} (sw.js, _apiFailureBody). Das ist
// gültiges JSON, und applyData() nahm es als Stand: jede Liste leer, das
// Barcode-Register leer, die Anzeige "synchronisiert". Ein kurzer Aussetzer im
// WLAN reichte, und danach war jedes Etikett "unbekannt", bis die nächste
// Abfrage durchkam — oder bis jemand die App neu startete, was am Ende der
// einzige Ausweg war, den man sah.
async function dataResponse(r) {
  if (!r.ok) throw new Error('HTTP ' + r.status);
  return r.json();
}
async function loadData() {
  setSyncStatus('busy', 'Syncing...');
  try {
    const r = await authFetch('/api/data');
    const d = await dataResponse(r);
    // Das ETag gehoert zu dem Stand, der jetzt gezeichnet wird. Ohne es fragte
    // die naechste Abfrage (etwa auf die eigene Meldung "data-changed" hin)
    // ohne If-None-Match und lud denselben Stand noch einmal ganz.
    const etag = r.headers && r.headers.get ? r.headers.get('ETag') : null;
    if (etag) _lastEtag = etag;
    lastHash = JSON.stringify(d);
    applyData(d);
    lastSyncTime = Date.now();
    setSyncStatus('ok', t('sync.syncedAt', { time: formatRelativeTime(lastSyncTime) }));
    refresh();
    // Gut-Knöpfe und Notizliste folgen dem neuen Stand; das Notizfeld nicht,
    // in dem tippt vielleicht gerade jemand.
    renderBlockGoodButtons();
    renderBiNotesList();
    if (_bbOpen()) loadBlockBook();
    // The remaining-kilogram figures are what the next Charge gets planned
    // against, so they have to move with every sync — but they come down inside
    // /api/data now rather than costing a second round-trip on every SSE event.
    if (typeof refreshSubstrateBatches === 'function') refreshSubstrateBatches(d.substrateBatches);
    // Nach einem Neuladen wegen einer neuen Version: zurück auf die Seite, auf
    // der man war. Dann erst der Stand-Vergleich, der selbst neu laden kann.
    restoreAfterUpdate();
    noteServerBuild(d.build);
  } catch (e) {
    if (e.message !== 'unauthorized') setSyncStatus('err', 'Sync error');
  }
}
// Last-scan-per-bag lookup. The four hot spots that need it (dashboard
// harvest tasks, batch-row bag chips, bag-info modal, getBatchLoc) all
// previously did `[...scanLog].reverse().find(...)` once per bag — O(N×M)
// for N bags and M scan-log entries. Building this map once per call site
// turns the per-bag work into a single O(1) Map.get(). Iterating forward
// and overwriting means the last entry for a given bag wins, equivalent
// to the original `reverse().find()`. Cheap to build, so we don't bother
// with global memoisation + invalidation across the 14 scanLog mutation
// sites.
function buildLastScanByBag() {
  const m = new Map();
  for (const e of scanLog) {
    const k = (e.bag || '').toUpperCase();
    if (k) m.set(k, e);
  }
  return m;
}
// Ob /api/data jemals angekommen ist. Ohne diesen Unterschied ist eine leere
// Liste nicht von einer ungeladenen zu unterscheiden, und die Seiten behaupten
// "noch nichts angelegt", während in Wahrheit noch nichts da ist.
let datenGeladen = false;
function applyData(d) {
  // P-05: invalidate per-batch status cache. scanLog is replaced wholesale,
  // so the lazy rebuild on next getStatus() will pick up the new state.
  _statusByBatch = null;
  _rhythmIndex = null;
  _placementByBag = null;
  // Same reason, same wholesale replacement: the search index is built from
  // these arrays and every one of them is about to be a different array.
  gsIndexInvalidate();
  mushroomStrains = d.mushroomStrains || [];
  staemme = d.staemme || [];
  batches = d.batches || [];
  scanLog = d.scanLog || [];
  movements = d.movements || d.scanLog || [];
  manualTasks = d.manualTasks || [];
  experiments = d.experiments || [];
  workPackages = d.workPackages || [];
  projectNotes = d.projectNotes || [];
  // Die Vorhaben-Texte kommen nicht mit, nur ihre Marke. Hat jemand sie ersetzt,
  // gilt der geladene Stand als veraltet und wird beim nächsten Öffnen eines
  // Reiters neu geholt. Neu gezeichnet wird hier nichts: im Notizfeld darunter
  // tippt vielleicht gerade jemand.
  if ((d.projectDocsStamp || '') !== projectDocsStamp) {
    if (projectDocsStamp !== null) projectDocs = null;
    projectDocsStamp = d.projectDocsStamp || '';
  }
  harvests = d.harvests || [];
  blockNotes = d.blockNotes || [];
  cultures = d.cultures || [];
  inventory = d.inventory || defaultInventory();
  teamMembers = d.teamMembers || [];
  caldav = d.caldav || {};
  duckdns = d.duckdns || {};
  calendarEvents = d.calendarEvents || [];
  zones = d.zones || [];
  suppliers = d.suppliers || [];
  pickupLocations = d.pickupLocations || [];
  weekRhythm = d.weekRhythm || {};
  rhythmTasks = d.rhythmTasks || [];
  recurringTasks = d.recurringTasks || [];
  datenGeladen = true;
  // Build barcode registry from server data
  barcodeRegistry = new Map();
  barcodeByEntity = new Map();
  for (const bc of d.barcodes || []) {
    barcodeRegistry.set(bc.barcode, { type: bc.entity_type, id: bc.entity_id });
    barcodeByEntity.set(bc.entity_type + ':' + bc.entity_id, bc.barcode);
  }
  rebuildZoneConstants();
  // ZPL label dimensions (set by server from LABEL_WIDTH_DOTS / LABEL_HEIGHT_DOTS
  // env vars). Fall back to the default 50×30mm @ 203dpi if missing.
  if (d.labelDims && typeof d.labelDims.widthDots === 'number' && typeof d.labelDims.heightDots === 'number') {
    labelDims.widthDots = d.labelDims.widthDots;
    labelDims.heightDots = d.labelDims.heightDots;
  }
  batches.forEach((b) => spColor(b.species));
  cultures.forEach((c) => spColor(c.species));
  fillStrainSelects();
  fillCultureSelect('nb-culture', ['PD', 'LC', 'G2G', 'GS']);
  fillCultureSelect('gs-culture', ['PD', 'LC', 'SY', 'GS']);
  updateTodoBadge();
  if (typeof fillCalendarUserFilter === 'function') fillCalendarUserFilter();
  if (d.notifications && typeof d.notifications.unread === 'number') {
    renderNotifBadge(d.notifications.unread);
  }
  harvestRelease.on = !!(d.harvestRelease && d.harvestRelease.on);
}
function defaultInventory() {
  return {
    stock: { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0 },
    thresholds: { hardwood: { minKg: 50 }, wheatbran: { minKg: 20 }, gypsum: { minKg: 5 }, grain: { minKg: 10 } },
    // Average substrate composition used for "~X bags" estimates
    // These are editable in the Inventory → Stock tab
    avgComposition: { hwPct: 75, wbPct: 25, rhPct: 63, bagKg: 3, grainBagKg: 1, grainRhPct: 52 },
    labThresholds: { MC: 0, PD: 0, LC: 0, G2G: 0, GS: 0, SY: 0 },
    bagCountFrom: null,
    log: []
  };
}
// saveData() removed — all mutations now use atomic REST endpoints (apiPost/apiPatch/apiDelete)
let _mutating = 0; // tracks in-flight mutations to block pollSync from overwriting
// Die Fotos, deren Original noch unterwegs ist (pjOriginaleHochladen). Sie
// zaehlen nicht zu _mutating: ein Original braucht auf dem Handy Minuten, und
// so lange darf der Sync nicht stehen. Ein Neuladen fuer ein Update wartet
// aber auf sie, wer die Seite schliesst, wird gefragt, und ihre Kachel bietet
// das Nachreichen erst an, wenn sie fertig sind.
const pjOriginaleUnterwegs = new Set();
let lastSyncTime = null;
function formatRelativeTime(ts) {
  const sec = Math.round((Date.now() - ts) / 1000);
  if (sec < 5) return t('time.justNow');
  if (sec < 60) return t('time.secsAgo', { n: sec });
  const min = Math.floor(sec / 60);
  if (min < 60) return t('time.minsAgo', { n: min });
  const hr = Math.floor(min / 60);
  if (hr < 24) return t('time.hoursAgo', { n: hr });
  return t('time.daysAgo', { n: Math.floor(hr / 24) });
}
// ─── NOTIFICATIONS ──────────────────────────────────────────
let _notifOpen = false;
let _notifItems = [];
let _notifOutsideHandler = null;

function renderNotifBadge(count) {
  const n = typeof count === 'number' && count > 0 ? count : 0;
  const text = n > 99 ? '99+' : String(n);
  for (const id of ['bell-badge', 'bell-badge-m']) {
    const el = document.getElementById(id);
    if (!el) continue;
    if (n > 0) {
      el.textContent = text;
      el.hidden = false;
    } else {
      el.hidden = true;
    }
  }
}

async function openNotifDropdown(anchorEl) {
  if (_notifOpen) return closeNotifDropdown();
  const dd = document.getElementById('notif-dropdown');
  if (!dd) return;
  // Load items
  try {
    const r = await authFetch('/api/notifications');
    const data = await r.json();
    _notifItems = Array.isArray(data.items) ? data.items : [];
    if (typeof data.unread === 'number') renderNotifBadge(data.unread);
  } catch (e) {
    _notifItems = [];
  }
  renderNotifList(_notifItems);
  positionNotifDropdown(dd, anchorEl);
  dd.hidden = false;
  _notifOpen = true;
  // Outside-click to close (captured on next tick so the opening click doesn't fire it)
  setTimeout(() => {
    _notifOutsideHandler = (e) => {
      if (!dd.contains(e.target) && !e.target.closest('#n-notif') && !e.target.closest('#n-notif-m')) {
        closeNotifDropdown();
      }
    };
    document.addEventListener('click', _notifOutsideHandler);
  }, 0);
}

function positionNotifDropdown(dd, anchorEl) {
  // On mobile the CSS already pins it to the top-right of the viewport.
  // On desktop, anchor it to the sidebar bell: the CSS default covers this.
  // If the user clicks the mobile bell we let CSS handle positioning.
  if (!anchorEl) return;
  // No JS positioning needed; CSS handles both the sidebar and mobile cases.
}

function closeNotifDropdown() {
  const dd = document.getElementById('notif-dropdown');
  if (dd) dd.hidden = true;
  _notifOpen = false;
  if (_notifOutsideHandler) {
    document.removeEventListener('click', _notifOutsideHandler);
    _notifOutsideHandler = null;
  }
}

function renderNotifList(items) {
  const list = document.getElementById('notif-list');
  const empty = document.getElementById('notif-empty');
  if (!list || !empty) return;
  if (!items.length) {
    list.innerHTML = '';
    empty.hidden = false;
    return;
  }
  empty.hidden = true;
  list.innerHTML = items
    .map((it) => {
      const ts = it.created ? new Date(it.created).getTime() : Date.now();
      const rel = formatRelativeTime(ts);
      const unreadCls = it.read ? '' : 'unread';
      // esc() is the existing HTML-escape helper used throughout app.js
      return (
        '<button type="button" class="notif-item ' +
        unreadCls +
        '" data-nid="' +
        it.id +
        '" data-link-type="' +
        esc(it.linkType || '') +
        '" data-link-id="' +
        esc(it.linkId || '') +
        '">' +
        '<div class="notif-item-title">' +
        esc(it.title || '') +
        '</div>' +
        (it.body ? '<div class="notif-item-body">' + esc(it.body) + '</div>' : '') +
        '<div class="notif-item-time">' +
        esc(rel) +
        '</div>' +
        '</button>'
      );
    })
    .join('');
  // Wire click handlers on each item
  for (const el of list.querySelectorAll('.notif-item')) {
    el.addEventListener('click', onNotifItemClick);
  }
}

function onNotifItemClick(e) {
  const el = e.currentTarget;
  const id = parseInt(el.getAttribute('data-nid'), 10);
  const linkType = el.getAttribute('data-link-type');
  const linkId = el.getAttribute('data-link-id');
  // Optimistic: mark this single item as read so the badge drops instantly
  if (!Number.isNaN(id)) {
    apiPost('/api/notifications/read', { ids: [id] }).catch(() => {});
    const badge = document.getElementById('bell-badge');
    const n = badge && !badge.hidden ? Math.max(0, parseInt(badge.textContent, 10) - 1) : 0;
    renderNotifBadge(n);
  }
  closeNotifDropdown();
  if (linkType === 'calendar_event' && linkId) {
    // Navigate to the calendar tab, then open the event detail modal
    go('cal', 'n-cal');
    const ce = calendarEvents.find((x) => x.id === linkId);
    if (ce) {
      // openEventDetail accepts a simplified occurrence object; match its shape
      openEventDetail({ type: 'custom', id: ce.id, date: ce.startDate });
    }
  } else if (linkType === 'task' && linkId) {
    // Tasks in the calendar are keyed by their `created` timestamp, so look
    // the task up by its numeric DB id first, then dispatch to the detail
    // modal using the timestamp — same shape clicking the task tile produces.
    go('cal', 'n-cal');
    const tid = parseInt(linkId, 10);
    const tk = manualTasks.find((x) => x.id === tid);
    if (tk) openEventDetail({ type: 'task-due', id: tk.created, date: tk.dueDate });
  } else if (linkType === 'sale' && linkId) {
    // "Bestellt, aber nicht da" (checkSaleAlerts): the species on the Labor
    // page, with its sheet open. linkId is "<species>/<slot>".
    const sid = parseInt(linkId.split('/')[0], 10);
    go('lab', 'n-lab');
    loadLabStock().then(() => lbSheetOpen(sid));
  } else if (linkType === 'label_unsaved' && linkId) {
    // "Gedruckt, aber nicht gespeichert" (checkUnsavedLabels): a culture goes
    // straight into the intake, dated from its label, as if it had been scanned.
    // A bag has no intake; the notice text says what to do.
    const k = kulturKennungLesen(linkId);
    if (k && ['MC', 'PD', 'LC', 'SY'].includes(k.type) && !cultures.some((c) => c.id === k.id)) msQuickOpenIntake(k);
  } else if (linkType === 'customer' && linkId) {
    // An eBay account-closure request. The server records it and raises this
    // notification but deliberately never erases on its own, so this alert is the
    // whole trail — and clicking it used to fall through every branch after
    // marking it read, so the only pointer to the request destroyed itself and
    // the admin landed nowhere. Take them to the Kunden table with the row
    // highlighted, which is where the erase actually happens.
    go('orders', 'n-orders');
    openStab('orders', 'customers');
    _ohHighlightCustomer = parseInt(linkId, 10) || null;
    renderOrdersCustomers();
  }
}

async function markAllNotifRead() {
  try {
    await apiPost('/api/notifications/read', { all: true });
  } catch (e) {
    /* ignore */
  }
  renderNotifBadge(0);
  // Update local list to reflect read state
  _notifItems = _notifItems.map((it) => ({ ...it, read: 1 }));
  renderNotifList(_notifItems);
}

// The label is one line and clips rather than wraps, because a second line
// moved the Admin button above it. The title carries whatever did not fit.
function setSyncLabel(text) {
  const el = document.getElementById('sync-label');
  el.textContent = text;
  el.title = text;
}
function setSyncStatus(cls, msg) {
  document.getElementById('sync-dot').className = 'sync-dot ' + cls;
  setSyncLabel(msg);
  const m = document.getElementById('sync-dot-m');
  if (m) m.className = 'sync-dot ' + cls;
  if (cls === 'ok') lastSyncTime = Date.now();
}
// Update relative time display every 5 seconds
setInterval(() => {
  if (!lastSyncTime) return;
  const dot = document.getElementById('sync-dot');
  if (!dot || !dot.classList.contains('ok')) return;
  setSyncLabel(t('sync.syncedAt', { time: formatRelativeTime(lastSyncTime) }));
}, 5000);
let _polling = false;
let _lastEtag = null;
// Wer auf eine schon laufende Abfrage wartet (syncNow), statt eine zweite
// danebenzustellen. Bekommt deren Ergebnis.
const _pollWaiters = [];
// Wie lange eine Abfrage höchstens laufen darf. Eine, die hängt — das Telefon
// schlief mitten in der Anfrage, das WLAN wechselte —, hielt _polling für immer
// auf true, und damit ließ jede weitere Abfrage sich selbst aus: das Telefon
// blieb auf seinem alten Stand, bis die App neu startete. Eine Minute reicht
// auch für langsames Netz.
const POLL_TIMEOUT_MS = 60000;
// Ergebnis: true, wenn der Server geantwortet hat (neuer Stand oder "nichts
// Neues"); false, wenn nicht; null, wenn die Abfrage ausgelassen wurde, weil
// gerade gespeichert wird. opts.force lässt sie trotzdem laufen.
async function pollSync(opts) {
  if (_polling) return new Promise((res) => _pollWaiters.push(res));
  if (_mutating > 0 && !(opts && opts.force)) return null;
  _polling = true;
  let ok = false;
  try {
    // P-04: send If-None-Match so the server can short-circuit with 304
    // when nothing has changed. Server sets ETag from the monotonic
    // data_version counter, so a cached version is authoritative.
    const init = {};
    if (_lastEtag) init.headers = { 'If-None-Match': _lastEtag };
    if (typeof AbortSignal !== 'undefined' && typeof AbortSignal.timeout === 'function') {
      init.signal = AbortSignal.timeout(POLL_TIMEOUT_MS);
    }
    const r = await authFetch('/api/data', init);
    if (r.status === 304) {
      // No change — keep the existing data, just refresh the "synced at" time.
      lastSyncTime = lastSyncTime || Date.now();
      setSyncStatus('ok', t('sync.syncedAt', { time: formatRelativeTime(lastSyncTime) }));
      ok = true;
      return ok;
    }
    const newEtag = r.headers && r.headers.get ? r.headers.get('ETag') : null;
    const d = await dataResponse(r);
    const h = JSON.stringify(d);
    if (h !== lastHash) {
      lastHash = h;
      _lastEtag = newEtag;
      applyData(d);
      lastSyncTime = Date.now();
      setSyncStatus('ok', t('sync.syncedAt', { time: formatRelativeTime(lastSyncTime) }));
      refresh();
    } else {
      // Body unchanged but ETag may have advanced (e.g. mutation that
      // reverted to the same content). Track the new ETag so the next poll
      // can still 304 cleanly.
      if (newEtag) _lastEtag = newEtag;
      lastSyncTime = lastSyncTime || Date.now();
    }
    ok = true;
    // Ein 200 nach einem Deploy: der Stand im ETag hat sich bewegt.
    noteServerBuild(d.build);
  } catch (e) {
    if (e.message !== 'unauthorized') setSyncStatus('err', 'Sync error');
  } finally {
    _polling = false;
    for (const res of _pollWaiters.splice(0)) res(ok);
  }
  return ok;
}

// Den Stand jetzt holen, statt auf den nächsten Takt zu warten. Läuft gerade
// eine Speicherung, kurz warten — pollSync() lässt sonst aus, damit der
// Server-Stand die eigene, noch unterwegs befindliche Änderung nicht
// überschreibt. Hängt sie, geht die Abfrage nach drei Sekunden trotzdem raus:
// ein Scanner, der auf eine tote Speicherung wartet, hilft niemandem.
// true, wenn der Server geantwortet hat.
async function syncNow() {
  for (let i = 0; i < 30 && _mutating > 0; i++) await new Promise((r) => setTimeout(r, 100));
  return (await pollSync({ force: true })) === true;
}

// ─── NEUE VERSION ────────────────────────────────────────────
// Nach einem Deploy lief auf jedem Telefon, das die App offen hatte, der alte
// Code weiter — tagelang, wenn niemand neu lud, und ohne dass es jemand sah.
// Der Server nennt den Stand seiner App-Dateien (appBuild() in server.js) bei
// jeder Abfrage und beim Verbinden des Ereignisstroms. Welcher Stand hier läuft,
// meldet der Service Worker beim Ausliefern von app.js; ohne diese Meldung gilt
// der erste Stand, den der Server nach dem Laden nennt.
//
// Weichen die beiden ab, lädt die App sich selbst neu — aber nur, wo es
// niemanden stört: beim Start, wenn sie aus dem Hintergrund zurückkommt oder
// dorthin verschwindet, und nie, solange etwas offen, unterwegs oder eingetippt
// ist. Sonst sagt ein Balken oben, dass eine neue Version da ist, mit einem
// Knopf dafür; beim nächsten ruhigen Moment lädt sie trotzdem von selbst.
let _loadedBuild = null;
let _serverBuild = null;
const _pageLoadedAt = Date.now();
let _resumedAt = 0;
// So lange nach dem Start oder dem Zurückkommen stört ein Neuladen niemanden:
// man hat noch nichts angefangen.
const UPDATE_QUIET_MS = 5000;

function noteServerBuild(build) {
  if (!build) return;
  _serverBuild = build;
  if (!_loadedBuild) _loadedBuild = build;
  checkForUpdate();
}
// Der Stand des app.js, das diese Seite wirklich bekommen hat. Er geht dem
// ersten Stand vom Server vor: kam app.js aus dem Zwischenspeicher, wäre der
// Stand des Servers der neue, obwohl hier der alte läuft.
function noteLoadedBuild(build) {
  if (!build) return;
  _loadedBuild = build;
  checkForUpdate();
}
function appOutdated() {
  return !!(_loadedBuild && _serverBuild && _loadedBuild !== _serverBuild);
}
function checkForUpdate() {
  const alt = appOutdated();
  const bar = document.getElementById('update-bar');
  if (bar) bar.hidden = !alt;
  if (!alt) return;
  const ruhig = document.hidden || Date.now() - Math.max(_pageLoadedAt, _resumedAt) < UPDATE_QUIET_MS;
  if (ruhig && reloadIsSafe() && updateReloadAllowed()) reloadForUpdate();
}

// Ist gerade etwas offen, unterwegs oder eingetippt, das ein Neuladen verlöre?
function reloadIsSafe() {
  if (_mutating > 0 || pjOriginaleUnterwegs.size > 0) return false;
  if (leaveGuards.some((g) => askGuard(g))) return false;
  // Jedes Fenster, die Kamera eingeschlossen — sie ist auch eines.
  if (document.querySelector('.modal-bg.open')) return false;
  const huelle = document.getElementById('scan-overlay');
  if (huelle && huelle.classList.contains('open')) return false;
  const ernte = document.getElementById('harvest-panel');
  if (ernte && ernte.style.display === 'block') return false;
  const fokus = document.activeElement;
  if (fokus && (/^(INPUT|TEXTAREA|SELECT)$/.test(fokus.tagName) || fokus.isContentEditable)) return false;
  return !pageHasTypedText();
}
// Ein sichtbares Textfeld auf der offenen Seite, in dem etwas steht, das beim
// Laden nicht drin stand. Die meisten Eingaben laufen über Fenster (oben schon
// abgefangen); das hier sind die Formulare, die auf einer Seite selbst stehen.
// Suchfelder zählen nicht, Auswahllisten auch nicht — die füllt das Programm
// selbst vor, und eine Auswahl ist schnell wieder getroffen.
function pageHasTypedText() {
  const seite = document.querySelector('.page.active');
  if (!seite) return false;
  for (const el of seite.querySelectorAll('input, textarea')) {
    if (el.disabled || el.readOnly || el.offsetParent === null) continue;
    const art = el.tagName === 'TEXTAREA' ? 'text' : el.type || 'text';
    if (!/^(text|number|email|tel|url|password)$/.test(art)) continue;
    if (el.value && el.value !== el.defaultValue) return true;
  }
  return false;
}

// Die Marke gegen eine Schleife: kommt nach dem Neuladen wieder der alte Code
// (das Netz war zu langsam, app.js kam aus dem Zwischenspeicher), lädt die App
// nicht gleich noch einmal, sondern zeigt den Balken.
function updateReloadAllowed() {
  try {
    const m = JSON.parse(sessionStorage.getItem('mp-update-reload') || 'null');
    return !(m && m.build === _serverBuild && Date.now() - m.at < 2 * 60 * 1000);
  } catch {
    return true;
  }
}
// Neu laden, und danach dort weitermachen, wo man war. Ohne das landete jedes
// Neuladen auf der Startseite, und wer auf "Chargen" gestanden hatte, suchte.
function reloadForUpdate() {
  try {
    sessionStorage.setItem('mp-update-reload', JSON.stringify({ build: _serverBuild, at: Date.now() }));
    sessionStorage.setItem('mp-update-where', JSON.stringify({ ...whereAmI(), at: Date.now() }));
  } catch {
    /* storage blocked — reload anyway, just without the way back */
  }
  location.reload();
}
function whereAmI() {
  const seite = document.querySelector('.page.active');
  const nav = document.querySelector('.sb-nav .sb-btn.active, .sb-footer .sb-btn.active');
  const reiter = seite ? seite.querySelector('.stab.active') : null;
  return {
    page: seite ? seite.id.replace(/^p-/, '') : null,
    btnId: nav ? nav.id : null,
    stab: reiter ? reiter.id : null,
    drilled: !!(seite && seite.classList.contains('stab-drilled'))
  };
}
function restoreAfterUpdate() {
  let w = null;
  try {
    w = JSON.parse(sessionStorage.getItem('mp-update-where') || 'null');
    sessionStorage.removeItem('mp-update-where');
  } catch {
    return;
  }
  if (!w || Date.now() - w.at > 60 * 1000) return;
  if (!w.page || !w.btnId || !document.getElementById('p-' + w.page) || !document.getElementById(w.btnId)) return;
  go(w.page, w.btnId);
  // Den Reiter wie mit einem Tipp öffnen. Am Telefon nur, wenn man in ihm
  // stand — sonst stand man auf der Liste der Reiter, und dort landet go().
  if (w.stab && (w.drilled || !sbIsPhone())) {
    const r = document.getElementById(w.stab);
    if (r) r.click();
  }
}

// Coalesce SSE-triggered reconciliation polls. Every scan (by any client)
// broadcasts a data-changed event; without coalescing, a burst of scans fires
// one full /api/data refetch per scan — the dominant cause of scan sluggishness
// as history grows. The scanning client already applies its own scan locally
// (optimistic update), so the authoritative reconcile can be deferred and
// folded into a single poll per window.
let _ssePollTimer = null;
function scheduleSsePoll() {
  if (_ssePollTimer) return; // a poll is already queued — fold this event into it
  _ssePollTimer = setTimeout(function () {
    _ssePollTimer = null;
    // If a local mutation is mid-flight, its own flow keeps the UI correct;
    // retry shortly so we still pick up other clients' interleaved changes.
    if (_mutating > 0 || _polling) {
      scheduleSsePoll();
      return;
    }
    pollSync();
  }, 500);
}

// ── SSE real-time sync (replaces 5s polling for connected clients) ──
let _sse = null;
let _sseReconnectTimer = null;
let _sseRetryDelay = 1000;
let _sseOpenedOnce = false;
function connectSSE() {
  if (_sse) return;
  try {
    _sse = new EventSource('/api/events');
    _sse.onopen = function () {
      _sseRetryDelay = 1000; // Reset backoff on successful connection
      setSyncStatus('ok', 'Connected');
      // Nach dem Wiederverbinden: was in der Lücke geändert wurde, kam als
      // Ereignis nie an. Einmal nachfragen, statt auf den nächsten Takt zu warten.
      if (_sseOpenedOnce) scheduleSsePoll();
      _sseOpenedOnce = true;
    };
    _sse.onmessage = function (ev) {
      try {
        const msg = JSON.parse(ev.data);
        if (msg.type === 'data-changed') scheduleSsePoll();
        // The stick backup announces itself; loadUsbBackup asks only for admins.
        if (msg.type === 'usb-backup') loadUsbBackup();
        if (msg.type === 'connected') {
          setSyncStatus('ok', 'Connected');
          // Nach einem Deploy startet der Server neu, und hier kommt als Erstes
          // sein Stand an — noch bevor die nächste Abfrage fällig wäre.
          noteServerBuild(msg.build);
        }
      } catch (e) {
        /* ignore parse errors */
      }
    };
    _sse.onerror = function () {
      _sse.close();
      _sse = null;
      setSyncStatus('err', 'Connection lost');
      // Exponential backoff reconnect, capped at 30s
      if (!_sseReconnectTimer) {
        _sseReconnectTimer = setTimeout(
          () => {
            _sseReconnectTimer = null;
            connectSSE();
          },
          Math.min(_sseRetryDelay, 30000)
        );
        _sseRetryDelay = Math.min(_sseRetryDelay * 2, 30000);
      }
    };
  } catch (e) {
    /* SSE not supported — polling fallback active */
  }
}

// ─── SIDEBAR ────────────────────────────────────────────────
//
// Two arrangements behind one button, and the button asks the window which one
// it is in. It asks at the moment of the click, and the answer can have changed
// since the drawer opened. Open the drawer at 760px, widen the window past 769,
// and `.sb-overlay.sb-show` stays: it is display:block at every width, and the
// only code that takes it off refuses to run above the breakpoint. What is left
// is a 40 percent black sheet over the whole application, and the tap that
// should lift it now falls into the desktop branch below and collapses the
// docked sidebar instead. Escape did not know the drawer at all. The way out
// was a reload, and the gesture that gets you there is an ordinary one: a split
// window being resized.
//
// So the phone arrangement gets a query of its own, asked once and listened to,
// instead of a width read at click time.
const sbPhone = typeof window.matchMedia === 'function' ? window.matchMedia('(max-width: 768px)') : null;
const sbIsPhone = () => (sbPhone ? sbPhone.matches : window.innerWidth <= 768);

function toggleSidebar() {
  const sb = document.getElementById('sidebar');
  const ov = document.getElementById('sb-overlay');
  if (sbIsPhone()) {
    sb.classList.toggle('sb-open');
    ov.classList.toggle('sb-show');
    document.body.classList.toggle('sb-mobile-open');
  } else {
    sb.classList.toggle('sb-collapsed');
    document.body.classList.toggle('sb-is-collapsed');
  }
  sbSyncInert();
}

// The drawer's three classes, off. Every route out of the drawer goes through
// here: navigating, Escape, tapping the veil, and crossing the breakpoint. Four
// call sites that each removed their own subset is how one of them came to
// remove none.
function sbClose() {
  document.getElementById('sidebar').classList.remove('sb-open');
  document.getElementById('sb-overlay').classList.remove('sb-show');
  document.body.classList.remove('sb-mobile-open');
  sbSyncInert();
}

// The other arrangement's state, off. Collapsing is a desktop idea, and the
// rules that carry it out (styles.css:454-461) sit outside any min-width block,
// so the phone block never takes them back. A sidebar collapsed on a desk and
// then met on a phone opens full width with every label, every group heading
// and the logo text set to display:none. Same disease as the veil this fix is
// about, in the direction the crossing handler claimed to cover.
function sbUncollapse() {
  document.getElementById('sidebar').classList.remove('sb-collapsed');
  document.body.classList.remove('sb-is-collapsed');
}

// Close the drawer when navigating. No phone gate: sbClose() removes three
// classes that the desktop arrangement never sets and derives inert from the
// arrangement itself, so on a desk it already does nothing. The gate could only
// ever suppress a cleanup, never enable one, and it was the last place left
// where a state change depended on re-reading the arrangement after the fact,
// which is the shape of the bug this branch was opened about.
function sbCloseMobile() {
  sbClose();
}

// A closed drawer is off-screen, not gone. `transform: translateX(-100%)` keeps
// all fourteen of its rows in the tab order, and there is no tabindex anywhere
// in this markup, so focus order is document order: the sidebar opens at
// index.html:1255 and closes at 1764, and the top bar with its hamburger only
// begins at 1767. The invisible rows are therefore what the FIRST Tab into the
// page walks, and what Shift+Tab from the hamburger walks back into. (An
// earlier version of this comment said Tab forward from the top bar, which
// cannot happen: forward from the hamburger leads away from the drawer.)
// `inert` is what takes an element out of tabbing and hit-testing without
// hiding it from the transition that slides it back in. Docked, the sidebar is
// on screen and must never be inert, so the flag is derived from both facts
// rather than toggled alongside the class.
function sbSyncInert() {
  const sb = document.getElementById('sidebar');
  if (!sb) return;
  sb.inert = sbIsPhone() && !sb.classList.contains('sb-open');
}

// Crossing the line in either direction puts BOTH arrangements' state back to
// nothing, because either one is meaningless in the other. Below the line the
// drawer's three classes are what must go; above it, the collapse. Doing only
// half of that is the bug this fix was opened about.
if (sbPhone) {
  sbPhone.addEventListener('change', () => {
    sbClose();
    sbUncollapse();
  });
}

// ─── NAV ─────────────────────────────────────────────────────
const PAGES = {
  dash: 'n-dash',
  batch: 'n-batch',
  lab: 'n-lab',
  print: 'n-print',
  cal: 'n-cal',
  settings: 'n-settings',
  strains: 'n-strains',
  orders: 'n-orders',
  pickups: 'n-pickups'
};
// ─── UNSAVED WORK ────────────────────────────────────────────────────────────
//
// Most of this application writes as it goes: a scan is a scan, a move is a
// move, and there is nothing to forget. A few screens cannot work that way,
// because what they store is read by somebody outside this building the moment
// it lands — a release amount typed as 50 on the way to 5 reaches a shop window
// before the second digit does. Those screens keep a Save button, and register
// here so that the button's one weakness is covered: the edit nobody pressed it
// for.
//
// Two doors, both guarded. `go()` is the way to another page; `beforeunload` is
// the tab, the reload and the back button.
const leaveGuards = [];

/**
 * @param {() => string|null} ask the question to put to the user, or null when
 *   nothing is pending.
 * @param {() => void} [discard] run once leaving is confirmed. Without it the
 *   screen would go on treating the dropped edits as pending and keep refusing
 *   the refresh that would put it right.
 */
function guardUnsaved(ask, discard) {
  leaveGuards.push({ ask, discard });
}

// A guard that throws must not lock the application on one page.
function askGuard(g) {
  try {
    return g.ask();
  } catch (e) {
    return null;
  }
}

/** True when walking away is fine — nothing pending, or it was confirmed. */
function mayLeavePage() {
  // Ask every pending guard before discarding any of them: a "cancel" on the
  // second question must not leave the first one's edits already thrown away.
  const offen = leaveGuards.map((g) => [g, askGuard(g)]).filter(([, frage]) => frage);
  for (const [, frage] of offen) if (!window.confirm(frage)) return false;
  for (const [g] of offen) if (g.discard) g.discard();
  return true;
}

// The browser writes its own wording here and ignores ours — the string only has
// to be non-empty. The sentence people actually read is the one in mayLeavePage().
window.addEventListener('beforeunload', (e) => {
  if (!leaveGuards.some((g) => askGuard(g))) return;
  e.preventDefault();
  e.returnValue = '';
});
// Originale unterwegs halten nur das Schliessen auf, nicht go(): ein Wechsel
// der Seite in der App laesst sie weiterlaufen.
window.addEventListener('beforeunload', (e) => {
  if (!pjOriginaleUnterwegs.size) return;
  e.preventDefault();
  e.returnValue = '';
});

// Where "Zurück" out of the admin section leads. Recorded on the way in, so it
// lands where the user actually was instead of always on the dashboard.
let lastMainPage = { page: 'dash', btnId: 'n-dash' };

function go(page, btnId) {
  if (!mayLeavePage()) return;
  if (page !== 'settings') lastMainPage = { page, btnId };
  // Admin borrows the sidebar on a desktop; styles.css reads this flag.
  document.body.classList.toggle('admin-mode', page === 'settings');
  // The footer button changes job with it. Sighted users read that off the
  // arrow and the green; a screen reader reads only the label, so say it.
  const adminBtn = document.getElementById('n-settings');
  if (adminBtn) adminBtn.setAttribute('aria-label', t(page === 'settings' ? 'nav.adminBack' : 'nav.admin'));
  document.querySelectorAll('.page').forEach((p) => p.classList.remove('active'));
  document.querySelectorAll('.sb-nav .sb-btn, .sb-footer .sb-btn').forEach((b) => b.classList.remove('active'));
  document.querySelectorAll('.bottom-nav-btn').forEach((b) => b.classList.remove('active'));
  document.getElementById('p-' + page).classList.add('active');
  const navBtn = document.getElementById(btnId);
  navBtn.classList.add('active');
  // The mobile topbar says which page this is. Read off the entry that opened it
  // rather than a second table of names: a page added to the sidebar is named
  // here without anyone remembering to, and a renamed one is renamed once.
  const title = document.getElementById('topbar-title');
  const label = navBtn.querySelector('[data-i18n]');
  if (title && label) {
    title.dataset.i18n = label.dataset.i18n;
    title.textContent = label.textContent;
  }
  // Mirror active state onto the mobile bottom nav for the four pages it covers.
  const bnBtn = document.querySelector('.bottom-nav-btn[data-page="' + page + '"]');
  if (bnBtn) bnBtn.classList.add('active');
  // The pipeline strip and the "where is everything" list live on the Chargen
  // page now, and lab stock on Labor — each section carries its own overview
  // instead of the dashboard carrying all of them. renderStatus fills both
  // #metrics and #dash-locations, so it belongs with the page that shows them.
  // The day's work is the top of Arbeitsgänge now, above the seven jobs that do
  // it — it was the Dashboard's Farm mode, which was two buttons and this row.
  if (page === 'work') {
    renderDashBatchTasks();
    loadLabStock();
  }
  if (page === 'batch') {
    renderStatus();
    renderBatches();
  }
  if (page === 'lab') {
    loadLabStock();
    renderCultures();
    renderGrainBatches();
  }
  if (page === 'inv') {
    renderInvStock();
  }
  if (page === 'zones') renderZones();
  if (page === 'print') {
    fillBatchSelect();
    renderLabList();
    refreshPrinterStatus();
  }
  if (page === 'cal') {
    renderCalendar();
    loadCalDAVImports().then(() => renderCalendar());
  }
  // Admin opens on whichever sub-tab is selected — Server on the first visit of
  // a session, and after that wherever the user last was. Clicking that button
  // rather than calling a loader here keeps one wiring per sub-tab: the strip
  // handler already knows what its panel needs, and it is the same path the
  // sidebar list takes.
  if (page === 'settings') {
    const stab = document.querySelector('#p-settings .stab.active');
    if (stab) stab.click();
  }
  // The history charts load on first arrival. applyDashMode() used to do this on
  // the way into Overview mode; the mode is gone and the page is the Overview.
  // Die Betriebsseite zeichnete sich nie selbst. renderOverviewKPIs() haengt
  // an renderStatus(), das fuer die Chargen-Seite laeuft — wer Betrieb oeffnete,
  // sah also, was beim letzten Besuch der Chargen uebrig geblieben war, und beim
  // Neuladen gar nichts. Dieselbe Sache wie bei Arbeitsgaenge (#566), eine Seite
  // weiter.
  if (page === 'dash') renderOverviewKPIs();
  if (page === 'dash' && !kpiHistoryData) loadKpiHistory();
  if (page === 'strains') renderStrains();
  // Dieselbe Regel wie bei Admin und Bestellungen: welcher Reiter aufgeht,
  // entscheidet die Leiste und nicht diese Liste. Der Reiter weiß selbst, was
  // sein Panel braucht, und es ist derselbe Weg, den ein Tipp auf die Leiste
  // nimmt — eine Verdrahtung je Unterseite statt zwei.
  if (page === 'proj') {
    const stab = document.querySelector('#p-proj .stab.active');
    if (stab) stab.click();
  }
  // Same rule as Admin above, and for the same reason: the strip handler already
  // knows what its panel needs. Rendering the inbox here instead drew a list the
  // user may not have asked for, every time — the four other views then drew
  // over it from openStab().
  if (page === 'orders') {
    const stab = document.querySelector('#p-orders .stab.active');
    if (stab) stab.click();
  }
  if (page === 'pickups') renderPickups();
  updateTodoBadge();
  // Every page, Admin included, is somewhere the user has now arrived, so the
  // drawer gets out of the way. Admin used to be the exception — the drawer
  // swapped its list for the sub-tabs and stayed open, because on a phone
  // closing it left nothing to navigate the section with. The section now has
  // its own list on the page, so keeping the drawer open would only put the
  // same thirteen entries on top of the thirteen behind it.
  sbCloseMobile();
}
function openStab(page, sub) {
  document.querySelectorAll(`#p-${page} .stab`).forEach((b) => b.classList.remove('active'));
  document.querySelectorAll(`#p-${page} .sp`).forEach((p) => p.classList.remove('active'));
  const stEl = document.getElementById(`st-${page}-${sub}`);
  if (stEl) stEl.classList.add('active');
  const spEl = document.getElementById(`sp-${page}-${sub}`);
  if (spEl) spEl.classList.add('active');
  // The sidebar list and the sub-tab strip show the same selection — the
  // sidebar on a desktop, the strip on a phone. Marking both here keeps them
  // in step whichever one was clicked. A no-op for pages without a sidebar list.
  document.querySelectorAll('.sb-admin-nav .sb-btn').forEach((b) => b.classList.remove('active'));
  const snEl = document.getElementById(`sn-${page}-${sub}`);
  if (snEl) snEl.classList.add('active');
  if (page === 'batch' && sub === 'list') {
    renderBatches();
  }
  // Painted on arrival rather than on every sync: renderStatus() walks the whole
  // scan log once per rack and once per zone, and this panel is display:none
  // until somebody asks for it.
  if (page === 'batch' && sub === 'locations') renderStatus();
  if (page === 'batch' && sub === 'new') nbEnsureReady();
  if (page === 'batch' && sub === 'substrate') renderSubstrateTab();
  if (page === 'batch' && sub === 'harvest') renderHarvests();
  if (page === 'batch' && sub === 'blocks') {
    renderBlockBook();
    loadBlockBook();
  }
  if (page === 'lab' && sub === 'cultures') renderCultures();
  if (page === 'lab' && sub === 'work') {
    lwUpdate();
    renderLabLog();
  }
  if (page === 'lab' && sub === 'lineage') fillLineageSelect();
  if (page === 'lab' && sub === 'contam') renderContamReports();
  if (page === 'inv' && sub === 'stock') renderInvStock();
  if (page === 'inv' && sub === 'delivery') {
    delMatChange();
    adjMatChange();
  }
  if (page === 'inv' && sub === 'log') renderInvLog();
  if (page === 'print' && sub === 'bags') fillBatchSelect();
  if (page === 'print' && sub === 'lab') {
    renderLabList();
    renderLabPreview();
  }
  if (page === 'print' && sub === 'ref') renderRefBarcodes();
  if (page === 'cal' && sub === 'cal') {
    loadCalDAVImports().then(() => renderCalendar());
    // Best effort, and deliberately not awaited: the calendar must draw whether
    // or not this answers. With no answer the warning simply does not fire.
    loadPickupBookings();
  }
  if (page === 'settings' && sub === 'caldav') loadCaldavSettings();
  if (page === 'settings' && sub === 'backup') loadUsbBackup();
  if (page === 'settings' && sub === 'duckdns') loadDuckdnsSettings();
  if (page === 'settings' && sub === 'harvestfeed') loadHarvestFeedSettings();
  if (page === 'settings' && sub === 'pickuplocations') renderPickupLocations();
  if (page === 'settings' && sub === 'versand') loadShipSettings();
  if (page === 'settings' && sub === 'channels') loadChannelsSettings();
  if (page === 'settings' && sub === 'mcp') loadMcpSettings();
  if (page === 'settings' && sub === 'log') renderLog();
  if (page === 'orders' && sub === 'pack') renderOrderBoard();
  if (page === 'orders' && sub === 'inbox') renderOrders();
  if (page === 'orders' && sub === 'tomake') renderOrdersDemand();
  if (page === 'orders' && sub === 'mapping') renderOrdersMapping();
  if (page === 'orders' && sub === 'customers') renderOrdersCustomers();
  if (page === 'orders' && sub === 'versand') renderOrdersVersand();
  if (page === 'proj') {
    if (sub === 'versuch') renderVersuch();
    else renderProjekte(sub);
  }
  // A phone shows one sub-page at a time, with a back row where the strip was.
  // Every route into a sub-page runs through here — the strip, the admin
  // drawer, and the dozen `openStab(...)` calls that land somewhere after a
  // save — so this is the one place that has to say "we are inside one now".
  //
  // Both guards are load-bearing. `stab-drill` is only on the pages
  // stabDrillInit() gave a back row to, so a page with no way out never gets
  // shut into a sub-page. And a tab that is not in the list is not a place to
  // land — see stabLandable().
  const pgEl = document.getElementById(`p-${page}`);
  if (pgEl && pgEl.classList.contains('stab-drill') && stabLandable(stEl, spEl))
    pgEl.classList.add('stab-drilled');
}

// A sub-tab hidden from the strip is not somewhere to send a phone: the list it
// would have to go back through does not offer it. Admin's "Server" is the one
// that exists — it opens on first visit of a session and is display:none in
// both the strip and the sidebar list — so on a phone Admin opens on its index
// instead of on a panel the index cannot reach.
// Zweiter Weg hinein: ein Panel, das ein Leitknopf über der Leiste öffnet.
//
// "Neue Charge" und "Laborarbeit" waren einmal Reiter. Sie sind jetzt Knöpfe
// über der Leiste, weil sie etwas anlegen statt eine Ansicht zu wechseln —
// und mit dem Reiter verschwand das Element, an dem diese Prüfung hängt. Am
// Telefon hieß das: Knopf antippen, .sp bekommt .active, und die Regel
// `.page.stab-drill:not(.stab-drilled) .sp { display: none }` lässt es
// trotzdem verborgen. Der Knopf tat nichts, auf genau dem Gerät, auf dem die
// Anwendung meistens läuft.
//
// Die ursprüngliche Begründung bleibt gültig: ein Ziel braucht einen Weg
// zurück, den die Liste anbietet. Ein Leitknopf ist so ein Weg, er steht nur
// über der Liste statt darin. Panels, die so erreicht werden, sagen es selbst.
function stabLandable(stab, panel) {
  if (panel && panel.dataset && panel.dataset.stabLead !== undefined) return true;
  return !!stab && stab.style.display !== 'none';
}

// Gives each sub-tab strip its back row and decides which of the two states the
// page starts in. See the drill-down block in styles.css for what the states
// look like; this only sets the class, so above 769px it is inert.
function stabDrillInit() {
  document.querySelectorAll('.page > .stabs').forEach((strip) => {
    // A strip that is hidden is not an index anyone can go back to, so a page
    // carrying one gets no back row. Nothing hides one today — Bestellungen was
    // the last, and its five views were sidebar entries at the time.
    if (strip.style.display === 'none') return;
    const page = strip.parentElement;
    const home = strip.dataset.stabHome;
    const back = document.createElement('button');
    back.type = 'button';
    back.className = 'stab-back';
    // The label is the page's own name — where the row leads, not where you
    // are; the sub-page below it already says that. data-i18n on the span (and
    // data-i18n-aria-label on the button) hands both to translatePage(), so a
    // language switch reaches them like any other string in the markup.
    back.setAttribute('data-i18n-aria-label', 'nav.backToList');
    back.setAttribute('aria-label', t('nav.backToList'));
    const ico = document.createElement('span');
    ico.className = 'stab-back-ico';
    ico.setAttribute('aria-hidden', 'true');
    ico.textContent = '\u2190';
    const label = document.createElement('span');
    label.setAttribute('data-i18n', home);
    label.textContent = t(home);
    back.append(ico, label);
    back.addEventListener('click', () => page.classList.remove('stab-drilled'));
    page.insertBefore(back, strip);
    // The marker is what scopes the CSS. Only a page that got a back row here
    // may have its sub-pages hidden, because only that page can get them back:
    // Bestellungen keeps its strip display:none on every device, and hiding its
    // panels on the way to an index it does not have renders the page blank.
    page.classList.add('stab-drill');
    // Land on the sub-page the page defaults to, unless that tab is not one you
    // can land on — same rule as openStab(), so both entrances agree.
    if (stabLandable(strip.querySelector('.stab.active'))) page.classList.add('stab-drilled');
  });
}
function refresh() {
  // P-05: invalidate the per-batch status cache before each render. This is
  // belt-and-braces — applyData() also clears it on incoming data — but
  // covers local mutation paths (push to scanLog, removeBag, etc.) that
  // don't go through applyData. The cache is rebuilt lazily on first
  // getStatus() call within this render pass, then reused for the rest.
  _statusByBatch = null;
  _rhythmIndex = null;
  _placementByBag = null;
  const active = document.querySelector('.page.active');
  if (!active) return;
  const id = active.id.replace('p-', '');
  // Arbeitsgänge ist die Seite, mit der die App aufmacht, und der einzige Zweig,
  // der ihre Liste zeichnete, hieß 'dash' — dort stand die Karte, bevor sie
  // hierher zog. Also zeigte ein Neuladen die sieben Kacheln und darüber nichts,
  // bis man die Seite verließ und über go() zurückkam; und solange man blieb,
  // frischte weder ein SSE-Ereignis noch der 30-Sekunden-Takt sie je auf.
  // #dash-batch-tasks steht nicht auf p-dash, der alte Zweig zeichnete also eine
  // Karte, die auf der offenen Seite gar nicht vorkommt.
  if (id === 'work') {
    renderDashBatchTasks();
    loadLabStock();
  }
  if (id === 'dash') renderOverviewKPIs();
  if (id === 'batch') {
    renderStatus();
    renderBatches();
  }
  if (id === 'lab') {
    loadLabStock();
    renderCultures();
    renderGrainBatches();
  }
  if (id === 'inv') renderInvStock();
  if (id === 'zones') renderZones();
  if (id === 'cal') renderCalendar();
  if (id === 'strains') renderStrains();
  if (id === 'proj') pjRefresh();
  if (id === 'orders') _refreshOrdersActive();
  // Pickups arrive on the feed's own schedule, not on any action taken here, so
  // this page has no other way to notice that something changed.
  if (id === 'pickups') renderPickups();
  updateTodoBadge();
  // Cheap, and how a language switch reaches the stick reminder and card.
  renderUsbReminder();
  if (id === 'settings') renderUsbCard();
}

// ═══ ORDER HUB (Phase 0) ═══════════════════════════════════════════════════
// Sales orders → products → production demand. Fetched on demand from the
// dedicated /api/orders, /api/products, /api/customers endpoints (not the
// /api/data full-state blob). See ORDERS_HUB_DESIGN.md.
//
// Module-level DOM helper: the app's main `$` is declared local to
// initEventListeners, so these top-level render functions need their own.
const $ = (id) => document.getElementById(id);
let _ordersCache = [];
let _ordersFilter = '';

function _ohEmpty(cols, msg) {
  return `<tr><td class="empty" colspan="${cols}" style="text-align:center;padding:16px;color:var(--c-text-muted)">${esc(msg)}</td></tr>`;
}
// The channel's name on its own. _ohChannel() wraps it in the pill; the search
// index wants the words without the markup around them.
function _ohChannelLabel(ch) {
  return ch === 'manual' ? t('orders.manual') : ch === 'ebay' ? 'eBay' : ch ? ch.charAt(0).toUpperCase() + ch.slice(1) : '—';
}
function _ohChannel(ch) {
  return `<span class="oh-ch oh-ch-${esc(ch || 'manual')}">${esc(_ohChannelLabel(ch))}</span>`;
}
function _ohStatus(st) {
  return `<span class="oh-st oh-st-${esc(st)}">${esc(t('orders.status.' + st))}</span>`;
}
function _refreshOrdersActive() {
  const active = document.querySelector('#p-orders .sp.active');
  const id = active ? active.id : 'sp-orders-pack';
  if (id === 'sp-orders-pack') renderOrderBoard();
  else if (id === 'sp-orders-tomake') renderOrdersDemand();
  else if (id === 'sp-orders-mapping') renderOrdersMapping();
  else if (id === 'sp-orders-customers') renderOrdersCustomers();
  else if (id === 'sp-orders-versand') renderOrdersVersand();
  else renderOrders();
}

// One reader for the orders snapshot, and one for the customer list. Both used
// to be fetched from two places — the page that shows them and the search that
// indexes them — each writing the module cache from its own `.then()`, so two
// answers to the same question could land in either order and the table could
// end up showing rows the cache no longer held. The endpoint and its limit are
// written once here, so they cannot drift apart either.
function loadOrders() {
  return apiGet('/api/orders?limit=500').then((d) => {
    _ordersCache = d.items || [];
    gsIndexInvalidate();
    return _ordersCache;
  });
}
// The server caps this at 1000 and defaults to 200 (db.listCustomers), ordered
// by spend. 200 is a fine page of a table and a poor thing to search: a customer
// past the first 200 would not exist as far as the palette was concerned, with
// nothing on screen to say so. Ask for the maximum the server will give.
function loadCustomers() {
  return apiGet('/api/customers?limit=1000').then((d) => {
    _ohCustomerCache = d.items || [];
    gsIndexInvalidate();
    return _ohCustomerCache;
  });
}

function renderOrders() {
  const body = $('orders-body');
  if (!body) return;
  loadOrders()
    .then(() => {
      _renderOrdersInbox();
    })
    .catch(() => {
      body.innerHTML = _ohEmpty(6, t('common.error'));
    });
  apiGet('/api/products/unmapped')
    .then((d) => {
      const items = d.items || [];
      const banner = $('orders-unmapped-banner');
      if (banner) banner.style.display = items.length ? 'flex' : 'none';
      const cnt = $('orders-unmapped-count');
      if (cnt) cnt.textContent = items.length;
    })
    .catch(() => {});
}

function _renderOrdersInbox() {
  const body = $('orders-body');
  if (!body) return;
  const rows = _ordersCache.filter((o) => !_ordersFilter || o.status === _ordersFilter);
  if (!rows.length) {
    body.innerHTML = _ohEmpty(6, t('orders.none'));
    return;
  }
  body.innerHTML = rows
    .map(
      (o) =>
        `<tr data-find="order:${esc(o.channelOrderId)}"><td data-mlabel="${esc(t('orders.th.channel'))}">${_ohChannel(o.channel)}</td>` +
        `<td class="fs-xs" data-mlabel="${esc(t('orders.th.order'))}" style="font-family:monospace">${esc(o.channelOrderId)}</td>` +
        `<td data-mlabel="${esc(t('orders.th.customer'))}">${esc(o.customerName || '—')}</td>` +
        `<td data-mlabel="${esc(t('orders.th.items'))}">${o.itemCount || 0}${o.unmappedCount ? ` <span class="oh-warn" title="${esc(t('orders.unmappedLines'))}">⚠︎</span>` : ''}</td>` +
        `<td class="fs-xs" data-mlabel="${esc(t('orders.th.shipBy'))}">${o.shipBy ? esc(fmtDt(o.shipBy)) : '—'}</td>` +
        `<td data-mlabel="${esc(t('orders.th.status'))}">${_ohStatus(o.status)}</td></tr>`
    )
    .join('');
}

function setOrdersFilter(f) {
  _ordersFilter = f;
  document
    .querySelectorAll('#sp-orders-inbox .oh-fchip')
    .forEach((c) => c.classList.toggle('active', (c.dataset.filter || '') === f));
  _renderOrdersInbox();
}

function renderOrdersDemand() {
  const body = $('demand-body');
  if (!body) return;
  body.innerHTML = _ohEmpty(6, t('common.loading'));
  apiGet('/api/orders/demand')
    .then((d) => {
      const rows = d.items || [];
      if (!rows.length) {
        body.innerHTML = _ohEmpty(5, t('orders.demandNone'));
        return;
      }
      body.innerHTML = rows
        .map((r) => {
          const comps = (r.components || []).length
            ? r.components
                .map(
                  (c) =>
                    `<span style="display:inline-block;margin-right:10px;${c.short > 0 ? 'color:var(--c-red-dark);font-weight:600' : 'color:var(--c-text-muted)'}">` +
                    `${esc(_ohMatName(c.mat))} ${_ohN(c.need)}${esc(c.unit || '')}${c.short > 0 ? ' (−' + _ohN(c.short) + ')' : ' ✓'}</span>`
                )
                .join('')
            : '<span class="muted">—</span>';
          const produce =
            r.toProduce > 0
              ? `<strong>${r.toProduce}</strong>${r.componentsShort ? ` <span class="oh-warn" title="${esc(t('orders.componentsShort'))}">⚠︎</span>` : ''}`
              : r.backorder > 0
                ? `<span class="oh-st oh-st-cancelled">${r.backorder} ${esc(t('orders.backorder'))}</span>`
                : '<span class="muted">0</span>';
          return (
            `<tr><td data-mlabel="${esc(t('orders.th.product'))}"><strong>${esc(r.product)}</strong> <span class="muted fs-xs">${esc(r.category || '')}</span></td>` +
            `<td data-mlabel="${esc(t('orders.th.demand'))}">${r.demand}</td>` +
            `<td data-mlabel="${esc(t('orders.th.fromStock'))}">${r.fromStock}</td>` +
            `<td data-mlabel="${esc(t('orders.th.toProduce'))}">${produce}</td>` +
            `<td class="fs-xs" data-mlabel="${esc(t('orders.th.startBy'))}">${r.startBy ? esc(r.startBy) : '—'}</td>` +
            `<td class="fs-xs" data-mlabel="${esc(t('orders.th.components'))}">${comps}</td></tr>`
          );
        })
        .join('');
    })
    .catch(() => {
      body.innerHTML = _ohEmpty(5, t('common.error'));
    });
}

// ── Packen: what to pack today, what to make first ─────────────────────────
// The shop orders Billbee holds, as the floor reads them: one card per parcel
// to pack, and one total per made-to-order product. Built on the server
// (order-board.js) from what the 15-minute Billbee sync stored; this only draws.
// Cards rather than a table, because this is read on a phone at the packing
// table, and a table of five columns is a sideways scroll there.
//
// "Gepackt" and "Hergestellt" are this app's own marks, one tap each with an
// undo. Billbee's state is shown on the card and decides nothing: its rules
// buy the label and set "Versendet" before anybody has packed the parcel.
let _obBoard = null;

// A day as the floor says it: "heute", "morgen", or a short weekday and date.
// Parsed at noon so no time zone can push the day over midnight.
function _obDay(day) {
  if (!day || !_obBoard) return '';
  if (day === _obBoard.today) return t('orders.board.today');
  const d = new Date(day + 'T12:00:00');
  const tomorrow = new Date(_obBoard.today + 'T12:00:00');
  tomorrow.setDate(tomorrow.getDate() + 1);
  if (d.toDateString() === tomorrow.toDateString()) return t('orders.board.tomorrow');
  return d.toLocaleDateString(loc(), { weekday: 'short', day: '2-digit', month: '2-digit' });
}
function _obTime(iso) {
  const d = new Date(iso);
  return String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0');
}
// Who and when, for a mark: "10:42 · erika", or the date when it was not today.
function _obWhoWhen(m) {
  if (!m) return '';
  const day = fmtDtShort(m.at);
  const when = day === fmtDtShort(new Date()) ? _obTime(m.at) : day + ' ' + _obTime(m.at);
  return m.by ? when + ' · ' + m.by : when;
}
// The shop an order came from. Billbee orders name it; the direct connections
// are their own shop. The pill colour follows the shop, the text is its name.
function _obShop(o) {
  const name = o.shop || _ohChannelLabel(o.channel);
  const n = String(name).toLowerCase();
  const slug = ['ebay', 'etsy', 'wix', 'shopify'].find((s) => n.includes(s)) || 'manual';
  return `<span class="oh-ch oh-ch-${slug}">${esc(name)}</span>`;
}
function _obBillbee(o) {
  if (o.channel !== 'billbee') return '';
  return `<span class="ob-bb ob-bb-${esc(o.billbee)}">${esc(t('orders.board.bb.' + o.billbee))}</span>`;
}
function _obItems(items) {
  if (!items || !items.length) return `<div class="muted fs-meta">${esc(t('orders.board.noItems'))}</div>`;
  return (
    '<ul class="ob-items">' +
    items
      .map(
        (it) =>
          // Quantity and SKU, nothing else: the SKU is what is on the shelf.
          // A line without one shows its title instead, so it is not lost.
          `<li${it.title ? ` title="${esc(it.title)}"` : ''}><span class="ob-qty">${esc(it.qty)}×</span> ` +
          (it.sku
            ? `<span class="ob-line-sku">${esc(it.sku)}</span>`
            : `<span class="ob-title">${esc(it.title || '—')}</span>`) +
          (it.madeToOrder ? ` <span class="ob-tag ob-tag-make">${esc(t('orders.board.madeTag'))}</span>` : '') +
          '</li>'
      )
      .join('') +
    '</ul>'
  );
}
function _obMarkBtn(o, kind, on, primary) {
  const label = on
    ? t(kind === 'packed' ? 'orders.board.markPacked' : 'orders.board.markMade')
    : t(kind === 'packed' ? 'orders.board.unpack' : 'orders.board.unmade');
  return (
    `<button class="btn btn-sm${primary ? ' btn-p' : ''}" data-action="ob-mark" data-id="${o.id}"` +
    ` data-kind="${kind}" data-on="${on ? 1 : 0}">${esc(label)}</button>`
  );
}
function _obPlan(o) {
  if (!o.plannedLabelDay) return '';
  return `<span class="ob-plan${o.labelDue ? ' is-due' : ''}">${esc(t('orders.board.labelOn', { day: _obDay(o.plannedLabelDay) }))}</span>`;
}
function _obOrderCard(o, mode) {
  // The person first, so the parcel can be matched to a label at a glance.
  const who = o.customer ? `<div class="ob-customer">${esc(o.customer)}</div>` : '';
  const top =
    who +
    `<div class="ob-order-top">${_obShop(o)}` +
    `<span class="ob-num">${esc(o.number)}</span>` +
    `<span class="ob-when">${esc(_obDay(o.orderDay))}</span>` +
    _obBillbee(o) +
    (o.webUrl
      ? `<a class="ob-link" href="${esc(o.webUrl)}" target="_blank" rel="noopener">${esc(t('orders.board.openBillbee'))}</a>`
      : '') +
    '</div>';
  const notes = [];
  if (o.combine && o.combine.size === 1) notes.push(t('orders.board.combineTagged'));
  if (o.waitsForGroup) notes.push(t('orders.board.waitsForGroup'));
  const noteHtml = notes.map((n) => `<div class="ob-combine-solo">${esc(n)}</div>`).join('');
  let foot = '';
  if (mode === 'pack') {
    const made = o.made
      ? `<span class="ob-done">✓ ${esc(t('orders.board.madeBy', { who: _obWhoWhen(o.made) }))}</span>` +
        _obMarkBtn(o, 'made', false, false)
      : '';
    foot = `<div class="ob-order-foot">${_obPlan(o)}${made}${_obMarkBtn(o, 'packed', true, true)}</div>`;
  } else if (mode === 'later') {
    const btn = o.needsMaking ? _obMarkBtn(o, 'made', true, true) : '';
    foot = `<div class="ob-order-foot">${_obPlan(o)}${btn}</div>`;
  } else if (mode === 'done') {
    foot =
      `<div class="ob-order-foot"><span class="ob-done">✓ ${esc(t('orders.board.packedBy', { who: _obWhoWhen(o.packed) }))}</span>` +
      _obMarkBtn(o, 'packed', false, false) +
      '</div>';
  }
  return `<div class="ob-order${mode === 'done' ? ' is-packed' : ''}">${top}${noteHtml}${_obItems(o.items)}${foot}</div>`;
}
// Orders that go into one parcel sit in one frame, with the reason on top, so
// nobody tapes up the first box before the second order is in it.
function _obOrderList(rows, mode) {
  let html = '';
  for (let i = 0; i < rows.length; i++) {
    const o = rows[i];
    const key = o.combine && o.combine.key;
    if (key && o.combine.size > 1) {
      const group = [];
      while (i < rows.length && rows[i].combine && rows[i].combine.key === key) group.push(rows[i++]);
      i--;
      // The other order of the pair is in another list (packed already, say).
      // Say so on the card instead of framing a group of one.
      if (group.length === 1) {
        html += _obOrderCard(o, mode).replace(
          '<ul class="ob-items">',
          `<div class="ob-combine-solo">${esc(t('orders.board.combineElsewhere'))}</div><ul class="ob-items">`
        );
        continue;
      }
      html +=
        `<div class="ob-group"><div class="ob-group-head">${esc(t('orders.board.combine', { n: group.length }))}</div>` +
        group.map((g) => _obOrderCard(g, mode)).join('') +
        '</div>';
    } else {
      html += _obOrderCard(o, mode);
    }
  }
  return html;
}
function _obEmpty(msg) {
  return `<div class="ob-empty">${esc(msg)}</div>`;
}
function _obSyncLine(b) {
  const el = $('ob-sync');
  if (!el) return;
  const s = b.sync || {};
  const when = s.lastSync ? fmtDtTime(s.lastSync) : null;
  const parts = [];
  if (s.problem) parts.push(`<span>${esc(t('orders.board.sync.' + s.problem, { time: when || '—' }))}</span>`);
  else if (when) parts.push(`<span class="muted">${esc(t('orders.board.syncedAt', { time: when }))}</span>`);
  if (b.unpaid)
    parts.push(
      `<span class="muted">${esc(t(b.unpaid === 1 ? 'orders.board.unpaid.one' : 'orders.board.unpaid.other', { n: b.unpaid }))}</span>`
    );
  if (s.canSync) parts.push(`<button class="btn btn-sm" data-action="ob-sync-now">${esc(t('orders.board.syncNow'))}</button>`);
  el.innerHTML = parts.join('');
  el.classList.toggle('is-warn', !!s.problem && s.problem !== 'never');
  el.style.display = parts.length ? 'flex' : 'none';
}
// A size as the shelf says it: 1750 → "1,75 kg", 700 → "700 g". Sizes that are
// not grams (a sort, an old SKU number) are shown as they are.
function _obSize(sz) {
  if (sz.grams == null) return sz.size || '';
  if (sz.grams >= 1000) return (sz.grams / 1000).toLocaleString(loc(), { maximumFractionDigits: 2 }) + ' kg';
  return sz.grams + ' g';
}
// Alles zusammen: every open order counted once, per product — the list to
// pull from the shelf before packing order by order.
function _obTotals(totals) {
  if (!totals || !totals.length) return _obEmpty(t('orders.board.totalsNone'));
  return totals
    .map((tt) => {
      const sizes = tt.sizes
        .filter((sz) => sz.size != null)
        .map((sz) => `<span class="ob-size">${esc(sz.pieces)} × ${esc(_obSize(sz))}</span>`)
        .join('');
      const skus = tt.skus.map((x) => `${esc(x.qty)}× ${esc(x.sku)}`).join(' · ');
      return (
        `<div class="ob-total">` +
        `<div class="ob-total-top"><span class="ob-total-n">${esc(tt.pieces)}</span>` +
        `<span class="ob-total-name">${esc(tt.product || tt.title || '—')}</span>` +
        (tt.madeToOrder ? ` <span class="ob-tag ob-tag-make">${esc(t('orders.board.madeTag'))}</span>` : '') +
        `<span class="ob-total-orders">${esc(t(tt.orders === 1 ? 'orders.board.ordersN.one' : 'orders.board.ordersN.other', { n: tt.orders }))}</span></div>` +
        (sizes ? `<div class="ob-sizes">${sizes}</div>` : '') +
        (skus ? `<div class="ob-total-skus">${skus}</div>` : '') +
        '</div>'
      );
    })
    .join('');
}
function _obMakeList(make) {
  if (!make.length) return _obEmpty(t('orders.board.makeNone'));
  return make
    .map(
      (m) =>
        `<div class="ob-make${m.overdue ? ' is-late' : ''}">` +
        `<div class="ob-make-top"><span class="ob-make-qty">${esc(m.qty)}×</span>` +
        `<span class="ob-line-sku"${m.title ? ` title="${esc(m.title)}"` : ''}>${esc(m.sku)}</span></div>` +
        `<div class="ob-make-meta">${esc(t(m.orders === 1 ? 'orders.board.ordersN.one' : 'orders.board.ordersN.other', { n: m.orders }))}</div>` +
        '<div class="ob-make-days">' +
        m.byDay
          .map(
            (d) =>
              `<span class="ob-day${d.day <= _obBoard.today ? ' is-late' : ''}">${esc(t('orders.board.labelOnQty', { qty: d.qty, day: _obDay(d.day) }))}</span>`
          )
          .join('') +
        '</div></div>'
    )
    .join('');
}
function _renderOrderBoard() {
  const b = _obBoard;
  if (!b) return;
  _obSyncLine(b);
  const tot = $('ob-totals');
  if (tot) tot.innerHTML = _obTotals(b.totals);
  const cnt = $('ob-pack-count');
  if (cnt) cnt.textContent = b.pack.length ? String(b.pack.length) : '';
  const pack = $('ob-pack');
  if (pack) pack.innerHTML = b.pack.length ? _obOrderList(b.pack, 'pack') : _obEmpty(t('orders.board.packNone'));
  const make = $('ob-make');
  if (make) make.innerHTML = _obMakeList(b.make);
  const laterCard = $('ob-later-card');
  if (laterCard) laterCard.style.display = b.later.length ? '' : 'none';
  const later = $('ob-later');
  if (later) later.innerHTML = _obOrderList(b.later, 'later');
  const lc = $('ob-later-count');
  if (lc) lc.textContent = b.later.length ? String(b.later.length) : '';
  const done = $('ob-done');
  if (done) done.innerHTML = b.done.length ? _obOrderList(b.done, 'done') : _obEmpty(t('orders.board.doneNone'));
  const dc = $('ob-done-count');
  if (dc) dc.textContent = b.done.length ? String(b.done.length) : '';
}
function renderOrderBoard() {
  const pack = $('ob-pack');
  if (!pack) return;
  if (!_obBoard) pack.innerHTML = _obEmpty(t('common.loading'));
  apiGet('/api/orders/board')
    .then((b) => {
      _obBoard = b;
      _renderOrderBoard();
    })
    .catch(() => {
      // Keep the last list on screen if there is one: a dropped connection on
      // the floor should not blank what somebody is packing from.
      const el = $('ob-sync');
      if (el) {
        el.innerHTML = `<span>${esc(t('orders.board.loadFailed'))}</span>`;
        el.classList.add('is-warn');
        el.style.display = 'flex';
      }
      if (!_obBoard) pack.innerHTML = '';
    });
}
// One tap sets the mark, the bar offers the way back. The mark lives in this
// app (order_marks) with who and when; Billbee is not told.
function _obSetMark(id, kind, on) {
  return apiPost('/api/orders/board/mark', { id: Number(id), kind, on }).then((r) => {
    if (r && r.error) {
      toast(t('orders.board.saveFailed'), 'err');
      return false;
    }
    return true;
  });
}
function obMark(id, kind, on) {
  _obSetMark(id, kind, on).then((ok) => {
    if (!ok) return;
    renderOrderBoard();
    const msg = t(
      kind === 'packed'
        ? on
          ? 'orders.board.packedMsg'
          : 'orders.board.unpackedMsg'
        : on
          ? 'orders.board.madeMsg'
          : 'orders.board.unmadeMsg'
    );
    showUndoBar(msg, () => _obSetMark(id, kind, !on).then(() => renderOrderBoard()));
  });
}
function obSyncNow(btn) {
  if (btn) btn.disabled = true;
  apiPost('/api/channels/billbee/sync').then((r) => {
    if (btn) btn.disabled = false;
    if (r && r.error) toast(t('orders.board.syncFailed'), 'err');
    renderOrderBoard();
  });
}

function renderOrdersMapping() {
  renderInventoryCard();
  const left = $('orders-unmapped-list');
  if (!left) return;
  Promise.all([apiGet('/api/products/unmapped'), apiGet('/api/products')])
    .then(([u, p]) => {
      const products = p.items || [];
      const opts = products.map((pr) => `<option value="${pr.id}">${esc(pr.name)}</option>`).join('');
      const items = u.items || [];
      left.innerHTML = items.length
        ? items
            .map(
              (it) =>
                `<div class="oh-maprow">${_ohChannel(it.channel)}` +
                `<div style="flex:1;min-width:0"><div class="fs-sm" style="font-weight:600">${esc(it.title || it.channelSku || it.listingId || '—')}</div>` +
                `<div class="muted fs-xs" style="font-family:monospace">${esc(it.channelSku || it.listingId || '')} · ${it.qty || 0}×</div></div>` +
                `<select class="oh-mapsel fs-meta" data-channel="${esc(it.channel)}" data-sku="${esc(it.channelSku || '')}" data-listing="${esc(it.listingId || '')}" data-title="${esc(it.title || '')}" style="width:auto">` +
                `<option value="">— ${esc(t('orders.choose'))} —</option>${opts}</select>` +
                `<button class="btn btn-sm btn-p" data-action="oh-map">${esc(t('orders.assign'))}</button></div>`
            )
            .join('')
        : `<div style="padding:14px;color:var(--c-text-muted)">${esc(t('orders.allMapped'))}</div>`;
      // The standing mappings, and the one form that can create one without an
      // order having carried the listing in first.
      const fixSel = $('oh-fixmap-product');
      if (fixSel) {
        const keep = fixSel.value;
        fixSel.innerHTML = `<option value="">— ${esc(t('orders.choose'))} —</option>${opts}`;
        if (keep) fixSel.value = keep;
      }
      renderFixedMappings();
      const cat = $('orders-catalog-body');
      if (cat) {
        cat.innerHTML = products.length
          ? products
              .map(
                (pr) =>
                  `<tr><td data-mlabel="${esc(t('orders.th.product'))}"><strong>${esc(pr.name)}</strong></td>` +
                  `<td data-mlabel="${esc(t('orders.th.category'))}">${esc(pr.category || '—')}</td>` +
                  `<td data-mlabel="${esc(t('orders.th.sku'))}" class="muted fs-xs">${esc(pr.sku || '')}</td>` +
                  `<td class="oh-actions"><button class="btn btn-sm" data-action="oh-prod-edit" data-id="${pr.id}">${esc(t('orders.edit'))}</button></td></tr>`
              )
              .join('')
          : _ohEmpty(4, t('orders.noProducts'));
      }
    })
    .catch(() => {
      left.innerHTML = `<div style="padding:14px;color:var(--c-text-muted)">${esc(t('common.error'))}</div>`;
    });
}

// The mappings that already stand for the channel chosen in the form, so a typo
// is visible and can be corrected by mapping the same SKU again (the insert is an
// upsert). Without this list the mapping is a black box: these rows are what
// every incoming order line is resolved against, and nothing else.
function renderFixedMappings() {
  const box = $('orders-fixmap-list');
  const sel = $('oh-fixmap-channel');
  if (!box || !sel) return;
  apiGet('/api/products/mappings?channel=' + encodeURIComponent(sel.value))
    .then((d) => {
      const rows = (d && d.items) || [];
      box.innerHTML = rows.length
        ? rows
            .map(
              (m) =>
                `<div class="oh-maprow"><div style="flex:1;min-width:0">` +
                `<span style="font-family:monospace">${esc(m.channelSku || m.listingId || '—')}</span>` +
                ` → <strong>${esc(m.productName || '—')}</strong>` +
                (m.productActive === 0 ? ` <span class="muted fs-xs">(${esc(t('orders.retired'))})</span>` : '') +
                `</div></div>`
            )
            .join('')
        : `<div class="muted fs-meta" style="padding:8px 2px">${esc(t('orders.fixmapNone'))}</div>`;
    })
    .catch(() => {
      box.innerHTML = `<div class="muted fs-meta" style="padding:8px 2px">${esc(t('common.error'))}</div>`;
    });
}

// Set when an eBay account-closure notification is clicked, so the row that the
// request is about is findable in a 200-row table. Cleared on the next render.
let _ohHighlightCustomer = null;
// Kept for the search index. This table re-fetches on every visit and renders
// straight from the response, so nothing here remembered a customer between
// renders — and the palette cannot search a list that only ever existed inside
// a .then().
let _ohCustomerCache = [];
function renderOrdersCustomers() {
  const body = $('orders-customers-body');
  if (!body) return;
  // /api/customers is behind requireShipping, not requireAdmin, so packers load
  // this table too. Gate the header with the cells — otherwise they get a titled,
  // permanently empty column stealing width on a table already wide enough to
  // need horizontal scrolling on a phone. Same pattern as showAdminNav().
  const isAdmin = !!(currentUser && currentUser.role === 'admin');
  const privacyTh = document.getElementById('orders-customers-privacy-th');
  if (privacyTh) privacyTh.hidden = !isAdmin;
  const cols = isAdmin ? 7 : 6;
  body.innerHTML = _ohEmpty(cols, t('common.loading'));
  loadCustomers()
    .then((rows) => {
      if (!rows.length) {
        body.innerHTML = _ohEmpty(cols, t('orders.noCustomers'));
        return;
      }
      body.innerHTML = rows
        .map((c) => {
          const chans = (c.channels || '').split(',').filter(Boolean).map(_ohChannel).join(' ');
          const ltv = c.totalSpent != null ? Number(c.totalSpent).toFixed(2) : '0.00';
          // Ask the server, do not infer. `!c.name && !c.email` looked equivalent
          // but was wrong for exactly the population this feature serves: eBay
          // masks the buyer email and carries identity in customer_identities, so
          // those customers have neither column and were never erased — yet they
          // rendered as "already erased" while their shipping address, phone and
          // raw payload sat in orders, with no way to run the erasure. Manual
          // entry and CSV import without those columns produce the same shape.
          // erased_at is written only by eraseCustomer.
          const erased = !!c.erasedAt;
          // btn-r is the repo's destructive style (delete batch, remove member,
          // delete camera). No inline padding: it would override the coarse-pointer
          // rule that gives every .btn-sm a 44px target, which is not something the
          // most destructive control in the app should opt out of.
          const privacy = !isAdmin
            ? ''
            : erased
              ? `<span class="fs-xs" style="color:var(--c-text-muted)">${esc(t('orders.erased'))}</span>`
              : `<button type="button" class="btn btn-sm btn-r" data-action="oh-erase-customer" data-id="${esc(String(c.id))}" data-name="${esc(c.name || c.email || String(c.id))}">${esc(t('orders.erase'))}</button>`;
          // Arrived here from an account-closure notification: mark the row the
          // request is about, otherwise it is one of up to 200 and the admin has
          // only an id to go on.
          const hit = _ohHighlightCustomer && c.id === _ohHighlightCustomer;
          return (
            `<tr data-find="customer:${esc(String(c.id))}"${hit ? ' style="outline:2px solid var(--c-red-dark);outline-offset:-2px"' : ''}>` +
            `<td data-mlabel="${esc(t('orders.th.customer'))}"><strong>${esc(c.name || c.email || '—')}</strong></td>` +
            `<td data-mlabel="${esc(t('orders.th.channels'))}">${chans}</td>` +
            `<td data-mlabel="${esc(t('orders.th.orders'))}">${c.orderCount || 0}</td>` +
            `<td data-mlabel="${esc(t('orders.th.ltv'))}"><strong>${ltv} ${esc(c.currency || '€')}</strong></td>` +
            `<td class="fs-xs" data-mlabel="${esc(t('orders.th.last'))}">${c.lastOrder ? esc(fmtDt(c.lastOrder)) : '—'}</td>` +
            `<td data-mlabel="${esc(t('orders.th.type'))}">${(c.orderCount || 0) > 1 ? `<span class="oh-st oh-st-ready">${esc(t('orders.repeat'))}</span>` : ''}</td>` +
            (isAdmin ? `<td data-mlabel="${esc(t('orders.th.privacy'))}">${privacy}</td>` : '') +
            '</tr>'
          );
        })
        .join('');
      // Consumed by this render; a later visit must not re-highlight whatever
      // row now holds that id.
      _ohHighlightCustomer = null;
    })
    .catch(() => {
      body.innerHTML = _ohEmpty(cols, t('common.error'));
    });
}
// ═══ PICKUPS ═══════════════════════════════════════════════════════════════
// Collection slots the harvest-feed receiver reported back in its reply. Every
// value on this page came from outside this machine, so every value goes
// through esc() — including the ones that "obviously" cannot contain markup,
// because the reason they cannot is a validation rule in another file that
// somebody may relax later.
//
// Read-only by design. The receiver took the booking and repeats each open
// pickup until this end confirms it; an edit here would be overwritten by the
// next reply that carried the same id.

/**
 * The window, as the customer was told it.
 *
 * slotText is the receiver's own wording and wins whenever it is there — it
 * already reads the way the confirmation email did. The fallback assembles
 * from/to, which are LOCAL wall-clock at the pickup place: printed as they
 * arrived, never parsed into a Date. Feeding them to the browser's clock would
 * reinterpret them in whoever-is-looking's timezone and silently move a 9 a.m.
 * pickup by an hour or two.
 */
function _pickupWhen(p) {
  if (p.slotText) return esc(p.slotText);
  if (!p.from) return '—';
  const day = p.from.slice(0, 10);
  const fromTime = p.from.slice(11, 16);
  const toTime = p.to ? p.to.slice(11, 16) : '';
  return esc(day + ' ' + fromTime + (toTime ? '–' + toTime : ''));
}

// Which half of the list is on screen. Not remembered across a reload: the half
// that is still work is what this page is opened for, and coming back to a
// screen full of finished collections is the state this switch exists to end.
let pickupsPast = false;

function renderPickups() {
  // The upper half of the page. Not awaited: the two halves come from different
  // routes and neither needs the other, so making the bookings wait on the
  // release table would only add a stall to the half people open this page for.
  loadHarvestReleases();

  const body = $('pickups-body');
  if (!body) return;
  const count = $('pickups-count');
  const schalter = $('pickups-past-btn');
  if (schalter) schalter.textContent = t(pickupsPast ? 'pickups.showUpcoming' : 'pickups.showPast');
  body.innerHTML = _ohEmpty(5, t('common.loading'));
  apiGet('/api/pickups' + (pickupsPast ? '?past=1' : ''))
    .then((d) => {
      const rows = d.items || [];
      if (count) count.textContent = rows.length ? t('pickups.count', { n: rows.length }) : '';
      if (!rows.length) {
        // Two different empties. "Nothing booked" is news; "nothing has
        // happened yet" is not, and telling them apart stops an empty past
        // list from reading like a lost one.
        body.innerHTML = _ohEmpty(5, t(pickupsPast ? 'pickups.nonePast' : 'pickups.none'));
        return;
      }
      body.innerHTML = rows
        .map((p) => {
          const items = (p.items || [])
            .map((it) => esc(it.kind) + ' ' + Math.round(it.grams) + ' g')
            .join('<br>');
          // The zone belongs next to the time or the time means nothing. A
          // pickup in another country is exactly when the label earns its width.
          const zone = p.zone ? `<div class="fs-xs" style="color:var(--c-text-muted)">${esc(p.zone)}</div>` : '';
          // Two different states, and only one of them is a problem. Overbooked
          // is the receiver saying it sold more of that slot than it should
          // have; unconfirmed just means the next push has not gone out yet.
          const state = p.overbooked
            ? `<span class="oh-st oh-st-over">${esc(t('pickups.overbooked'))}</span>`
            : p.acked
              ? `<span class="oh-st oh-st-ready">${esc(t('pickups.confirmed'))}</span>`
              : `<span class="fs-xs" style="color:var(--c-text-muted)">${esc(t('pickups.pending'))}</span>`;
          return (
            '<tr>' +
            `<td data-mlabel="${esc(t('pickups.th.when'))}"><strong>${_pickupWhen(p)}</strong>${zone}</td>` +
            `<td data-mlabel="${esc(t('pickups.th.place'))}">${esc(p.place || '—')}</td>` +
            `<td data-mlabel="${esc(t('pickups.th.order'))}">${esc(p.order || '—')}</td>` +
            `<td class="fs-meta" data-mlabel="${esc(t('pickups.th.items'))}">${items || '—'}</td>` +
            `<td data-mlabel="${esc(t('pickups.th.state'))}">${state}</td>` +
            '</tr>'
          );
        })
        .join('');
    })
    .catch(() => {
      body.innerHTML = _ohEmpty(5, t('common.error'));
    });
}

// Carry out a marketplace account-closure request. This is the authenticated
// counterpart to the eBay deletion endpoint, which records such requests and
// notifies admins but never erases on its own — that endpoint is unauthenticated
// by necessity, so anyone able to reach the host would otherwise be able to
// destroy a customer's order history with one request.
//
// Irreversible: the server NULLs the customer's name and email, every ship_*
// field on their orders, and the raw_json that could have restored them. The
// order rows themselves survive, so revenue history stays intact.
function eraseCustomer(id, name) {
  confirm2(t('orders.eraseTitle'), t('orders.eraseMsg', { name }), t('orders.eraseYes'), () => {
    apiPost('/api/customers/erase', { customerId: Number(id) }).then((r) => {
      if (r && r.error) {
        setFb('err', r.error);
        return;
      }
      setFb('ok', t('orders.eraseDone', { name, n: (r && r.orders) || 0 }));
      renderOrdersCustomers();
    });
  });
}

// ── Versand: order list + buy-label modal ──
function renderOrdersVersand() {
  const body = $('versand-orders-body');
  if (!body) return;
  body.innerHTML = _ohEmpty(5, t('common.loading'));
  authFetch('/api/ship/config')
    .then((r) => r.json())
    .then((cfg) => {
      const warn = $('versand-config-warn');
      if (warn) warn.style.display = cfg && cfg.enabled && cfg.publicKey ? 'none' : 'block';
    })
    .catch(() => {});
  apiGet('/api/orders?limit=500')
    .then((d) => {
      const rows = (d.items || []).filter((o) => o.status !== 'cancelled');
      if (!rows.length) {
        body.innerHTML = _ohEmpty(5, t('orders.none'));
        return;
      }
      body.innerHTML = rows
        .map((o) => {
          const btn =
            o.status === 'shipped'
              ? `<button class="btn btn-sm" data-action="oh-ship-open" data-order-id="${o.id}">${t('versand.relabel')}</button>`
              : `<button class="btn btn-sm btn-p" data-action="oh-ship-open" data-order-id="${o.id}">${t('versand.shipBtn')}</button>`;
          return (
            `<tr><td>${_ohChannel(o.channel)}</td>` +
            `<td class="fs-xs" style="font-family:monospace">${esc(o.channelOrderId)}</td>` +
            `<td>${esc(o.customerName || '—')}</td>` +
            `<td>${_ohStatus(o.status)}</td>` +
            `<td style="white-space:nowrap">${btn}</td></tr>`
          );
        })
        .join('');
    })
    .catch(() => {
      body.innerHTML = _ohEmpty(5, t('common.error'));
    });
}

function shipModalClose() {
  const m = $('ship-modal');
  if (m) m.style.display = 'none';
}
function shipModalOpen(orderId) {
  if (!orderId) return;
  const m = $('ship-modal');
  if (!m) return;
  $('ship-m-orderid').value = orderId;
  $('ship-m-result').textContent = '';
  const set = (id, v) => {
    const el = document.getElementById(id);
    if (el) el.value = v == null ? '' : v;
  };
  // Prefill from the stored order (ship_* filled by a prior label or channel sync).
  apiGet('/api/ship/order/' + orderId)
    .then((o) => {
      if (!o || o.error) o = {};
      $('ship-m-sub').textContent = (o.channel ? o.channel + ' · ' : '') + (o.channelOrderId || '#' + orderId);
      set('ship-m-name', o.shipName || o.customerName || '');
      set('ship-m-company', o.shipCompany);
      set('ship-m-street', o.shipStreet);
      set('ship-m-house', o.shipHouse);
      set('ship-m-address2', o.shipAddress2);
      set('ship-m-postal', o.shipPostal);
      set('ship-m-city', o.shipCity);
      set('ship-m-country', (o.shipCountry || 'DE').toUpperCase());
      set('ship-m-phone', o.shipPhone);
      set('ship-m-weight', o.shipWeightG || 1000);
      shipLoadMethods();
    })
    .catch(() => shipLoadMethods());
  m.style.display = 'flex';
}
function shipLoadMethods() {
  const sel = $('ship-m-method');
  if (!sel) return;
  const country = ($('ship-m-country').value || 'DE').toUpperCase();
  const weight = parseInt($('ship-m-weight').value, 10) || 1000;
  sel.innerHTML = `<option value="">${esc(t('versand.loadingMethods'))}</option>`;
  apiGet('/api/ship/methods?country=' + encodeURIComponent(country) + '&weight=' + weight)
    .then((d) => {
      const methods = (d && d.methods) || [];
      sel.innerHTML = methods.length
        ? methods.map((m) => `<option value="${m.id}">${esc(m.name)}</option>`).join('')
        : `<option value="">${esc(t('versand.noMethods'))}</option>`;
    })
    .catch(() => {
      sel.innerHTML = `<option value="">${esc(t('common.error'))}</option>`;
    });
}
function shipBuyLabel() {
  const orderId = parseInt($('ship-m-orderid').value, 10);
  const methodId = $('ship-m-method').value;
  if (!orderId) return;
  if (!methodId) {
    setFb('err', t('versand.pickMethod'));
    return;
  }
  const v = (id) => ($(id) ? $(id).value.trim() : '');
  const weightG = parseInt($('ship-m-weight').value, 10) || 1000;
  const address = {
    shipName: v('ship-m-name'),
    shipCompany: v('ship-m-company'),
    shipStreet: v('ship-m-street'),
    shipHouse: v('ship-m-house'),
    shipAddress2: v('ship-m-address2'),
    shipPostal: v('ship-m-postal'),
    shipCity: v('ship-m-city'),
    shipCountry: (v('ship-m-country') || 'DE').toUpperCase(),
    shipPhone: v('ship-m-phone'),
    shipWeightG: weightG
  };
  const res = $('ship-m-result');
  if (res) res.textContent = t('common.loading');
  apiPost('/api/ship/label', { orderId, methodId, weightG, address })
    .then((r) => {
      if (!r || r.error) {
        if (res) res.textContent = '⚠ ' + ((r && r.error) || t('common.error'));
        return;
      }
      if (r.test) {
        // Test mode announced the parcel without buying a billable label.
        if (res) res.textContent = '✓ ' + t('versand.testAnnounced');
        setFb('ok', t('versand.testAnnounced'));
        renderOrdersVersand();
        return;
      }
      const pdf = '/api/ship/label/' + r.id + '/pdf';
      const pushMsg = r.channelPushed
        ? '<br>↪ ' + esc(t('versand.pushedToChannel'))
        : r.pushError
          ? '<br>⚠ ' + esc(t('versand.pushFailed')) + ': ' + esc(r.pushError)
          : '';
      if (res)
        res.innerHTML =
          '✓ ' +
          esc(t('versand.bought')) +
          (r.trackingNumber ? ' · ' + esc(r.trackingNumber) : '') +
          ` · <a href="${pdf}" target="_blank" rel="noopener">${esc(t('versand.openLabel'))}</a>` +
          pushMsg;
      setFb('ok', t('versand.bought'));
      renderOrdersVersand();
    })
    .catch(() => {
      if (res) res.textContent = '⚠ ' + t('common.error');
    });
}

function ordersActionHandler(e) {
  const btn = e.target.closest('[data-action]');
  if (!btn) return;
  const action = btn.dataset.action;
  if (action === 'oh-erase-customer') {
    eraseCustomer(btn.dataset.id, btn.dataset.name);
  } else if (action === 'ob-mark') {
    obMark(btn.dataset.id, btn.dataset.kind, btn.dataset.on === '1');
  } else if (action === 'ob-sync-now') {
    obSyncNow(btn);
  } else if (action === 'oh-filter') {
    setOrdersFilter(btn.dataset.filter || '');
  } else if (action === 'oh-goto-mapping') {
    openStab('orders', 'mapping');
  } else if (action === 'oh-manual-toggle') {
    const p = $('orders-manual-panel');
    if (p) p.style.display = p.style.display === 'none' ? 'block' : 'none';
  } else if (action === 'oh-import-csv') {
    const f = $('orders-csv-file');
    if (f) f.click();
  } else if (action === 'oh-manual-submit') {
    _ordersManualSubmit();
  } else if (action === 'oh-map-fixed') {
    const channel = ($('oh-fixmap-channel') || {}).value;
    const sku = (($('oh-fixmap-sku') || {}).value || '').trim();
    const productId = parseInt(($('oh-fixmap-product') || {}).value || '', 10);
    if (!sku || !productId) {
      setFb('err', t('orders.fixmapNeeds'));
      return;
    }
    apiPost('/api/products/map', { channel, channelSku: sku, productId }).then((r) => {
      if (r && r.error) {
        setFb('err', r.error);
        return;
      }
      $('oh-fixmap-sku').value = '';
      setFb('ok', t('orders.mapped'));
      renderOrdersMapping();
    });
  } else if (action === 'oh-map') {
    const row = btn.closest('.oh-maprow');
    const sel = row && row.querySelector('.oh-mapsel');
    if (!sel || !sel.value) {
      setFb('err', t('orders.choose'));
      return;
    }
    apiPost('/api/products/map', {
      channel: sel.dataset.channel,
      channelSku: sel.dataset.sku || null,
      listingId: sel.dataset.listing || null,
      title: sel.dataset.title || null,
      productId: parseInt(sel.value, 10)
    }).then((r) => {
      if (r && r.error) {
        setFb('err', r.error);
        return;
      }
      setFb('ok', t('orders.mapped'));
      renderOrdersMapping();
    });
  } else if (action === 'oh-prod-new') {
    _ohProductForm(null);
  } else if (action === 'oh-prod-cancel') {
    const f = $('orders-prod-form');
    if (f) f.style.display = 'none';
  } else if (action === 'oh-prod-edit') {
    apiGet('/api/products/' + btn.dataset.id)
      .then((p) => _ohProductForm(p))
      .catch(() => setFb('err', t('common.error')));
  } else if (action === 'oh-prod-save') {
    _ohProductSave();
  } else if (action === 'oh-prod-delete') {
    _ohProductDelete();
  } else if (action === 'oh-inv-set') {
    const row = btn.closest('tr');
    const inp = row && row.querySelector('.oh-inv-input');
    if (!inp) return;
    const val = parseFloat(inp.value);
    if (!(val >= 0)) {
      setFb('err', t('orders.invBadValue'));
      return;
    }
    invSetAbsolute(btn.dataset.mat, val, 'manual', 'order-hub').then((r) => {
      if (r && r.error) {
        setFb('err', r.error);
        return;
      }
      setFb('ok', t('orders.invSaved'));
      if (inventory && inventory.stock) inventory.stock[btn.dataset.mat] = val;
      renderInventoryCard();
    });
  } else if (action === 'oh-ship-open') {
    shipModalOpen(parseInt(btn.dataset.orderId, 10));
  } else if (action === 'oh-ship-buy') {
    shipBuyLabel();
  } else if (action === 'oh-ship-close') {
    shipModalClose();
  }
}

function _ordersManualSubmit() {
  const oid = ($('oh-m-oid').value || '').trim();
  if (!oid) {
    setFb('err', t('orders.needOrderId'));
    return;
  }
  const order = {
    channel: $('oh-m-channel').value || 'manual',
    channelOrderId: oid,
    customerName: ($('oh-m-cust').value || '').trim() || null,
    customerEmail: ($('oh-m-email').value || '').trim() || null,
    shipBy: $('oh-m-shipby').value || null,
    items: [
      {
        channelSku: ($('oh-m-sku').value || '').trim() || null,
        title: ($('oh-m-title').value || '').trim() || null,
        qty: parseInt($('oh-m-qty').value, 10) || 1
      }
    ]
  };
  apiPost('/api/orders/import', order).then((r) => {
    if (r && r.error) {
      setFb('err', r.error);
      return;
    }
    setFb('ok', t('orders.added'));
    ['oh-m-oid', 'oh-m-cust', 'oh-m-email', 'oh-m-sku', 'oh-m-title', 'oh-m-shipby'].forEach((id) => {
      const el = $(id);
      if (el) el.value = '';
    });
    const q = $('oh-m-qty');
    if (q) q.value = '1';
    renderOrders();
  });
}

function _ordersImportCsv(file) {
  const reader = new FileReader();
  reader.onload = () => {
    try {
      const lines = String(reader.result || '')
        .split(/\r?\n/)
        .filter((l) => l.trim());
      if (lines.length < 2) {
        setFb('err', t('orders.csvEmpty'));
        return;
      }
      const splitRow = (l) => l.split(/[,;]/).map((c) => c.trim().replace(/^"|"$/g, ''));
      const head = splitRow(lines[0]).map((h) => h.toLowerCase());
      const col = (names) => {
        for (const n of names) {
          const i = head.indexOf(n);
          if (i >= 0) return i;
        }
        return -1;
      };
      const ci = {
        channel: col(['channel', 'kanal']),
        oid: col(['order_id', 'order id', 'channel_order_id', 'bestellnummer', 'order']),
        name: col(['customer_name', 'customer', 'name', 'kunde']),
        email: col(['customer_email', 'email', 'e-mail']),
        shipby: col(['ship_by', 'ship by', 'liefern bis', 'deliver_by']),
        sku: col(['sku', 'channel_sku', 'artikelnummer']),
        title: col(['title', 'item', 'artikel', 'produkt']),
        qty: col(['qty', 'quantity', 'menge', 'anzahl'])
      };
      if (ci.oid < 0) {
        setFb('err', t('orders.csvNoOrderId'));
        return;
      }
      const byId = new Map();
      for (let i = 1; i < lines.length; i++) {
        const cells = splitRow(lines[i]);
        const oid = cells[ci.oid];
        if (!oid) continue;
        const channel = (ci.channel >= 0 && cells[ci.channel]) || 'manual';
        const key = channel + '|' + oid;
        if (!byId.has(key)) {
          byId.set(key, {
            channel,
            channelOrderId: oid,
            customerName: ci.name >= 0 ? cells[ci.name] || null : null,
            customerEmail: ci.email >= 0 ? cells[ci.email] || null : null,
            shipBy: ci.shipby >= 0 ? cells[ci.shipby] || null : null,
            items: []
          });
        }
        byId.get(key).items.push({
          channelSku: ci.sku >= 0 ? cells[ci.sku] || null : null,
          title: ci.title >= 0 ? cells[ci.title] || null : null,
          qty: ci.qty >= 0 ? parseInt(cells[ci.qty], 10) || 1 : 1
        });
      }
      const orders = [...byId.values()];
      if (!orders.length) {
        setFb('err', t('orders.csvEmpty'));
        return;
      }
      apiPost('/api/orders/import', { orders }).then((r) => {
        if (r && r.error) {
          setFb('err', r.error);
          return;
        }
        setFb('ok', t('orders.imported', { n: r.imported != null ? r.imported : orders.length }));
        renderOrders();
      });
    } catch (err) {
      setFb('err', t('common.error'));
    }
  };
  reader.readAsText(file);
}

// ── Product catalog editor ──
const _OH_MAT_KEY = {
  grain: 'inv.grain',
  hardwood: 'inv.hardwood',
  wheatbran: 'inv.wheatBran',
  gypsum: 'inv.gypsum',
  coir: 'inv.coir',
  corn: 'inv.corn',
  calcium: 'inv.calcium'
};
function _ohMatName(mat) {
  return t(_OH_MAT_KEY[mat] || mat);
}
function _ohN(x) {
  return Math.round((x || 0) * 100) / 100;
}

// ── Hydration math: the ONE client-side source of truth ──────────────────────
// "Wet" substrate/grain weights include soak water; raw-material need is the dry
// matter left after removing rh% water. The SERVER (db.js computeBatchMaterialDeltas
// / computeProductMaterialNeed) is authoritative for inventory — these mirror it,
// so if the formula ever changes, KEEP db.js AND this in sync.
function mtGrainFactor(rhPct) {
  const rh = Number(rhPct) || 0;
  return rh > 0 ? 1 - rh / 100 : 1;
}
function mtDryKg(wetKg, rhPct) {
  return (Number(wetKg) || 0) * mtGrainFactor(rhPct);
}

// Per-unit raw-material need (dry kg) — mirrors db.computeProductMaterialNeed
// so the editor preview matches the demand board exactly.
function _ohProdNeedCompute(spec) {
  const need = { grain: 0, hardwood: 0, wheatbran: 0, gypsum: 0, coir: 0 };
  const num = (v) => (isFinite(+v) ? +v : 0);
  const type = spec.prodType || 'buy';
  if (type === 'block' || type === 'allinone') {
    const bagKg = num(spec.prodBagKg);
    const rh = num(spec.prodRhPct);
    const dry = mtDryKg(bagKg, rh);
    if ((spec.prodSubstrate || 'holzkleie') === 'cvg') {
      need.coir += dry * ((num(spec.prodCoirPct) || 100) / 100);
    } else {
      need.hardwood += dry * (num(spec.prodHardwoodPct) / 100);
      need.wheatbran += dry * (num(spec.prodWheatbranPct) / 100);
    }
    if (spec.prodGypsum) need.gypsum += dry * 0.01;
  }
  if (type === 'grain' || type === 'allinone') {
    const gKg = num(spec.prodGrainKg);
    const gRh = spec.prodGrainRhPct != null && spec.prodGrainRhPct !== '' ? num(spec.prodGrainRhPct) : 52;
    need.grain += mtDryKg(gKg, gRh);
  }
  return need;
}

function _ohReadProdForm() {
  return {
    prodType: $('oh-p-prodtype').value || 'buy',
    prodSubstrate: $('oh-p-substrate').value || 'holzkleie',
    prodBagKg: $('oh-p-bagkg').value,
    prodRhPct: $('oh-p-rh').value,
    prodHardwoodPct: $('oh-p-hw').value,
    prodWheatbranPct: $('oh-p-wb').value,
    prodCoirPct: $('oh-p-coir').value,
    prodGypsum: $('oh-p-gyp').checked ? 1 : 0,
    prodGrainKg: $('oh-p-grainkg').value,
    prodGrainRhPct: $('oh-p-grainrh').value
  };
}

function _ohProdTypeChange() {
  const type = $('oh-p-prodtype').value || 'buy';
  const sub = $('oh-p-substrate').value || 'holzkleie';
  const set = (id, disp) => {
    const el = $(id);
    if (el) el.style.display = disp;
  };
  set('oh-p-subgroup', type === 'block' || type === 'allinone' ? 'block' : 'none');
  set('oh-p-graingroup', type === 'grain' || type === 'allinone' ? 'block' : 'none');
  set('oh-p-holzgroup', sub === 'holzkleie' ? 'grid' : 'none');
  set('oh-p-coirgroup', sub === 'cvg' ? 'grid' : 'none');
  _ohProdNeed();
}

function _ohProdNeed() {
  const el = $('oh-p-need');
  if (!el) return;
  const need = _ohProdNeedCompute(_ohReadProdForm());
  const parts = Object.keys(need)
    .filter((m) => need[m] > 0)
    .map((m) => `${esc(_ohMatName(m))} ${_ohN(need[m])} kg`);
  el.textContent = parts.length ? t('orders.p.needPrefix') + ' ' + parts.join(' · ') : '';
}

function _ohProductForm(p) {
  const f = $('orders-prod-form');
  if (!f) return;
  f.style.display = 'block';
  $('oh-p-id').value = p && p.id ? p.id : '';
  $('oh-p-name').value = p ? p.name || '' : '';
  $('oh-p-sku').value = p ? p.sku || '' : '';
  $('oh-p-category').value = p ? p.category || 'all-in-one' : 'all-in-one';
  $('oh-p-stock').value = p && p.stock != null ? p.stock : 0;
  $('oh-p-lead').value = p && p.leadDays != null ? p.leadDays : 0;
  $('oh-p-prodtype').value = (p && p.prodType) || 'buy';
  $('oh-p-substrate').value = (p && p.prodSubstrate) || 'holzkleie';
  $('oh-p-bagkg').value = p && p.prodBagKg != null ? p.prodBagKg : 0;
  $('oh-p-rh').value = p && p.prodRhPct != null ? p.prodRhPct : 0;
  $('oh-p-hw').value = p && p.prodHardwoodPct != null ? p.prodHardwoodPct : 0;
  $('oh-p-wb').value = p && p.prodWheatbranPct != null ? p.prodWheatbranPct : 0;
  $('oh-p-coir').value = p && p.prodCoirPct != null ? p.prodCoirPct : 100;
  $('oh-p-gyp').checked = !!(p && p.prodGypsum);
  $('oh-p-grainkg').value = p && p.prodGrainKg != null ? p.prodGrainKg : 0;
  $('oh-p-grainrh').value = p && p.prodGrainRhPct != null ? p.prodGrainRhPct : 52;
  $('oh-p-prodtype').onchange = _ohProdTypeChange;
  $('oh-p-substrate').onchange = _ohProdTypeChange;
  f.oninput = _ohProdNeed;
  _ohProdTypeChange();
  const del = $('oh-p-delete');
  if (del) del.style.display = p && p.id ? 'inline-flex' : 'none';
}

function _ohProductSave() {
  const name = ($('oh-p-name').value || '').trim();
  if (!name) {
    setFb('err', t('orders.needName'));
    return;
  }
  const spec = _ohReadProdForm();
  const id = $('oh-p-id').value;
  const payload = {
    name,
    sku: ($('oh-p-sku').value || '').trim() || null,
    category: $('oh-p-category').value || null,
    stock: parseFloat($('oh-p-stock').value) || 0,
    leadDays: parseInt($('oh-p-lead').value, 10) || 0,
    prodType: spec.prodType,
    prodSubstrate: spec.prodSubstrate,
    prodBagKg: parseFloat(spec.prodBagKg) || 0,
    prodRhPct: parseFloat(spec.prodRhPct) || 0,
    prodHardwoodPct: parseFloat(spec.prodHardwoodPct) || 0,
    prodWheatbranPct: parseFloat(spec.prodWheatbranPct) || 0,
    prodCoirPct: parseFloat(spec.prodCoirPct) || 0,
    prodGypsum: spec.prodGypsum,
    prodGrainKg: parseFloat(spec.prodGrainKg) || 0,
    prodGrainRhPct: parseFloat(spec.prodGrainRhPct) || 52
  };
  const req = id ? apiPatch('/api/products/' + id, payload) : apiPost('/api/products', payload);
  req.then((r) => {
    if (r && r.error) {
      setFb('err', r.error);
      return;
    }
    setFb('ok', t('orders.productSaved'));
    const f = $('orders-prod-form');
    if (f) f.style.display = 'none';
    renderOrdersMapping();
  });
}

// ── Raw-material inventory (shared ledger) ──
function renderInventoryCard() {
  const body = $('orders-rawstock-body');
  if (!body) return;
  const stock = (inventory && inventory.stock) || {};
  const thr = (inventory && inventory.thresholds) || {};
  const mats = ['grain', 'hardwood', 'wheatbran', 'gypsum', 'coir', 'corn', 'calcium'];
  body.innerHTML = mats
    .map((m) => {
      const have = stock[m] || 0;
      const min = (thr[m] && thr[m].minKg) || 0;
      const low = min > 0 && have <= min;
      return (
        `<tr><td data-mlabel="${esc(t('orders.mat.name'))}"><strong>${esc(_ohMatName(m))}</strong></td>` +
        `<td data-mlabel="${esc(t('orders.rawStockKg'))}">${_ohN(have)}${low ? ' <span class="oh-warn">⚠︎</span>' : ''}</td>` +
        `<td class="oh-actions" style="white-space:nowrap"><input class="oh-inv-input" data-mat="${m}" type="number" min="0" step="0.1" value="${_ohN(have)}" style="width:80px" /> ` +
        `<button class="btn btn-sm" data-action="oh-inv-set" data-mat="${m}">${esc(t('orders.set'))}</button></td></tr>`
      );
    })
    .join('');
}
function _ohProductDelete() {
  const id = $('oh-p-id').value;
  if (!id) return;
  confirm2(t('common.delete'), t('orders.confirmDelete'), t('common.delete'), () => {
    apiDelete('/api/products/' + id).then((r) => {
      if (r && r.error) {
        setFb('err', r.error);
        return;
      }
      setFb('ok', t('orders.productDeleted'));
      const f = $('orders-prod-form');
      if (f) f.style.display = 'none';
      renderOrdersMapping();
    });
  });
}

// ─── MODALS ──────────────────────────────────────────────────
function confirm2(title, body, label, cb, cancelCb) {
  document.getElementById('m-title').textContent = title;
  document.getElementById('m-body').textContent = body;
  document.getElementById('m-ok').textContent = label || t('common.confirm');
  confirmCb = cb;
  confirmCancelCb = cancelCb || null;
  document.getElementById('m-confirm').classList.add('open');
}
function closeConfirm() {
  document.getElementById('m-confirm').classList.remove('open');
  // Read and clear before calling: a cancel handler that opens another dialog
  // would otherwise find this one's callbacks still in place.
  const cancel = confirmCancelCb;
  confirmCb = null;
  confirmCancelCb = null;
  if (cancel) cancel();
}
document.getElementById('m-ok').onclick = () => {
  const cb = confirmCb;
  confirmCb = null;
  // Cleared first, or closing after a Yes would report a No as well.
  confirmCancelCb = null;
  document.getElementById('m-confirm').classList.remove('open');
  if (cb) cb();
};

/**
 * Say which field is wrong by marking it, not only by describing it.
 *
 * The bar fixed three of the four things wrong with alert() and left the fourth:
 * a message that names a problem without pointing at it. "Menge eingeben" over a
 * form with nine inputs is a puzzle, and the answer is obvious only to whoever
 * wrote the check.
 *
 * So the field gets the red ring, the focus and the scroll, and the bar still
 * carries the words. The words are deliberately *not* moved under the input: the
 * twenty-eight fields this is called for sit in grid cells, plain blocks and
 * non-wrapping flex rows, and a block inserted after the input lands differently
 * in each. Marking and focusing is what answers "which one", and it does so the
 * same way everywhere.
 *
 * The ring clears on the next keystroke in that field, because a ring that
 * outlives the mistake is a field that looks broken while it is being fixed.
 *
 * @param {string|Element} el the input, or its id
 * @param {string} msg what is wrong with it
 */
function fieldError(el, msg) {
  const input = typeof el === 'string' ? document.getElementById(el) : el;
  // No element is not a reason to say nothing: a renamed id falls back to what
  // every one of these call sites did before, rather than failing silently.
  if (!input) return toast(msg, 'err');
  toast(msg, 'err');
  input.classList.add('is-invalid');
  input.setAttribute('aria-invalid', 'true');
  const clear = () => {
    input.classList.remove('is-invalid');
    input.removeAttribute('aria-invalid');
  };
  input.addEventListener('input', clear, { once: true });
  input.addEventListener('change', clear, { once: true });
  // A field two screens down is not pointed at by being focused alone; and
  // focus() on a hidden or disabled input is a no-op, which is why the ring is
  // set first and does not depend on it.
  try {
    input.scrollIntoView({ block: 'center', behavior: 'smooth' });
    input.focus({ preventScroll: true });
  } catch (e) {
    /* an input the browser will not focus is still marked */
  }
}

/**
 * The dialog confirm2() opens, as a promise, so a caller can keep the shape it
 * had with window.confirm(): `if (!(await askConfirm(…))) return;`.
 *
 * Eight irreversible actions in this app asked through window.confirm(), and the
 * button that agrees to one is labelled **OK**. "Kamera löschen?" answered with
 * OK is a worse button than one that says Löschen: the label is the last thing
 * read before the thing happens, and OK does not say what it does. confirm2()
 * has taken a label since it was written — these eight had simply never been
 * moved onto it.
 *
 * It settles both ways. Cancel, the backdrop and closeConfirm() all resolve
 * false, because an await that never settles leaves the rest of the caller
 * suspended for the life of the page.
 *
 * The ninth confirm() stays native: mayLeavePage() runs from `beforeunload`,
 * which is synchronous by specification, and a promise there resolves after the
 * tab is already gone.
 *
 * @param {string} title  the action, short — it is also the button's label
 * @param {string} body   what happens if they say yes
 * @param {string} label  the button. Never "OK".
 * @returns {Promise<boolean>}
 */
function askConfirm(title, body, label) {
  return new Promise((resolve) => {
    confirm2(
      title,
      body,
      label,
      () => resolve(true),
      () => resolve(false)
    );
  });
}
document.getElementById('si-close').onclick = closeSubstrateInfo;
document.getElementById('m-subinfo').addEventListener('click', (e) => {
  if (e.target.id === 'm-subinfo') closeSubstrateInfo();
});
document.getElementById('m-confirm').addEventListener('click', (e) => {
  if (e.target.id === 'm-confirm') closeConfirm();
});

let confirmCancelCb = null;
let confirm3CbA = null;
let confirm3CbB = null;
function confirm3(title, body, labelA, labelB, cbA, cbB) {
  document.getElementById('m-title3').textContent = title;
  document.getElementById('m-body3').textContent = body;
  document.getElementById('m-ok3a').textContent = labelA;
  document.getElementById('m-ok3b').textContent = labelB;
  confirm3CbA = cbA;
  confirm3CbB = cbB;
  document.getElementById('m-confirm3').classList.add('open');
}
function closeConfirm3() {
  document.getElementById('m-confirm3').classList.remove('open');
  confirm3CbA = null;
  confirm3CbB = null;
}
document.getElementById('m-ok3a').onclick = () => {
  const cb = confirm3CbA;
  closeConfirm3();
  if (cb) cb();
};
document.getElementById('m-ok3b').onclick = () => {
  const cb = confirm3CbB;
  closeConfirm3();
  if (cb) cb();
};
document.getElementById('m-cancel3').onclick = closeConfirm3;
document.getElementById('m-confirm3').addEventListener('click', (e) => {
  if (e.target.id === 'm-confirm3') closeConfirm3();
});
let promptCb = null;
// opts.inputmode gets set on every open, never only when asked for: a phone that
// was handed a decimal keypad once would keep it at the next prompt that wants
// letters, and the leak would be invisible on a desktop. opts.value pre-fills,
// which is what correcting a number wants — retyping it to change one digit is
// how the wrong digit survives.
function prompt2(title, placeholder, cb, opts) {
  const o = opts || {};
  document.getElementById('m-pr-title').textContent = title;
  const inp = document.getElementById('m-pr-input');
  inp.value = o.value == null ? '' : String(o.value);
  inp.setAttribute('inputmode', o.inputmode || 'text');
  inp.placeholder = placeholder || '';
  promptCb = cb;
  document.getElementById('m-prompt').classList.add('open');
  setTimeout(() => inp.focus(), 80);
}
function closePrompt() {
  document.getElementById('m-prompt').classList.remove('open');
  promptCb = null;
}
document.getElementById('m-pr-ok').onclick = () => {
  if (promptCb) promptCb(document.getElementById('m-pr-input').value.trim());
  closePrompt();
};
document.getElementById('m-pr-cancel').onclick = closePrompt;
document.getElementById('m-prompt').addEventListener('click', (e) => {
  if (e.target.id === 'm-prompt') closePrompt();
});
// Derselbe Weg hinaus wie beim Vorgaenger: ein Klick neben das Fenster.
document.getElementById('m-dayqty').addEventListener('click', (e) => {
  if (e.target.id === 'm-dayqty') closeDayQty();
});
document.getElementById('m-pr-input').addEventListener('keydown', (e) => {
  if (e.key === 'Enter') {
    e.preventDefault();
    document.getElementById('m-pr-ok').click();
  }
});
function openNote(id) {
  const b = batches.find((x) => x.batchId === id);
  if (!b) return;
  noteId = id;
  document.getElementById('m-note-title').textContent = t('note.prefix') + id;
  document.getElementById('m-note-text').value = b.notes || '';
  document.getElementById('m-note').classList.add('open');
  setTimeout(() => document.getElementById('m-note-text').focus(), 80);
}
function closeNote() {
  document.getElementById('m-note').classList.remove('open');
  noteId = null;
}
function saveNote() {
  const b = batches.find((x) => x.batchId === noteId);
  if (b) {
    b.notes = document.getElementById('m-note-text').value.trim();
    apiPatch('/api/batches/' + encodeURIComponent(noteId), { notes: b.notes });
    renderBatches();
  }
  closeNote();
}
document.getElementById('m-note').addEventListener('click', (e) => {
  if (e.target.id === 'm-note') closeNote();
});

// Batch-add modal
function openBatchAdd() {
  const bs = document.getElementById('ba-batch');
  bs.innerHTML =
    '<option value="">— choose batch —</option>' +
    batches
      .map((b) => {
        const kz = b.strainKuerzel || b.strain || '';
        const name = b.strainName || b.species || '';
        const st = (b.strainText || '').trim();
        const label = (kz ? '[' + esc(kz) + '] ' : '') + esc(b.batchId) + ' — ' + esc(name) + (st ? ' ' + esc(st) : '');
        return `<option value="${esc(b.batchId)}">${label}</option>`;
      })
      .join('');
  const ls = document.getElementById('ba-loc');
  ls.innerHTML = [...ZONES, ...ALL_RACKS].map((l) => `<option value="${esc(l)}">${esc(l)}</option>`).join('');
  bs.onchange = baPreview;
  ls.onchange = baPreview;
  document.getElementById('m-batchadd').classList.add('open');
}
function closeBatchAdd() {
  document.getElementById('m-batchadd').classList.remove('open');
}
function baPreview() {
  const id = document.getElementById('ba-batch').value,
    loc = document.getElementById('ba-loc').value,
    b = batches.find((x) => x.batchId === id);
  document.getElementById('ba-prev').textContent = b ? `Will log ${b.bags.length} bags → ${loc}` : '';
}
document.getElementById('m-batchadd').addEventListener('click', (e) => {
  if (e.target.id === 'm-batchadd') closeBatchAdd();
});
function confirmBatchAdd() {
  const id = document.getElementById('ba-batch').value,
    loc = document.getElementById('ba-loc').value,
    batch = batches.find((x) => x.batchId === id);
  if (!id || !batch) {
    fieldError('ba-batch', t('batchadd.selectBatch'));
    return;
  }
  if (!loc) {
    fieldError('ba-loc', t('batchadd.selectLoc'));
    return;
  }
  const now = new Date().toISOString();
  const entries = [];
  batch.bags.forEach((bagId) => {
    const tempId = 's' + ++_scanTempIdCounter;
    const entry = {
      time: now,
      action: 'ADD',
      batch: id,
      bag: bagId,
      from: null,
      to: loc,
      species: batch.species,
      strain: batch.strain,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      _tempId: tempId
    };
    scanLog.push(entry);
    movements.push(entry);
    if (!sessionStartTime) sessionStartTime = Date.now();
    sessionEntries.push(entry);
    scan.count++;
    entries.push(entry);
  });
  apiPost('/api/scan-log', { entries }).then(function (r) {
    if (r && r.ids)
      entries.forEach((e, i) => {
        setEntryServerId(e, r.ids[i]);
      });
  });
  updateSD();
  setFb('ok', `Batch ADD: ${batch.bags.length} bags → ${loc}`);
  closeBatchAdd();
}

// ─── HELPERS ─────────────────────────────────────────────────
const abbrev = (s) => {
  if (!s) return 'BAGX';
  const ms = mushroomStrains.find((x) => x.name.toLowerCase() === s.toLowerCase());
  if (ms && ms.kuerzel) return ms.kuerzel;
  return s.replace(/\s+/g, '').slice(0, 4).toUpperCase().padEnd(4, 'X');
};
// TTMMJJ. Ohne Angabe heute; mit einem Tag der, an dem angesetzt wurde — bei der
// Inventur trägt die Kennung das Datum, das auch auf dem Glas steht.
const todayStr = (d = new Date()) => {
  return (
    String(d.getDate()).padStart(2, '0') + String(d.getMonth() + 1).padStart(2, '0') + String(d.getFullYear()).slice(2)
  );
};
// Die nächste freie Nummer, nicht die Anzahl plus eins: an einem Tag, von dem
// eine Charge gelöscht wurde, gäbe die Anzahl eine Kennung, die es schon gibt,
// und der Server wiese die neue Charge ab. Mit angesetzten Tagen aus der
// Vergangenheit (Inventur) trifft man solche Tage öfter.
const genBatchId = (sp, d) => {
  const ab = abbrev(sp),
    dt = todayStr(d),
    prefix = ab + '-' + dt + '-',
    n = batches.reduce((mx, b) => {
      const k = b.batchId.startsWith(prefix) ? parseInt(b.batchId.slice(prefix.length), 10) : 0;
      return Number.isFinite(k) && k > mx ? k : mx;
    }, 0);
  return prefix + String(n + 1).padStart(2, '0');
};
// ─── STATUS CALC ─────────────────────────────────────────────
// I-10/I-14/I-21: derive zone counts from the *last* event per bag instead
// of incrementally counting deltas. This naturally handles out-of-order
// scan replays (e.g. an offline REMOVE that arrives after a fresh ADD): the
// latest scan-log entry by id always wins, so a stale event can't push a
// bag's tracked count below zero or above one.
//
// P-05: getStatus(id) used to walk the entire scanLog per call, and was
// invoked from inside the renderBatches fingerprint loop AND the body
// `.map`. With N batches × M scans that was N × M comparisons per
// render. We now build a per-batch lookup map once per applyData() and
// invalidate it whenever scanLog mutates (set _statusByBatch = null).
let _statusByBatch = null;
function _emptyStatus() {
  const c = {};
  if (Array.isArray(ZONES)) ZONES.forEach((z) => (c[z] = 0));
  return { c, total: 0, status: 'EMPTY', action: '' };
}
// Which growth stage a bag of `batchType` is in while it sits in a zone of
// `role`. The room alone cannot answer this: grain spawn can sit in an
// incubation room while it waits, and finished blocks can be parked in a
// spawn room — so keying off the room called grain "incubating"
// and called blocks a "spawn run". A fruiting or contamination room still wins
// outright (that genuinely IS a stage change); anywhere else the batch decides.
function stageOf(role, batchType) {
  if (role === 'fruiting' || role === 'contaminated') return role;
  return batchType === 'grain' ? 'spawn' : 'incubation';
}
// A bag in a contamination zone is nobody's stock: no count of a batch's or a
// Sorte's bags may include it. Only the contamination zone itself shows it.
function isContamLoc(loc) {
  const z = loc ? ZONE_BY_ID[toZone(loc)] : null;
  return !!(z && z.role === 'contaminated');
}
function _statusFromCounts(c, hasScans, batchType) {
  let total = 0;
  for (const k in c) total += c[k];
  const byRole = {};
  for (const z of zones) {
    const st = stageOf(z.role, batchType);
    if (!byRole[st]) byRole[st] = 0;
    byRole[st] += c[z.id] || 0;
  }
  let status = 'EMPTY',
    action = '';
  if (byRole.fruiting > 0) {
    status = 'FRUITING';
    action = t('status.action.harvest');
  } else if (byRole.incubation > 0) {
    status = 'INCUBATING';
    action = t('status.action.moveTent');
  } else if (byRole.spawn > 0) {
    status = 'SPAWN RUN';
    action = t('status.action.monitorSpawn');
  } else if (byRole.contaminated > 0) {
    status = 'CONTAM';
    action = t('status.action.discard');
  } else if (total === 0 && hasScans) {
    // Scan events exist for this batch but no remaining bags — DONE
    status = 'DONE';
  }
  return { c, total, status, action };
}
function _buildStatusByBatch() {
  // For each batch, find the last scan-log event per bag. Pre-bucket by
  // batch so we never iterate scanLog more than once. scanLog is ordered
  // by server id (see db.js getScanLog ORDER BY s.id), so a simple
  // forward iteration makes the highest-id entry win for each bag.
  const lastByBatchBag = new Map(); // batchId -> Map<bagKey, event>
  for (const e of scanLog) {
    if (!e.batch) continue;
    let m = lastByBatchBag.get(e.batch);
    if (!m) {
      m = new Map();
      lastByBatchBag.set(e.batch, m);
    }
    const key = e.bag || `__batch__:${e.batch}`;
    m.set(key, e);
  }
  // batch -> type, so stageOf() can tell grain from a block without a lookup
  // inside the per-zone loop.
  const typeById = new Map();
  for (const b of batches) typeById.set(b.batchId, b.batchType);
  const out = new Map();
  for (const [batchId, m] of lastByBatchBag) {
    const c = {};
    if (Array.isArray(ZONES)) ZONES.forEach((z) => (c[z] = 0));
    for (const e of m.values()) {
      if (e.action === 'REMOVE') continue;
      const tz = toZone(e.to);
      if (tz && c[tz] !== undefined) c[tz]++;
    }
    out.set(batchId, _statusFromCounts(c, true, typeById.get(batchId)));
  }
  return out;
}
function getStatus(id) {
  if (!_statusByBatch) _statusByBatch = _buildStatusByBatch();
  const cached = _statusByBatch.get(id);
  if (cached) return cached;
  // No scan events for this batch yet — return EMPTY.
  return _emptyStatus();
}
const getHarvested = (id) => harvests.filter((h) => h.batch === id).reduce((s, h) => s + (h.grams || 0), 0);

// ─── DASHBOARD ───────────────────────────────────────────────
let batchYieldInst = null,
  timelineInst = null;

// True iff the batch's due date is strictly before today (local-midnight comparison).
// Both sides are normalized to local midnight so the answer doesn't flip partway
// through the day in non-UTC timezones — b.due is stored as toISOString() (UTC),
// so comparing it against "now" would otherwise drift by the local offset.
function isBatchOverdue(b, now) {
  const today = now ? new Date(now) : new Date();
  today.setHours(0, 0, 0, 0);
  const due = new Date(b.due);
  due.setHours(0, 0, 0, 0);
  return due < today;
}

// ─── SORTEN OVERVIEW ─────────────────────────────────────────
// Replaces the pipeline KPI strip. That strip answered "how many bags are in
// each stage" and mixed its units doing it — "Chargen gesamt" and "Fertig"
// counted batches while the three stages beside them counted bags, all in one
// row. It also could not answer the question this page is actually opened
// with: which Sorte is running out, so which one needs a batch started.
//
// Both live here now. The first tile is the old total; the rest are one tile
// per Sorte, and every number on all of them is bags.

// ─── SORTE IDENTITY ──────────────────────────────────────────
// One key for a Sorte, used by the rollup, the tile filter, the grouping and
// every programme lookup.
//
// `b.species` is NOT it, and keying on it was one bug wearing seven faces:
// createBatch (and db.js insertBatch) write "Name (KÜRZEL)" while
// createGrainBatch writes "Name", so the SAME Sorte reaches this code under two
// spellings. Grain never joined its blocks, the programme flag never matched
// anything, and buildSupplyTasks() returned an empty list on real data.
//
// Batches carry strain_id and db.js resolves strainName from it, so the id is
// the key wherever it exists. _spKey is the fallback for rows that predate
// strain_id: it is the normalisation spColor has always used, and stripping the
// " (KZ)" suffix is exactly what it was written for.
function sorteKey(rec) {
  if (rec && rec.strainId) return 'id:' + rec.strainId;
  return 'n:' + _spKey((rec && (rec.strainName || rec.species || rec.name)) || '');
}
// A Sorte row may be reached by either key — id for batches that carry one,
// name for the older ones — so a lookup table has to answer to both.
function _strainKeys(ms) {
  return ['id:' + ms.id, 'n:' + _spKey(ms.name || '')];
}
// The Pilzsorten row behind a sorteKey(), for the buttons that have to open a
// form for it. Answers to both key forms, exactly as the programme map does.
function _strainByKey(key) {
  if (!key) return null;
  for (const ms of mushroomStrains || []) if (_strainKeys(ms).includes(key)) return ms;
  return null;
}
// Choose a type in the Laborarbeit quick dialog.
//
// The picker spells grain spawn KB where MIN_TYPES spells it GS; without the
// translation the membership check below silently fails and the dialog opens on
// whatever was selected last — a "Körnerbrut anlegen" button that registers a
// slant. Setting .value in script does not fire the select's onchange either,
// and that handler is what refills the parent list, so it is called directly.
function _msqPickType(type) {
  const lt = document.getElementById('ms-q-labtype');
  const want = type === 'GS' ? 'KB' : type;
  if (!lt || !want || ![...lt.options].some((o) => o.value === want)) return;
  lt.value = want;
  msQuickLabTypeChanged();
}

// What to print. The resolved strain name when there is one; otherwise the
// species with its " (KZ)" suffix stripped, so the card never shows one Sorte
// under two labels.
function sorteName(b) {
  const n = (b.strainName || '').trim();
  if (n) return n;
  const s = String(b.species || '')
    .replace(/\s*\([^)]*\)\s*$/, '')
    .trim();
  return s || t('batch.noSorte');
}

// Bags of one batch, bucketed by production stage. Same source as the status
// badge and the old strip — getStatus().c is the per-zone count derived from
// the last scan per bag — so the tiles cannot disagree with the row beneath
// them. stageOf() is what folds grain jars into 'spawn' regardless of the zone
// they sit in.
function _stageBagsOf(b) {
  const { c } = getStatus(b.batchId);
  const out = { spawn: 0, incubation: 0, fruiting: 0, contaminated: 0 };
  for (const z of zones) {
    const n = c[z.id] || 0;
    if (!n) continue;
    const st = stageOf(z.role, b.batchType);
    if (out[st] !== undefined) out[st] += n;
  }
  return out;
}

// How much of each Sorte is where, and whether anything is behind it.
//
// The chain on this farm runs grain -> block -> fruiting, and the verdict reads
// the first two steps SEPARATELY, because they are different lead times.
// Incubation is the next harvest; grain is what the harvest after that has to
// be made from. A Sorte with a full incubation and no grain has no problem
// today and a certain one in two cycles — a different thing from "running low",
// wanting a different answer on a different day.
//
//   grain 0, incubating 0  -> 'now'      behind the fruiting blocks: nothing
//   grain 0, incubating >0 -> 'nospawn'  next harvest yes, the one after no
//   incubating < fruiting  -> 'low'      the chain runs, but it is thinning
//   otherwise              -> 'ok'
//
// ── Why grain is counted apart rather than added in ──
//
// stageOf() puts a BLOCK into 'incubation' from any zone that is not fruiting
// or contaminated — blocks have no spawn-run stage in this app, only grain
// does. So "bags in spawn" is not a thing a block can be, and reading it that
// way would have made the spawn count permanently zero and the distinction
// above meaningless. Grain lives in its own batches (batchType 'grain', listed
// under Labor), and that is where the number has to come from.
//
// It is therefore in a DIFFERENT UNIT: kilograms, not blocks, and a kilo of
// grain makes several blocks. Adding it to a bag count would repeat exactly the
// mistake this card was built to fix — the old strip put batch counts and bag
// counts in one row. So grain stays out of `bags` and out of the bar's
// arithmetic; it is named in its own right, in kilograms, beside them.
//
// Everything here comes out of data the app already has. A real days-of-cover
// number would need a target per Sorte or consumption from the order side;
// neither exists, so it is not guessed at.
const SUPPLY_RANK = { now: 0, nospawn: 1, low: 2, ok: 3, off: 4 };
// Wieviel Körnerbrut dieser Charge noch dasteht, in KILOGRAMM.
//
// Eine Regel, ein Glas: es zählt, solange sein letzter Scan kein REMOVE ist und
// es nicht in einer Kontaminationszone steht. Sonst nichts.
//
// Das ersetzt zwei Sonderfälle, die beide falsch lagen. Der eine las
// getStatus().c, also Gläser mit Scan-Position — und createGrainBatch schreibt
// keine Scans, also war heute angesetzte Brut null. Der andere warf die ganze
// Charge weg, sobald sie archiviert war, und zählte sie bis dahin voll: neun von
// zehn Gläsern verbraucht, und die Kachel meldete weiter zehn. "Körner fehlen"
// konnte damit erst umschlagen, wenn das letzte Glas der letzten Charge ging.
//
// Die eine Regel deckt beides ab, ohne einen Zweig für keins von beidem:
//   kein Eintrag  — heute angesetzt, noch nirgends hingestellt → zählt
//   ADD / MOVE    — steht irgendwo → zählt
//   REMOVE        — in Blöcke gegangen oder verworfen → zählt nicht
//   in CONTAM     — da, aber nicht brauchbar → zählt nicht
//
// Ist eine Charge ganz verbraucht, ergibt die Summe von selbst 0; es braucht
// keine Archiv-Abfrage mehr — und damit auch keinen Merker dafür, ob eine
// Charge überhaupt schon gescannt wurde.
//
// Das Gewicht kommt je Glas aus bagWeights, das db.js schon auflöst (bag_kg der
// Zeile, sonst der Charge, sonst 3). `w || 1` stand hier und machte aus einem
// mit 0 gewogenen Glas eines von einem Kilo — und widersprach nebenbei dem
// Standardwert der Serverseite.
function _grainKgOf(b) {
  const platz = placementByBag();
  // Wenn niemand sagt, wie schwer ein Glas ist, gilt dasselbe Ersatzmass wie
  // beim Auslesen: db.js setzt fuer bagWeights `r.bag_kg || 3`. Hier stand 0,
  // und damit meldete eine Charge ohne Gewichtsangabe null Kilogramm ueber
  // einem vollen Regal -- genau die "Koerner fehlen"-Meldung, gegen die diese
  // Funktion zweimal umgeschrieben wurde. Zwei Wege durch dieselbe Zahl
  // muessen dasselbe Ersatzmass nehmen, sonst widersprechen sie sich.
  const ERSATZ_KG = 3;
  const glasKg = (bag) => {
    const w = b.bagWeights && b.bagWeights[bag];
    if (Number.isFinite(w)) return w;
    return Number.isFinite(b.bagKg) ? b.bagKg : ERSATZ_KG;
  };
  const glaeser = b.bags && b.bags.length ? b.bags : null;
  // Ohne Glasliste bleibt nur die Angabe der Charge selbst.
  if (!glaeser) return (b.qty || 0) * (Number.isFinite(b.bagKg) ? b.bagKg : ERSATZ_KG);
  let kg = 0;
  for (const bag of glaeser) {
    const letzter = platz.get(String(bag).toUpperCase());
    if (letzter && letzter.action === 'REMOVE') continue;
    if (letzter && letzter.to) {
      const z = ZONE_BY_ID[toZone(letzter.to)];
      if (z && z.role === 'contaminated') continue;
    }
    kg += glasKg(bag);
  }
  return kg;
}
function sorteRollup() {
  const bySorte = new Map();
  for (const b of batches) {
    const key = sorteKey(b);
    let r = bySorte.get(key);
    if (!r) {
      r = {
        key,
        name: sorteName(b),
        kuerzel: '',
        grain: 0, // kilograms of grain spawn — a different unit, kept apart
        incubation: 0,
        fruiting: 0,
        nBatches: 0, // block batches with bags still on the floor
        nAll: 0, // block batches, live and finished — what the table below lists
        lastDays: null,
        nextDue: null
      };
      bySorte.set(key, r);
    }
    if (!r.kuerzel) r.kuerzel = (b.strainKuerzel || '').trim();
    // Grain contributes one thing and one thing only: how much is ready to make
    // the next blocks from. It is not a batch on this page and not a bag in
    // these totals.
    if (b.batchType === 'grain') {
      r.grain += _grainKgOf(b);
      continue;
    }
    const st = _stageBagsOf(b);
    r.nAll++;
    // Age, not recipe length. b.days is the planned incubation duration — the
    // number the table prints as "14d" — so reading it here printed a constant
    // that never moved, under a label saying "last one N days ago".
    const age = Math.max(0, Math.round((Date.now() - new Date(b.created)) / 864e5));
    if (Number.isFinite(age) && (r.lastDays == null || age < r.lastDays)) r.lastDays = age;
    r.incubation += st.incubation;
    r.fruiting += st.fruiting;
    if (st.incubation + st.fruiting > 0) {
      r.nBatches++;
      // The next batch due to reach fruiting — only the ones not already there.
      const due = new Date(b.due);
      if (st.fruiting === 0 && (r.nextDue == null || due < r.nextDue)) r.nextDue = due;
    }
  }
  // Is the farm growing this one at the moment? Keyed by BOTH of a strain's
  // keys, because a batch reaches the rollup under its id and an older one
  // under its name. A Sorte with no row in Pilzsorten at all is treated as in
  // the programme — it is being grown, somebody just never wrote it down, and
  // going quiet about it would hide real work — but `known` records which case
  // it was, so a caller that needs the stricter reading can have it.
  const programme = new Map();
  for (const m of mushroomStrains) for (const k of _strainKeys(m)) programme.set(k, m.imProgramm !== false);
  const out = [...bySorte.values()];
  for (const r of out) {
    if (!r.kuerzel) r.kuerzel = abbrev(r.name);
    const p = programme.get(r.key);
    r.known = p !== undefined;
    r.imProgramm = p === undefined ? true : p;
    // Blocks only — the same unit as every other number on the tile.
    r.bags = r.incubation + r.fruiting;
    r.supply =
      r.grain === 0 && r.incubation === 0
        ? 'now'
        : r.grain === 0
          ? 'nospawn'
          : r.incubation < r.fruiting
            ? 'low'
            : 'ok';
    // Out of the programme, the light goes off entirely rather than turning
    // green. Green would claim the supply is fine; the truth is that nobody is
    // asking. A Sorte paused for the season has no grain and nothing incubating BY
    // DEFINITION, and a red card every day for a Sorte nobody is growing
    // teaches people to stop reading the card.
    if (!r.imProgramm) r.supply = 'off';
  }
  // A Sorte that exists only as grain has no block batches and nothing for the
  // list below; it still belongs on the card, because "there is spawn ready and
  // no blocks made from it" is precisely a thing worth seeing.
  return out;
}

function renderOverviewKPIs() {
  const weekEl = document.getElementById('ov-kpi-week');
  const substratesEl = document.getElementById('ov-kpi-substrates');
  const qualEl = document.getElementById('ov-kpi-quality');
  if (!weekEl || !qualEl) return;

  applyOvPeriod();

  const now = Date.now();
  const nowDate = new Date();

  // Period start based on selected period
  let periodStart;
  if (ovPeriod === 'week') {
    // Monday of the current week (Mon–Sun)
    periodStart = new Date(nowDate);
    periodStart.setDate(periodStart.getDate() - ((periodStart.getDay() + 6) % 7));
    periodStart.setHours(0, 0, 0, 0);
  } else if (ovPeriod === 'month') periodStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), 1);
  else periodStart = new Date(nowDate.getFullYear(), 0, 1);

  // ── PRODUCTION ─────────────────────────────────────────────
  // 1. Bags created
  const bagsCreated = batches.filter((b) => new Date(b.created) >= periodStart).reduce((s, b) => s + (b.qty || 0), 0);

  // 2. Grain used (kg) — from inventory log
  const grainUsed = (inventory.log || [])
    .filter((e) => e.mat === 'grain' && e.type === 'batch' && new Date(e.time) >= periodStart)
    .reduce((s, e) => s + Math.abs(e.deltaKg || 0), 0);

  // 3. Harvest (kg)
  const periodHarvests = harvests.filter((h) => new Date(h.time) >= periodStart);
  const periodHarvestKg = periodHarvests.reduce((s, h) => s + (h.grams || 0), 0) / 1000;

  // 4. Substrate used (kg) — hardwood and wheat bran tracked separately
  let hardwoodUsed = 0,
    wheatbranUsed = 0;
  (inventory.log || []).forEach((e) => {
    if (e.type !== 'batch' || new Date(e.time) < periodStart) return;
    if (e.mat === 'hardwood') hardwoodUsed += Math.abs(e.deltaKg || 0);
    else if (e.mat === 'wheatbran') wheatbranUsed += Math.abs(e.deltaKg || 0);
  });

  // ── QUALITY & EFFICIENCY ──────────────────────────────────
  // 5. Avg yield per bag (g) — all-time + period comparison
  const uniqueHarvestedBags = new Set(harvests.map((h) => h.bag)).size;
  const avgYield =
    uniqueHarvestedBags > 0 ? Math.round(harvests.reduce((s, h) => s + (h.grams || 0), 0) / uniqueHarvestedBags) : 0;
  // Period yield: avg grams per unique bag harvested in selected period
  const periodBags = new Set(periodHarvests.map((h) => h.bag));
  const periodYield =
    periodBags.size > 0 ? Math.round(periodHarvests.reduce((s, h) => s + (h.grams || 0), 0) / periodBags.size) : 0;
  const yieldDelta = avgYield > 0 && periodYield > 0 ? periodYield - avgYield : null;
  // periodSub = label for the selected period ("This week"/"This month"/…).
  // Declared here (not further down) because yieldSub below references it —
  // a later `const` would throw a temporal-dead-zone ReferenceError and abort
  // the whole render whenever there is a harvest in the period.
  const periodSub = t('dash.ov.period' + ovPeriod.charAt(0).toUpperCase() + ovPeriod.slice(1));
  let yieldSub = t('dash.ov.perBag');
  if (periodYield > 0) {
    const arrow = yieldDelta > 0 ? '↑' : yieldDelta < 0 ? '↓' : '=';
    const color = yieldDelta > 0 ? 'var(--c-green-dark)' : yieldDelta < 0 ? 'var(--c-red-dark)' : '';
    yieldSub = periodSub + ': ' + periodYield + 'g <span style="color:' + color + '">' + arrow + '</span>';
  }

  // 6. Contamination rate (%)
  // I-13: numerator must be a subset of the denominator. addedBags is the
  // set of bags that ever had an ADD; contamBagSet only counts bags that
  // both had an ADD AND were moved to a contaminated zone. Without this
  // intersection a MOVE-only contaminated bag (e.g. an auto-MOVE from a
  // contamination report on a bag that pre-dated explicit ADD tracking)
  // would push the percentage above 100.
  const addedBags = new Set(scanLog.filter((e) => e.action === 'ADD' && e.bag).map((e) => e.bag));
  const allBagsPlaced = addedBags.size;
  const contamBagSet = new Set();
  scanLog.forEach((e) => {
    if (!e.to || !e.bag) return;
    if (!addedBags.has(e.bag)) return;
    const z = ZONE_BY_ID[toZone(e.to)];
    if (z && z.role === 'contaminated') contamBagSet.add(e.bag);
  });
  const contamRate = allBagsPlaced > 0 ? +((contamBagSet.size / allBagsPlaced) * 100).toFixed(1) : 0;
  // The -dark variants, not the mid tones. `card()` puts this colour on two
  // things: the 24px value, which sits on the white card, and the icon glyph,
  // which sits on the tinted chip beside it. The mid tones fail both — green
  // reads 2.3:1 on white against the 3.0 large text needs, amber 2.1, and as
  // glyphs on their own -light backgrounds 2.1 and 1.9 against the same 3.0 for
  // non-text. The six cards either side of these two are hand-picked darks
  // between 3.7 and 6.4, so the two quality KPIs were the washed-out pair in a
  // row of eight. Red is moved with them: at 3.8 it passes, but leaving it mid
  // while its two siblings go dark makes the worst state the palest of the
  // three. The -dark family lands 7.1-8.3 on white and 6.4-6.8 on the chips.
  const contamColor =
    contamRate === 0 ? 'var(--c-green-dark)' : contamRate <= 5 ? 'var(--c-amber-dark)' : 'var(--c-red-dark)';
  const contamBg =
    contamRate === 0 ? 'var(--c-green-light)' : contamRate <= 5 ? 'var(--c-amber-light)' : 'var(--c-red-light)';

  // 7. Days without contamination (streak)
  const contamEvents = scanLog.filter((e) => {
    if (!e.to || !e.bag) return false;
    const z = ZONE_BY_ID[toZone(e.to)];
    return z && z.role === 'contaminated';
  });
  let daysSinceContam = null,
    daysSinceLabel = '';
  if (contamEvents.length === 0) {
    daysSinceContam = batches.length > 0 ? Math.floor((now - new Date(batches[0].created)) / 864e5) : null;
    daysSinceLabel = t('dash.ov.neverContam');
  } else {
    daysSinceContam = Math.floor((now - new Date(contamEvents[contamEvents.length - 1].time)) / 864e5);
    daysSinceLabel = daysSinceContam === 1 ? t('dash.ov.dayAgo') : t('dash.ov.daysAgo', { n: daysSinceContam });
  }
  // Same three states, same card, same reason — see contamColor above.
  const streakColor =
    daysSinceContam === null
      ? 'var(--c-text-muted)'
      : daysSinceContam >= 14
        ? 'var(--c-green-dark)'
        : daysSinceContam >= 7
          ? 'var(--c-amber-dark)'
          : 'var(--c-red-dark)';
  const streakBg =
    daysSinceContam === null
      ? 'var(--c-bg)'
      : daysSinceContam >= 14
        ? 'var(--c-green-light)'
        : daysSinceContam >= 7
          ? 'var(--c-amber-light)'
          : 'var(--c-red-light)';

  // 8. Flush 2+ bags (bags that have had ≥2 harvests logged)
  const bagFlushMax = {};
  harvests.forEach((h) => {
    if (!bagFlushMax[h.bag] || h.flush > bagFlushMax[h.bag]) bagFlushMax[h.bag] = h.flush || 1;
  });
  const flush2Plus = Object.values(bagFlushMax).filter((f) => f >= 2).length;

  // ── HELPER ────────────────────────────────────────────────
  function card(icon, value, label, sub, accentColor, accentBg) {
    return `<div class="ov-kpi-card">
      <div class="ov-kpi-icon" style="color:${accentColor};background:${accentBg}">${icon}</div>
      <div class="ov-kpi-body">
        <div class="ov-kpi-value" style="color:${accentColor}">${value}</div>
        <div class="ov-kpi-label">${label}</div>
        ${sub ? `<div class="ov-kpi-sub">${sub}</div>` : ''}
      </div>
    </div>`;
  }

  const fmtKg = (v) => (v >= 10 ? Math.round(v) + 'kg' : v.toFixed(1) + 'kg');

  // Icons
  const iconBag = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M6 2L3 6v14a2 2 0 002 2h14a2 2 0 002-2V6l-3-4z"/><line x1="3" y1="6" x2="21" y2="6"/><path d="M16 10a4 4 0 01-8 0"/></svg>`;
  const iconGrain = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 2a10 10 0 110 20A10 10 0 0112 2z"/><path d="M12 6v12M8 8l4 4 4-4M8 16l4-4 4 4"/></svg>`;
  const iconHarvest = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 2L2 7l10 5 10-5-10-5z"/><path d="M2 17l10 5 10-5"/><path d="M2 12l10 5 10-5"/></svg>`;
  const iconSubstrate = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><path d="M8 12h8M12 8v8"/></svg>`;
  const iconYield = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="22 7 13.5 15.5 8.5 10.5 2 17"/><polyline points="16 7 22 7 22 13"/></svg>`;
  const iconContam = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M10.29 3.86L1.82 18a2 2 0 001.71 3h16.94a2 2 0 001.71-3L13.71 3.86a2 2 0 00-3.42 0z"/><line x1="12" y1="9" x2="12" y2="13"/><line x1="12" y1="17" x2="12.01" y2="17"/></svg>`;
  const iconStreak = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><path d="M12 22s8-4 8-10V5l-8-3-8 3v7c0 6 8 10 8 10z"/></svg>`;
  const iconFlush = `<svg width="18" height="18" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="1 4 1 10 7 10"/><path d="M3.51 15a9 9 0 102.13-9.36L1 10"/></svg>`;

  const periodLabel = document.getElementById('ov-period-label');
  if (periodLabel) periodLabel.textContent = periodSub;

  weekEl.innerHTML = [
    card(iconBag, bagsCreated || '0', t('dash.ov.bagsCreated'), periodSub, '#2d6a4f', '#e6f2ec'),
    card(
      iconHarvest,
      periodHarvestKg > 0 ? fmtKg(periodHarvestKg) : '—',
      t('dash.ov.harvestThisWeek'),
      periodHarvests.length + ' ' + t('dash.ov.harvests'),
      '#c2703e',
      '#faf0e6'
    ),
    card(iconFlush, flush2Plus || '0', t('dash.ov.flush2Plus'), t('dash.ov.bagsOnSecondFlush'), '#3a7d7b', '#e6f2f1'),
    card(iconYield, avgYield > 0 ? avgYield + 'g' : '—', t('dash.ov.avgYield'), yieldSub, '#5a8a32', '#eef4e5')
  ].join('');

  if (substratesEl)
    substratesEl.innerHTML = [
      card(
        iconGrain,
        grainUsed > 0 ? fmtKg(grainUsed) : '—',
        t('dash.ov.grainUsed'),
        t('dash.ov.fromBatches'),
        '#6b7c3f',
        '#f0f2e6'
      ),
      card(
        iconSubstrate,
        hardwoodUsed > 0 ? fmtKg(hardwoodUsed) : '—',
        t('dash.ov.hardwoodUsed'),
        t('dash.ov.fromBatches'),
        '#8b5e3c',
        '#f5ede6'
      ),
      card(
        iconSubstrate,
        wheatbranUsed > 0 ? fmtKg(wheatbranUsed) : '—',
        t('dash.ov.wheatbranUsed'),
        t('dash.ov.fromBatches'),
        // Was #c9a227, the one card in this row that had been picked for its
        // hue rather than its weight: 2.4:1 on the card and 2.2:1 as a glyph on
        // its own chip, where its six neighbours run 3.7 to 6.4. Same gold, taken
        // down to 4.7 — which lands it between the olive at 4.6 and the teal at
        // 4.8, so the row reads as one set instead of six numbers and a faint one.
        '#8f6f16',
        '#faf5e0'
      )
    ].join('');

  qualEl.innerHTML = [
    card(
      iconContam,
      contamRate + '%',
      t('dash.ov.contamRate'),
      contamBagSet.size + ' / ' + allBagsPlaced + ' ' + t('dash.ov.bags'),
      contamColor,
      contamBg
    ),
    card(
      iconStreak,
      daysSinceContam !== null ? daysSinceContam : t('dash.ov.na'),
      t('dash.ov.daysSinceContam'),
      daysSinceLabel,
      streakColor,
      streakBg
    )
  ].join('');

  renderOverviewCharts(periodStart);
}

let ovChartHarvestInst = null,
  ovChartSpeciesInst = null,
  ovChartSubstrateInst = null,
  ovChartBagsInst = null;

function renderOverviewCharts(periodStart) {
  // P-02: Chart.js is lazy-loaded. If the idle preload hasn't fired yet,
  // skip this render and re-fire once the lib is ready. The page is fully
  // usable in the meantime — just no charts. (renderOverviewCharts is
  // already a no-op when the canvases aren't in the DOM, so callers don't
  // need their own guard.)
  if (typeof Chart === 'undefined') {
    loadVendorLibs().then(() => renderOverviewCharts(periodStart));
    return;
  }
  const nowDate = new Date();
  const periodHarvests = harvests.filter((h) => new Date(h.time) >= periodStart);
  const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];

  // ── Helpers: build time buckets depending on period ──────
  function buildTimeBuckets() {
    if (ovPeriod === 'week') {
      // Full week Mon–Sun (7 days)
      const days = [];
      const cur = new Date(periodStart);
      for (let i = 0; i < 7; i++) {
        days.push(localDateStr(cur));
        cur.setDate(cur.getDate() + 1);
      }
      const dayNames = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So'];
      return { keys: days, label: (k, i) => dayNames[i] + ' ' + fmtDtShort(k), groupKey: (d) => localDateStr(d) };
    }
    if (ovPeriod === 'month') {
      // Full month 1st to last day
      const days = [];
      const cur = new Date(periodStart);
      const lastDay = new Date(nowDate.getFullYear(), nowDate.getMonth() + 1, 0);
      while (cur <= lastDay) {
        days.push(localDateStr(cur));
        cur.setDate(cur.getDate() + 1);
      }
      return { keys: days, label: (k) => fmtDtShort(k), groupKey: (d) => localDateStr(d) };
    }
    // year — monthly buckets Jan–Dec
    const mKeys = Array.from({ length: 12 }, (_, i) => `${nowDate.getFullYear()}-${String(i + 1).padStart(2, '0')}`);
    return {
      keys: mKeys,
      label: (k) => monthNames[parseInt(k.split('-')[1]) - 1],
      groupKey: (d) => `${d.getFullYear()}-${String(d.getMonth() + 1).padStart(2, '0')}`
    };
  }
  const { keys, label, groupKey } = buildTimeBuckets();

  // ── Chart titles ─────────────────────────────────────────
  const harvestLabel = document.getElementById('ov-chart-harvest-label');
  const speciesLabel = document.getElementById('ov-chart-species-label');
  const substrateLabel = document.getElementById('ov-chart-substrate-label');
  const bagsLabel = document.getElementById('ov-chart-bags-label');
  if (ovPeriod === 'week') {
    if (harvestLabel) harvestLabel.textContent = t('dash.ov.dailyHarvest') || 'Daily harvest';
    if (substrateLabel) substrateLabel.textContent = t('dash.ov.weeklySubstrate') || 'Substrate usage';
    if (bagsLabel) bagsLabel.textContent = t('dash.ov.bagsCreated') || 'Bags created';
  } else if (ovPeriod === 'month') {
    if (harvestLabel) harvestLabel.textContent = t('dash.ov.dailyHarvest') || 'Daily harvest';
    if (substrateLabel) substrateLabel.textContent = t('dash.ov.weeklySubstrate') || 'Substrate by week';
    if (bagsLabel) bagsLabel.textContent = t('dash.ov.bagsCreated') || 'Bags created';
  } else {
    if (harvestLabel) harvestLabel.textContent = t('dash.ov.monthlyHarvest') || 'Monthly harvest';
    if (substrateLabel) substrateLabel.textContent = t('dash.ov.weeklySubstrate') || 'Substrate by month';
    if (bagsLabel) bagsLabel.textContent = t('dash.ov.monthlyBags') || 'Bags created by month';
  }
  if (speciesLabel) speciesLabel.textContent = t('dash.harvestBySpecies') || 'Harvest by species (kg)';

  // ── 1. Harvest over time ─────────────────────────────────
  const c1 = document.getElementById('ov-chart-harvest');
  if (c1) {
    const harvestMap = {};
    periodHarvests.forEach((h) => {
      const k = groupKey(new Date(h.time));
      harvestMap[k] = (harvestMap[k] || 0) + (h.grams || 0);
    });
    if (ovChartHarvestInst) {
      ovChartHarvestInst.destroy();
      ovChartHarvestInst = null;
    }
    const ctx = c1.getContext('2d');
    const grad = ctx.createLinearGradient(0, 0, 0, 180);
    grad.addColorStop(0, 'rgba(194,112,62,0.25)');
    grad.addColorStop(1, 'rgba(194,112,62,0.02)');
    const useBar = ovPeriod === 'year';
    ovChartHarvestInst = new Chart(c1, {
      type: useBar ? 'bar' : 'line',
      data: {
        labels: keys.map((k, i) => label(k, i)),
        datasets: [
          {
            data: keys.map((k) => +((harvestMap[k] || 0) / 1000).toFixed(2)),
            fill: !useBar,
            backgroundColor: useBar
              ? keys.map((k, i) =>
                  ovPeriod === 'year' && i === nowDate.getMonth() ? '#c2703e' : 'rgba(194,112,62,0.55)'
                )
              : grad,
            borderColor: '#c2703e',
            borderWidth: 2,
            pointRadius: keys.length > 20 ? 0 : 3,
            pointBackgroundColor: '#c2703e',
            borderRadius: useBar ? 6 : 0,
            tension: 0.35
          }
        ]
      },
      options: {
        responsive: true,
        plugins: { legend: { display: false }, tooltip: { callbacks: { label: (c) => c.parsed.y.toFixed(2) + 'kg' } } },
        scales: {
          y: { ticks: { callback: (v) => v + 'kg', color: '#94a3b8' }, grid: { color: '#e2e8f0' }, beginAtZero: true },
          x: { ticks: { font: { size: 9 }, color: '#94a3b8', maxTicksLimit: 14 }, grid: { display: false } }
        }
      }
    });
  }

  // ── 2. Harvest by species ────────────────────────────────
  const c2 = document.getElementById('ov-chart-species');
  if (c2) {
    const bySpecies = {};
    periodHarvests.forEach((h) => {
      bySpecies[h.species] = (bySpecies[h.species] || 0) + (h.grams || 0);
    });
    const spLabels = Object.keys(bySpecies);
    const spData = spLabels.map((s) => bySpecies[s] / 1000);
    if (ovChartSpeciesInst) {
      ovChartSpeciesInst.destroy();
      ovChartSpeciesInst = null;
    }
    if (!spLabels.length) {
      const ctx = c2.getContext('2d');
      ctx.clearRect(0, 0, c2.width, c2.height);
      ctx.fillStyle = '#94a3b8';
      ctx.font = '12px system-ui';
      ctx.textAlign = 'center';
      ctx.fillText(t('harvest.noData'), c2.width / 2, 80);
    } else {
      const fmtKg = (v) => Math.round(v * 100) / 100 + 'kg';
      const ctx = c2.getContext('2d');
      const bgColors = spLabels.map((s) => {
        const g = ctx.createLinearGradient(0, 0, 0, c2.clientHeight || 180);
        g.addColorStop(0, spColor(s) + 'ee');
        g.addColorStop(1, spColor(s) + '55');
        return g;
      });
      const dataLabelPlugin = {
        id: 'harvestDataLabels',
        afterDatasetsDraw(chart) {
          const { ctx: cc, data } = chart;
          chart.getDatasetMeta(0).data.forEach((bar, i) => {
            const val = data.datasets[0].data[i];
            if (!val) return;
            cc.save();
            cc.fillStyle = '#475569';
            cc.font = 'bold 11px system-ui';
            cc.textAlign = 'center';
            cc.textBaseline = 'bottom';
            cc.fillText(fmtKg(val), bar.x, bar.y - 4);
            cc.restore();
          });
        }
      };
      ovChartSpeciesInst = new Chart(c2, {
        type: 'bar',
        plugins: [dataLabelPlugin],
        data: {
          labels: spLabels,
          datasets: [
            {
              data: spData,
              backgroundColor: bgColors,
              borderColor: spLabels.map((s) => spColor(s)),
              borderWidth: 1.5,
              borderRadius: 8,
              borderSkipped: false
            }
          ]
        },
        options: {
          responsive: true,
          layout: { padding: { top: 22 } },
          plugins: { legend: { display: false }, tooltip: { callbacks: { label: (c) => fmtKg(c.parsed.y) } } },
          scales: {
            y: {
              ticks: { callback: (v) => fmtKg(v), color: '#94a3b8' },
              grid: { color: '#e2e8f0' },
              beginAtZero: true
            },
            x: { grid: { display: false }, ticks: { color: '#94a3b8' } }
          }
        }
      });
    }
  }

  // ── 3. Substrate usage ───────────────────────────────────
  const c3 = document.getElementById('ov-chart-substrate');
  if (c3) {
    const hwMap = {},
      wbMap = {},
      grMap = {};
    (inventory.log || []).forEach((e) => {
      if (e.type !== 'batch') return;
      if (e.mat !== 'hardwood' && e.mat !== 'wheatbran' && e.mat !== 'grain') return;
      const d = new Date(e.time);
      if (d < periodStart) return;
      let k;
      if (ovPeriod === 'year') {
        k = groupKey(d);
      } else {
        // group by week (Monday)
        const mon = new Date(d);
        mon.setDate(d.getDate() - ((d.getDay() + 6) % 7));
        k = localDateStr(mon);
      }
      if (e.mat === 'hardwood') hwMap[k] = (hwMap[k] || 0) + Math.abs(e.deltaKg || 0);
      else if (e.mat === 'wheatbran') wbMap[k] = (wbMap[k] || 0) + Math.abs(e.deltaKg || 0);
      else if (e.mat === 'grain') grMap[k] = (grMap[k] || 0) + Math.abs(e.deltaKg || 0);
    });
    let subKeys, subLabels;
    if (ovPeriod === 'year') {
      subKeys = keys;
      subLabels = keys.map((k, i) => label(k, i));
    } else {
      subKeys = [...new Set([...Object.keys(hwMap), ...Object.keys(wbMap), ...Object.keys(grMap)])].sort();
      subLabels = subKeys.map((k) => 'KW ' + isoWeekNumber(k));
    }
    if (ovChartSubstrateInst) {
      ovChartSubstrateInst.destroy();
      ovChartSubstrateInst = null;
    }
    if (!subKeys.length) {
      const ctx = c3.getContext('2d');
      ctx.clearRect(0, 0, c3.width, c3.height);
      ctx.fillStyle = '#94a3b8';
      ctx.font = '12px system-ui';
      ctx.textAlign = 'center';
      ctx.fillText(t('dash.noHarvestData'), c3.width / 2, 60);
    } else {
      ovChartSubstrateInst = new Chart(c3, {
        type: 'bar',
        data: {
          labels: subLabels,
          datasets: [
            {
              label: t('dash.ov.grain'),
              data: subKeys.map((k) => +(grMap[k] || 0).toFixed(1)),
              backgroundColor: '#6b7c3f',
              borderRadius: 5
            },
            {
              label: t('dash.ov.hardwood'),
              data: subKeys.map((k) => +(hwMap[k] || 0).toFixed(1)),
              backgroundColor: '#8b5e3c',
              borderRadius: 5
            },
            {
              label: t('dash.ov.wheatbran'),
              data: subKeys.map((k) => +(wbMap[k] || 0).toFixed(1)),
              backgroundColor: '#c9a227',
              borderRadius: 5
            }
          ]
        },
        options: {
          responsive: true,
          plugins: {
            legend: { position: 'bottom', labels: { boxWidth: 10, font: { size: 10 } } },
            tooltip: { callbacks: { label: (c) => c.dataset.label + ': ' + c.parsed.y.toFixed(1) + 'kg' } }
          },
          scales: {
            y: {
              ticks: { callback: (v) => v + 'kg', color: '#94a3b8' },
              grid: { color: '#e2e8f0' },
              beginAtZero: true
            },
            x: { ticks: { color: '#94a3b8' }, grid: { display: false } }
          }
        }
      });
    }
  }

  // ── 4. Bags created ──────────────────────────────────────
  const c4 = document.getElementById('ov-chart-bags');
  if (c4) {
    const bagMap = {};
    batches
      .filter((b) => new Date(b.created) >= periodStart)
      .forEach((b) => {
        const k = groupKey(new Date(b.created));
        bagMap[k] = (bagMap[k] || 0) + (b.qty || 0);
      });
    if (ovChartBagsInst) {
      ovChartBagsInst.destroy();
      ovChartBagsInst = null;
    }
    ovChartBagsInst = new Chart(c4, {
      type: 'bar',
      data: {
        labels: keys.map((k, i) => label(k, i)),
        datasets: [
          {
            data: keys.map((k) => bagMap[k] || 0),
            backgroundColor: keys.map((k, i) =>
              ovPeriod === 'year' && i === nowDate.getMonth() ? '#2d6a4f' : 'rgba(45,106,79,0.55)'
            ),
            borderRadius: 6
          }
        ]
      },
      options: {
        responsive: true,
        plugins: {
          legend: { display: false },
          tooltip: { callbacks: { label: (c) => c.parsed.y + ' ' + t('dash.ov.bags') } }
        },
        scales: {
          y: { ticks: { color: '#94a3b8' }, grid: { color: '#e2e8f0' }, beginAtZero: true },
          x: { ticks: { font: { size: 9 }, color: '#94a3b8', maxTicksLimit: 14 }, grid: { display: false } }
        }
      }
    });
  }
}

// ── KPI History (daily snapshot trend charts) ───────────────
let kpiHistoryData = null;
let ovHistHarvestInst = null,
  ovHistPipelineInst = null,
  ovHistContamInst = null,
  ovHistStockInst = null;

async function loadKpiHistory() {
  try {
    const r = await fetch('/api/kpi-snapshots?limit=90');
    if (!r.ok) return;
    const j = await r.json();
    kpiHistoryData = j.items || [];
    renderKpiHistory();
  } catch (e) {
    console.warn('KPI history load failed', e);
  }
}

function renderKpiHistory() {
  const wrap = document.getElementById('ov-kpi-history');
  const emptyEl = document.getElementById('ov-history-empty');
  const chartsEl = document.getElementById('ov-history-charts');
  if (!wrap) return;
  // P-02: Chart.js may not be loaded yet (idle preload). Defer.
  if (typeof Chart === 'undefined') {
    loadVendorLibs().then(() => renderKpiHistory());
    return;
  }

  if (!kpiHistoryData || kpiHistoryData.length < 2) {
    if (emptyEl) emptyEl.style.display = '';
    if (chartsEl) chartsEl.style.display = 'none';
    return;
  }
  if (emptyEl) emptyEl.style.display = 'none';
  if (chartsEl) chartsEl.style.display = '';

  // Filter snapshots by the selected overview period + build fixed date range
  const nowDate = new Date();
  const monthNames = ['Jan', 'Feb', 'Mar', 'Apr', 'May', 'Jun', 'Jul', 'Aug', 'Sep', 'Oct', 'Nov', 'Dec'];
  let periodStart;
  if (ovPeriod === 'week') {
    periodStart = new Date(nowDate);
    periodStart.setDate(periodStart.getDate() - ((periodStart.getDay() + 6) % 7));
    periodStart.setHours(0, 0, 0, 0);
  } else if (ovPeriod === 'month') {
    periodStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), 1);
  } else {
    periodStart = new Date(nowDate.getFullYear(), 0, 1);
  }
  const periodKey = localDateStr(periodStart);
  const filtered = kpiHistoryData.filter((s) => s.date >= periodKey);
  if (!filtered.length) {
    if (emptyEl) emptyEl.style.display = '';
    if (chartsEl) chartsEl.style.display = 'none';
    return;
  }

  // Build lookup + fixed date keys so x-axis always covers the full period
  const snapshotMap = {};
  filtered.forEach((s) => {
    snapshotMap[s.date] = s;
  });

  const histKeys = []; // date keys for x-axis
  const histLabels = []; // display labels
  if (ovPeriod === 'week') {
    // Mon–Sun (7 days)
    const dayNames = ['Mo', 'Di', 'Mi', 'Do', 'Fr', 'Sa', 'So'];
    const cur = new Date(periodStart);
    for (let i = 0; i < 7; i++) {
      histKeys.push(localDateStr(cur));
      histLabels.push(dayNames[i] + ' ' + fmtDtShort(cur));
      cur.setDate(cur.getDate() + 1);
    }
  } else if (ovPeriod === 'month') {
    // 1st to last day of month
    const cur = new Date(periodStart);
    const lastDay = new Date(nowDate.getFullYear(), nowDate.getMonth() + 1, 0);
    while (cur <= lastDay) {
      histKeys.push(localDateStr(cur));
      histLabels.push(fmtDtShort(cur));
      cur.setDate(cur.getDate() + 1);
    }
  } else {
    // Year — Jan to Dec monthly buckets, use last snapshot per month
    for (let m = 0; m < 12; m++) {
      histKeys.push(`${nowDate.getFullYear()}-${String(m + 1).padStart(2, '0')}`);
      histLabels.push(monthNames[m]);
    }
    // Build monthly lookup: last snapshot of each month
    const monthSnap = {};
    filtered.forEach((s) => {
      const mk = s.date.slice(0, 7);
      monthSnap[mk] = s;
    });
    // Override snapshotMap for monthly access
    histKeys.forEach((mk) => {
      if (monthSnap[mk]) snapshotMap[mk] = monthSnap[mk];
    });
  }

  const snapVal = (key, field) => {
    const s = snapshotMap[key];
    return s ? s[field] || 0 : null;
  };

  const chartOpts = (yLabel, cb, extraOpts) => ({
    responsive: true,
    plugins: {
      legend: { display: true, labels: { boxWidth: 12, font: { size: 11 } } },
      tooltip: { callbacks: { label: cb || undefined } },
      ...((extraOpts && extraOpts.plugins) || {})
    },
    scales: {
      y: {
        ticks: { color: '#94a3b8', callback: (v) => v + yLabel },
        grid: { color: '#e2e8f0' },
        beginAtZero: true,
        ...(extraOpts && extraOpts.yMax ? { max: extraOpts.yMax } : {})
      },
      x: {
        ticks: { color: '#94a3b8', maxRotation: 45, font: { size: 9 } },
        grid: { display: false },
        ...(extraOpts && extraOpts.xStacked ? { stacked: true } : {})
      }
    }
  });
  const lineDs = (label, data, color, fill) => ({
    label,
    data,
    borderColor: color,
    backgroundColor: fill || color + '33',
    tension: 0.35,
    pointRadius: 2,
    pointBackgroundColor: color,
    fill: !!fill,
    spanGaps: true
  });

  // 1. Harvest chart
  const c1 = document.getElementById('ov-history-harvest-chart');
  if (c1) {
    if (ovHistHarvestInst) {
      ovHistHarvestInst.destroy();
      ovHistHarvestInst = null;
    }
    ovHistHarvestInst = new Chart(c1, {
      type: 'line',
      data: {
        labels: histLabels,
        datasets: [
          lineDs(
            t('dash.ov.harvestThisWeek'),
            histKeys.map((k) => {
              const v = snapVal(k, 'harvest_kg');
              return v !== null ? +v.toFixed(2) : null;
            }),
            '#c2703e',
            'rgba(194,112,62,0.10)'
          )
        ]
      },
      options: chartOpts('kg', (c) => c.parsed.y.toFixed(2) + 'kg')
    });
  }

  // 2. Pipeline chart — stacked area showing bag counts through stages
  const c3 = document.getElementById('ov-history-pipeline-chart');
  if (c3) {
    if (ovHistPipelineInst) {
      ovHistPipelineInst.destroy();
      ovHistPipelineInst = null;
    }
    const pipeStages = ['bags_spawn', 'bags_incubation', 'bags_fruiting', 'bags_contaminated'];
    const pipeFills = [
      'rgba(124,82,149,0.45)',
      'rgba(74,127,165,0.45)',
      'rgba(61,122,74,0.45)',
      'rgba(176,80,64,0.25)'
    ];
    const pipeBorders = ['#7c5295', '#4a7fa5', '#3d7a4a', '#b05040'];
    const pipeNames = [t('dash.ov.spawn'), t('dash.ov.incubation'), t('dash.ov.fruiting'), t('dash.ov.contaminated')];
    // Compute absolute bag counts + total line
    const pipeAbsData = pipeStages.map((stage) =>
      histKeys.map((k) => {
        const s = snapshotMap[k];
        return s ? s[stage] || 0 : null;
      })
    );
    const totalData = histKeys.map((k) => {
      const s = snapshotMap[k];
      if (!s) return null;
      // Contaminated bags are no part of the total; they have their own line.
      return (s.bags_spawn || 0) + (s.bags_incubation || 0) + (s.bags_fruiting || 0);
    });
    ovHistPipelineInst = new Chart(c3, {
      type: 'line',
      data: {
        labels: histLabels,
        datasets: [
          ...pipeStages.map((_, i) => ({
            label: pipeNames[i],
            data: pipeAbsData[i],
            borderColor: pipeBorders[i],
            backgroundColor: pipeFills[i],
            borderWidth: 1.5,
            fill: 'origin',
            tension: 0.35,
            pointRadius: 0,
            spanGaps: true,
            order: pipeStages.length - i
          })),
          {
            label: 'Total',
            data: totalData,
            borderColor: '#555',
            backgroundColor: 'transparent',
            borderWidth: 2,
            borderDash: [5, 3],
            tension: 0.35,
            pointRadius: 2,
            pointBackgroundColor: '#555',
            fill: false,
            spanGaps: true,
            order: 0
          }
        ]
      },
      options: {
        responsive: true,
        plugins: {
          legend: { display: true, labels: { boxWidth: 12, font: { size: 11 } } },
          tooltip: {
            mode: 'index',
            callbacks: {
              label: (c) => c.dataset.label + ': ' + c.parsed.y + ' ' + t('dash.ov.bags'),
              footer: (items) => {
                const total = items.find((i) => i.dataset.label === 'Total');
                return total ? '─── Total: ' + total.parsed.y + ' bags' : '';
              }
            }
          }
        },
        interaction: { mode: 'index', intersect: false },
        scales: {
          y: { stacked: false, ticks: { color: '#94a3b8' }, grid: { color: '#e2e8f0' }, beginAtZero: true },
          x: { ticks: { color: '#94a3b8', font: { size: 9 } }, grid: { display: false } }
        }
      }
    });
  }

  // 4. Contamination rate chart
  const c4 = document.getElementById('ov-history-contam-chart');
  if (c4) {
    if (ovHistContamInst) {
      ovHistContamInst.destroy();
      ovHistContamInst = null;
    }
    ovHistContamInst = new Chart(c4, {
      type: 'line',
      data: {
        labels: histLabels,
        datasets: [
          lineDs(
            t('dash.ov.contamRate'),
            histKeys.map((k) => {
              const v = snapVal(k, 'contam_rate_pct');
              return v !== null ? +v.toFixed(1) : null;
            }),
            '#b05040',
            'rgba(176,80,64,0.08)'
          )
        ]
      },
      options: chartOpts('%', (c) => c.parsed.y.toFixed(1) + '%')
    });
  }

  // 5. Stock levels chart
  const c5 = document.getElementById('ov-history-stock-chart');
  if (c5) {
    if (ovHistStockInst) {
      ovHistStockInst.destroy();
      ovHistStockInst = null;
    }
    ovHistStockInst = new Chart(c5, {
      type: 'line',
      data: {
        labels: histLabels,
        datasets: [
          lineDs(
            t('dash.ov.hardwoodUsed').replace(/ .*/, ''),
            histKeys.map((k) => {
              const v = snapVal(k, 'stock_hardwood_kg');
              return v !== null ? +v.toFixed(1) : null;
            }),
            '#8b5e3c'
          ),
          lineDs(
            t('dash.ov.wheatbranUsed').replace(/ .*/, ''),
            histKeys.map((k) => {
              const v = snapVal(k, 'stock_wheatbran_kg');
              return v !== null ? +v.toFixed(1) : null;
            }),
            '#c9a227'
          ),
          lineDs(
            t('dash.ov.grain'),
            histKeys.map((k) => {
              const v = snapVal(k, 'stock_grain_kg');
              return v !== null ? +v.toFixed(1) : null;
            }),
            '#6b7c3f'
          )
        ]
      },
      options: chartOpts('kg', (c) => c.parsed.y.toFixed(1) + 'kg')
    });
  }
}

async function takeKpiSnapshot() {
  try {
    const r = await fetch('/api/kpi-snapshots/now', { method: 'POST' });
    if (r.status === 401 || r.status === 403) {
      toast(t('dash.ov.snapshotAuthErr') || 'Admin login required', 'err');
      return;
    }
    if (!r.ok) throw new Error('Failed');
    await loadKpiHistory();
  } catch (e) {
    console.error('Snapshot failed', e);
    toast(t('dash.ov.snapshotErr') || 'Snapshot failed', 'err');
  }
}

function exportOverviewCSV() {
  const nowDate = new Date();
  const now = Date.now();
  let periodStart, periodLabel;
  if (ovPeriod === 'week') {
    periodStart = new Date(nowDate);
    periodStart.setDate(periodStart.getDate() - ((periodStart.getDay() + 6) % 7));
    periodStart.setHours(0, 0, 0, 0);
    periodLabel = 'KW ' + isoWeekNumber(nowDate);
  } else if (ovPeriod === 'month') {
    periodStart = new Date(nowDate.getFullYear(), nowDate.getMonth(), 1);
    periodLabel = String(nowDate.getMonth() + 1).padStart(2, '0') + '.' + nowDate.getFullYear();
  } else {
    periodStart = new Date(nowDate.getFullYear(), 0, 1);
    periodLabel = String(nowDate.getFullYear());
  }

  // Bags created
  const bagsCreated = batches.filter((b) => new Date(b.created) >= periodStart).reduce((s, b) => s + (b.qty || 0), 0);

  // Materials
  let grainUsed = 0,
    hardwoodUsed = 0,
    wheatbranUsed = 0;
  (inventory.log || []).forEach((e) => {
    if (e.type !== 'batch' || new Date(e.time) < periodStart) return;
    if (e.mat === 'grain') grainUsed += Math.abs(e.deltaKg || 0);
    else if (e.mat === 'hardwood') hardwoodUsed += Math.abs(e.deltaKg || 0);
    else if (e.mat === 'wheatbran') wheatbranUsed += Math.abs(e.deltaKg || 0);
  });

  // Harvests
  const periodHarvests = harvests.filter((h) => new Date(h.time) >= periodStart);
  const harvestKg = periodHarvests.reduce((s, h) => s + (h.grams || 0), 0) / 1000;

  // Harvest by species
  const bySpecies = {};
  periodHarvests.forEach((h) => {
    bySpecies[h.species] = (bySpecies[h.species] || 0) + (h.grams || 0);
  });

  // Harvest by day
  const byDay = {};
  periodHarvests.forEach((h) => {
    const key = localDateStr(new Date(h.time));
    byDay[key] = (byDay[key] || 0) + (h.grams || 0);
  });

  // Build CSV rows
  const rows = [];
  rows.push(['Overview Export — ' + periodLabel]);
  rows.push([]);
  rows.push(['KPI', 'Value']);
  rows.push(['Bags created', bagsCreated]);
  rows.push(['Grain used (kg)', +grainUsed.toFixed(2)]);
  rows.push(['Harvest (kg)', +harvestKg.toFixed(2)]);
  rows.push(['Hardwood used (kg)', +hardwoodUsed.toFixed(2)]);
  rows.push(['Wheat bran used (kg)', +wheatbranUsed.toFixed(2)]);
  rows.push(['Harvests logged', periodHarvests.length]);
  rows.push([]);

  // Harvest by species
  rows.push(['Harvest by species', 'kg']);
  Object.keys(bySpecies)
    .sort()
    .forEach((sp) => {
      rows.push([sp, +(bySpecies[sp] / 1000).toFixed(2)]);
    });
  rows.push([]);

  // Harvest by day
  const dayKeys = Object.keys(byDay).sort();
  if (dayKeys.length) {
    rows.push(['Date', 'Harvest (kg)']);
    dayKeys.forEach((k) => {
      rows.push([fmtDtShort(k) + '.' + new Date(k).getFullYear(), +(byDay[k] / 1000).toFixed(2)]);
    });
  }

  // KPI History snapshots for this period
  if (kpiHistoryData && kpiHistoryData.length) {
    const periodKey = localDateStr(periodStart);
    const snaps = kpiHistoryData.filter((s) => s.date >= periodKey);
    if (snaps.length) {
      rows.push([]);
      rows.push(['KPI History (daily snapshots)']);
      rows.push([
        'Date',
        'Bags created',
        'Harvest (kg)',
        'Grain (kg)',
        'Hardwood (kg)',
        'Wheat bran (kg)',
        'Contam rate (%)',
        'Spawn',
        'Incubation',
        'Fruiting',
        'Contaminated',
        'Stock HW (kg)',
        'Stock WB (kg)',
        'Stock Grain (kg)'
      ]);
      snaps.forEach((s) => {
        rows.push([
          fmtDtShort(s.date) + '.' + s.date.slice(0, 4),
          s.bags_created || 0,
          +(s.harvest_kg || 0).toFixed(2),
          +(s.grain_used_kg || 0).toFixed(2),
          +(s.hardwood_used_kg || 0).toFixed(2),
          +(s.wheatbran_used_kg || 0).toFixed(2),
          +(s.contam_rate_pct || 0).toFixed(1),
          s.bags_spawn || 0,
          s.bags_incubation || 0,
          s.bags_fruiting || 0,
          s.bags_contaminated || 0,
          +(s.stock_hardwood_kg || 0).toFixed(1),
          +(s.stock_wheatbran_kg || 0).toFixed(1),
          +(s.stock_grain_kg || 0).toFixed(1)
        ]);
      });
    }
  }

  const csv =
    '\uFEFF' +
    rows.map((r) => r.map((c) => '"' + String(c == null ? '' : c).replace(/"/g, '""') + '"').join(';')).join('\r\n');
  const blob = new Blob([csv], { type: 'text/csv;charset=utf-8' });
  const a = document.createElement('a');
  a.href = URL.createObjectURL(blob);
  a.download = 'overview_' + ovPeriod + '_' + nowDate.toISOString().slice(0, 10) + '.csv';
  a.click();
}

const CHEVRON_SVG =
  '<svg class="location-section-toggle" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><polyline points="6 9 12 15 18 9"/></svg>';
let ZONE_LABELS = {};
let ZONE_COLORS = {};
function rackLabel(id) {
  const m = id.match(/\d+$/);
  return m ? t('dash.rackN', { n: m[0] }) : id.replace(/_/g, ' ');
}

function renderStatus() {
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();
  const el = document.getElementById('dash-locations');
  if (!el) return;
  // The room view moved to its own sub-tab, and rebuilding it while that tab is
  // closed is pure waste: getRackBags/getZoneBags walk the entire scan log, and
  // this function calls them about thirty times. Only the Sorten tiles still
  // have to run, so only the rack markup is skipped.
  //
  // renderOverviewKPIs() stand hier einmal mit, aus der Zeit, als die
  // Betriebsseite sich nicht selbst zeichnete. Es endet in
  // renderOverviewCharts(), und das ruft .destroy() und new Chart() auf vier
  // Leinwaenden — auf einer Seite mit display:none, bei jedem Scan. Seit
  // go() und refresh() die Betriebsseite kennen, zeichnet sie sich selbst.
  const panel = document.getElementById('sp-batch-locations');
  if (panel && !panel.classList.contains('active')) {
    renderBatches();
    return;
  }
  if (!zones.length) {
    // Wie auf der Zonenseite: ohne Daten keine Aussage über die Daten.
    el.innerHTML = '<div class="empty">' + t(datenGeladen ? 'dash.noZones' : 'common.loading') + '</div>';
    renderBatches();
    return;
  }
  if (!batches.length) {
    el.innerHTML = '<div class="empty">' + t('dash.noBatches') + '</div>';
    renderBatches();
    return;
  }

  // Compute per-batch status.
  //
  // The four per-stage bag counters that used to be accumulated here fed
  // renderPipelineKPIs() and nothing else. The Sorten tiles need the same
  // numbers broken down per Sorte rather than as one total, so they are
  // summed in sorteRollup() from the same getStatus().c — one place doing
  // it once, instead of a total here and a breakdown there that could drift.
  const batchData = batches.map((b) => {
    const { c, total, status } = getStatus(b.batchId);
    const harv = getHarvested(b.batchId);
    const due = new Date(b.due);
    const ov =
      isBatchOverdue(b) && zones.some((z) => (z.role === 'incubation' || z.role === 'spawn') && (c[z.id] || 0) > 0);
    return { b, c, total, status, harv, due, ov };
  });

  // Filter by search
  const filtered = batchData.filter(
    (d) =>
      !q ||
      d.b.batchId.toLowerCase().includes(q) ||
      (d.b.species || '').toLowerCase().includes(q) ||
      (d.b.strain || '').toLowerCase().includes(q) ||
      (d.b.strainName || '').toLowerCase().includes(q)
  );

  // One sort control above all the rooms, not one per room — the question
  // "what am I looking at first" has the same answer in every tent.
  let html = locSortControlHtml();
  // Render zones dynamically by role
  const fruitingZones = zones.filter((z) => z.role === 'fruiting');
  const contamZones = zones.filter((z) => z.role === 'contaminated');
  zones
    .filter((z) => z.role !== 'fruiting' && z.role !== 'contaminated')
    .forEach((z) => {
      if (z.racks.length > 0)
        html += renderRackSection(
          z.id,
          z.racks.map((r) => r.id),
          filtered
        );
      else html += renderSimpleZoneSection(z, filtered);
    });
  if (fruitingZones.length) html += renderFruitingSection(fruitingZones, filtered);
  contamZones.forEach((z) => {
    const contamBags = getZoneBags(z.id);
    if (Object.keys(contamBags).length > 0) html += renderContamSection(z, filtered);
  });

  el.innerHTML = html;
  renderBatches();
  updateActionBar();
}

function renderRackSection(zone, racks, filtered) {
  const color = ZONE_COLORS[zone];
  const zoneObj = zones.find((z) => z.id === zone);
  const cap = zoneObj ? zoneObj.maxCapacity : null;
  let totalBags = 0;
  racks.forEach((r) => (totalBags += Object.keys(getRackBags(r)).length));
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();

  const rackCards = racks
    .map((rackId) => {
      const bags = getRackBags(rackId);
      const count = Object.keys(bags).length;
      const byBatch = {};
      Object.entries(bags).forEach(([bagId, d]) => {
        if (!byBatch[d.batchId]) byBatch[d.batchId] = { sp: d.species, st: d.strain, bags: [] };
        byBatch[d.batchId].bags.push({ id: bagId, loc: rackId });
      });
      // Filter batches by search
      const batchEntries = sortZoneBatches(Object.entries(byBatch)).filter(
        ([bid, d]) =>
          !q || bid.toLowerCase().includes(q) || d.sp.toLowerCase().includes(q) || d.st.toLowerCase().includes(q)
      );

      let batchHtml = batchEntries
        .map(([bid, d]) => {
          const bd = filtered.find((f) => f.b.batchId === bid);
          const ov = bd ? bd.ov : false;
          d.bags.sort((a, b) => (parseInt(a.id.split('-').pop()) || 0) - (parseInt(b.id.split('-').pop()) || 0));
          return `<div class="batch-card${ov ? ' batch-overdue' : ''}" onclick="this.classList.toggle('expanded')">
        <div class="batch-card-header">
          <span class="batch-card-species">${esc(d.sp)}</span>
          <span class="batch-card-count">${d.bags.length}</span>
        </div>
        <div class="batch-card-meta">
          <span class="fs-micro" style="font-family:monospace">${esc(bid)}</span>
          <span>${esc(d.st)}</span>
          ${bd && bd.ov ? `<span class="overdue-text">${t('dash.overdue')}</span>` : ''}
        </div>
        <div class="batch-card-chips">${d.bags
          .map((bg) => {
            const sel = selectedLocBags.has(bg.id);
            return `<span class="bag-chip${sel ? ' selected' : ''}" data-bag="${esc(bg.id)}" data-batch="${esc(bid)}" data-loc="${esc(bg.loc)}">${bg.id.split('-').pop()}</span>`;
          })
          .join('')}</div>
      </div>`;
        })
        .join('');
      if (!batchEntries.length && !count)
        batchHtml = `<div class="fs-xs" style="color:var(--c-text-muted);font-style:italic">${t('dash.empty')}</div>`;

      return `<div class="rack-card-new">
      <div class="rack-card-header">
        <span class="rack-card-name">${rackLabel(rackId)}</span>
        <span class="rack-card-count">${tp('dash.bags', count)}</span>
      </div>
      <div class="rack-card-bar"><div class="rack-card-bar-fill" style="background:${color};width:${Math.min(100, Math.round((count / 20) * 100))}%"></div></div>
      <div class="rack-card-batches">${batchHtml}</div>
    </div>`;
    })
    .join('');

  const rackCount = racks.length;
  const gridClass = rackCount > 4 ? 'rack-grid rack-grid-5col' : 'rack-grid';
  const capHtml = cap
    ? `<div style="display:flex;align-items:center;gap:8px;margin-top:4px">
      <div style="flex:1;height:6px;background:var(--c-bg);border-radius:3px;overflow:hidden"><div style="height:100%;background:${totalBags > cap ? '#ef4444' : color};width:${Math.min(100, Math.round((totalBags / cap) * 100))}%;border-radius:3px"></div></div>
      <span class="fs-xs" style="color:${totalBags > cap ? '#ef4444' : 'var(--c-text-muted)'};white-space:nowrap">${Math.round((totalBags / cap) * 100)}%</span>
    </div>`
    : '';
  const zoneHasUrgent = filtered.some(
    (d) => d.ov && Object.keys(d.c).some((zid) => zid === zone || racks.includes(zid))
  );
  // Open when there is something to see. This used to read `dashMode === 'farm' &&`
  // — a toggle on the Dashboard silently deciding how the Chargen page looked, so
  // switching to Übersicht once left every zone here collapsed with no visible cause.
  const sectionClass = 'location-section' + (zoneHasUrgent ? '' : ' collapsed');
  return `<div class="${sectionClass}" data-zone="${esc(zone)}">
    <div class="location-section-header" onclick="this.parentElement.classList.toggle('collapsed')">
      <div class="location-section-title">${CHEVRON_SVG}<span class="zone-dot" style="background:${color}"></span>${esc(zoneDisplayName(zone))}</div>
      <span class="location-section-count">${cap ? totalBags + ' / ' + cap + ' Bags' : tp('dash.bags', totalBags)}</span>
      <button class="fs-xs" type="button" data-zone-check="${esc(zone)}" style="margin-left:8px;flex:none;font-weight:600;padding:5px 10px;border-radius:8px;border:1px solid var(--c-border);background:var(--c-card);cursor:pointer">${esc(t('zoneCheck.btn'))}</button>
    </div>
    <div class="location-section-body">${capHtml}
      <div class="${gridClass}">${rackCards}</div>
    </div>
  </div>`;
}

function renderFruitingSection(fruitingZones, filtered) {
  let totalBags = 0;
  fruitingZones.forEach((z) => (totalBags += Object.keys(getZoneBags(z.id)).length));
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();
  const color = fruitingZones[0]?.color || ZONE_ROLE_COLOR.fruiting;

  const tentCols = fruitingZones
    .map((z) => {
      const bags = getZoneBags(z.id);
      const entries = Object.entries(bags);
      const byBatch = {};
      entries.forEach(([bagId, d]) => {
        if (!byBatch[d.batchId]) byBatch[d.batchId] = { sp: d.species, st: d.strain, bags: [] };
        byBatch[d.batchId].bags.push({ id: bagId, loc: d.loc });
      });
      const batchEntries = sortZoneBatches(Object.entries(byBatch)).filter(
        ([bid, d]) =>
          !q || bid.toLowerCase().includes(q) || d.sp.toLowerCase().includes(q) || d.st.toLowerCase().includes(q)
      );

      if (!batchEntries.length) {
        return `<div class="tent-column">
        <div class="tent-column-header">${esc(zoneDisplayName(z.id))}</div>
        <div class="tent-column-empty">${t('dash.empty')}</div>
      </div>`;
      }
      const cards = batchEntries
        .map(([bid, d]) => {
          const bd = filtered.find((f) => f.b.batchId === bid);
          const harv = bd ? bd.harv : 0;
          const due = bd ? bd.due : null;
          const ov = bd ? bd.ov : false;
          d.bags.sort((a, b) => (parseInt(a.id.split('-').pop()) || 0) - (parseInt(b.id.split('-').pop()) || 0));
          return `<div class="batch-card${ov ? ' batch-overdue' : ''}" onclick="this.classList.toggle('expanded')">
        <div class="batch-card-header">
          <span class="batch-card-species">${esc(d.sp)}</span>
          <span class="batch-card-count">${d.bags.length}</span>
        </div>
        <div class="batch-card-meta">
          <span class="fs-micro" style="font-family:monospace">${esc(bid)}</span>
          <span>${esc(d.st)}</span>
          ${harv > 0 ? `<span style="color:var(--c-amber-dark);font-weight:500">${t('dash.harvested')}: ${harv}g</span>` : ''}
          ${due ? `<span style="color:${ov ? 'var(--c-red-dark)' : 'var(--c-text-muted)'}">${t('dash.due')}: ${fmtDt(due)}${ov ? ' \u26a0' : ''}</span>` : ''}
        </div>
        <div class="batch-card-chips">${d.bags
          .map((bg) => {
            const sel = selectedLocBags.has(bg.id);
            return `<span class="bag-chip${sel ? ' selected' : ''}" data-bag="${esc(bg.id)}" data-batch="${esc(bid)}" data-loc="${esc(bg.loc)}">${bg.id.split('-').pop()}</span>`;
          })
          .join('')}</div>
      </div>`;
        })
        .join('');
      const cap = z.maxCapacity;
      const capBar = cap
        ? `<div style="display:flex;align-items:center;gap:6px;margin:4px 0">
        <div style="flex:1;height:5px;background:var(--c-bg);border-radius:3px;overflow:hidden"><div class="${entries.length > cap ? 'kap-voll' : ''}" style="height:100%;background-color:${z.color || color};width:${Math.min(100, Math.round((entries.length / cap) * 100))}%;border-radius:3px"></div></div>
        <span class="fs-micro" style="color:${entries.length > cap ? '#ef4444' : 'var(--c-text-muted)'}">${Math.round((entries.length / cap) * 100)}%</span>
      </div>`
        : '';
      return `<div class="tent-column">
      <div class="tent-column-header">${esc(zoneDisplayName(z.id))} <span class="fs-xs" style="font-weight:400;color:var(--c-text-muted)">(${cap ? entries.length + '/' + cap : entries.length})</span></div>${capBar}
      ${cards}
    </div>`;
    })
    .join('');

  const fruitSectionClass = 'location-section' + (totalBags > 0 ? '' : ' collapsed');
  return `<div class="${fruitSectionClass}" data-zone="fruiting">
    <div class="location-section-header" onclick="this.parentElement.classList.toggle('collapsed')">
      <div class="location-section-title">${CHEVRON_SVG}<span class="zone-dot" style="background:${color}"></span>${t('dash.fruitingTents')}</div>
      <span class="location-section-count">${tp('dash.bags', totalBags)}</span>
    </div>
    <div class="location-section-body">
      <div class="tent-columns">${tentCols}</div>
    </div>
  </div>`;
}

// The room lists came out in scan-log insertion order — effectively the order
// bags happened to be added, which is no order at all once a tent holds twenty
// batches. One sort, shared by the simple, rack and fruiting renderers so a
// room never sorts differently from the room next to it.
const LOC_SORTS = ['due', 'species', 'bags', 'id'];
const LOC_SORT_LABEL = { due: 'th.due', species: 'th.species', bags: 'worklist.bags', id: 'th.batchId' };
let _locSortKey = null;
function locSortKey() {
  if (_locSortKey === null) {
    // Guarded like the other stored preferences: storage revoked mid-session
    // must not throw inside a render.
    try {
      _locSortKey = localStorage.getItem('mp-loc-sort') || '';
    } catch (e) {
      _locSortKey = '';
    }
  }
  // Due date is the default because it is the one that says what to do next.
  return LOC_SORTS.includes(_locSortKey) ? _locSortKey : 'due';
}
function setLocSort(key) {
  if (!LOC_SORTS.includes(key)) return;
  _locSortKey = key;
  try {
    localStorage.setItem('mp-loc-sort', key);
  } catch (e) {
    /* storage disabled — the choice just won't survive a reload */
  }
  renderStatus();
}
function locSortControlHtml() {
  const cur = locSortKey();
  return (
    '<div style="display:flex;flex-wrap:wrap;align-items:center;gap:6px;margin-bottom:8px">' +
    '<span class="fs-xs" style="color:var(--c-text-muted);flex-shrink:0">' +
    esc(t('sort.by')) +
    '</span>' +
    LOC_SORTS.map((k) => {
      const on = k === cur;
      return (
        '<button type="button" class="fs-floor" data-action="loc-sort" data-key="' +
        esc(k) +
        '" aria-pressed="' +
        on +
        '" style="--fs-own:10.5px;padding:3px 8px;border-radius:11px;cursor:pointer;font-family:inherit;border:1px solid ' +
        (on ? 'var(--c-accent)' : 'var(--c-border)') +
        ';background:' +
        (on ? 'var(--c-accent)' : 'transparent') +
        ';color:' +
        (on ? '#fff' : 'var(--c-text-sec)') +
        '">' +
        esc(t(LOC_SORT_LABEL[k])) +
        '</button>'
      );
    }).join('') +
    '</div>'
  );
}
// batchEntries is [batchId, {sp, st, bags}] in all three renderers, so they can
// share this. Ties break on the batch id, which keeps the order stable rather
// than reshuffling equal rows on every re-render.
function sortZoneBatches(batchEntries) {
  const key = locSortKey();
  const dueOf = (bid) => {
    const b = batchById(bid);
    return b ? b.due : null;
  };
  return [...batchEntries].sort((x, y) => {
    if (key === 'species') return sortCmp(x[1].sp, y[1].sp) || sortCmp(x[0], y[0]);
    // Most bags first: "where is the bulk of the work" is the question here.
    if (key === 'bags') return y[1].bags.length - x[1].bags.length || sortCmp(x[0], y[0]);
    if (key === 'id') return sortCmp(x[0], y[0]);
    // sortCmp already sinks null to the end, so an undated batch lands last
    // rather than pretending to be the most urgent thing in the room.
    return sortCmp(dueOf(x[0]), dueOf(y[0])) || sortCmp(x[0], y[0]);
  });
}
function renderSimpleZoneSection(zone, filtered) {
  const bags = getZoneBags(zone.id);
  const entries = Object.entries(bags);
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();
  const byBatch = {};
  entries.forEach(([bagId, d]) => {
    if (!byBatch[d.batchId]) byBatch[d.batchId] = { sp: d.species, st: d.strain, bags: [] };
    byBatch[d.batchId].bags.push({ id: bagId, loc: d.loc });
  });
  const batchEntries = sortZoneBatches(Object.entries(byBatch)).filter(
    ([bid, d]) =>
      !q || bid.toLowerCase().includes(q) || d.sp.toLowerCase().includes(q) || d.st.toLowerCase().includes(q)
  );
  const cards = batchEntries
    .map(([bid, d]) => {
      d.bags.sort((a, b) => (parseInt(a.id.split('-').pop()) || 0) - (parseInt(b.id.split('-').pop()) || 0));
      return `<div class="batch-card" onclick="this.classList.toggle('expanded')">
      <div class="batch-card-header"><span class="batch-card-species">${esc(d.sp)}</span><span class="batch-card-count">${d.bags.length}</span></div>
      <div class="batch-card-meta"><span class="fs-micro" style="font-family:monospace">${esc(bid)}</span><span>${esc(d.st)}</span></div>
      <div class="batch-card-chips">${d.bags
        .map((bg) => {
          const sel = selectedLocBags.has(bg.id);
          return `<span class="bag-chip${sel ? ' selected' : ''}" data-bag="${esc(bg.id)}" data-batch="${esc(bid)}" data-loc="${esc(bg.loc)}">${bg.id.split('-').pop()}</span>`;
        })
        .join('')}</div>
    </div>`;
    })
    .join('');
  if (!cards) return '';
  const cap = zone.maxCapacity;
  const capHtml = cap
    ? `<div style="display:flex;align-items:center;gap:8px;margin-top:4px">
      <div style="flex:1;height:6px;background:var(--c-bg);border-radius:3px;overflow:hidden"><div style="height:100%;background:${entries.length > cap ? '#ef4444' : zone.color};width:${Math.min(100, Math.round((entries.length / cap) * 100))}%;border-radius:3px"></div></div>
      <span class="fs-xs" style="color:${entries.length > cap ? '#ef4444' : 'var(--c-text-muted)'};white-space:nowrap">${Math.round((entries.length / cap) * 100)}%</span>
    </div>`
    : '';
  return `<div class="location-section">
    <div class="location-section-header">
      <div class="location-section-title"><span class="zone-dot" style="background:${zone.color}"></span>${esc(zoneDisplayName(zone.id))}</div>
      <span class="location-section-count">${cap ? entries.length + ' / ' + cap + ' Bags' : tp('dash.bags', entries.length)}</span>
    </div>${capHtml}
    <div style="display:flex;flex-direction:column;gap:6px">${cards}</div>
  </div>`;
}

function renderContamSection(zone, filtered) {
  const bags = getZoneBags(zone.id);
  const entries = Object.entries(bags);
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();
  const byBatch = {};
  entries.forEach(([bagId, d]) => {
    if (!byBatch[d.batchId]) byBatch[d.batchId] = { sp: d.species, st: d.strain, bags: [] };
    byBatch[d.batchId].bags.push({ id: bagId, loc: d.loc });
  });
  const batchEntries = sortZoneBatches(Object.entries(byBatch)).filter(
    ([bid, d]) =>
      !q || bid.toLowerCase().includes(q) || d.sp.toLowerCase().includes(q) || d.st.toLowerCase().includes(q)
  );
  if (!batchEntries.length) return '';

  const cards = batchEntries
    .map(([bid, d]) => {
      d.bags.sort((a, b) => (parseInt(a.id.split('-').pop()) || 0) - (parseInt(b.id.split('-').pop()) || 0));
      return `<div class="batch-card" onclick="this.classList.toggle('expanded')">
      <div class="batch-card-header">
        <span class="batch-card-species">${esc(d.sp)}</span>
        <span class="batch-card-count">${d.bags.length}</span>
      </div>
      <div class="batch-card-meta">
        <span class="fs-micro" style="font-family:monospace">${esc(bid)}</span>
        <span>${esc(d.st)}</span>
      </div>
      <div class="batch-card-chips">${d.bags
        .map((bg) => {
          const sel = selectedLocBags.has(bg.id);
          return `<span class="bag-chip${sel ? ' selected' : ''}" data-bag="${esc(bg.id)}" data-batch="${esc(bid)}" data-loc="${esc(bg.loc)}">${bg.id.split('-').pop()}</span>`;
        })
        .join('')}</div>
    </div>`;
    })
    .join('');

  return `<div class="location-section contam-section">
    <div class="location-section-header">
      <div class="location-section-title"><span class="zone-dot" style="background:${zone.color}"></span>\u26a0 ${esc(zoneDisplayName(zone.id))}</div>
      <span class="location-section-count">${tp('dash.bags', entries.length)}</span>
    </div>
    <div style="display:flex;flex-direction:column;gap:6px">${cards}</div>
  </div>`;
}

function updateActionBar() {
  const bar = document.getElementById('loc-action-bar');
  if (!bar) return;
  const n = selectedLocBags.size;
  if (n > 0) {
    bar.style.display = 'flex';
    bar.innerHTML = `<span class="action-bar-count">${tp('dash.bagsSelected', n)}</span><span style="flex:1"></span>
      <button class="btn btn-sm fs-xs" onclick="locSelectAllVisible()">${t('dash.selectAll')}</button>
      <button class="btn btn-sm fs-xs" onclick="selectedLocBags.clear();renderStatus()">${t('dash.clear')}</button>
      <button class="btn btn-sm btn-p fs-xs" onclick="openLocMovePopup()">${t('dash.move')}</button>
      <button class="btn btn-sm btn-r fs-xs" onclick="locRemoveSelected()">${t('dash.remove')}</button>`;
  } else {
    bar.style.display = 'none';
  }
}

function locSelectAllVisible() {
  const q = (document.getElementById('status-q')?.value || '').toLowerCase();
  ZONES.forEach((z) => {
    const bags = getZoneBags(z);
    Object.entries(bags).forEach(([bagId, d]) => {
      if (
        !q ||
        bagId.toLowerCase().includes(q) ||
        (d.batchId || '').toLowerCase().includes(q) ||
        (d.species || '').toLowerCase().includes(q) ||
        (d.strain || '').toLowerCase().includes(q)
      )
        selectedLocBags.set(bagId, { batchId: d.batchId, loc: d.loc });
    });
  });
  renderStatus();
}
function setOvPeriod(p) {
  ovPeriod = p;
  localStorage.setItem('mp-ov-period', p);
  renderOverviewKPIs();
  renderKpiHistory();
}
function applyOvPeriod() {
  ['week', 'month', 'year'].forEach((p) => {
    const btn = document.getElementById('ov-p-' + p);
    if (btn) btn.classList.toggle('active', ovPeriod === p);
  });
}

// ─── WORK LIST (pick / walk sheet) ──────────────────────────
// Tapping a summary chip opens a findable, printable list of the batches that
// need moving / harvesting, grouped by their CURRENT location so a worker can
// walk zone by zone. Print goes to a normal browser printer (e.g. a Canon),
// separate from the Zebra label printer.
let _workListData = null;
let _workListMode = localStorage.getItem('mp-wl-group') === 'batch' ? 'batch' : 'location';
function _batchZoneCounts(batch, lastByBag) {
  const counts = {};
  (batch.bags || []).forEach((bag) => {
    const last = lastByBag.get(bag.toUpperCase());
    if (!last || last.action === 'REMOVE' || !last.to || isContamLoc(last.to)) return;
    const z = toZone(last.to);
    counts[z] = (counts[z] || 0) + 1;
  });
  return counts;
}
// Flattens the move/harvest tasks into (batch, zone, count) rows. The same rows
// then group either by zone or by batch (see _groupWorkList). total is the
// distinct batch count, so the title matches the dashboard summary chip.
function buildWorkList(kind) {
  const lastByBag = buildLastScanByBag();
  const rows = [];
  const pushRows = (batchId, species, strain, note) => {
    const b = batches.find((x) => x.batchId === batchId);
    if (!b) return;
    const counts = _batchZoneCounts(b, lastByBag);
    Object.keys(counts).forEach((z) =>
      rows.push({
        batchId,
        species: species || b.species,
        strain: (strain || '').trim(),
        zone: z,
        zoneName: zoneDisplayName(z),
        count: counts[z],
        note: note || ''
      })
    );
  };
  if (kind === 'move') {
    buildAutoTasks()
      .filter((tk) => tk.taskAction === 'move' && tk.ready)
      .forEach((tk) => {
        const b = batches.find((x) => x.batchId === tk.batchId);
        pushRows(tk.batchId, b && b.species, b && (b.strainText || b.strain), tk.detail);
      });
  } else if (kind === 'harvest') {
    buildHarvestTasks().forEach((tk) => pushRows(tk.batchId, tk.species, tk.strain, tp('harvest.daysFruiting', tk.daysFruiting)));
  }
  return {
    kind,
    title: kind === 'move' ? t('dash.sumMove') : t('dash.sumHarvest'),
    rows,
    total: new Set(rows.map((r) => r.batchId)).size
  };
}
// Groups the flat rows for one of the two views. 'location' → a card per zone
// listing its batches (walk the room zone by zone); 'batch' → a card per batch
// listing where that batch's bags currently sit.
function _groupWorkList(rows, mode) {
  const byKey = new Map();
  rows.forEach((r) => {
    const key = mode === 'batch' ? r.batchId : r.zone;
    if (!byKey.has(key)) {
      byKey.set(key, {
        key,
        batchId: r.batchId,
        name: mode === 'batch' ? r.batchId : r.zoneName,
        sub: mode === 'batch' ? r.species + (r.strain ? ' · ' + r.strain : '') : '',
        bags: 0,
        items: []
      });
    }
    const g = byKey.get(key);
    g.items.push(r);
    g.bags += r.count;
  });
  const list = [...byKey.values()];
  list.sort((a, b) => a.name.localeCompare(b.name));
  list.forEach((g) =>
    g.items.sort((a, b) => (mode === 'batch' ? a.zoneName.localeCompare(b.zoneName) : a.batchId.localeCompare(b.batchId)))
  );
  return list;
}
function openWorkList(kind) {
  _workListData = buildWorkList(kind);
  renderWorkList();
  document.getElementById('m-worklist').classList.add('open');
}
// Renders the open work list for the current _workListMode: title count, the
// Ort/Charge toggle's active state, and the grouped body. Split from
// openWorkList so flipping the toggle can re-render without rebuilding tasks.
function renderWorkList() {
  const data = _workListData;
  if (!data) return;
  const mode = _workListMode;
  const bags = esc(t('worklist.bags'));
  document.getElementById('wl-title').textContent = data.title + ' (' + data.total + ')';
  document.querySelectorAll('#wl-group [data-wl-group]').forEach((b) => {
    const on = b.dataset.wlGroup === mode;
    b.style.background = on ? 'var(--c-primary, #16a34a)' : 'transparent';
    b.style.color = on ? '#fff' : 'var(--c-text-sec)';
    b.style.borderColor = on ? 'var(--c-primary, #16a34a)' : 'var(--c-border)';
    b.setAttribute('aria-pressed', on ? 'true' : 'false');
  });
  const body = document.getElementById('wl-body');
  const groups = _groupWorkList(data.rows, mode);
  if (!groups.length) {
    body.innerHTML =
      '<div style="color:var(--c-text-muted);font-style:italic;padding:14px 0">' + esc(t('worklist.empty')) + '</div>';
    return;
  }
  body.innerHTML = groups
    .map((g) => {
      if (mode === 'batch') {
        const zoneRows = g.items
          .map(
            (it) =>
              `<div style="display:flex;align-items:center;gap:10px;padding:8px 6px 8px 14px;border-bottom:0.5px solid var(--c-border)">` +
              `<span class="fs-sm" style="flex:1;min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(it.zoneName)}</span>` +
              `<span class="fs-floor" style="--fs-own:0.875rem;font-weight:600;white-space:nowrap">${it.count} ${bags}</span>` +
              `</div>`
          )
          .join('');
        return (
          `<div data-wl-batch="${esc(g.batchId)}" style="margin-bottom:14px;cursor:pointer">` +
          `<div style="display:flex;justify-content:space-between;align-items:baseline;gap:10px;padding:6px 4px;border-bottom:2px solid var(--c-border)">` +
          `<span style="min-width:0;overflow:hidden;text-overflow:ellipsis;white-space:nowrap"><span class="fs-sm" style="font-family:monospace;font-weight:700">${esc(g.batchId)}</span>${g.sub ? `<span class="fs-meta" style="color:var(--c-text-sec)"> · ${esc(g.sub)}</span>` : ''}</span>` +
          `<span class="fs-meta" style="color:var(--c-text-muted);white-space:nowrap">${g.bags} ${bags}</span></div>` +
          zoneRows +
          `</div>`
        );
      }
      const batchRows = g.items
        .map(
          (it) =>
            `<div data-wl-batch="${esc(it.batchId)}" style="display:flex;align-items:center;gap:10px;padding:10px 6px;border-bottom:0.5px solid var(--c-border);cursor:pointer">` +
            `<span class="fs-sm" style="font-family:monospace;font-weight:600">${esc(it.batchId)}</span>` +
            `<span class="fs-meta" style="flex:1;min-width:0;color:var(--c-text-sec);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(it.species)}${it.strain ? ' · ' + esc(it.strain) : ''}</span>` +
            `<span class="fs-floor" style="--fs-own:0.875rem;font-weight:600;white-space:nowrap">${it.count} ${bags}</span>` +
            `</div>`
        )
        .join('');
      return (
        '<div style="margin-bottom:14px">' +
        `<div style="display:flex;justify-content:space-between;align-items:baseline;padding:6px 4px;border-bottom:2px solid var(--c-border)"><span class="fs-sm" style="font-weight:700">${esc(g.name)}</span><span class="fs-meta" style="color:var(--c-text-muted)">${g.bags} ${bags}</span></div>` +
        batchRows +
        '</div>'
      );
    })
    .join('');
}
function setWorkListMode(mode) {
  const m = mode === 'batch' ? 'batch' : 'location';
  if (m === _workListMode) return;
  _workListMode = m;
  localStorage.setItem('mp-wl-group', m);
  renderWorkList();
}
function printWorkList() {
  const d = _workListData;
  if (!d) return;
  const rows = _groupWorkList(d.rows, _workListMode)
    .flatMap((g) => g.items)
    .map(
      (it) =>
        `<tr><td class="c">&#9744;</td><td>${esc(it.zoneName)}</td><td class="m">${esc(it.batchId)}</td><td>${esc(it.species)}${it.strain ? ' · ' + esc(it.strain) : ''}</td><td class="n">${it.count}</td></tr>`
    )
    .join('');
  // px-auf-papier: a whole print document of its own, opened in a new window
  // and sent to a printer. Its sizes are physical -- 13px in that table is an
  // eighth of an inch of paper -- and a reader's browser font setting has no
  // business changing how many rows fit on a sheet.
  const html =
    '<!doctype html><html><head><meta charset="utf-8"><title>' +
    esc(d.title) +
    '</title><style>body{font-family:Arial,Helvetica,sans-serif;margin:18px;color:#000}h1{font-size:18px;margin:0 0 2px}.s{color:#555;font-size:12px;margin-bottom:14px}table{width:100%;border-collapse:collapse;font-size:13px}th,td{text-align:left;padding:7px 8px;border-bottom:1px solid #ccc}th{border-bottom:2px solid #000;font-size:11px;text-transform:uppercase}.c{width:22px;font-size:16px}.m{font-family:monospace}.n{text-align:right;width:56px;font-weight:bold}</style></head><body>' +
    '<h1>' +
    esc(d.title) +
    '</h1><div class="s">' +
    esc(localDateStr(new Date())) +
    ' · ' +
    d.total +
    ' ' +
    esc(t('worklist.batches')) +
    '</div><table><thead><tr><th></th><th>' +
    esc(t('worklist.location')) +
    '</th><th>' +
    esc(t('worklist.batchCol')) +
    '</th><th>' +
    esc(t('batch.species')) +
    '</th><th style="text-align:right">' +
    esc(t('worklist.bags')) +
    '</th></tr></thead><tbody>' +
    rows +
    '</tbody></table><scr' +
    'ipt>window.onload=function(){window.print()}<\/scr' +
    'ipt></body></html>';
  const win = window.open('', '_blank');
  if (!win) {
    toast(t('worklist.popupBlocked'), 'err');
    return;
  }
  win.document.write(html);
  win.document.close();
}
// Warnungen is for problems you can't see anywhere else on the dashboard: low
// stock, lab issues, zones at capacity. It deliberately does NOT restate
// due-today / overdue batches — those are already the "zu verschieben" chip and
// the Chargen-Aufgaben list directly above, and repeating them as two more lines
// said nothing new while burying the alerts that only appear here.
function buildAlertTasks() {
  const out = [];
  const add = (a, rang) => out.push({ ...a, rang });
  // Bestand zuerst. Leer werden dauert länger zu beheben als voll sein: Nachschub
  // muss bestellt oder angesetzt werden, ein voller Raum wird beim nächsten Umzug
  // von selbst leerer. Und die Liste zeigt sechs Zeilen, bevor sie zuklappt.
  for (const a of getInvAlerts()) add({ ...a, goPage: 'inv', goBtn: 'n-inv' }, 0);
  for (const a of getLabAlerts()) add({ ...a, goPage: 'lab', goBtn: 'n-lab' }, 0);
  for (const z of zones) {
    if (!z.maxCapacity) continue;
    let cnt = 0;
    if (z.racks && z.racks.length) z.racks.forEach((r) => (cnt += Object.keys(getRackBags(r.id)).length));
    else cnt = Object.keys(getZoneBags(z.id)).length;
    const pct = Math.round((cnt / z.maxCapacity) * 100);
    if (pct >= 90)
      add(
        {
          text: zoneDisplayName(z.id) + ': ' + cnt + '/' + z.maxCapacity + ' (' + pct + '%)',
          urgent: pct >= 100,
          goPage: 'zones',
          goBtn: 'n-zones'
        },
        1
      );
  }
  return out.sort((a, b) => a.rang - b.rang || Number(b.urgent) - Number(a.urgent));
}
// Split-batch detection: flag batches whose active bags straddle multiple
// production stages ({spawn, incubation, fruiting}). Harvested, removed, and
// contaminated bags are excluded so deliberate placements don't trigger alerts.
// lastByBag is optional: the dashboard has already built this index by the time
// it calls us, and rebuilding it walked the whole scan log a second time.
function getSplitBatches(sharedLastByBag) {
  const STAGE_ORDER = { spawn: 1, incubation: 2, fruiting: 3 };
  const zoneRole = {};
  zones.forEach((z) => (zoneRole[z.id] = z.role));
  const harvestedBags = new Set();
  harvests.forEach((h) => h && h.bag && harvestedBags.add(String(h.bag).toUpperCase()));
  // Reuse the caller's index when it passes one — the dashboard has already built
  // exactly this map by the time it calls us. Only the per-batch last-move time
  // still needs a pass of its own, and that one allocates nothing per entry.
  const own = sharedLastByBag ? null : new Map();
  const lastMoveTimeByBatch = {};
  scanLog.forEach((e) => {
    if (own && e.bag) own.set(String(e.bag).toUpperCase(), e);
    if (e.batch && (e.action === 'ADD' || e.action === 'MOVE' || e.action === 'MOVE_BATCH')) {
      const cur = lastMoveTimeByBatch[e.batch];
      if (!cur || (e.time && e.time > cur)) lastMoveTimeByBatch[e.batch] = e.time;
    }
  });
  const lastByBag = sharedLastByBag || own;
  const now = Date.now();
  const STALE_HOURS = 24;
  const out = [];
  batches.forEach((b) => {
    const bags = b.bags || [];
    if (!bags.length) return;
    const zoneCounts = {};
    const stageCounts = {};
    bags.forEach((bag) => {
      const key = String(bag).toUpperCase();
      if (harvestedBags.has(key)) return;
      const last = lastByBag.get(key);
      if (!last || last.action === 'REMOVE' || !last.to) return;
      const z = toZone(last.to);
      const role = zoneRole[z];
      if (!role || role === 'contaminated') return;
      // Stage comes from the batch, not the room — see stageOf(). Without it,
      // grain sitting in an incubation room read as "incubation" and blocks
      // parked in a spawn room read as "spawn", so batches were reported split
      // across stages when every bag was really at the same one.
      const stage = stageOf(role, b.batchType);
      if (!STAGE_ORDER[stage]) return;
      zoneCounts[z] = (zoneCounts[z] || 0) + 1;
      stageCounts[stage] = (stageCounts[stage] || 0) + 1;
    });
    const stages = Object.keys(stageCounts);
    if (stages.length < 2) return;
    const behindStage = stages.reduce((a, c) => (STAGE_ORDER[c] < STAGE_ORDER[a] ? c : a));
    const behindCount = stageCounts[behindStage];
    const entries = Object.keys(zoneCounts).map((z) => ({
      zone: z,
      role: stageOf(zoneRole[z], b.batchType),
      count: zoneCounts[z],
      behind: stageOf(zoneRole[z], b.batchType) === behindStage
    }));
    entries.sort((a, c) => (STAGE_ORDER[a.role] || 99) - (STAGE_ORDER[c.role] || 99));
    const lastTime = lastMoveTimeByBatch[b.batchId];
    const ageHours = lastTime ? (now - new Date(lastTime).getTime()) / 3600000 : STALE_HOURS + 1;
    const urgent = ageHours > STALE_HOURS;
    out.push({
      batchId: b.batchId,
      species: b.species || '',
      strain: b.strain || b.species || '',
      behindStage,
      behindCount,
      entries,
      // Per stage, not per zone: two incubation rooms are one stage, and the
      // card is about how far along the bags are, not which room they sit in.
      stages: Object.keys(stageCounts)
        .sort((a, c) => (STAGE_ORDER[a] || 99) - (STAGE_ORDER[c] || 99))
        .map((role) => ({ role, count: stageCounts[role], behind: role === behindStage })),
      urgent
    });
  });
  out.sort((a, c) => {
    if (a.urgent !== c.urgent) return a.urgent ? -1 : 1;
    return (c.behindCount || 0) - (a.behindCount || 0);
  });
  return out;
}
// Preferred one-tap fruiting destination: the most recently used fruiting
// zone/rack (matches how it's actually done — nearly always the same tent),
// else the first zone tagged role 'fruiting'. Null if no fruiting zone exists.
function _fruitingDest() {
  const isFruiting = (id) => {
    const z = ZONE_BY_ID[toZone(id)];
    return z && z.role === 'fruiting';
  };
  for (let i = scanLog.length - 1; i >= 0; i--) {
    const e = scanLog[i];
    if ((e.action === 'MOVE' || e.action === 'MOVE_BATCH') && e.to && isFruiting(e.to)) return e.to;
  }
  const first = zones.find((z) => z.role === 'fruiting');
  return first ? first.id : null;
}
// One-tap whole-batch move to fruiting for the dashboard "needs to move" cards.
// Same move semantics as the Verschieben picker (moveBatchTo skips bags that
// are unplaced/removed or already there) — just with the destination preset.
// ── Undo for bag moves ──────────────────────────────────────
// A "Rückgängig" snackbar reverses a move: we snapshot each bag's location
// before it, then move the exact same bags back on undo (a compensating MOVE,
// so the scan history stays honest). Used by every whole-batch move path —
// one-tap → Fruchtung, the per-zone bulk, the Verschieben picker and the
// scan action sheet — so a mistap costs one tap to reverse wherever it happens.
// Bags that were not placed before the move are absent from the snapshot and
// stay where they were put: there is no prior location to restore them to.
let _undoTimer = null;
function showUndoBar(msg, undoCb) {
  const bar = document.getElementById('undo-bar');
  if (!bar) return;
  document.getElementById('undo-msg').textContent = msg;
  const btn = document.getElementById('undo-btn');
  btn.textContent = t('dash.undo');
  btn.style.display = '';
  btn.onclick = () => {
    clearTimeout(_undoTimer);
    hideUndoBar();
    if (undoCb) undoCb();
  };
  bar.onclick = null;
  bar.classList.remove('is-err');
  bar.setAttribute('role', 'status');
  bar.setAttribute('aria-live', 'polite');
  bar.classList.add('show');
  clearTimeout(_undoTimer);
  _undoTimer = setTimeout(hideUndoBar, 8000);
}
// The app's own message line, and the reason it exists twice over. flashUndoBar
// is the receipt half — the bar with no button on it — and `toast` is the same
// bar carrying what used to go through alert() 77 times.
//
// alert() was the wrong control for that in four ways, and the fourth is why it
// could not simply be styled: it is not the app. On a phone it renders as
// `192.168.x.x sagt:` in the OS font, ignoring the theme and the 56px touch
// floor everything else in this app now guarantees. It also blocks — a gloved
// thumb has to find one small OK before anything else can happen — and it
// detaches the message from the field that caused it, so the user dismisses a
// sentence and then has to work out which of nine inputs it meant. This bar
// fixes the first three. The fourth, putting the message under its own field,
// is field-level validation and is not this change.
//
// Errors are read out assertively and sit for six seconds rather than two and a
// half, because a validation message that leaves before the eye reaches it is a
// message nobody got. A tap dismisses either kind.
function toast(msg, kind) {
  const bar = document.getElementById('undo-bar');
  if (!bar) return;
  const err = kind === 'err';
  document.getElementById('undo-msg').textContent = msg;
  document.getElementById('undo-btn').style.display = 'none';
  bar.classList.toggle('is-err', err);
  bar.setAttribute('role', err ? 'alert' : 'status');
  bar.setAttribute('aria-live', err ? 'assertive' : 'polite');
  // Tap anywhere to dismiss. Only on this path: an undo offer that vanished
  // under a stray tap would take the undo with it.
  bar.onclick = hideUndoBar;
  bar.classList.add('show');
  clearTimeout(_undoTimer);
  _undoTimer = setTimeout(hideUndoBar, err ? 6000 : 2500);
}
function flashUndoBar(msg) {
  toast(msg);
}
function hideUndoBar() {
  const bar = document.getElementById('undo-bar');
  if (!bar) return;
  bar.classList.remove('show');
  // Dropped on the way out, not on the way in: the bar fades rather than
  // vanishing, and removing the skin while it is still visible recolours it
  // mid-fade. The next caller sets its own anyway.
  setTimeout(() => {
    if (!bar.classList.contains('show')) bar.classList.remove('is-err');
  }, 250);
}
function _snapshotBeforeMove(batchList, dest, lastByBag) {
  const snap = [];
  const d = dest.toUpperCase();
  batchList.forEach((b) => {
    (b.bags || []).forEach((bag) => {
      const last = lastByBag.get(bag.toUpperCase());
      if (!last || last.action === 'REMOVE' || !last.to) return;
      if (last.to.toUpperCase() === d) return; // already there → won't move
      snap.push({ batch: b, bag, from: last.to });
    });
  });
  return snap;
}
function _undoMove(snap) {
  if (!snap || !snap.length) return;
  const groups = new Map();
  snap.forEach((s) => {
    const key = s.batch.batchId + '|' + s.from;
    if (!groups.has(key)) groups.set(key, { batch: s.batch, dest: s.from, bags: [] });
    groups.get(key).bags.push(s.bag);
  });
  let back = 0;
  // Marked 'undo', so the bags get their old move-in day back in getZoneBags()
  // instead of arriving today.
  groups.forEach((g) => moveBagsTo(g.batch, g.bags, g.dest, (m) => (back += m || 0), { reason: 'undo' }));
  updateSD();
  renderBatches();
  renderStatus();
  renderDashBatchTasks();
  flashUndoBar(t('dash.undone', { n: back }));
}
function moveBatchToFruiting(batchId) {
  const b = batches.find((x) => x.batchId === batchId);
  if (!b) return;
  const dest = fruitingTarget();
  if (!dest) {
    setFb('err', t('dash.noFruitingZone'));
    return;
  }
  const snap = _snapshotBeforeMove([b], dest, buildLastScanByBag());
  moveBatchTo(b, dest, function (moved, skipped) {
    updateSD();
    renderBatches();
    renderStatus();
    renderDashBatchTasks();
    if (!moved) {
      setFb(
        'ok',
        skipped ? t('batch.allAlreadyAt', { n: skipped, loc: zoneDisplayName(dest) }) : t('batch.noBagsToMove')
      );
    } else {
      showUndoBar(b.batchId + ': ' + moved + ' → ' + zoneDisplayName(dest), () => _undoMove(snap));
    }
  });
}
// One-tap action button(s) for a single batch-tasks row.
function dashTaskBtn(tk) {
  const id = esc(tk.batchId);
  if (tk.taskAction === 'inoculate') {
    // Colonised grain: the useful next step is making blocks from it, so go
    // straight to the create dialog rather than offering a move.
    return `<button class="btn btn-sm btn-p fs-xs" data-action="inoculate-from" data-batch="${id}" style="padding:3px 10px;flex-shrink:0">${esc(t('dash.doInoculate'))}</button>`;
  }
  if (tk.taskAction === 'move' && tk.ready) {
    // One-tap \u2192 Fruchtung (the dominant move) as the primary action; the
    // Verschieben picker stays for any other destination. Only offer it for
    // batches actually in incubation \u2014 never for SPAWN RUN, where jumping
    // grain spawn straight to a fruiting tent skips a whole growth stage.
    //
    // tk.ready gates both: a batch 3-7 days out is listed so the week ahead is
    // visible, but offering a one-tap move for it ends incubation early, and the
    // only way back is an 8-second undo snackbar. Not ready \u2014 falls through to
    // the passive "Ansehen" button below, which is what it did before the tabs.
    const canFruit = getStatus(tk.batchId).status === 'INCUBATING' && zones.some((z) => z.role === 'fruiting');
    const toFruiting = canFruit
      ? `<button class="btn btn-sm btn-p fs-xs" data-action="move-to-fruiting" data-batch="${id}" style="padding:3px 10px;flex-shrink:0">\u2192 ${esc(t('dash.toFruiting'))}</button>`
      : '';
    return (
      toFruiting +
      `<button class="btn btn-sm fs-xs" data-action="open-move-modal" data-batch="${id}" style="padding:3px 10px;flex-shrink:0;margin-left:${toFruiting ? '4px' : '0'}">${t('dash.move')}</button>`
    );
  }
  return `<button class="btn btn-sm fs-xs" data-action="go-to-batch" data-batch="${id}" style="padding:3px 10px;flex-shrink:0">${t('dash.view')}</button>`;
}
// The urgency sections of the batch-tasks card, in the order a worker triages:
// what is late, what is due today, what is coming, and what got left behind.
// 'left' is not date-driven — it is bags of a batch still sitting a stage behind
// the rest of it (see getSplitBatches), which is why it sits below the dated
// sections instead of being forced into "today".
const DASH_SECTIONS = ['overdue', 'today', 'week', 'left'];
// Which fruiting tent the one-tap moves target, remembered across reloads.
//
// This used to be _fruitingDest() alone: whichever tent something was last moved
// into. With one tent that is always right. With several it is a hidden global —
// move one batch into tent 3 by hand and every "→ Fruchtung" on the card silently
// retargets to tent 3, with nothing on screen saying so. Worse, a tent that has
// never received a move is unreachable from the card entirely.
//
// So the choice is explicit and visible. _fruitingDest() stays as the seed for a
// user who has never picked one, which keeps the single-tent case zero-effort.
function fruitingZones() {
  return zones.filter((z) => z.role === 'fruiting');
}
let _fruitingTargetKey = null;
function fruitingTarget() {
  const avail = fruitingZones();
  if (!avail.length) return null;
  if (_fruitingTargetKey === null) {
    // Guarded like the read in initDashCollapse(): storage revoked mid-session
    // (site data blocked, partitioned context, a backgrounded PWA evicted by
    // iOS) must not throw inside a render and abort everything queued behind it.
    try {
      _fruitingTargetKey = localStorage.getItem('mp-fruiting-target') || '';
    } catch (e) {
      _fruitingTargetKey = '';
    }
  }
  // The stored tent can have been deleted, renamed to another id, or had its
  // role changed since it was picked — never move bags at a stale target.
  if (_fruitingTargetKey && avail.some((z) => z.id === _fruitingTargetKey)) return _fruitingTargetKey;
  return _fruitingDest();
}
function setFruitingTarget(id) {
  if (!fruitingZones().some((z) => z.id === id)) return;
  _fruitingTargetKey = id;
  try {
    localStorage.setItem('mp-fruiting-target', id);
  } catch (e) {
    /* storage disabled — the choice just won't survive a reload */
  }
  renderDashBatchTasks();
}
// How full a tent is, and whether this many more bags would overflow it.
// max_capacity is optional and unset by default: with no capacity recorded there
// is nothing to warn about, and the (linear) getZoneBags walk is skipped
// entirely. Reuses getZoneBags rather than re-deriving occupancy, so the
// same-zone-move rule it encodes cannot drift out of sync here.
function fruitingFill(zoneId, incoming) {
  const z = zones.find((x) => x.id === zoneId);
  const cap = z && z.maxCapacity ? z.maxCapacity : 0;
  if (!cap) return null;
  const used = Object.keys(getZoneBags(zoneId)).length;
  return { used, cap, incoming: incoming || 0, over: used + (incoming || 0) > cap };
}
// How many rows the open day shows. Six leaves the whole week on one screen
// with a day open; the rest is one tap away rather than pushed off the bottom.
const DASH_DAY_CAP = 6;
// Ab wie vielen gerissenen Labor-Untergrenzen sie zu einer Zeile werden.
//
// Alle Sorten mal vier Typen sind schnell Dutzende Zeilen an einem Tag, und sie
// sortieren vor den Rundgang — einzeln aufgeführt füllten sie die sechs, die
// der Tag zeigt, und schoben den Weg hinter die Klappe. Eine Zeile, die sagt
// wie viele, und sich auf Tippen öffnet, lässt beides stehen.
const LABMIN_GROUP_AT = 3;
let dashLabGroupOpen = false;
const _dashRoomOpen = {};
function toggleDashRoom(key) {
  _dashRoomOpen[key] = !_dashRoomOpen[key];
  renderDashBatchTasks();
}
// Which day of the week strip is open, as an offset from today rather than a
// weekday number — a stored weekday would silently point at a different day
// after midnight, and 0 always means "today" no matter when it is read.
let _dashDayOffset = 0;
let _dashDayOnly = localStorage.getItem('mp-dash-view') === 'day';
function setDashView(nurTag) {
  _dashDayOnly = !!nurTag;
  localStorage.setItem('mp-dash-view', _dashDayOnly ? 'day' : 'week');
  renderDashBatchTasks();
}
function setDashDay(off) {
  const n = Number(off);
  if (!Number.isInteger(n) || n < 0 || n > 6) return;
  _dashDayOffset = n;
  renderDashBatchTasks();
}
// The theme for a weekday, and whether it is the farm's decision or only this
// card's guess from history. Showing "no theme" on a card whose whole purpose
// is to give the week a shape was the worst possible default; a labelled guess
// is honest and useful, and the editor turns it into a decision.
let _rhythmGuess = null;
function themeFor(weekday) {
  const set = themeOf(weekday);
  if (set) return { theme: set, suggested: false };
  if (Object.keys(weekRhythm).length) return { theme: '', suggested: false };
  if (!_rhythmGuess) _rhythmGuess = suggestWeekRhythm();
  return { theme: _rhythmGuess[weekday] || '', suggested: true };
}
// ─── Weekly rhythm ──────────────────────────────────────────
// Must stay in step with WEEK_THEMES in db.js, which rejects anything else.
// Nur, was sich planen UND zaehlen laesst. Muss mit WEEK_THEMES in db.js
// uebereinstimmen, die alles andere ablehnt.
//
// Fruchtung, Ernte und Labor standen hier, weil sie zaehlbar sind. Geplant hat
// sie nie jemand: man zieht um, wenn durchwachsen ist, und erntet, wenn reif
// ist, nicht dienstags. Sechs Eintraege, von denen zwei benutzt werden, machen
// aus einer Auswahl eine Suche.
//
// Alles Uebrige, was regelmaessig zu tun ist, ist jetzt eine eigene Aufgabe mit
// eigenem Namen und eigenem Takt -- der Platz, an dem so etwas wachsen darf,
// ohne dass diese Liste mitwaechst.
const WEEK_THEMES = ['substrate', 'grain', 'free'];
// Weekdays in the order a working week reads, not the order getDay() numbers
// them — Monday first, Sunday last, while the stored keys stay 0 = Sunday.
const WEEK_DAYS = [1, 2, 3, 4, 5, 6, 0];
// Ein Thema, das die Auswahl nicht mehr kennt, darf trotzdem nicht als
// Rohschluessel auf dem Schirm landen. Migration 81 laesst aufgezeichnete Tage
// bewusst stehen, wie sie waren -- eine Aufnahme der Vergangenheit anzufassen,
// weil sich ein Menue geaendert hat, waere die Umkehrung von allem, was hier
// gilt. Also bleiben die drei alten Beschriftungen erhalten, und alles, wofuer
// es gar keine gibt, liest "ohne Thema" statt "rhythm.theme.irgendwas".
const WEEK_THEME_LABELS = [...WEEK_THEMES, 'fruiting', 'harvest', 'lab'];
function weekThemeLabel(theme) {
  if (!theme || !WEEK_THEME_LABELS.includes(theme)) return t('rhythm.theme.none');
  return t('rhythm.theme.' + theme);
}
// Which theme a given weekday carries, or '' if the farm has not said.
// The whole entry for a weekday: {theme, targetQty, strainId, note}. A day the
// farm has not set returns null. Older payloads stored a bare theme string, so
// one is normalised rather than left to blow up on .theme.
function rhythmOf(weekday) {
  const v = weekRhythm[weekday] || weekRhythm[String(weekday)] || null;
  if (!v) return null;
  return typeof v === 'string' ? { theme: v, targetQty: null, strainId: null, note: null } : v;
}
function themeOf(weekday) {
  const r = rhythmOf(weekday);
  return r ? r.theme || '' : '';
}
function _ymd(d) {
  const p = (n) => String(n).padStart(2, '0');
  return d.getFullYear() + '-' + p(d.getMonth() + 1) + '-' + p(d.getDate());
}
// The tracked job for a date, if one was planned. Past days and today are
// snapshots taken when they arrived; a future day has none yet, so it is read
// from the template and marked as still only a plan.
function rhythmTaskOn(date) {
  const key = _ymd(date);
  const row = rhythmTasks.find((x) => x.date === key);
  if (row) return row;
  const r = rhythmOf(date.getDay());
  if (!r || r.theme === 'free' || !r.targetQty) return null;
  return {
    date: key,
    weekday: date.getDay(),
    theme: r.theme,
    targetQty: r.targetQty,
    strainId: r.strainId,
    note: r.note,
    doneQty: 0,
    planned: true
  };
}
// Was an einem Tag wirklich entstanden ist, gemessen am Thema des Tages.
//
// Vorher trug der Rhythmus eine eigene Zahl, die nur der "Erfassen"-Knopf
// bewegte. Wer Blöcke ansetzte und nicht daneben eintippte, dass er es getan
// hatte, sah den Tag weiter offen stehen — die Anlage führte zwei
// Buchhaltungen über dieselbe Arbeit, und die zweite war die, die niemand
// pflegt. Dieselbe Entscheidung wie bei den Versorgungslücken und den
// Labor-Untergrenzen: abgeleitet, nicht abgehakt. Es gibt nichts zu tippen und
// nichts zu vergessen.
//
// Ein Thema misst das, was an dem Tag dabei herauskommt: Substrattag zaehlt
// angesetzte Blöcke, Körnertag die Kilogramm Brut, Fruchtungstag die Beutel,
// die in eine Fruchtungszone gezogen sind, Erntetag die erfassten Ernten,
// Labortag die angelegten Kulturen.
// Was an welchem Tag entstanden ist, in EINEM Durchgang je Auffrischung.
//
// rhythmMadeOn() lief vorher je rückständigem Tag und ging dabei jedes Mal
// batches, scanLog, harvests und cultures ganz durch, mit einem Date-Aufbau je
// Element — und rhythmArrears() warf danach die erledigten Tage weg, die den
// Durchgang schon bezahlt hatten. rhythmTasks wächst um eine Zeile je Tag und
// wird nie beschnitten, also wuchs das mit dem Alter der Anlage: gemessen 156 ms
// nach drei Monaten, 2314 ms nach einem Jahr, auf der Startseite, bei jedem
// SSE-Ereignis. Ein Index, gebaut wie _statusByBatch und in refresh() genauso
// verworfen, macht daraus einen Kartenzugriff.
let _rhythmIndex = null;
function _rhythmMadeIndex() {
  if (_rhythmIndex) return _rhythmIndex;
  const idx = new Map();
  const bucket = (wert) => {
    if (!wert) return null;
    const d = new Date(wert);
    if (isNaN(d)) return null;
    const k = _ymd(d);
    let e = idx.get(k);
    if (!e) idx.set(k, (e = { substrate: 0, grain: 0, fruiting: 0, harvest: 0, lab: 0 }));
    return e;
  };
  for (const b of batches || []) {
    const e = bucket(b.created);
    if (!e) continue;
    // Beides zaehlt, was an dem Tag ENTSTANDEN ist, und nicht, was davon heute
    // noch dasteht. _grainKgOf() waere hier falsch: es gibt 0 zurueck, sobald
    // eine Charge archiviert ist, also kam ein erfuellter Koernertag als
    // Rueckstand zurueck, sobald die Glaeser verbraucht waren -- dauerhaft, und
    // ohne Knopf, der ihn noch schliessen koennte.
    //
    // Und in Glaesern, nicht in Kilogramm: das Ziel wird als Anzahl eingegeben
    // ('Wie viele am {date}?', setRhythmTarget verlangt eine ganze Zahl), also
    // muss die Zahl daneben dieselbe Einheit haben. In Kilogramm gemessen war
    // ein Ziel von 20 mit sieben 3-kg-Glaesern erfuellt, und mit 0,5-kg-Glaesern
    // nie.
    if (b.batchType === 'grain') e.grain += b.qty || 0;
    else e.substrate += b.qty || 0;
  }
  for (const s of scanLog || []) {
    if (!s || !s.bag || !s.to) continue;
    if (s.action !== 'MOVE' && s.action !== 'MOVE_BATCH') continue;
    const z = ZONE_BY_ID[toZone(s.to)];
    if (!z || z.role !== 'fruiting') continue;
    const e = bucket(s.time);
    if (e) e.fruiting++;
  }
  for (const h of harvests || []) {
    const e = bucket(h && h.time);
    if (e) e.harvest++;
  }
  for (const c of cultures || []) {
    const e = bucket(c && c.created);
    if (e) e.lab++;
  }
  _rhythmIndex = idx;
  return idx;
}
function rhythmMadeOn(dateKey, theme) {
  const tag = _rhythmMadeIndex().get(dateKey);
  return tag && tag[theme] != null ? tag[theme] : 0;
}
// Ab wann der Rhythmus überhaupt mitzählt.
//
// Ohne das steht jeder Montag vor der Inbetriebnahme als verfehlt da, und an
// einer Woche, die niemand mehr bearbeiten kann, ist nichts nachzuholen.
function rhythmCountsFrom() {
  return (inventory && inventory.bagCountFrom) || null;
}

// --- Eigene Aufgaben der Anlage ---------------------------------------------
//
// Der Rhythmus zaehlt Produktion; er kann nur, was eine Buchung hinterlaesst.
// Das hier ist alles andere, was regelmaessig ansteht und keine hinterlaesst:
// putzen, warten, pruefen. Selbst benannt, selbst getaktet, selbst abgehakt.
//
// Abgehakt und nicht gezaehlt -- als Einziges in dieser Datei. Das ist keine
// Ruecknahme des Grundsatzes, sondern seine Bedingung: gezaehlt wird, wo es
// etwas zu zaehlen gibt, und hinter einem geputzten Raum steht nichts, woraus
// sich das ableiten liesse. Ein Haken ist hier die einzige Quelle, die es gibt.

// Wann eine Aufgabe faellt, rechnet der Server aus: listRecurringTasks() legt
// die Termine des Zeitraums als `due` bei. Hier stand dieselbe Regel ein
// zweites Mal, und ein Test hielt die beiden Fassungen ueber 480 Daten
// gegeneinander -- eine Naht, die nur haelt, solange jemand an sie denkt, und
// die gegen einen Unterschied in dem, was die Zwillinge AUFRUFEN, ohnehin
// blind war. Jetzt gibt es die Regel einmal, und zwar dort, wo sie auch
// beim Abhaken geprueft wird.
function recurringDueOn(task, dateKey) {
  return !!(task && task.due && task.due.indexOf(dateKey) >= 0);
}
function recurringDoneOn(task, dateKey) {
  return !!(task && task.done && task.done.indexOf(dateKey) >= 0);
}
// Was an einem Tag faellt, mit dem Stand des Hakens.
function recurringOn(dateKey) {
  return (recurringTasks || [])
    .filter((x) => x && x.active && recurringDueOn(x, dateKey))
    .map((x) => ({ task: x, done: recurringDoneOn(x, dateKey) }));
}
// Versaeumte Termine -- je Aufgabe hoechstens einer, naemlich der juengste.
//
// Wer zweimal nicht geputzt hat, putzt einmal und ist wieder aktuell. Drei
// offene Putztermine nebeneinander waeren eine Liste, die niemand abarbeiten
// kann und die deshalb keiner mehr liest: genau die Dauerwarnung, gegen die an
// dieser Stelle ueberall geschrieben ist.
//
// Faellt die Aufgabe heute ohnehin an, steht sie schon in der Tagesliste. Den
// versaeumten Termin daneben zu setzen hiesse: zwei Zeilen mit zwei Haken fuer
// einmal Putzen.
//
// Kein Rueckwaertsgang mehr ueber Kalendertage: `due` kommt fertig vom Server
// und reicht so weit zurueck, wie der laengste Takt es verlangt. Der alte
// Gang in festen 864e5 Millisekunden uebersprang im Fruehjahr den Tag der
// Zeitumstellung -- ein an ihm versaeumter Termin war damit unsichtbar.
function recurringArrears(today) {
  const heute = _ymd(today);
  const out = [];
  for (const x of recurringTasks || []) {
    if (!x || !x.active || !x.due || !x.due.length) continue;
    if (x.due.indexOf(heute) >= 0) continue;
    const vergangen = x.due.filter((d) => d < heute);
    if (!vergangen.length) continue;
    const letzter = vergangen[vergangen.length - 1];
    if (!recurringDoneOn(x, letzter)) out.push({ task: x, date: letzter });
  }
  return out;
}
// "jede Woche" / "alle 2 Wochen" -- eine Eins liest sich anders als eine Zahl.
function recurEveryLabel(n) {
  return Number(n) === 1 ? t('recur.everyWeek') : t('recur.everyN', { n: Number(n) || 1 });
}
// Everything asked for before today and not finished. This is the point of
// tracking at all: 10 planned for one day with 8 made means the next day still owes
// 2. Without it the shortfall simply vanished and the same 10 came round again
// the following week as though nothing had been missed.
function rhythmArrears(today) {
  const cut = _ymd(today);
  const ab = rhythmCountsFrom();
  const geplant = rhythmTasks
    .filter((x) => x.date < cut && x.targetQty && (!ab || x.date >= ab))
    .sort((a, b) => (a.date < b.date ? -1 : 1));
  if (!geplant.length) return [];

  // Ein Tag wird von der Arbeit bezahlt, die an ihm ODER SPÄTER getan wurde.
  //
  // Vorher zählte jeder Tag nur, was an genau diesem Datum entstand. Der Plan
  // sagt "10 Substrat" für einen Tag, gemacht wird es später — also stand der
  // Tag auf 10 offen, während in derselben Woche 20 Blöcke entstanden waren,
  // und blieb dort. Genau die Dauerwarnung, gegen die alles hier geschrieben
  // ist, nur eine Ebene höher: erst wurde das Melden abgeschafft, und dann
  // half das Zählen nicht, weil es am falschen Tag suchte.
  //
  // Ein Tag ist eine Vorgabe, kein Termin. Also ein laufendes Konto je Thema:
  // Produktion zahlt die älteste offene Vorgabe zuerst, und was übrig bleibt,
  // steht für die nächste bereit. Wer später in der Woche 20 macht, hat den Tag
  // erledigt, und niemand muss das irgendwo eintragen.
  //
  // Nur vorwärts: Arbeit von vor einer Vorgabe zahlt sie nicht. Sonst hätte
  // eine gute Vorwoche eine schlechte Woche im Voraus entschuldigt.
  const idx = _rhythmMadeIndex();
  const rest = new Map(geplant.map((t) => [t.date, t.targetQty]));
  const themen = {};
  for (const t of geplant) (themen[t.theme] = themen[t.theme] || []).push(t);

  for (const [theme, liste] of Object.entries(themen)) {
    const tage = [...new Set([...liste.map((t) => t.date), ...idx.keys()])]
      .filter((d) => d >= liste[0].date && d < cut)
      .sort();
    let guthaben = 0;
    let i = 0;
    for (const d of tage) {
      guthaben += (idx.get(d) || {})[theme] || 0;
      while (i < liste.length && liste[i].date <= d && guthaben > 0) {
        const offen = rest.get(liste[i].date);
        const zahlung = Math.min(offen, guthaben);
        rest.set(liste[i].date, offen - zahlung);
        guthaben -= zahlung;
        if (rest.get(liste[i].date) <= 0) i++;
      }
    }
  }

  return geplant
    .map((t) => Object.assign({}, t, { doneQty: t.targetQty - rest.get(t.date), outstanding: rest.get(t.date) }))
    .filter((t) => t.outstanding > 0);
}
// The recipe behind the plan, for the day that is actually open. Empty when no
// Sorte is chosen or that Sorte carries no substrate recipe.
function rhythmMixText(weekday) {
  const r = rhythmOf(weekday);
  if (!r || !r.strainId) return '';
  const ms = mushroomStrains.find((m) => m.id === r.strainId);
  if (!ms) return '';
  const bits = [];
  if (ms.recBagKg) bits.push(ms.recBagKg + ' kg');
  if (ms.recHardwoodPct) bits.push('HW ' + ms.recHardwoodPct + '%');
  if (ms.recWheatbranPct) bits.push('WB ' + ms.recWheatbranPct + '%');
  // recGypsum is a flag ("add gypsum"), not a percentage — the app labels it
  // "Gips (~1%)" everywhere else, so printing the flag as a number would invent
  // a figure the recipe never held.
  if (ms.recGypsum) bits.push(t('inv.gypsum'));
  return bits.join(' · ');
}
// Propose a rhythm from what the farm already does, so the editor opens on a
// draft to correct rather than seven empty rows to invent.
//
// Picking the busiest activity per day would just print "substrate" on every
// weekday — blocks far outnumber grain runs, so they win everywhere. What
// makes a day *characteristic* is the share of an activity that lands on it:
// most grain runs can fall on one weekday even though grain is rare. So
// each day takes the activity most concentrated on it, and a day that holds no
// meaningful share of anything is offered as free rather than mislabelled.
function suggestWeekRhythm() {
  // Nur Themen, die WEEK_THEMES auch kennt.
  //
  // 'fruiting' stand hier noch, nachdem es aus der Auswahl geflogen war. Zwei
  // Folgen, beide still: der Wochenkopf zeichnete den Rohschluessel
  // "rhythm.theme.fruiting", weil t() bei fehlender Uebersetzung den Schluessel
  // selbst zurueckgibt -- und im Editor fand das <select> keine passende
  // Option, waehlte die erste ('substrate'), und _rhythmSyncFromForm() las beim
  // Speichern genau diese zurueck. Wer den Vorschlag ungeprueft bestaetigte,
  // speicherte einen Substrattag, ohne etwas geaendert zu haben.
  const KINDS = ['substrate', 'grain'];
  const byDay = {};
  const totals = { substrate: 0, grain: 0 };
  for (let d = 0; d < 7; d++) byDay[d] = { substrate: 0, grain: 0 };
  const typeOf = {};
  for (const b of batches) typeOf[b.batchId] = b.batchType;
  for (const e of scanLog) {
    if (!e || !e.time) continue;
    const dt = new Date(e.time);
    if (isNaN(dt)) continue;
    const d = dt.getDay();
    let kind = null;
    if (e.action === 'ADD') kind = typeOf[e.batch] === 'grain' ? 'grain' : 'substrate';
    if (!kind) continue;
    byDay[d][kind]++;
    totals[kind]++;
  }
  // Share alone over-rewards rare work. Say moves into fruiting number 100 against
  // 1000 block builds: a day holding 30 moves scores a higher share
  // (0.30) than the 250 blocks built the same day (0.25) — and that day would be
  // labelled a fruiting day when most of what happens on it is substrate.
  //
  // So share only decides when it decides clearly. A kind must lead the
  // runner-up by half again to name the day; otherwise the day is named by what
  // there is simply most of. That still names a grain day where grain is
  // genuinely concentrated (say 0.5 against 0.2), without letting a thin margin
  // rename a day around a handful of events.
  const MARGIN = 1.5;
  // A day holding almost nothing all year is offered as free rather than being
  // given a theme on the strength of a handful of entries.
  const QUIET = 0.1;
  const dayTotal = (d) => KINDS.reduce((n, k) => n + byDay[d][k], 0);
  let busiest = 0;
  for (let d = 0; d < 7; d++) busiest = Math.max(busiest, dayTotal(d));

  const out = {};
  for (let d = 0; d < 7; d++) {
    if (!busiest || dayTotal(d) < QUIET * busiest) {
      out[d] = 'free';
      continue;
    }
    const shares = KINDS.map((k) => ({ k, share: totals[k] ? byDay[d][k] / totals[k] : 0, n: byDay[d][k] })).sort(
      (a, b) => b.share - a.share
    );
    const runnerUp = shares[1] ? shares[1].share : 0;
    if (shares[0].share > 0 && shares[0].share >= runnerUp * MARGIN) out[d] = shares[0].k;
    else out[d] = KINDS.reduce((best, k) => (byDay[d][k] > byDay[d][best] ? k : best), KINDS[0]);
  }
  return out;
}
// The next seven days, starting today, each with the work that lands on it.
//
// A rolling window rather than Monday-to-Sunday: a calendar week spends part of
// itself in the past, and the first question this card exists to answer is what
// to do now. Every weekday still appears exactly once, so the rhythm is just as
// visible — today is simply the one at the top.
//
// Overdue work folds onto today. It is not Tuesday's job any more; it is this
// morning's, and leaving it on the day it was missed would show an empty today
// beside a backlog nobody is looking at.

// A Sorte with nothing coming is work, and it was only ever visible on the
// Chargen tab. Somebody reading the day's list had no way to learn that a
// Sorte had run out — the list only ever knew about batches that already exist,
// so the one thing missing from the farm was the one thing it could not say.
//
// These rows are DERIVED, like the move and harvest rows beside them, and that
// is what makes "until it is actually made" work without any bookkeeping: make
// the grain and the Sorte stops being 'now'; make the blocks and it stops being
// 'nospawn'. There is no done flag to set, and none to forget.
//
// Only Sorten in this season's programme (v78) qualify. Without that, a Sorte
// nobody is growing this half of the year has no grain and nothing incubating
// by definition, so it would report the same gap every day forever — and a
// warning that is always on drags the real ones down with it.
function buildSupplyTasks() {
  const out = [];
  for (const r of sorteRollup()) {
    if (r.supply !== 'now' && r.supply !== 'nospawn') continue;
    // The rollup already resolved this against the programme, by key. Rebuilding
    // the same judgement from names here is what made this function return an
    // empty list on real data: a block batch's name carries a " (KZ)" suffix the
    // strain row does not.
    //
    // A Sorte with no Pilzsorten row is left out rather than assumed in. The
    // tile may show it — an observation can err towards telling you something —
    // but a task is an instruction, and "nothing said otherwise" is not enough
    // to issue one.
    if (!r.imProgramm || !r.known) continue;
    out.push({
      key: r.key,
      name: r.name,
      supply: r.supply,
      // What to make, in the order the chain runs: no grain means grain first.
      taskAction: r.grain === 0 ? 'make-grain' : 'make-blocks'
      // Ohne Begruendung. Hier stand "keine Koerner, nichts in der Inkubation --
      // nach der Fruchtung (12) ist Schluss": eine Herleitung dessen, was der
      // Knopf daneben ohnehin verlangt, und in der Zeile, die man im Vorbeigehen
      // liest, die laengste Zeile von allen. Wer die Sorte kennt, weiss das; und
      // dass es eilt, sagt der rote Streifen, den supply === 'now' schon setzt.
    });
  }
  // Worst first, and stable, so the row does not jump about between renders.
  return out.sort((a, b) => SUPPLY_RANK[a.supply] - SUPPLY_RANK[b.supply] || a.name.localeCompare(b.name));
}

// Laborarbeit, die ansteht: je Art, was ihr fehlt.
//
// Dieselben Zahlen wie Nachproduzieren auf der Laborseite (db.labStock), nicht
// eine zweite Rechnung aus den Kulturen hier: zwei Rechnungen über dasselbe
// Regal sind genau das, was Kacheln und Verkaufsbestand auseinanderlaufen
// ließ. Eine Zeile je Art, denn aus einer Quelle setzt man alles an, was ihr
// fehlt (lbAnsetzen). Eine Art außer Programm fehlt nirgends, nur eine offene
// Bestellung zählt noch; das entscheidet der Server.
//
// Leer, bis die Zahlen da sind: loadLabStock() zeichnet die Tagesliste neu,
// sobald sie ankommen.
function buildLabMinTasks() {
  return _lbSpecies()
    .map((sp) => ({ sp, fehlt: _lbFehlt(sp) }))
    .filter((x) => x.fehlt.length)
    .map(({ sp, fehlt }) => ({
      strainId: sp.strainId,
      key: 'id:' + sp.strainId,
      name: sp.name,
      kz: sp.kuerzel,
      // "empty" heißt in der Tagesliste "überfällig": nur eine Bestellung, die
      // nicht rausgehen kann. Alles andere ist knapp, auch bei null.
      empty: _lbDringend(sp),
      detail: fehlt.map(_lbChip).join(' · '),
      gaps: fehlt.length
    }))
    .sort((a, b) => Number(b.empty) - Number(a.empty) || b.gaps - a.gaps || a.name.localeCompare(b.name));
}

function buildWeekPlan() {
  const midnight = new Date();
  midnight.setHours(0, 0, 0, 0);
  const lastByBag = buildLastScanByBag();
  const days = [];
  for (let off = 0; off < 7; off++) {
    // Auch hier addDays(): mit festen 864e5 fielen im Oktober zwei Spalten auf
    // dasselbe Datum (25.10. zweimal) und der Montag darauf verschwand. Seit
    // die eigenen Aufgaben an _ymd(days[i].date) haengen, ist der Schluessel
    // tragend: zwei Spalten zeichneten denselben Haken.
    const date = addDays(midnight, off);
    days.push({ offset: off, date, weekday: date.getDay(), theme: themeOf(date.getDay()), items: [] });
  }
  const put = (off, item) => days[Math.max(0, Math.min(6, off))].items.push(item);
  const biggestZone = (counts) => {
    let top = '';
    for (const z in counts) if (!top || counts[z] > counts[top]) top = z;
    return top;
  };

  // Ein niedriger Bestand ist Arbeit: er sagt "bestell nach" oder "setz an",
  // genau wie eine Versorgungslücke. Als eigene Karte stand er neben der Liste,
  // die alles andere zu tun hatte — das einzige auf dem Schirm, das zweimal
  // gelesen werden musste, und beim Aufräumen der Nachbarkarten hatte es sich
  // auch noch die ganze Zeilenbreite geerbt.
  for (const a of buildAlertTasks()) {
    put(0, {
      kind: 'alert',
      species: '',
      label: a.text,
      detail: '',
      bags: 0,
      zone: '',
      overdue: !!a.urgent,
      ready: true,
      task: a
    });
  }
  // Eigene Aufgaben: was an dem Tag faellt, samt Stand des Hakens.
  for (let i = 0; i < days.length; i++) {
    const key = _ymd(days[i].date);
    for (const f of recurringOn(key)) {
      put(i, {
        kind: 'chore',
        species: '',
        label: f.task.name,
        detail: recurEveryLabel(f.task.everyWeeks),
        bags: 0,
        zone: '',
        overdue: false,
        ready: true,
        done: f.done,
        task: { id: f.task.id, date: key, done: f.done }
      });
    }
  }
  // Und der eine versaeumte Termin je Aufgabe, auf heute gezogen und mit seinem
  // eigenen Datum beschriftet -- so wie ein Rueckstand aus dem Rhythmus auch.
  for (const r of recurringArrears(midnight)) {
    put(0, {
      kind: 'chore',
      species: '',
      label: r.task.name,
      detail: t('recur.missedFrom', { date: fmtDt(r.date) }),
      bags: 0,
      zone: '',
      overdue: true,
      ready: true,
      done: false,
      task: { id: r.task.id, date: r.date, done: false }
    });
  }
  const laborMin = buildLabMinTasks();
  const gebuendelt = laborMin.length > LABMIN_GROUP_AT;
  if (gebuendelt) {
    put(0, {
      kind: 'labgroup',
      species: '',
      label: t('todo.labGroup', { n: laborMin.length }),
      // Die ersten Arten mit Namen, der Rest steht in den Zeilen darunter,
      // sobald man aufklappt.
      detail:
        laborMin
          .slice(0, 3)
          .map((l) => l.name)
          .join(', ') + (laborMin.length > 3 ? ' …' : ''),
      bags: 0,
      zone: '',
      overdue: laborMin.some((l) => l.empty),
      ready: true,
      // Wie viele Zeilen diese eine vertritt, sagt PLAN_KINDS.labgroup.weight --
      // ausgerechnet aus task.rows, die ohnehin hier stehen.
      task: { rows: laborMin }
    });
  }
  for (const l of gebuendelt && !dashLabGroupOpen ? [] : laborMin) {
    // Today, like the supply rows and for the same reason: a floor breached is
    // not a dated job, it is a state, and it is only ever "still under".
    put(0, {
      kind: 'labmin',
      species: l.name,
      label: l.name,
      detail: l.detail,
      bags: 0,
      zone: '',
      overdue: l.empty,
      ready: true,
      task: l
    });
  }
  for (const s of buildSupplyTasks()) {
    // Always today. This is not a dated job — it is a gap, and a gap is only
    // ever "still open". It disappears the moment the batch exists, because it
    // is derived from the same counts the Sorten card reads; there is nothing
    // to tick off and nothing that can be forgotten in a done-list.
    put(0, {
      kind: 'supply',
      species: s.name,
      label: s.name,
      detail: s.detail,
      bags: 0,
      zone: '',
      overdue: s.supply === 'now',
      ready: true,
      task: s
    });
  }
  for (const tk of buildAutoTasks()) {
    const place = _dashTaskPlace(tk.batchId, lastByBag);
    put(Math.max(0, tk.dueIn), {
      kind: tk.taskAction === 'inoculate' ? 'grain' : 'fruiting',
      batchId: tk.batchId,
      species: tk.species,
      label: tk.batchId,
      detail: tk.detail,
      bags: place.bags,
      zone: biggestZone(place.counts),
      overdue: tk.dueIn < 0,
      ready: tk.ready,
      // Carry the task itself so the row reuses dashTaskBtn, which already
      // encodes every guard: never offer a tent to grain spawn, never offer a
      // one-tap move to a batch that is not due yet, fall back to "Ansehen".
      task: tk
    });
  }
  for (const h of buildHarvestTasks()) {
    // remaining > 0 means it is still filling out; anything at or past its target
    // is work for today. No target at all means judge it by eye, so it is listed.
    const off = h.remaining == null ? 0 : Math.max(0, h.remaining);
    if (off > 6) continue;
    put(off, {
      kind: 'harvest',
      batchId: h.batchId,
      species: h.species,
      label: h.batchId,
      detail: h.target ? t('todo.dueIn', { n: Math.max(0, h.remaining) }) : '',
      bags: h.bagsInTent,
      zone: (h.zoneIds && h.zoneIds[0]) || '',
      overdue: h.target ? h.remaining < 0 : false,
      ready: true,
      task: h
    });
  }
  // Bags a split left a stage behind: not dated, but they are not going to fix
  // themselves either, so they belong in today's work rather than nowhere.
  for (const r of _dashLeftBehindRows(getSplitBatches(lastByBag))) {
    put(0, {
      kind: 'left',
      batchId: r.batchId,
      species: r.species,
      label: r.batchId,
      // These rows carry an instruction ("still in incubation") rather than a
      // due date, and offer no one-tap move — the split has to be looked at.
      detail: r.instruction || r.detail || '',
      bags: r.bags || 0,
      zone: '',
      overdue: false,
      ready: false,
      task: null
    });
  }
  for (const mt of manualTasks) {
    if (!mt || mt.done || !mt.dueDate) continue;
    const due = new Date(mt.dueDate);
    if (isNaN(due)) continue;
    due.setHours(0, 0, 0, 0);
    const off = Math.round((due - midnight) / 864e5);
    if (off > 6) continue;
    put(Math.max(0, off), {
      kind: 'manual',
      taskId: mt.id,
      label: mt.text || '',
      detail: '',
      bags: 0,
      zone: '',
      overdue: off < 0,
      ready: true,
      task: mt
    });
  }
  return days;
}
// How much of today is already behind you. Generated work vanishes as it is
// done — a moved batch simply stops being a task — so a bare "N left" can only
// ever shrink and never reads as progress. Counting what was actually recorded
// today gives the denominator something to move against.
function todayProgress(todayItems) {
  const midnight = new Date();
  midnight.setHours(0, 0, 0, 0);
  let done = 0;
  for (const e of scanLog) {
    if (!e || !e.time) continue;
    const dt = new Date(e.time);
    if (isNaN(dt) || dt < midnight) continue;
    if (e.action === 'ADD') done++;
    else if ((e.action === 'MOVE' || e.action === 'MOVE_BATCH') && e.to) {
      const z = ZONE_BY_ID[toZone(e.to)];
      if (z && z.role === 'fruiting') done++;
    }
  }
  for (const h of harvests) {
    if (!h || !h.time) continue;
    const dt = new Date(h.time);
    if (!isNaN(dt) && dt >= midnight) done++;
  }
  for (const mt of manualTasks) if (mt && mt.done && mt.dueDate) done++;
  // Eine abgehakte eigene Aufgabe ist erledigte Arbeit wie jede andere.
  for (const it of todayItems) if (it && it.done) done++;
  // Supply and lab-floor rows are derived from stock levels: they clear when
  // the stock changes, never by being ticked, and counting them in the
  // denominator made a finished day read 5/8. They are work, but they are not
  // work this bar can measure.
  // Abgeleitete Zeilen zählen nicht mit — welche das sind, sagt PLAN_KINDS.
  //
  // Und Erledigtes auch nicht. total ist done + countable, also zaehlte eine
  // abgehakte Aufgabe zweimal: einmal oben im Zaehler und einmal hier im
  // Nenner. Ein fertiger Tag las 4/5 und konnte nie 100% erreichen -- derselbe
  // Fehler wie bei den abgeleiteten Zeilen, nur von der anderen Seite.
  //
  // Genau das tut die Liste fuer manuelle Aufgaben schon an der Quelle
  // (`if (!mt || mt.done || !mt.dueDate) continue`); die eigenen Aufgaben
  // muessen in der Liste bleiben, weil man den Haken auch zuruecknehmen darf.
  const countable = todayItems.filter((it) => {
    if (it && it.done) return false;
    const k = planKind(it);
    return k ? k.counts : true;
  });
  return { done, total: done + countable.length };
}
// The editor works on a draft rather than straight off the DOM. Changing a
// theme has to redraw the row — a free day carries no target — and redrawing
// off the DOM would discard whatever else was half-typed. The draft holds the
// answer; the form is only ever a view of it.
let _rhythmDraft = null;
function _rhythmSyncFromForm() {
  const rows = document.getElementById('rhythm-rows');
  if (!rows || !_rhythmDraft) return;
  rows.querySelectorAll('select[data-rhythm-day]').forEach((s) => {
    const d = s.getAttribute('data-rhythm-day');
    const e = (_rhythmDraft[d] = _rhythmDraft[d] || {});
    e.theme = s.value;
  });
  rows.querySelectorAll('[data-rhythm-qty]').forEach((i) => {
    const e = _rhythmDraft[i.getAttribute('data-rhythm-qty')];
    if (e) e.targetQty = i.value === '' ? null : Number(i.value);
  });
  rows.querySelectorAll('[data-rhythm-strain]').forEach((i) => {
    const e = _rhythmDraft[i.getAttribute('data-rhythm-strain')];
    if (e) e.strainId = i.value === '' ? null : Number(i.value);
  });
  rows.querySelectorAll('[data-rhythm-note]').forEach((i) => {
    const e = _rhythmDraft[i.getAttribute('data-rhythm-note')];
    if (e) e.note = i.value.trim() || null;
  });
}
function _renderRhythmRows() {
  const rows = document.getElementById('rhythm-rows');
  if (!rows || !_rhythmDraft) return;
  const seit = document.getElementById('rhythm-start-now');
  if (seit) seit.textContent = inventory && inventory.bagCountFrom ? fmtDt(inventory.bagCountFrom) : t('rhythm.startNone');
  // '' is a real choice: a day can have a target without naming a Sorte.
  const strainOpts = (sel) =>
    '<option value="">—</option>' +
    [...mushroomStrains]
      .sort((a, b) => String(a.name).localeCompare(String(b.name)))
      .map((m) => '<option value="' + m.id + '"' + (m.id === sel ? ' selected' : '') + '>' + esc(m.name) + '</option>')
      .join('');
  rows.innerHTML = WEEK_DAYS.map((d) => {
    const cur = _rhythmDraft[d] || {};
    const sel = cur.theme || 'free';
    const opts = WEEK_THEMES.map(
      (k) => '<option value="' + esc(k) + '"' + (k === sel ? ' selected' : '') + '>' + esc(weekThemeLabel(k)) + '</option>'
    ).join('');
    // A free day takes no target, so it is not asked for one.
    const detail =
      sel === 'free'
        ? ''
        : '<div style="display:flex;gap:6px;margin:0 0 5px 46px">' +
          '<input type="number" min="0" step="1" data-rhythm-qty="' +
          d +
          '" value="' +
          esc(cur.targetQty == null ? '' : String(cur.targetQty)) +
          '" placeholder="' +
          esc(t('rhythm.qtyPh')) +
          '" style="width:70px;padding:4px" />' +
          '<select data-rhythm-strain="' +
          d +
          '" style="flex:1;min-width:0;padding:4px">' +
          strainOpts(cur.strainId || 0) +
          '</select></div>' +
          '<div style="margin:0 0 9px 46px"><input type="text" maxlength="200" data-rhythm-note="' +
          d +
          '" value="' +
          esc(cur.note || '') +
          '" placeholder="' +
          esc(t('rhythm.notePh')) +
          '" style="width:100%;padding:4px" /></div>';
    return (
      '<label style="display:flex;align-items:center;gap:8px;margin-bottom:4px">' +
      '<span class="fs-sm" style="width:38px;flex-shrink:0">' +
      esc(t('rhythm.day.' + d)) +
      '</span><select data-rhythm-day="' +
      d +
      '" style="flex:1;padding:5px">' +
      opts +
      '</select></label>' +
      detail
    );
  }).join('');
  rows.querySelectorAll('select[data-rhythm-day]').forEach((s) => {
    s.addEventListener('change', () => {
      _rhythmSyncFromForm();
      _renderRhythmRows();
    });
  });
  // Die Summe rechnet beim Tippen mit, aber die Zeilen werden dabei NICHT neu
  // gebaut: ein Neuaufbau mitten in der Eingabe nimmt dem Feld den Fokus und
  // setzt den Cursor zurück, und man tippt "70" als "0".
  rows.querySelectorAll('[data-rhythm-qty]').forEach((i) => {
    i.addEventListener('input', () => {
      _rhythmSyncFromForm();
      _renderRhythmTotal();
    });
  });
  _renderRhythmTotal();
}
// Was die Woche verlangt, je Thema.
//
// Getrennt und nicht als eine Zahl: Substrat sind Blöcke, Körnerbrut sind
// Gläser, Ernte ist Kilogramm. "100 diese Woche" über drei Einheiten summiert
// wäre eine Zahl, die nichts misst — und genau die Frage, die hier gestellt
// wird ("50 Substrat die Woche"), stellt sich ohnehin je Thema.
function _rhythmWeekTotals() {
  const sums = {};
  for (const d of WEEK_DAYS) {
    const e = (_rhythmDraft && _rhythmDraft[d]) || {};
    const th = e.theme || 'free';
    // NaN aus einem halb getippten Feld ist falsy und fällt hier heraus, statt
    // die Summe auf NaN zu ziehen.
    if (th === 'free' || !e.targetQty) continue;
    sums[th] = (sums[th] || 0) + e.targetQty;
  }
  return sums;
}
function _renderRhythmTotal() {
  const el = document.getElementById('rhythm-total');
  if (!el) return;
  const sums = _rhythmWeekTotals();
  const teile = WEEK_THEMES.filter((k) => sums[k]).map((k) => sums[k] + ' ' + weekThemeLabel(k));
  el.innerHTML =
    '<div class="fs-sm rhythm-total-sum">' +
    esc(t('rhythm.weekTotal')) +
    ' ' +
    esc(teile.length ? teile.join(' · ') : t('rhythm.weekTotalNone')) +
    '</div>' +
    '<div class="fs-xs rhythm-total-hint">' +
    esc(t('rhythm.weekTotalHint')) +
    '</div>';
}
// Opens on the saved week, or — the first time, when nothing has been saved —
// on the one derived from the farm's own history, so the first interaction is
// correcting a draft rather than filling in seven blanks. A suggestion can only
// guess the theme; the target and the Sorte are the farm's call.
function openRhythmEditor() {
  const modal = document.getElementById('m-rhythm');
  const hint = document.getElementById('rhythm-hint');
  if (!modal) return;
  const saved = Object.keys(weekRhythm).length > 0;
  const guess = saved ? null : suggestWeekRhythm();
  _rhythmDraft = {};
  for (const d of WEEK_DAYS) {
    const cur = rhythmOf(d);
    _rhythmDraft[d] = saved
      ? { theme: (cur && cur.theme) || 'free', targetQty: (cur && cur.targetQty) || null, strainId: (cur && cur.strainId) || null, note: (cur && cur.note) || null }
      : { theme: guess[d] || 'free', targetQty: null, strainId: null, note: null };
  }
  if (hint) hint.textContent = saved ? '' : t('rhythm.suggested');
  _renderRhythmRows();
  _ownEdit = null;
  _renderRhythmOwn();
  // .modal-bg is display:none and only .modal-bg.open is display:flex, so
  // clearing the hidden attribute alone leaves the dialog invisible.
  modal.hidden = false;
  modal.classList.add('open');
}
// Die eigenen Aufgaben, verwaltet an derselben Stelle wie der Rhythmus: beides
// beantwortet dieselbe Frage, naemlich was diese Anlage regelmaessig tut.
//
// Nur fuer Admins sichtbar. Eine wiederkehrende Aufgabe anzulegen ist eine
// Festlegung fuer alle und fortan -- dieselbe Grenze, die der Server zwischen
// /api/recurring-task (Admin) und /api/recurring-done (jeder) zieht. Ein Feld
// anzubieten, dessen Speichern mit 403 zurueckkommt, waere schlimmer als keins.
const RECUR_EVERY_CHOICES = [1, 2, 3, 4, 6, 8, 12];
// Welche Aufgabe gerade bearbeitet wird, oder null.
let _ownEdit = null;
// Die drei Felder einer Aufgabe, einmal geschrieben: die Zeile zum Anlegen und
// die zum Bearbeiten sind dieselben drei Fragen.
function _ownFieldsHtml(suffix, wert) {
  const w = wert || {};
  const wd = w.anchor ? new Date(w.anchor + 'T00:00:00').getDay() : new Date().getDay();
  return (
    '<input type="text" id="own-name' +
    suffix +
    '" maxlength="80" value="' +
    esc(w.name || '') +
    '" placeholder="' +
    esc(t('recur.namePh')) +
    '" /><select id="own-every' +
    suffix +
    '">' +
    RECUR_EVERY_CHOICES.map(
      (n) => '<option value="' + n + '"' + (Number(w.everyWeeks) === n ? ' selected' : '') + '>' + esc(recurEveryLabel(n)) + '</option>'
    ).join('') +
    '</select><select id="own-day' +
    suffix +
    '">' +
    WEEK_DAYS.map(
      (d) => '<option value="' + d + '"' + (d === wd ? ' selected' : '') + '>' + esc(t('rhythm.day.' + d)) + '</option>'
    ).join('') +
    '</select>'
  );
}
function _renderRhythmOwn() {
  const el = document.getElementById('rhythm-own');
  if (!el) return;
  const admin = !!(currentUser && currentUser.role === 'admin');
  el.hidden = !admin;
  if (!admin) return;
  const zeilen = (recurringTasks || [])
    .map((x) => {
      // In Bearbeitung: dieselben drei Felder wie beim Anlegen, plus Speichern
      // und Abbrechen. Vorher gab es das gar nicht -- ein Vertipper im Namen
      // oder der falsche Wochentag liessen sich nur durch Loeschen und
      // Neuanlegen beheben, und Loeschen nimmt die ganze Haken-Historie mit.
      if (_ownEdit === x.id) {
        return (
          '<div class="rhythm-own-edit" data-id="' +
          esc(String(x.id)) +
          '">' +
          _ownFieldsHtml('-edit', x) +
          '<button type="button" class="btn btn-sm btn-p" data-action="own-save" data-id="' +
          esc(String(x.id)) +
          '">' +
          esc(t('common.save')) +
          '</button><button type="button" class="btn btn-sm" data-action="own-cancel">' +
          esc(t('common.cancel')) +
          '</button></div>'
        );
      }
      return (
        '<div class="rhythm-own-row' +
        (x.active ? '' : ' ruht') +
        '"><span class="rhythm-own-name">' +
        esc(x.name) +
        '</span><span class="fs-xs rhythm-own-when">' +
        esc(
          recurEveryLabel(x.everyWeeks) +
            ' · ' +
            t('rhythm.day.' + new Date(x.anchor + 'T00:00:00').getDay()) +
            (x.active ? '' : ' · ' + t('recur.paused'))
        ) +
        '</span><button type="button" class="btn btn-sm fs-xs" data-action="own-edit" data-id="' +
        esc(String(x.id)) +
        '">' +
        esc(t('recur.edit')) +
        '</button><button type="button" class="btn btn-sm fs-xs" data-action="own-pause" data-id="' +
        esc(String(x.id)) +
        '">' +
        esc(t(x.active ? 'recur.pause' : 'recur.resume')) +
        '</button><button type="button" class="btn btn-sm fs-xs" data-action="own-del" data-id="' +
        esc(String(x.id)) +
        '">' +
        esc(t('recur.remove')) +
        '</button></div>'
      );
    })
    .join('');
  el.innerHTML =
    '<div class="fs-sm rhythm-own-head">' +
    esc(t('recur.title')) +
    '</div><div class="fs-xs rhythm-own-hint">' +
    esc(t('recur.hint')) +
    '</div>' +
    (zeilen || '<div class="fs-xs rhythm-own-hint">' + esc(t('recur.none')) + '</div>') +
    '<div class="rhythm-own-add">' +
    _ownFieldsHtml('', null) +
    '<button type="button" class="btn btn-sm btn-p" data-action="own-add">' +
    esc(t('recur.add')) +
    '</button></div>';
}
// Der Anker zu einem gewaehlten Wochentag: der naechste solche Tag, heute
// eingeschlossen. Damit ist er zugleich Wochentag und Phase des Takts -- und
// eine heute angelegte Aufgabe hat nicht rueckwirkend gefehlt.
//
// addDays() und nicht plus 864e5: mit festen Millisekunden landete eine am
// Samstag vor der Umstellung angelegte Montagsaufgabe auf einem Sonntag.
function _ownAnchorFor(weekday) {
  const heute = new Date();
  heute.setHours(0, 0, 0, 0);
  return _ymd(addDays(heute, (Number(weekday) - heute.getDay() + 7) % 7));
}
// Die drei Felder auslesen. suffix trennt die Zeile zum Anlegen von der zum
// Bearbeiten, die gleichzeitig im DOM stehen koennen.
function _ownRead(suffix) {
  const feld = (id) => document.getElementById(id + suffix);
  const name = ((feld('own-name') || {}).value || '').trim();
  const every = Number((feld('own-every') || {}).value) || 1;
  const wd = Number((feld('own-day') || {}).value);
  return { name, everyWeeks: every, anchor: _ownAnchorFor(wd) };
}
function _ownSpeichern(daten, fertig) {
  apiPost('/api/recurring-task', daten).then((res) => {
    if (!res || res.error) {
      toast((res && res.error) || t('recur.saveFailed'), 'err');
      return;
    }
    fertig(res);
    _renderRhythmOwn();
    renderDashBatchTasks();
  });
}
function addOwnTask() {
  const daten = _ownRead('');
  if (!daten.name) {
    setFb('err', t('recur.needName'));
    return;
  }
  _ownSpeichern(daten, (res) => {
    recurringTasks.push(Object.assign({ id: res.id, active: true, done: [], due: [] }, daten));
    setFb('ok', t('recur.added', { name: daten.name }));
  });
}
function saveOwnTask(id) {
  const daten = _ownRead('-edit');
  if (!daten.name) {
    setFb('err', t('recur.needName'));
    return;
  }
  const alt = (recurringTasks || []).find((x) => String(x.id) === String(id));
  _ownSpeichern(Object.assign({ id: Number(id), active: alt ? alt.active : true }, daten), () => {
    if (alt) Object.assign(alt, daten);
    _ownEdit = null;
    setFb('ok', t('recur.saved'));
  });
}
// Stilllegen statt loeschen: die Aufgabe verschwindet aus dem Plan, ihre
// Termine und Haken bleiben. Der uebliche Fall ist "gerade nicht", nicht "nie
// wieder", und nur fuer den zweiten gibt es Loeschen.
function pauseOwnTask(id) {
  const x = (recurringTasks || []).find((y) => String(y.id) === String(id));
  if (!x) return;
  _ownSpeichern({ id: Number(id), name: x.name, everyWeeks: x.everyWeeks, anchor: x.anchor, active: !x.active }, () => {
    x.active = !x.active;
  });
}
async function delOwnTask(id) {
  const x = (recurringTasks || []).find((y) => String(y.id) === String(id));
  const n = x && x.done ? x.done.length : 0;
  // Nachfragen, weil es die Haken mitnimmt und nichts es zurueckholt. Beim
  // Abhaken selbst ist eine Rueckfrage teurer als der Fehler -- ein zweiter
  // Tipp nimmt sie zurueck. Hier gibt es keinen zweiten Tipp.
  const frage = n ? t('recur.removeWithTicks', { name: (x && x.name) || '', n }) : t('recur.removeAsk', { name: (x && x.name) || '' });
  if (!(await askConfirm(t('recur.remove'), frage, t('recur.remove')))) return;
  apiDelete('/api/recurring-task/' + encodeURIComponent(id)).then((res) => {
    if (res && res.error) {
      toast(res.error, 'err');
      return;
    }
    const i = (recurringTasks || []).findIndex((y) => String(y.id) === String(id));
    if (i >= 0) recurringTasks.splice(i, 1);
    if (_ownEdit === Number(id)) _ownEdit = null;
    _renderRhythmOwn();
    renderDashBatchTasks();
  });
}

// Ein Tipp hakt ab, der naechste nimmt es zurueck. Der Server laesst den Haken
// nur auf einem Datum zu, an dem die Aufgabe wirklich faellt.
function setChoreDone(id, date, done) {
  apiPost('/api/recurring-done', { taskId: Number(id), date, done: !!done }).then((res) => {
    if (!res || res.error) {
      toast((res && res.error) || t('recur.saveFailed'), 'err');
      return;
    }
    const task = (recurringTasks || []).find((x) => String(x.id) === String(id));
    if (task) {
      task.done = task.done || [];
      const i = task.done.indexOf(date);
      if (done && i < 0) task.done.push(date);
      if (!done && i >= 0) task.done.splice(i, 1);
    }
    renderDashBatchTasks();
  });
}
function closeRhythmEditor() {
  const m = document.getElementById('m-rhythm');
  if (m) m.classList.remove('open');
  _rhythmDraft = null;
}
// Ab wann der Rhythmus mitzählt. Steht beim Bearbeiten der Ziele, weil es
// dieselbe Frage ist: was diese Anlage sich vornimmt, und ab wann.
function setRhythmStart() {
  const jetzt = (inventory && inventory.bagCountFrom) || '';
  prompt2(t('rhythm.startPrompt'), jetzt, function (raw) {
    if (raw === null || raw === undefined) return;
    const s = String(raw).trim();
    apiPost('/api/rhythm-start', { bagCountFrom: s || null }).then((res) => {
      if (res && res.error) {
        toast(res.error, 'err');
        return;
      }
      inventory.bagCountFrom = res && res.bagCountFrom !== undefined ? res.bagCountFrom : s || null;
      setFb('ok', t('rhythm.startSaved'));
      renderDashBatchTasks();
    });
  });
}
function saveRhythmEditor() {
  _rhythmSyncFromForm();
  if (!_rhythmDraft) return;
  const map = {};
  // 'free' is stored, not omitted: a day deliberately kept clear is a real
  // answer, and dropping it would look identical to never having decided —
  // which is what makes the editor offer a suggestion again.
  for (const d of WEEK_DAYS) {
    const e = _rhythmDraft[d] || {};
    map[d] =
      e.theme === 'free'
        ? { theme: 'free' }
        : { theme: e.theme || 'free', targetQty: e.targetQty, strainId: e.strainId, note: e.note };
  }
  apiPut('/api/week-rhythm', { rhythm: map }).then((res) => {
    if (res && res.error) {
      toast(res.error, 'err');
      return;
    }
    weekRhythm = map;
    closeRhythmEditor();
    setFb('ok', t('rhythm.saved'));
    renderDashBatchTasks();
  });
}
// Bags of this batch that are actually placed somewhere, plus the per-zone
// breakdown the row label needs. Returns counts rather than a formatted room so
// the (linear) zoneDisplayName lookup happens only for the rows actually shown.
function _dashTaskPlace(batchId, lastByBag) {
  const b = batchById(batchId);
  const counts = b ? _batchZoneCounts(b, lastByBag) : {};
  let bags = 0;
  for (const z in counts) bags += counts[z];
  return { bags, counts };
}
// Turns the "bags left behind" splits into rows shaped like every other row, so
// the section reads the same way: N bags of a batch, still one stage back, with
// the rest of the batch noted in the meta line.
function _dashLeftBehindRows(splits) {
  return splits.map((s) => {
    // behindStage / behindCount are already computed by getSplitBatches \u2014 do not
    // re-derive them, and never fabricate a fallback stage the batch is not in.
    const rest = s.stages
      .filter((x) => !x.behind)
      .map((x) => x.count + ' ' + t('dash.splitBatches.in') + ' ' + t('stage.' + x.role))
      .join(' \u00b7 ');
    return {
      batchId: s.batchId,
      species: s.species,
      bags: s.behindCount,
      instruction: t('dash.stillIn', { stage: t('stage.' + s.behindStage) }),
      where: rest ? '(' + rest + ')' : '',
      detail: s.urgent ? t('dash.splitBatches.stale') : '',
      // s.urgent means "unmoved for over 24h", which is a warning, not an overdue
      // date \u2014 it drives the orange dot and the amber stripe on .todo-row.warn.
      warn: s.urgent,
      taskAction: 'view',
      bucket: 'left'
    };
  });
}
// Where things are, on the screen the app opens on: one chip per zone with its
// bag count, and under the chosen one what is in it — a species with the day
// it went in and how long it has been there ("Blue Oyster, 4 Beutel, seit
// 30.09. · heute"), oldest first, because the bags that have been in longest
// are the ones to look at. The dates are the point of the card: how long a
// block has been fruiting is what the team works from. Batches and bag numbers
// fold away under each row.
//
// One zone at a time. Listing every zone with its rows ran every fruiting,
// spawn and incubation zone (a lot of bags) down the page and pushed the
// day's tasks off the phone. Fruiting zones first, then spawn run and incubation.
//
// Drawn with the day's tasks, so it refreshes whenever they do — which includes
// the 30-second tick, so the chosen zone and what someone unfolded are kept
// here rather than reset under their thumb. The zone also survives a reload.
const _wkTentFold = { open: new Set(), zone: null };
function _wkZoneList() {
  return fruitingZones().concat(zones.filter((z) => z.role === 'spawn' || z.role === 'incubation'));
}
function _wkZoneRowsHtml(z, bags) {
  const today = new Date();
  today.setHours(0, 0, 0, 0);
  const groups = new Map();
  for (const [bagId, d] of Object.entries(bags)) {
    const day = d.since ? new Date(d.since) : null;
    if (day) day.setHours(0, 0, 0, 0);
    const key = (d.species || '') + '|' + (day ? day.getTime() : '');
    if (!groups.has(key)) groups.set(key, { species: d.species || '—', day: day, batches: new Map() });
    const g = groups.get(key);
    if (!g.batches.has(d.batchId)) g.batches.set(d.batchId, []);
    g.batches.get(d.batchId).push(bagId);
  }
  return [...groups.values()]
    .sort((a, b) => (a.day ? a.day.getTime() : 0) - (b.day ? b.day.getTime() : 0) || a.species.localeCompare(b.species))
    .map((g) => {
      let n = 0;
      // A scan entry does not have to name its batch: the server takes one
      // without and stores an empty one as none, which MCP's scan tool lets
      // through. Its bags land here under a null key, and localeCompare on
      // that threw. This card is drawn before the day's tasks, so the tasks
      // went down with it.
      const detail = [...g.batches.entries()]
        .sort((a, b) => String(a[0] || '').localeCompare(String(b[0] || '')))
        .map(([bid, ids]) => {
          n += ids.length;
          const nums = ids
            .map((id) => id.split('-').pop())
            .sort((a, b) => (parseInt(a) || 0) - (parseInt(b) || 0))
            .join(', ');
          return '<div><span class="wk-tent-batch">' + esc(bid || '—') + '</span> ' + esc(nums) + '</div>';
        })
        .join('');
      let when = '';
      if (g.day) {
        const days = Math.round((today - g.day) / 864e5);
        when =
          t('work.tentSince', { date: fmtDtShort(g.day) }) +
          ' · ' +
          (days <= 0 ? t('work.tentToday') : tp('work.tentDays', days));
      }
      const rk = z.id + '|' + g.species + '|' + (g.day ? g.day.getTime() : '');
      return (
        '<details class="wk-tent-row" data-fold="' +
        esc(rk) +
        '"' +
        (_wkTentFold.open.has(rk) ? ' open' : '') +
        '><summary>' +
        '<span class="wk-tent-sp">' +
        esc(g.species) +
        '</span><span class="wk-tent-n">' +
        esc(tp('dash.bags', n)) +
        '</span>' +
        (when ? '<span class="wk-tent-when">' + esc(when) + '</span>' : '') +
        '</summary><div class="wk-tent-detail">' +
        detail +
        '</div></details>'
      );
    })
    .join('');
}
function renderWorkTents() {
  const card = document.getElementById('wk-tents');
  if (!card) return;
  const list = _wkZoneList();
  card.hidden = !list.length;
  if (!list.length) return;
  const bagsBy = {};
  for (const z of list) bagsBy[z.id] = getZoneBags(z.id);
  if (_wkTentFold.zone === null) {
    try {
      _wkTentFold.zone = localStorage.getItem('mp-work-zone') || '';
    } catch (_) {
      _wkTentFold.zone = '';
    }
  }
  // The remembered zone if it still exists; otherwise the first tent with bags
  // in it, since an empty tent is the least useful thing to open on.
  let sel = list.find((z) => z.id === _wkTentFold.zone);
  if (!sel) sel = list.find((z) => z.role === 'fruiting' && Object.keys(bagsBy[z.id]).length) || list[0];
  const chips = list
    .map((z) => {
      const on = z.id === sel.id;
      return (
        '<button type="button" class="wk-zchip" data-wk-zone="' +
        esc(z.id) +
        '" aria-pressed="' +
        on +
        '"><span class="zone-dot" style="background:' +
        esc(z.color || ZONE_ROLE_COLOR[z.role] || ZONE_ROLE_COLOR.fruiting) +
        '"></span><span class="wk-zchip-name">' +
        esc(zoneDisplayName(z.id)) +
        '</span><span class="wk-zchip-n">' +
        Object.keys(bagsBy[z.id]).length +
        '</span></button>'
      );
    })
    .join('');
  const rows = _wkZoneRowsHtml(sel, bagsBy[sel.id]);
  const box = document.getElementById('wk-tents-list');
  box.innerHTML =
    '<div class="wk-zchips" role="group" aria-label="' +
    esc(t('work.tentsTitle')) +
    '">' +
    chips +
    '</div><div class="wk-zone-rows">' +
    (rows || '<div class="wk-tent-empty">' + esc(t('work.tentEmpty')) + '</div>') +
    '</div>';
  if (!box.dataset.bound) {
    box.dataset.bound = '1';
    box.addEventListener('click', (ev) => {
      const chip = ev.target.closest('[data-wk-zone]');
      if (!chip) return;
      _wkTentFold.zone = chip.dataset.wkZone;
      try {
        localStorage.setItem('mp-work-zone', _wkTentFold.zone);
      } catch (_) {
        /* the choice just lasts until the page reloads */
      }
      renderWorkTents();
    });
    // toggle does not bubble; capture catches it for every <details> in the box.
    box.addEventListener(
      'toggle',
      (ev) => {
        const d = ev.target;
        if (d.dataset && d.dataset.fold) _wkTentFold.open[d.open ? 'add' : 'delete'](d.dataset.fold);
      },
      true
    );
  }
}
// Today in one line, above the task list: "Heute: 3 Umziehen · 2 Ernten". The
// list itself folds away behind it, so the start screen shows the tiles, where
// things are and what today asks for without scrolling; a tap opens the week.
// Open or closed is remembered per device.
//
// The strip above the tiles only appears when something is wrong: work that is
// overdue, or a zone past its capacity. On a normal day it takes no room.
let _wkTasksOpen = null;
function _wkTasksAreOpen() {
  if (_wkTasksOpen === null) {
    try {
      _wkTasksOpen = localStorage.getItem('mp-work-tasks-open') === '1';
    } catch (_) {
      _wkTasksOpen = false;
    }
  }
  return _wkTasksOpen;
}
function setWorkTasksOpen(open) {
  _wkTasksOpen = !!open;
  try {
    localStorage.setItem('mp-work-tasks-open', open ? '1' : '0');
  } catch (_) {
    /* kept for this session only */
  }
  const card = document.getElementById('dash-batch-tasks-card');
  if (card) card.classList.toggle('wk-tasks-closed', !open);
  const btn = document.getElementById('wk-today');
  if (btn) btn.setAttribute('aria-expanded', open ? 'true' : 'false');
}
function renderWorkSummary(week) {
  const todayItems = (week && week[0] ? week[0].items : []).filter((it) => !it.done);
  const counts = countByCategory(todayItems);
  const overdue = todayItems.reduce((n, i) => n + planOverdue(i), 0);
  const sum = document.getElementById('wk-today-sum');
  if (sum) {
    const parts = PLAN_CATS.filter((c) => counts[c]).map((c) => counts[c] + ' ' + t(PLAN_CAT_LABEL[c]));
    sum.textContent = parts.length ? parts.join(' · ') : t('work.todayNone');
  }
  setWorkTasksOpen(_wkTasksAreOpen());
  const btn = document.getElementById('wk-today');
  if (btn && !btn.dataset.bound) {
    btn.dataset.bound = '1';
    btn.addEventListener('click', () => setWorkTasksOpen(!_wkTasksAreOpen()));
  }
  const alert = document.getElementById('wk-alert');
  if (!alert) return;
  if (!alert.dataset.bound) {
    alert.dataset.bound = '1';
    alert.addEventListener('click', () => {
      setWorkTasksOpen(true);
      const card = document.getElementById('dash-batch-tasks-card');
      if (card) card.scrollIntoView({ behavior: 'smooth', block: 'start' });
    });
  }
  const msgs = [];
  if (overdue) msgs.push(t('cat.overdue', { n: overdue }));
  for (const z of zones) {
    if (!z.maxCapacity) continue;
    const n = Object.keys(getZoneBags(z.id)).length;
    if (n > z.maxCapacity) msgs.push(t('work.alertFull', { zone: zoneDisplayName(z.id), n: n, cap: z.maxCapacity }));
  }
  alert.hidden = !msgs.length;
  alert.textContent = msgs.length ? '⚠ ' + msgs.join(' · ') : '';
}
function renderDashBatchTasks() {
  renderWorkTents();
  const el = document.getElementById('dash-batch-tasks');
  if (!el) return;
  const week = buildWeekPlan();
  renderWorkSummary(week);
  const anyWork = week.some((d) => d.items.length);
  const hasRhythm = Object.keys(weekRhythm).length > 0;
  if (!anyWork && !hasRhythm) {
    el.innerHTML =
      _dashViewToggleHtml(_dashDayOnly) +
      '<div class="empty fs-sm" style="padding:12px;text-align:center;color:var(--c-text-muted)">' +
      esc(t('dash.noUrgent')) +
      '</div>' +
      _rhythmEditLink();
    return;
  }
  const sel = _dashDayOffset >= 0 && _dashDayOffset < 7 ? _dashDayOffset : 0;
  // Drei Reihen: die Woche, und darunter der Tag.
  //
  // Der Arbeitszettel des gewaehlten Tages stand in dessen Spalte -- und eine
  // Spalte ist ein Siebtel der Karte, also rund 170px. Auf dem Telefon fiel das
  // nicht auf, weil die Spalte dort ueber die ganze Breite geht; am Rechner
  // wurde derselbe Zettel in 170px gepresst. Ergebnis: "Black..." statt der
  // Sorte, "0,0 von 10,0" ueber drei Zeilen und ein Knopf, der breiter war als
  // die Spalte, die ihn hielt.
  //
  // Der Streifen oben ist die Woche auf einen Blick. Der Tag, an dem gearbeitet
  // wird, braucht die ganze Breite und bekommt sie darunter -- an jedem Schirm
  // dieselbe Anordnung, statt zweier Layouts, von denen eines nie geprueft war.
  const nurTag = _dashDayOnly;
  el.innerHTML =
    _dashViewToggleHtml(nurTag) +
    '<div class="wk' +
    (nurTag ? ' day-only' : '') +
    '">' +
    (nurTag
      ? _dayNavHtml(week, sel)
      : week.map((d, i) => _weekHeadHtml(d, i, i === sel)).join('') +
        week.map((d, i) => _weekColBodyHtml(d, i, i === sel)).join('')) +
    '<div class="wk-open">' +
    _weekDayBodyHtml(week[sel], sel, sel === 0) +
    '</div></div>' +
    _rhythmEditLink();
}
// Woche oder Tag.
//
// Sieben Spalten sind eine Uebersicht und ein Kompromiss: jede einzelne ist ein
// Siebtel breit, und was darin steht, muss klein sein. Wer den Tag arbeitet,
// braucht die Uebersicht gerade nicht -- also gibt es sie auf Wunsch nicht, und
// der Tag bekommt die ganze Karte samt groesserer Schrift.
//
// Kein "besseres" von beiden. Am Montagmorgen will man die Woche sehen, um halb
// vier will man wissen, was noch offen ist.
function _dashViewToggleHtml(nurTag) {
  const knopf = (tag, label) =>
    '<button type="button" class="wk-view-btn' +
    (nurTag === tag ? ' sel' : '') +
    '" data-action="dash-view" data-day="' +
    (tag ? '1' : '0') +
    '" aria-pressed="' +
    (nurTag === tag) +
    '">' +
    esc(t(label)) +
    '</button>';
  return '<div class="wk-view">' + knopf(false, 'dash.viewWeek') + knopf(true, 'dash.viewDay') + '</div>';
}
// Ohne den Streifen braucht der Tag einen anderen Weg zum naechsten Tag.
function _dayNavHtml(week, sel) {
  const d = week[sel];
  const th = themeFor(d.weekday);
  const titel =
    t('rhythm.day.' + d.weekday) +
    ', ' +
    d.date.toLocaleDateString(loc(), { day: 'numeric', month: 'long' }) +
    (th.theme && th.theme !== 'free' ? ' · ' + weekThemeLabel(th.theme) : '');
  const pfeil = (ziel, zeichen, label, aus) =>
    '<button type="button" class="btn btn-sm wk-daynav-btn" data-action="dash-day" data-off="' +
    ziel +
    '"' +
    (aus ? ' disabled' : '') +
    ' aria-label="' +
    esc(t(label)) +
    '">' +
    zeichen +
    '</button>';
  return (
    '<div class="wk-daynav">' +
    pfeil(sel - 1, '&#8249;', 'dash.dayPrev', sel <= 0) +
    '<span class="wk-daynav-t fs-sm">' +
    esc(titel) +
    '</span>' +
    pfeil(sel + 1, '&#8250;', 'dash.dayNext', sel >= 6) +
    '</div>'
  );
}
function _weekHeadHtml(d, off, sel) {
  const isToday = off === 0;
  const th = themeFor(d.weekday);
  const task = rhythmTaskOn(d.date);
  // The number is the day's own load: what the rhythm asks for if it asks for
  // anything, otherwise how much generated work landed on it.
  const n = task && task.targetQty ? task.targetQty : d.items.reduce((k, it) => k + planWeight(it), 0);
  const short = th.theme && th.theme !== 'free' ? weekThemeLabel(th.theme) : '';
  // Weekday label over a big day number — the same shape as the month and week
  // calendars (.cal-week-hdr-cell), because this strip is read as a calendar.
  // It used to put the day's *load* in that slot, so a busy day read as "the
  // 40th" and a day with no load showed a bare "·" and looked undated.
  //
  // The app's own weekday label rather than the locale's, so the strip and the
  // rhythm editor call Sunday the same thing.
  const dayName = t('rhythm.day.' + d.weekday);
  // Load and theme share the foot line: how much work, and what kind. The count
  // keeps its weight so the week is still scannable by load, but it no longer
  // sits where a date belongs. Empty stays a blank line rather than a "·" — a
  // quiet day is not missing data — but the line is held open with a nbsp so
  // the seven columns keep the same height.
  const nHtml = n ? '<span style="font-weight:700;color:var(--c-text-sec)">' + n + '</span>' : '';
  // Die Vorgabezahl stand zweimal übereinander: hier im Kopf und 20px darunter
  // im Spaltenkörper, wo sie zusätzlich bearbeitbar ist.
  //
  // Weg kann sie nur an einer Stelle, und welche das ist, hängt von der Breite
  // ab: auf breitem Schirm sind alle sieben Körper sichtbar, also trägt dort
  // der Körper die Zahl und der Kopf nur das Thema. Auf dem Telefon zeigt von
  // sechs Tagen nur der Kopf etwas (.wk-b { display: none }), also muss sie
  // dort im Kopf stehen. Das entscheidet .wk-h-t in styles.css, nicht dieser
  // Zweig — eine Bedingung auf die Auswahl hin würde die Zahl beim Tagwechsel
  // springen lassen.
  //
  // Nur für die Vorgabezahl. Wo n die Anzahl der Arbeitszeilen ist, wiederholt
  // der Körper sie nirgends, und sie bleibt auf jedem Schirm stehen.
  // Ein Punkt, wenn an diesem Tag eine eigene Aufgabe faellt.
  //
  // Unter 769px ist der Spaltenkoerper ausgeblendet, und die benannte Aufgabe
  // mit ihrem Haken steckt dort drin. Von sechs der sieben Tage sah man also
  // nur den Kopf, dessen Zahl sich zwar bewegte, aber nicht verriet, dass
  // etwas Eigenes dahintersteht. Getippt wird auf dem Telefon.
  const eigene = d.items.some((it) => it && it.kind === 'chore') ? '<span class="wk-h-own"></span>' : '';
  const foot =
    (task && task.targetQty
      ? '<span class="wk-h-t">' + nHtml + (short ? ' · ' : '') + '</span>' + (short ? esc(short) : '&nbsp;')
      : [nHtml, short ? esc(short) : ''].filter(Boolean).join(' · ')) + eigene;
  return (
    '<button type="button" role="tab" data-action="dash-day" data-off="' +
    off +
    '" aria-selected="' +
    sel +
    '" class="wk-h' +
    (sel ? ' sel' : '') +
    '" style="--col:' +
    (off + 1) +
    '" title="' +
    esc(
      d.date.toLocaleDateString(loc(), { weekday: 'long', day: 'numeric', month: 'long' }) +
        (short ? ' · ' + short : '')
    ) +
    '">' +
    // Today is the dark green, not the accent. The accent is the brand mid-tone
    // and it is the right fill behind white — but as 9.5px and 13px text on the
    // toolbar it reads 3.3:1, under the 4.5 small text needs. --c-green-dark is
    // 7.1:1, and it is the same move the sheet already makes for coloured text
    // everywhere else: mid tone fills, the -dark variant is what you read.
    '<span class="fs-floor" style="--fs-own:9.5px;display:block;font-weight:' +
    (isToday ? '700' : '600') +
    ';color:' +
    (isToday ? 'var(--c-green-dark)' : 'var(--c-text-sec)') +
    ';overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
    esc(dayName) +
    '</span>' +
    // The date, never conditional and never a placeholder — it is the one thing
    // a day column always has.
    '<span class="fs-sm" style="display:block;font-weight:700;letter-spacing:-0.3px;color:' +
    (isToday || sel ? 'var(--c-green-dark)' : 'var(--c-text)') +
    '">' +
    d.date.getDate() +
    '</span>' +
    // Clipped rather than wrapped: a wrapped word would push the columns to
    // different heights and the strip would stop reading as a row.
    '<span class="fs-floor" style="--fs-own:9px;display:block;color:var(--c-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
    (foot || '&nbsp;') +
    '</span></button>'
  );
}
// One column's work. Narrow by design — on a wide screen this is a seventh of
// the card, so rows are stripped to the batch and its count, with the detail
// on the open day only.
// Eine Spalte der Wochenuebersicht. Immer die Vorschau, auch fuer den
// gewaehlten Tag: was der Tag verlangt, steht ausfuehrlich darunter in
// .wk-open, und zweimal dasselbe nebeneinander waere nur laenger. Die Toenung
// sagt weiterhin, welcher Tag offen ist.
function _weekColBodyHtml(d, off, sel) {
  return (
    '<div class="wk-b' + (sel ? ' sel' : '') + '" style="--col:' + (off + 1) + '">' + _weekColPreviewHtml(d, sel) + '</div>'
  );
}
// What a row actually asks you to do, which is not the same as what it is. A
// colonised grain jar and a rhythm target both mean "make blocks today", so
// they belong together even though one is a batch and the other is a plan.
// Die Reihenfolge hier ist die Reihenfolge auf dem Schirm; rank() unten
// entscheidet nur, wer die sechs Zeilen überlebt. Beides muss stimmen, sonst
// steht ein Hinweis zwar in der Liste, aber unter dem Rundgang.
// In der Reihenfolge, in der die Kette laeuft: was fehlt, dann das Labor, dann
// die Chargen, dann umziehen und ernten.
//
// 'lab' war vorher mit 'create' zusammen unter "Ansetzen". Darunter standen
// dann "5 Sorten unter Labor-Minimum" und "Blue Oyster -- Koernerbrut
// ansetzen" nebeneinander: zwei Arbeiten, die in verschiedenen Raeumen
// stattfinden, unter einer Ueberschrift, die keine von beiden benennt.
//
// Koernerbrut bleibt bei den Chargen, nicht beim Labor: sie ist eine Charge
// (batchType 'grain'), und wer Bloecke ansetzt, setzt auch die Koerner an.
const PLAN_CATS = ['alert', 'lab', 'create', 'move', 'harvest', 'chore', 'other'];
const PLAN_CAT_LABEL = {
  alert: 'cat.alert',
  lab: 'cat.lab',
  create: 'cat.create',
  move: 'cat.move',
  harvest: 'cat.harvest',
  chore: 'recur.cat',
  other: 'rhythm.other'
};
const PLAN_CAT_COLOR = {
  alert: 'var(--c-red-dark)',
  lab: 'var(--c-teal-dark)',
  create: 'var(--c-accent)',
  move: 'var(--c-blue-dark, var(--c-accent))',
  harvest: 'var(--c-amber-dark)',
  chore: 'var(--c-purple-dark)',
  other: 'var(--c-text-muted)'
};
// Was eine Zeilenart ist, an einer Stelle.
//
// Es gab vier Leitern über dieselben neun Arten: planCategory() für die
// Reihenfolge auf dem Schirm, rank() für die über die Klappe, todayProgress()
// für den Nenner des Fortschrittsbalkens und _planBtn() für den Knopf. Eine
// neue Art hieß: vier Stellen ändern, und jede vergessene schweigt.
//
// Genau das ist passiert. 'labgroup' kam in drei der vier an und nicht in
// rank(), fiel damit auf 999 und wurde als Erstes von der Sechs-Zeilen-Klappe
// verdeckt — die Zusammenfassung, die eigens dafür erfunden war, dass die
// Klappe den Rundgang nicht frisst. Nichts hat gemeckert.
//
// Eine Zeile je Art, vier Spalten:
//
//   cat     wohin auf dem Schirm (PLAN_CATS gibt die Reihenfolge)
//   rank    wer die Klappe überlebt; kleiner ist weiter vorn, null heißt
//           "nach dem Rundgang einsortieren, nach Zone"
//   counts  zählt im Fortschrittsbalken mit
//   btn     welcher Knopf rechts steht ('' = der allgemeine "Ansehen")
//
// counts:false für alles Abgeleitete: solche Zeilen verschwinden, wenn sich der
// Bestand ändert, nie durch Abhaken. Sie in den Nenner zu nehmen hieße, einen
// fertigen Tag als 5/8 zu zeigen.
// Die Zeilen einer Zusammenfassung. Sie stehen in task.rows, und wie viele es
// sind, ist die einzige Zahl, die sie ueber sich selbst hinaus vertritt.
const _labRows = (it) => (it && it.task && it.task.rows) || [];
const PLAN_KINDS = {
  alert: { cat: 'alert', rank: -10, counts: false, btn: 'alert' },
  supply: { cat: 'create', rank: -1, counts: false, btn: 'supply' },
  labmin: { cat: 'lab', rank: -1, counts: false, btn: 'labmin' },
  // weight/late stehen hier und nicht an der Zeile.
  //
  // Sie lagen als Felder auf dem Eintrag, den buildWeekPlan() schreibt, und
  // planWeight() nahm 1 fuer alles, was sie vergass. Die naechste
  // zusammenfassende Art haette damit still wieder "1 Labor" statt 10 gezaehlt
  // -- derselbe Fehler, denselben Weg. In der Tabelle prueft ihn der Test mit,
  // der ohnehin jede Art gegen jede Spalte haelt.
  //
  // Aufgeklappt null: dann stehen die Einzelzeilen selbst daneben, und beides
  // zu zaehlen ergaebe das Doppelte.
  labgroup: {
    cat: 'lab',
    rank: -1,
    counts: false,
    btn: 'labgroup',
    weight: (it) => (dashLabGroupOpen ? 0 : _labRows(it).length),
    late: (it) => (dashLabGroupOpen ? 0 : _labRows(it).filter((l) => l.empty).length)
  },
  grain: { cat: 'create', rank: null, counts: true, btn: 'task' },
  fruiting: { cat: 'move', rank: null, counts: true, btn: 'task' },
  harvest: { cat: 'harvest', rank: null, counts: true, btn: 'harvest' },
  manual: { cat: 'other', rank: null, counts: true, btn: 'manual' },
  // Eine eigene Aufgabe der Anlage.
  //
  // Eigene Kategorie, nicht 'other': "Sonstiges" ist kein Name fuer "Growrooms
  // putzen", und ueber einer Zeile, die man abhaken soll, stand genau das.
  //
  // rank -0.5 -- vor dem Rundgang, hinter den abgeleiteten Zeilen. Sie hat
  // keine Zone, fiele sonst auf 999 und waere als Erstes von der
  // Sechs-Zeilen-Klappe verdeckt. Sie ist aber die einzige Zeile des Tages, an
  // die nichts anderes erinnert: eine Charge fehlt spaeter im Bestand, ein
  // ungeputzter Raum faellt niemandem auf.
  //
  // counts:true, denn sie ist Arbeit, die abgehakt wird; todayProgress() zaehlt
  // den Haken auf der Gegenseite mit, sonst wuechse nur der Nenner.
  chore: { cat: 'chore', rank: -0.5, counts: true, btn: 'chore' },
  left: { cat: 'other', rank: null, counts: true, btn: '' }
};
function planKind(it) {
  return (it && PLAN_KINDS[it.kind]) || null;
}
function planCategory(it) {
  const k = planKind(it);
  return k ? k.cat : 'other';
}
// Fuer wie viele Arbeiten eine Zeile steht. Fast immer fuer sich selbst -- nur
// die Labor-Zusammenfassung vertritt viele, und dann muss die Zahl daneben ihre
// und nicht ihre eigene sein.
function planWeight(it) {
  const k = planKind(it);
  const n = k && k.weight ? k.weight(it) : 1;
  return Number.isFinite(n) ? n : 1;
}
// Und wie viele davon zu spaet sind. Bei der Zusammenfassung sind das nicht
// alle, nur weil eine es ist.
function planOverdue(it) {
  if (!it) return 0;
  const k = planKind(it);
  if (k && k.late) {
    const n = k.late(it);
    return Number.isFinite(n) ? n : 0;
  }
  return it.overdue ? planWeight(it) : 0;
}
// Gezaehlt wird Arbeit, nicht Zeilen. Der Unterschied ist genau die
// Zusammenfassung: eine Zeile, die 10 vertritt, hat als "1" gezaehlt, und die
// Spalte sagte damit aus, wie viel gerade gezeichnet ist statt wie viel ansteht.
function countByCategory(items) {
  const c = {};
  for (const it of items) c[planCategory(it)] = (c[planCategory(it)] || 0) + planWeight(it);
  return c;
}
// A column's work at a glance: what, and how much. No actions — this is for
// reading the week; the day you want to act on is one click away.
//
// Counts per category rather than a list of ids. In a 170px column four
// truncated batch ids say almost nothing; "3 Umziehen · 2 Ernten" says what the
// day is. The ids are in the open day, where there is room for them.
// The one control for changing what a day asks for, used everywhere the amount
// is shown. Carries its affordance with it: a dashed underline and a pencil, so
// it reads as something you can change rather than a number somebody decided.
function _rhythmTargetBtn(date, target, label) {
  return (
    '<button type="button" data-action="rhythm-target" data-date="' +
    esc(date) +
    '" data-target="' +
    target +
    '" title="' +
    esc(t('rhythm.targetEdit')) +
    '" style="display:block;max-width:100%;text-align:left;border:0;background:none;padding:0;cursor:pointer;font-family:inherit;font-size:inherit;font-weight:600;color:inherit;' +
    'border-bottom:1px dashed var(--c-text-muted);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
    esc(label) +
    ' <span aria-hidden="true" style="color:var(--c-text-muted);font-weight:400">✎</span></button>'
  );
}
// Eine eigene Aufgabe in der schmalen Wochenspalte: Haken, Name, fertig.
//
// Der ganze Chip ist der Knopf. Ein getrennter Haken daneben brauchte in 170px
// Breite Platz, den der Name dann nicht mehr haette -- und es gibt hier ohnehin
// nur eine Sache zu tun.
function _choreChipHtml(it) {
  const k = it.task || {};
  return (
    '<button type="button" class="wk-chore' +
    (k.done ? ' done' : '') +
    (it.overdue ? ' late' : '') +
    '" data-action="chore-done" data-task="' +
    esc(String(k.id)) +
    '" data-date="' +
    esc(k.date || '') +
    '" data-done="' +
    (k.done ? '1' : '0') +
    '" title="' +
    esc(it.label + ' · ' + (it.detail || '')) +
    '"><span class="wk-chore-box" aria-hidden="true">' +
    (k.done ? '&#10003;' : '') +
    '</span><span class="wk-chore-name">' +
    esc(it.label) +
    '</span></button>'
  );
}
function _weekColPreviewHtml(d, offen) {
  const task = rhythmTaskOn(d.date);
  let html = '';
  // The amount is editable on every day it appears, not only the open one. It
  // used to be plain text here and a borderless button there, so it read as a
  // fixed number in both places — an edit nobody can find is the same as no
  // edit at all.
  if (task && task.targetQty) {
    const ms = task.strainId ? mushroomStrains.find((m) => m.id === task.strainId) : null;
    html +=
      '<div style="padding:3px 2px;border-left:2px solid var(--c-accent);margin-bottom:3px">' +
      _rhythmTargetBtn(task.date, task.targetQty, task.targetQty + (ms ? '× ' + ms.name : '')) +
      '</div>';
  } else if (rhythmOf(d.weekday) && rhythmOf(d.weekday).theme && rhythmOf(d.weekday).theme !== 'free') {
    // A themed day with no amount yet still needs a way in, or the first number
    // can only ever be set through the recurring editor.
    //
    // rhythmOf(), nicht themeFor(): themeFor() faellt auf den GESCHAETZTEN
    // Rhythmus zurueck, solange nichts gespeichert ist. Der Knopf erschien also
    // auf einer frischen Anlage, und der Dialog dahinter las rhythmOf() -- fand
    // nichts, sperrte das Planfeld mit der Begruendung "nur Admins aendern das"
    // (einem Admin gegenueber), und das Speichern endete in "No rhythm on".
    // Ein Knopf gehoert nur dorthin, wo er auch etwas bewirkt.
    html +=
      '<div style="padding:3px 2px;margin-bottom:3px">' +
      _rhythmTargetBtn(_ymd(d.date), 0, t('rhythm.setQty')) +
      '</div>';
  }
  if (!d.items.length && !html) {
    return '<div class="fs-micro" style="padding:3px 2px;color:var(--c-text-muted)">' + esc(t('rhythm.nothing')) + '</div>';
  }
  // Eigene Aufgaben stehen mit Namen da, nicht als Zahl in einer Kategorie.
  //
  // Die Zaehlung ist richtig fuer Chargen und Umzuege: vier abgeschnittene
  // Chargennummern sagen in 170px weniger als "3 Umziehen". Bei einer eigenen
  // Aufgabe ist es umgekehrt -- ihr Name IST die ganze Auskunft, und "1
  // Sonstiges" sagt gar nichts. Es sind wenige, sie passen.
  //
  // Und anklickbar, weil der Haken der ganze Umgang mit dieser Zeile ist. Der
  // Satz "keine Knoepfe, die Spalte ist zum Lesen" gilt fuer eine Charge, die
  // man erst ansehen muss; hier waere der Umweg ueber den geoeffneten Tag ein
  // Umweg um einen einzigen Tipp herum.
  const aufgaben = d.items.filter((it) => it.kind === 'chore');
  for (const c of aufgaben) html += _choreChipHtml(c);
  const rest = d.items.filter((it) => it.kind !== 'chore');
  const counts = countByCategory(rest);
  const overdue = rest.reduce((n, i) => n + planOverdue(i), 0);
  // Die Zaehlung ist ein Knopf, und er oeffnet den Tag.
  //
  // Vorher war sie totes Papier: "4 Achtung, 4 Ansetzen, 5 ueberfaellig" stand
  // da, man tippte darauf, und nichts geschah. Ein Kasten mit Zahlen darin sieht
  // aus wie etwas, das man aufklappen kann -- und genau das soll er auch tun.
  //
  // Ein einziger Knopf um alle Zeilen, nicht einer je Zeile: sie fuehren alle
  // an dieselbe Stelle, und drei Knoepfe untereinander, die dasselbe tun, sind
  // drei Entscheidungen, wo es keine gibt. Ausserhalb der eigenen Aufgaben, die
  // ihren eigenen Haken haben -- ein Knopf im Knopf geht nicht.
  let zeilen = '';
  for (const cat of PLAN_CATS) {
    if (!counts[cat]) continue;
    zeilen +=
      '<span class="wk-count" style="border-left-color:' +
      PLAN_CAT_COLOR[cat] +
      '"><span class="wk-count-n">' +
      counts[cat] +
      '</span><span class="wk-count-t">' +
      esc(t(PLAN_CAT_LABEL[cat])) +
      '</span></span>';
  }
  // Late work is the one thing that should pull the eye across the week.
  if (overdue) {
    zeilen += '<span class="wk-count-late">' + esc(t('cat.overdue', { n: overdue })) + '</span>';
  }
  if (zeilen) {
    // Ein Knopf nur, solange es noch etwas zu oeffnen gibt.
    //
    // Der offene Tag steht ausfuehrlich unter dem Streifen; seine Zaehlung dort
    // anzutippen hiess, ihn ein zweites Mal zu oeffnen -- ein Neuaufbau, der
    // exakt dasselbe zeichnete. Wieder ein Feld, das gedrueckt wird und nichts
    // tut, nur diesmal, weil es schon getan war.
    //
    // Stehen bleibt die Zaehlung trotzdem: ohne sie waere die Spalte des
    // gearbeiteten Tages die einzige leere in der Woche.
    html += offen
      ? '<div class="wk-counts fs-xs is-open">' + zeilen + '</div>'
      : '<button type="button" class="wk-counts fs-xs" data-action="dash-day" data-off="' +
        d.offset +
        '" title="' +
        esc(t('dash.openDay')) +
        '">' +
        zeilen +
        '</button>';
  }
  return html;
}
// The open day, flat and dense. The room is a label on the row rather than a
// heading of its own — the headings were most of the old view's height, and the
// rows are still ordered by the walk, so the list reads as a route without
// costing a line per room. Expanding shows the rest of the same list.
function _weekDayBodyHtml(d, off, isToday) {
  let html = '<div style="padding:2px 0 8px 4px">';
  const mix = rhythmMixText(d.weekday);
  const r = rhythmOf(d.weekday);
  // The column strip is too narrow to say a theme is only a guess, so the open
  // day says it. An unconfirmed suggestion must never read as a decision.
  const th = themeFor(d.weekday);
  const bits = [th.suggested && th.theme ? weekThemeLabel(th.theme) + ' (' + t('rhythm.guess') + ')' : '', mix, r && r.note];
  const line = bits.filter(Boolean).join(' · ');
  if (line) html += '<div class="fs-floor" style="--fs-own:10.5px;color:var(--c-text-muted);margin:0 0 5px">' + esc(line) + '</div>';
  // The day's own planned job, and — on today only — whatever earlier days
  // still owe. Arrears belong on today because that is when they can be done.
  const own = rhythmTaskOn(d.date);
  if (own) html += _rhythmTaskRowHtml(own, 0);
  if (isToday) for (const late of rhythmArrears(d.date)) html += _rhythmTaskRowHtml(late, late.outstanding);
  if (isToday) {
    const prog = todayProgress(d.items);
    if (prog.total) {
      const pct = Math.round((prog.done / prog.total) * 100);
      html +=
        '<div style="display:flex;align-items:center;gap:6px;margin:0 0 6px">' +
        '<div style="flex:1;height:4px;border-radius:2px;background:var(--c-border);overflow:hidden">' +
        '<div style="width:' +
        pct +
        '%;height:100%;background:var(--action-color,var(--c-accent))"></div></div>' +
        '<span class="fs-xs" style="color:var(--c-text-muted);flex-shrink:0">' +
        prog.done +
        '/' +
        prog.total +
        '</span></div>';
    }
  }
  if (!d.items.length) {
    return html + '<div class="fs-floor" style="--fs-own:11.5px;color:var(--c-text-muted)">' + esc(t('rhythm.nothing')) + '</div></div>';
  }
  html += _fruitingTargetHtml(d.items);

  // Ordered by the walk, so the flat list still reads as a route.
  const order = {};
  zones.forEach((z, i) => (order[z.id] = typeof z.sortOrder === 'number' ? z.sortOrder : i));
  // A supply gap and a breached lab floor carry no zone, so the walking order
  // had nothing to place them by and sorted them to the end — behind a fold
  // that is collapsed by default, on exactly the busy days they matter most.
  // They are not stops on the walk; they are what to start before setting off.
  // So they go first, and the six-row cap below can no longer reach past them.
  // Aus PLAN_KINDS, nicht aus einer eigenen Leiter. Eine Art mit rank null
  // sortiert sich nach dem Rundgang ein, also nach ihrer Zone; die Hinweise
  // tragen noch ihren eigenen Rang, damit Bestand vor Kapazität steht.
  const rank = (it) => {
    const k = planKind(it);
    if (k && k.rank != null) return k.rank + (it.kind === 'alert' ? (it.task && it.task.rang) || 0 : 0);
    return it.zone && order[it.zone] != null ? order[it.zone] : 999;
  };
  const items = [...d.items].sort((a, b) => rank(a) - rank(b));
  const openKey = 'day' + off;
  const full = !!_dashRoomOpen[openKey];
  const shown = full ? items : items.slice(0, DASH_DAY_CAP);
  // Grouped by what you would be doing, in the order the day runs: make blocks,
  // move what is ready, harvest what is out. Within a category the rows keep
  // their walking order, so the route survives the grouping.
  let lastCat = '';
  for (const it of PLAN_CATS.flatMap((c) => shown.filter((x) => planCategory(x) === c))) {
    const cat = planCategory(it);
    if (cat !== lastCat) {
      lastCat = cat;
      html +=
        '<div class="fs-floor" style="--fs-own:12px;display:flex;align-items:baseline;gap:5px;font-weight:600;color:var(--c-text-sec);margin:7px 0 2px">' +
        '<span style="width:6px;height:6px;border-radius:50%;background:' +
        PLAN_CAT_COLOR[cat] +
        ';flex-shrink:0"></span>' +
        esc(t(PLAN_CAT_LABEL[cat])) +
        '</div>';
    }
    html += _dashPlanRowHtml(it, true);
  }
  const hidden = items.length - shown.length;
  if (hidden > 0 || full) {
    html +=
      '<button type="button" class="fs-floor" data-action="dash-room-more" data-room="' +
      esc(openKey) +
      '" aria-expanded="' +
      full +
      '" style="--fs-own:11.5px;border:0;background:none;padding:3px 0;cursor:pointer;font-family:inherit;color:var(--c-text-sec)">' +
      esc(hidden > 0 ? '+ ' + t('dash.moreRows', { n: hidden }) : '− ' + t('dash.fewerRows')) +
      '</button>';
  }
  return html + '</div>';
}
// A planned job as a row you can act on: what was asked for, how much of it is
// done, and a button to record the rest. `outstanding` is set for a job carried
// over from an earlier day, which is shown by its date rather than pretending
// it belongs to today.
function _rhythmTaskRowHtml(task, outstanding) {
  const ms = task.strainId ? mushroomStrains.find((m) => m.id === task.strainId) : null;
  // Gezählt, nicht gemeldet. Ein geplanter Tag hat noch nichts, worauf man
  // zählen könnte. rhythmArrears() hat die Zahl für rückständige Tage schon
  // ermittelt und legt sie in doneQty ab; sie hier ein zweites Mal zu holen war
  // reine Wiederholung.
  const done = task.planned ? 0 : task.doneQty != null ? task.doneQty : rhythmMadeOn(task.date, task.theme);
  const target = task.targetQty || 0;
  const late = outstanding > 0;
  const label = (ms ? target + '× ' + ms.name : String(target)) + ' · ' + weekThemeLabel(task.theme);
  const meta = late
    ? t('rhythm.carriedFrom', { date: fmtDt(task.date), n: outstanding })
    : done
      ? t('rhythm.done', { done, total: target })
      : task.planned
        ? t('rhythm.planned')
        : t('rhythm.done', { done: 0, total: target });
  return (
    // The other .todo-row producer says `urgent` and gets the red stripe; this
    // one was left behind when the colour moved to the state. It was still
    // writing a species colour into --sp-color, which no rule has read since
    // that change, so a carried-over task drew the default grey stripe while
    // the identical row in the task list drew red. Same class, same question,
    // same answer now.
    '<div class="todo-row' +
    (late ? ' urgent' : '') +
    '" style="display:flex;align-items:center;gap:8px;padding:4px 0">' +
    // The amount is the thing that changes week to week, so it is the thing you
    // can tap. Editing it here changes this date only — the recurring rhythm is
    // the usual amount, and one busy Monday must not rewrite every Monday after.
    '<div class="fs-sm" style="flex:1;min-width:0">' +
    _rhythmTargetBtn(task.date, target, label) +
    '<div class="fs-xs" style="color:' +
    (late ? 'var(--c-red-dark)' : 'var(--c-text-muted)') +
    '">' +
    esc(meta) +
    '</div></div>' +
    // Kein Erfassen-Knopf mehr: die Zahl kommt aus dem, was angelegt wurde.
    // Stimmt sie nicht, ist die Charge nicht angelegt — und das ist die
    // Stelle, an der man das repariert, nicht hier.
    '</div>'
  );
}
// Was ein Tag verlangt: die Regel und die Ausnahme, an einer Stelle.
//
// Hier stand eine nackte Abfrage — "Wie viele am TT.MM.?" — und ein Feld. Wer
// 20 eintippte, bekam nirgends gesagt, dass er damit eine Ausnahme von den 10
// des Wochenrhythmus setzte; im Kalender standen danach zwei Zahlen, und keine
// sagte, welche die Regel war. Zwei Zahlen ohne Beschriftung sind keine zwei
// Ebenen, sondern ein Widerspruch.
//
// Also beide untereinander, jede benannt, und ihre Summe darunter:
//
//   Wochenplan             10   gilt für jeden Montag
//   Extra nur diese Woche  10   Ausnahme nur für den TT.MM.
//   ────────────────────────────────────────────────────
//   Macht 20 am TT.MM.
//
// Gespeichert wird weiterhin eine Zahl je Datum, nämlich die Summe. Das Extra
// ist eine Art, sie einzugeben, kein zweiter Wert, der irgendwo mitgeführt und
// irgendwann von der ersten abweichen könnte.
let _dayQty = null;
function editRhythmTarget(date, target) {
  if (!date) return;
  const m = document.getElementById('m-dayqty');
  if (!m) return;
  const wd = new Date(date + 'T00:00:00').getDay();
  const tpl = rhythmOf(wd) || {};
  const themed = !!(tpl.theme && tpl.theme !== 'free');
  const plan = tpl.targetQty || 0;
  const ist = Number.isFinite(target) ? target : plan;
  // Den Wochenplan ändert nur ein Admin — er gilt fortan für jeden dieser
  // Wochentage. Die Ausnahme für eine Woche setzt, wer die Woche arbeitet.
  // Dieselbe Grenze zieht der Server zwischen /api/week-rhythm und
  // /api/rhythm-task; sie hier nicht zu ziehen hiesse, ein Feld anzubieten,
  // dessen Speichern dann mit 403 fehlschlägt.
  const darfPlan = themed && !!(currentUser && currentUser.role === 'admin');
  _dayQty = { date, weekday: wd, plan, theme: tpl.theme || '', darfPlan };

  const tag = t('rhythm.day.' + wd);
  document.getElementById('dayqty-title').textContent = fmtDt(date);
  const sub = document.getElementById('dayqty-sub');
  sub.textContent = themed ? weekThemeLabel(tpl.theme) : '';
  sub.hidden = !sub.textContent;

  const fPlan = document.getElementById('dayqty-plan');
  fPlan.value = plan ? String(plan) : '';
  fPlan.disabled = !darfPlan;
  document.getElementById('dayqty-plan-hint').textContent = darfPlan
    ? t('dayqty.planHint', { day: tag })
    : t('dayqty.planLocked', { day: tag });

  // Die Differenz, nicht die gespeicherte Zahl: 0 heisst "wie immer", und
  // genau das soll dastehen, solange niemand eine Ausnahme gemacht hat.
  const fExtra = document.getElementById('dayqty-extra');
  fExtra.value = ist - plan === 0 ? '' : String(ist - plan);
  document.getElementById('dayqty-extra-hint').textContent = t('dayqty.extraHint', { date: fmtDt(date) });

  _renderDayQtySum();
  m.classList.add('open');
  setTimeout(() => fExtra.focus(), 80);
}
function _dayQtyValues() {
  const zahl = (id) => {
    const el = document.getElementById(id);
    const s = el ? String(el.value).trim() : '';
    if (s === '') return 0;
    const n = Number(s);
    return Number.isFinite(n) ? Math.trunc(n) : 0;
  };
  // Ist das Feld gesperrt, gilt der gespeicherte Plan — nicht der Feldwert, den
  // ein deaktiviertes Feld zwar zeigt, aber niemand ändern durfte.
  const plan = Math.max(0, _dayQty && !_dayQty.darfPlan ? _dayQty.plan : zahl('dayqty-plan'));
  const extra = zahl('dayqty-extra');
  return { plan, extra, gesamt: Math.max(0, plan + extra) };
}
function _renderDayQtySum() {
  const el = document.getElementById('dayqty-sum');
  if (!el || !_dayQty) return;
  el.textContent = t('dayqty.sum', { n: _dayQtyValues().gesamt, date: fmtDt(_dayQty.date) });
}
function closeDayQty() {
  const m = document.getElementById('m-dayqty');
  if (m) m.classList.remove('open');
  _dayQty = null;
}
// Die Menge eines Wochentags ändern — und nur die.
//
// Vorher baute das hier die ganze Woche aus `weekRhythm` neu zusammen und
// schickte sie an eine Route, die die Tabelle leert und neu füllt. Die sechs
// unberührten Tage kamen dabei aus dem Abbild, das dieser Browser zuletzt
// gesehen hatte: hatte inzwischen jemand anderes den Donnerstag geändert, war
// diese Änderung nach dem Speichern eines Montags fort. Ein Fenster, das eine
// einzige Zahl zeigt, schrieb sieben Tage.
function _saveWeekdayPlan(weekday, qty) {
  return apiPost('/api/week-rhythm-day', { weekday, targetQty: qty }).then((res) => {
    if (res && !res.error) {
      const e = rhythmOf(weekday);
      if (e) weekRhythm[weekday] = Object.assign({}, e, { targetQty: qty || null });
    }
    return res;
  });
}
function saveDayQty() {
  if (!_dayQty) return;
  const { plan, gesamt } = _dayQtyValues();
  const date = _dayQty.date;
  const weekday = _dayQty.weekday;
  const planGeaendert = _dayQty.darfPlan && plan !== _dayQty.plan;
  // Beide Zahlen prüfen, bevor irgendetwas geschrieben wird.
  //
  // Es sind zwei abhängige Schreibvorgänge: erst die Regel, dann die Ausnahme.
  // Scheiterte der zweite an einer Zahl, die der Server ablehnt, war der erste
  // längst gespeichert — der Wochenplan für jeden künftigen Montag stand auf
  // dem neuen Wert, die Meldung sprach nur vom Tag, und nichts sagte, dass die
  // Regel sich geändert hatte. Die Grenzen sind dieselben, die der Server
  // zieht, also lässt sich das hier entscheiden, bevor etwas passiert.
  for (const n of [plan, gesamt]) {
    if (!Number.isInteger(n) || n < 0 || n > 100000) {
      setFb('err', t('dayqty.bad'));
      return;
    }
  }
  // Erst die Regel, dann die Ausnahme. Der Server prüft die Ausnahme gegen die
  // Vorlage, und das muss die neue sein — sonst bliebe ein Tag als Ausnahme
  // stehen, der der eben gesetzten Regel exakt entspricht.
  (planGeaendert ? _saveWeekdayPlan(weekday, plan) : Promise.resolve(null)).then((res) => {
    if (res && res.error) {
      toast(res.error, 'err');
      return;
    }
    apiPost('/api/rhythm-task', { date, targetQty: gesamt }).then((r) => {
      if (r && r.error) {
        // Ist die Regel schon geschrieben, muss die Meldung das sagen. Sonst
        // liest sich ein halb gelungener Speichervorgang wie ein misslungener.
        toast(planGeaendert ? t('dayqty.planOnly', { err: r.error }) : r.error, 'err');
        if (planGeaendert) renderDashBatchTasks();
        return;
      }
      // Der Tag folgt wieder der Vorlage: der Server hat die eigene Zeile
      // gelöscht, also muss sie auch hier weg, sonst verdeckt eine Zeile, die
      // es nicht mehr gibt, weiterhin den Rhythmus.
      if (r && r.followsRhythm) {
        const i = rhythmTasks.findIndex((x) => x.date === date);
        if (i >= 0) rhythmTasks.splice(i, 1);
      } else {
        const row = rhythmTasks.find((x) => x.date === date);
        if (row) row.targetQty = gesamt || null;
        // A future date had no row until now; the server just made one, and the
        // next load will bring it. Re-render from what we know meanwhile.
        else {
          // Mit dem Thema des Wochentags, nicht mit ''. rhythmTaskOn() zieht eine
          // gespeicherte Zeile der Vorlage vor, also verdeckte der leere Platzhalter
          // das echte Thema: rhythmMadeOn(date, '') trifft keinen Zweig und gibt 0
          // zurück, und der Tag las "0 / 10" über 10 gemachten Blöcken. Der Server
          // setzt es beim Anlegen genauso aus week_rhythm.
          const tpl = rhythmOf(weekday) || {};
          rhythmTasks.push({
            date,
            weekday,
            theme: tpl.theme || '',
            strainId: tpl.strainId || null,
            targetQty: gesamt || null,
            doneQty: 0
          });
        }
      }
      closeDayQty();
      setFb('ok', t(r && r.followsRhythm ? 'rhythm.targetFollows' : 'rhythm.targetSaved'));
      renderDashBatchTasks();
    });
  });
}
function _rhythmEditLink() {
  return (
    '<div style="margin-top:8px;padding-top:8px;border-top:0.5px solid var(--c-border)">' +
    '<button class="fs-xs" type="button" data-action="edit-rhythm" style="border:0;background:none;padding:0;cursor:pointer;font-family:inherit;color:var(--c-text-sec)">' +
    esc(t('rhythm.edit')) +
    '</button></div>'
  );
}
// withRoom folds the room into the row's meta line. The flat day list has no
// room headings — they were most of its height — so the row has to say where
// to walk, or the list stops being a route.
function _dashPlanRowHtml(it, withRoom) {
  const btn = _planBtn(it);
  const room = withRoom && it.zone ? zoneDisplayName(it.zone) : '';
  const meta = [room, it.bags ? tp('dash.bags', it.bags) : '', it.detail].filter(Boolean).join(' · ');
  return (
    // The left edge carries the species colour, as it did before the redesign —
    // it is how a row is recognised at a glance without reading the id. Overdue
    // still overrides it: being late outranks knowing which mushroom it is.
    // Auch hier: der Streifen sagt den Zustand, die Sorte steht im Text.
    '<div class="todo-row' +
    (it.overdue ? ' urgent' : '') +
    '" style="display:flex;align-items:center;gap:8px;padding:4px 0">' +
    '<div style="flex:1;min-width:0">' +
    // fs-sm, nicht fs-meta. Das ist der Satz, der sagt, was zu tun ist; er
    // stand auf 12px am Rechner, zwischen einem 11px-Zusatz und einer
    // 10px-Ueberschrift, und war damit die kleinste Schrift auf dem Schirm fuer
    // die wichtigste Zeile darauf.
    '<div class="fs-sm" style="overflow:hidden;text-overflow:ellipsis;white-space:nowrap">' +
    esc(it.label) +
    '</div>' +
    (meta ? '<div class="fs-xs" style="color:var(--c-text-muted)">' + esc(meta) + '</div>' : '') +
    '</div>' +
    btn +
    '</div>'
  );
}
// Which tent today's moves are heading for, stated once above the rows and
// switchable. Only shown when something on the day can actually move there, and
// never on a day that also holds grain rows — naming a tent beside grain invites
// sending it there, which skips a growth stage.
function _fruitingTargetHtml(items) {
  const dest = fruitingTarget();
  const movable = items.filter((x) => x.kind === 'fruiting' && x.ready);
  const hasGrain = items.some((x) => x.kind === 'grain');
  if (!dest || hasGrain || !movable.length) return '';
  const tents = fruitingZones();
  let incoming = 0;
  for (const m of movable) incoming += m.bags || 0;
  const fill = fruitingFill(dest, incoming);
  const warn =
    fill && fill.over
      ? '<div class="fs-floor" style="--fs-own:10.5px;color:var(--c-red-dark);margin-bottom:4px">⚠ ' +
        esc(t('dash.destFull', { zone: zoneDisplayName(dest), n: fill.used + fill.incoming, cap: fill.cap })) +
        '</div>'
      : '';
  if (tents.length < 2) {
    return (
      '<div class="fs-floor" style="--fs-own:10.5px;color:var(--c-text-muted);margin:6px 0 2px">→ ' +
      esc(zoneDisplayName(dest)) +
      (fill ? ' ' + fill.used + '/' + fill.cap : '') +
      '</div>' +
      warn
    );
  }
  // Wraps rather than scrolls: four tents overflow a phone, and a tent pushed
  // off-screen is a tent nobody picks.
  const chips = tents
    .map((z) => {
      const on = z.id === dest;
      const zf = z.maxCapacity ? fruitingFill(z.id, on ? incoming : 0) : null;
      return (
        '<button type="button" class="fs-floor" data-action="dash-dest" data-zone="' +
        esc(z.id) +
        '" aria-pressed="' +
        on +
        '" title="' +
        esc(z.name) +
        '" style="--fs-own:10.5px;flex:0 0 auto;max-width:150px;overflow:hidden;text-overflow:ellipsis;white-space:nowrap;padding:3px 8px;border-radius:11px;cursor:pointer;font-family:inherit;border:1px solid ' +
        (on ? 'var(--c-accent)' : 'var(--c-border)') +
        ';background:' +
        (on ? 'var(--c-accent)' : 'transparent') +
        ';color:' +
        (on ? '#fff' : 'var(--c-text-sec)') +
        '">' +
        esc(z.name) +
        (zf ? '<span style="opacity:.75"> ' + zf.used + '/' + zf.cap + '</span>' : '') +
        '</button>'
      );
    })
    .join('');
  return (
    '<div style="display:flex;flex-wrap:wrap;align-items:center;gap:6px;margin:6px 0 2px">' +
    '<span class="fs-floor" style="--fs-own:10.5px;color:var(--c-text-muted);flex-shrink:0">' +
    esc(t('dash.destLabel')) +
    '</span>' +
    '<span role="group" aria-label="' +
    esc(t('dash.destLabel')) +
    '" style="display:flex;flex-wrap:wrap;gap:4px;min-width:0">' +
    chips +
    '</span>' +
    _bulkPillHtml(movable) +
    '</div>' +
    warn
  );
}
// "Alle → Fruchtung" for today, kept from the old card. Only when there is more
// than one, and only on today: a one-tap that moves a whole backlog is undoable
// for eight seconds and no longer. bulkSectionToFruiting('today') already sweeps
// overdue in with today, which is exactly how the week plan buckets them.
function _bulkPillHtml(movable) {
  if (movable.length < 2) return '';
  return (
    '<button type="button" class="btn btn-sm btn-p fs-xs" data-action="bulk-fruiting" data-bucket="today" ' +
    'style="padding:3px 10px;white-space:nowrap;flex-shrink:0;margin-left:auto">' +
    esc(t('dash.bulkFruiting')) +
    '</button>'
  );
}
// Each kind keeps the button it already had elsewhere on the dashboard, rather
// than a new one invented for this card. Batch work goes through dashTaskBtn so
// its guards travel with it; a harvest opens the batch where the flush is
// logged; a manual task toggles done.
// Der Knopf einer Zeile, aus der Tabelle statt aus einer Leiter.
//
// PLAN_KINDS traegt eine Spalte `btn`, und die Erklaerung darueber behauptet
// seit ihrer Einfuehrung, sie ersetze die vierte der vier parallelen Leitern.
// Sie tat es nicht: nichts las sie je, _planBtn() verzweigte weiter selbst
// ueber it.kind, und eine neue Art mit gesetztem btn bekam still den
// allgemeinen "Ansehen"-Knopf. Eine Attrappe, die autoritativ aussah.
//
// Jetzt ist sie ein Schluessel in diese Tabelle. Wer eine Art hinzufuegt und
// den Bauer vergisst, faellt im Test auf, der beide Seiten gegeneinander haelt.
const PLAN_BTNS = {
  alert: (it) => {
    const a = it.task || {};
    const ziel = a.attentionKey
      ? 'data-action="go-attention" data-key="' + esc(a.attentionKey) + '"'
      : 'data-action="go-page" data-page="' + esc(a.goPage || '') + '" data-btn="' + esc(a.goBtn || '') + '"';
    return (
      '<button class="btn btn-sm fs-xs" ' + ziel + ' style="padding:3px 10px;flex-shrink:0">' + esc(t('dash.view')) + '</button>'
    );
  },
  // Ein Tipp, und ein zweiter nimmt ihn zurueck. Keine Rueckfrage: die
  // Bestaetigung waere teurer als der Fehler, den sie verhindert.
  chore: (it) => {
    const k = it.task || {};
    return (
      '<button class="btn btn-sm fs-xs' +
      (k.done ? '' : ' btn-p') +
      '" data-action="chore-done" data-task="' +
      esc(String(k.id)) +
      '" data-date="' +
      esc(k.date || '') +
      '" data-done="' +
      (k.done ? '1' : '0') +
      '" style="padding:3px 10px;flex-shrink:0">' +
      esc(t(k.done ? 'recur.undo' : 'recur.tick')) +
      '</button>'
    );
  },
  labgroup: () =>
    '<button class="btn btn-sm fs-xs" data-action="labgroup-toggle" style="padding:3px 10px;flex-shrink:0">' +
    esc(t(dashLabGroupOpen ? 'todo.labGroupClose' : 'todo.labGroupOpen')) +
    '</button>',
  labmin: (it) =>
    '<button class="btn btn-sm btn-p fs-xs" data-action="labmin-make" data-strain="' +
    esc(String((it.task && it.task.strainId) || '')) +
    '" style="padding:3px 10px;flex-shrink:0">' +
    esc(t('np.go')) +
    '</button>',
  // Koerner zuerst, wenn keine da sind -- aus nichts lassen sich keine Bloecke
  // machen. Beide Knoepfe tragen den SCHLUESSEL der Sorte, nie ihren Namen:
  // _strainByKey() trifft 'id:3' und 'n:shiitake' und sonst nichts.
  supply: (it) => {
    const grain = it.task && it.task.taskAction === 'make-grain';
    return (
      '<button class="btn btn-sm btn-p fs-xs" data-action="' +
      (grain ? 'supply-make-grain' : 'supply-make-batch') +
      '" data-sorte="' +
      esc((it.task && it.task.key) || '') +
      '" style="padding:3px 10px;flex-shrink:0">' +
      esc(t(grain ? 'todo.makeGrain' : 'todo.makeBatch')) +
      '</button>'
    );
  },
  task: (it) => (it.task ? dashTaskBtn(it.task) : ''),
  // Die Zeile sagt "Ernte erfassen", also erfasst der Knopf eine Ernte. Vorher
  // sprang er nur zur Charge -- eine Stelle, an der Knopf und Arbeit
  // auseinanderliefen.
  harvest: (it) =>
    '<button class="btn btn-sm fs-xs" data-action="harvest-batch" data-batch="' +
    esc(it.batchId || '') +
    '" style="padding:3px 10px;flex-shrink:0;background:var(--c-amber-light);color:var(--c-amber-dark);border-color:var(--c-amber-border)">' +
    esc(t('harvest.logHarvest')) +
    '</button>',
  manual: (it) =>
    '<button class="btn btn-sm fs-xs" data-action="toggle-task" data-id="' +
    esc(String(it.taskId || '')) +
    '" style="padding:3px 10px;flex-shrink:0">' +
    esc(t('calDetail.markDone')) +
    '</button>',
  // Der allgemeine Weg: ansehen. Auch fuer eine Art, die die Tabelle nicht
  // kennt -- lieber ein Knopf, der zur Charge fuehrt, als gar keiner.
  '': (it) =>
    '<button class="btn btn-sm fs-xs" data-action="go-to-batch" data-batch="' +
    esc(it.batchId || '') +
    '" style="padding:3px 10px;flex-shrink:0">' +
    esc(t('dash.view')) +
    '</button>'
};
function _planBtn(it) {
  const k = planKind(it);
  const bau = PLAN_BTNS[(k && k.btn) || ''];
  return (bau || PLAN_BTNS[''])(it);
}
// One-tap: move every incubation-ready batch in one urgency section to fruiting.
// Confirms once, then reuses the same moveBatchTo path as the per-row button.
// Sections run most-urgent-first, and a batch can only ever become MORE urgent
// while the card sits on screen. So a tap is honoured for its own section or any
// more urgent one: without this, a pill rendered at 23:50 on "Heute" matched
// nothing at 00:05, because buildAutoTasks had re-bucketed those batches as
// "overdue" \u2014 and the button did nothing at all, with no confirm and no error.
function _bucketRank(key) {
  const i = DASH_SECTIONS.indexOf(key);
  return i < 0 ? 99 : i;
}
// One-tap: move every incubation-ready batch in one urgency section to fruiting.
// Confirms once, then reuses the same moveBatchTo path as the per-row button.
function bulkSectionToFruiting(bucket) {
  const dest = fruitingTarget();
  if (!dest) {
    setFb('err', t('dash.noFruitingZone'));
    return;
  }
  const lastByBag = buildLastScanByBag();
  const targets = [];
  let bags = 0;
  const rank = _bucketRank(bucket);
  buildAutoTasks()
    .filter((tk) => tk.taskAction === 'move' && tk.ready && _bucketRank(tk.bucket) <= rank)
    .forEach((tk) => {
      const b = batchById(tk.batchId);
      if (!b) return;
      if (getStatus(tk.batchId).status !== 'INCUBATING') return;
      targets.push(b);
      bags += _dashTaskPlace(tk.batchId, lastByBag).bags;
    });
  if (!targets.length) {
    // Say so rather than looking broken: the data moved on under the button.
    flashUndoBar(t('dash.nothingToMove'));
    renderDashBatchTasks();
    return;
  }
  confirm2(
    t('dash.bulkFruitingTitle'),
    t('dash.bulkFruitingMsg', { n: bags, zone: t('dash.sec.' + bucket), dest: zoneDisplayName(dest) }),
    t('dash.move'),
    () => {
      // moveBatchTo moves each target's ENTIRE bag set, which is what the "N
      // Beutel" on the section header now counts too — the section is a set of
      // whole batches, not a room. snap records every bag that actually moves,
      // so Undo restores them all exactly.
      const snap = _snapshotBeforeMove(targets, dest, buildLastScanByBag());
      let moved = 0;
      targets.forEach((b) => moveBatchTo(b, dest, (m) => (moved += m || 0)));
      updateSD();
      renderBatches();
      renderStatus();
      renderDashBatchTasks();
      showUndoBar(t('dash.bulkFruitingDone', { n: moved, dest: zoneDisplayName(dest) }), () => _undoMove(snap));
    }
  );
}
// Colonised grain → make blocks from it. Opens the same quick-create dialog as
// the dashboard's "Neue Charge" with this grain's Sorte preselected, so the
// recipe is already right. The grain itself is then picked under "Beimpft mit":
// that list is per bag, not per batch, so a multi-bag grain batch has no single
// bag we could honestly preselect — the worker scans the one they opened.
function inoculateFromBatch(batchId) {
  const b = batches.find((x) => x.batchId === batchId);
  const ms = b && b.strainId ? mushroomStrains.find((x) => x.id === b.strainId) : null;
  if (ms && ms.recBatchType) msQuickOpen('charge', ms);
  else msQuickChargeNew();
}
// Collapsible dashboard reference sections (KPIs / Live status / Lab). No saved
// choice → open on desktop, collapsed on phones (less scrolling); each toggle
// is remembered per section under mp-dash-collapse.
function initDashCollapse() {
  const read = () => {
    try {
      return JSON.parse(localStorage.getItem('mp-dash-collapse') || '{}') || {};
    } catch (e) {
      return {};
    }
  };
  const store = read();
  const desktop = window.matchMedia('(min-width: 769px)').matches;
  ['dc-kpi', 'dc-status', 'dc-lab'].forEach((id) => {
    const d = document.getElementById(id);
    if (!d) return;
    const initial = store[id] === undefined ? desktop : store[id] === 'open';
    d.open = initial;
    // Track the believed state so the toggle fired by the initial open= set above
    // (desktop first load) isn't mistaken for a user choice and persisted — that
    // would leak the desktop default onto a later phone visit.
    let last = initial;
    d.addEventListener('toggle', () => {
      if (d.open === last) return;
      last = d.open;
      const cur = read();
      cur[id] = d.open ? 'open' : 'closed';
      localStorage.setItem('mp-dash-collapse', JSON.stringify(cur));
    });
  });
}

// Attention filter: temporarily restrict the batches list to a subset (due today, overdue, ...)
// Set by dashboard View buttons; cleared by a banner in the batches list.
let batchAttentionFilter = null; // { pred: (batch) => boolean, label: string } | null

const BATCH_ATTENTION_PRESETS = {
  dueToday: {
    labelKey: 'alert.filterDueToday',
    pred: (b) => {
      const { status } = getStatus(b.batchId);
      // FRUITING/CONTAM are tracked elsewhere
      // (Ready-to-harvest / Contamination reports), not as due-today work.
      if (['DONE', 'EMPTY', 'FRUITING', 'CONTAM'].includes(status)) return false;
      const today = new Date();
      today.setHours(0, 0, 0, 0);
      const due = new Date(b.due);
      due.setHours(0, 0, 0, 0);
      const dl = Math.round((due - today) / 864e5);
      return dl <= 0;
    }
  },
  overdue: {
    labelKey: 'alert.filterOverdue',
    pred: (b) => {
      const { status } = getStatus(b.batchId);
      if (['DONE', 'EMPTY', 'FRUITING', 'CONTAM'].includes(status)) return false;
      return isBatchOverdue(b);
    }
  }
};

function goToBatchesAttention(key) {
  const preset = BATCH_ATTENTION_PRESETS[key];
  if (!preset) return;
  batchAttentionFilter = { pred: preset.pred, label: t(preset.labelKey) };
  // Das Archiv zeigt nichts Überfälliges; der Filter gilt der laufenden Liste.
  _slStand(SL_CHARGEN).archiv = false;
  go('batch', 'n-batch');
  openStab('batch', 'list');
}

function clearBatchAttentionFilter() {
  batchAttentionFilter = null;
  renderBatches();
}

function renderBatchAttentionBanner() {
  const card = document.getElementById('sp-batch-list')?.querySelector('.card');
  if (!card) return;
  let banner = document.getElementById('batch-attention-banner');
  if (!batchAttentionFilter) {
    banner?.remove();
    return;
  }
  if (!banner) {
    banner = document.createElement('div');
    banner.id = 'batch-attention-banner';
    banner.className = 'fs-meta';
    banner.style.cssText =
      'display:flex;align-items:center;gap:8px;padding:6px 10px;margin-bottom:8px;background:#fed7aa;border-left:4px solid #ea580c;border-radius:6px;color:#7c2d12;font-weight:500';
    card.insertBefore(banner, card.firstChild);
  }
  banner.innerHTML =
    `<div style="flex:1">${esc(batchAttentionFilter.label)}</div>` +
    `<button class="btn btn-sm fs-xs" data-action="clear-attention" style="padding:2px 8px;background:var(--c-amber-strong);color:#fff;border-color:transparent">${t('alert.filterShowAll')}</button>`;
}

// Zu einer Charge: ihre Sorte steht offen, die Zeile blinkt kurz. Körnerbrut
// liegt im Labor, alles andere unter Chargen.
function goToBatch(batchId) {
  batchAttentionFilter = null;
  const b = batches.find((x) => x.batchId === batchId);
  if (b && b.batchType === 'grain') {
    go('lab', 'n-lab');
    openStab('lab', 'grain');
    slZeige(SL_KOERNER, b);
  } else {
    go('batch', 'n-batch');
    openStab('batch', 'list');
    if (b) slZeige(SL_CHARGEN, b);
    else renderBatches();
  }
  setTimeout(() => {
    const row = document.querySelector('[data-find="batch:' + CSS.escape(batchId) + '"]');
    if (row) {
      row.scrollIntoView({ behavior: 'smooth', block: 'center' });
      row.classList.add('batch-row-flash');
      setTimeout(() => row.classList.remove('batch-row-flash'), 1500);
    }
  }, 80);
}

// ─── DASHBOARD READY-TO-HARVEST ─────────────────────────────
// Fruiting batches live here (not in Batch tasks) so they don't crowd out
// Move/Discard urgency — fruiting can stretch over weeks/flushes.
function buildHarvestTasks() {
  const today = new Date();
  today.setHours(0, 0, 0, 0);
  // Placement entries only (ADD/MOVE/REMOVE): a HARVEST entry must not be read
  // as "this bag left the tent" \u2014 logging a flush does not move anything.
  const lastByBag = buildLastPlacementByBag();
  const isFruitingZone = (loc) => {
    const z = ZONE_BY_ID[toZone(loc)];
    return !!(z && z.role === 'fruiting');
  };
  return batches
    .filter((b) => getStatus(b.batchId).status === 'FRUITING')
    .map((b) => {
      const zoneCounts = {};
      let activeBags = 0,
        bagsInTent = 0,
        enteredTent = null;
      b.bags.forEach((bag) => {
        const last = lastByBag.get(bag.toUpperCase());
        if (!last || last.action === 'REMOVE' || !last.to || isContamLoc(last.to)) return;
        activeBags++;
        const z = toZone(last.to);
        zoneCounts[z] = (zoneCounts[z] || 0) + 1;
        if (!isFruitingZone(last.to)) return;
        bagsInTent++;
        // The placement entry that put this bag where it now is IS its arrival
        // in the tent. The oldest such arrival is when this batch started
        // fruiting \u2014 which is what "days in the tent" should mean. The previous
        // code used the incubation due date instead, so the figure drifted by
        // however early or late the move happened (which can be days either way)
        // and clamped to 0 for anything moved in ahead of its due date.
        if (!enteredTent || last.time < enteredTent) enteredTent = last.time;
      });
      const zoneIds = Object.keys(zoneCounts).sort((a, z) => zoneCounts[z] - zoneCounts[a]);
      const zoneLabel = zoneIds.length ? zoneIds.map((z) => zoneDisplayName(z)).join(', ') : '\u2014';
      const harvTotal = harvests.filter((h) => h.batch === b.batchId).reduce((s, h) => s + (h.grams || 0), 0);
      let daysInTent = 0;
      if (enteredTent) {
        const t0 = new Date(enteredTent);
        t0.setHours(0, 0, 0, 0);
        daysInTent = Math.max(0, Math.round((today - t0) / 864e5));
      }
      // Expected tent time comes from the Sorte's recipe, read live rather than
      // frozen onto the batch, so batches already fruiting get a target too.
      // 0 / no recipe \u2192 no target, just show the elapsed days.
      const ms = b.strainId ? mushroomStrains.find((x) => x.id === b.strainId) : null;
      const target = ms && ms.recFruitDays > 0 ? ms.recFruitDays : 0;
      return {
        batchId: b.batchId,
        species: b.species,
        strain: b.strain,
        activeBags,
        bagsInTent,
        elsewhere: activeBags - bagsInTent,
        zoneLabel,
        // Already computed for the label; exposed so the day plan can group a
        // harvest under the room you actually walk to rather than re-deriving it.
        zoneIds,
        daysInTent,
        target,
        remaining: target ? target - daysInTent : null,
        harvTotal
      };
    })
    .filter((t) => t.bagsInTent > 0)
    .sort((a, z) => {
      // Most overdue first; batches without a target fall to the end, oldest
      // first, so they still read as a sensible list rather than random order.
      if (a.target && z.target) return a.remaining - z.remaining;
      if (a.target) return -1;
      if (z.target) return 1;
      return z.daysInTent - a.daysInTent;
    });
}

// ─── DASHBOARD LAB STOCK ────────────────────────────────────
// G2G steht nicht mehr darunter. Korn-zu-Korn ist kein eigener Bestand, den
// man zählt — es ist eine Herkunft: die neue Körnerbrut wird aus einer alten
// angesetzt, und was dabei entsteht, ist eine Körner-Charge wie jede andere.
// Als Kulturtyp hatte es nie einen Datensatz erzeugt; die Auswahl im Labor-
// formular endete in einem Fehler-Toast, der auf die Scan-Leiste verwies.
const LAB_TYPES = ['MC', 'PD', 'LC', 'GS', 'SY'];
// The types a Sorte can carry a minimum for. G2G and SY are made to order
// from the others, so a standing floor for them would ask for stock nobody
// keeps.
const MIN_TYPES = ['GS', 'LC', 'MC', 'PD'];
// MC has been the slant all along — the German interface has said "Slants" for as
// long as it has existed while the English said "Mother cultures", so a screenshot
// in one language named something you could not find in the other.
const LAB_LABELS = {
  MC: 'Slants',
  PD: 'Petri dishes',
  LC: 'Liquid cultures',
  G2G: 'G2G',
  GS: null,
  SY: 'Liquid syringes',
  DU: 'Dowels'
};
function getLabLabel(type) {
  if (type === 'GS') return t('lab.gsLabel');
  return LAB_LABELS[type] || type;
}
function getLabStockCounts() {
  const counts = { MC: 0, PD: 0, LC: 0, G2G: 0, GS: 0, SY: 0 };
  cultures
    .filter((c) => c.status === 'active')
    .forEach((c) => {
      if (counts[c.type] !== undefined) counts[c.type]++;
    });
  // Grain spawn in KILOGRAMS, from the one function that weighs it.
  //
  // This counted bags, and the card then ran that count through fmtKg() under a
  // "kg" label — so the headline read a bag count as kg above per-Sorte rows summing
  // to far more, and renderThresholds measured bags against a kilogram floor. Bags are
  // not a unit anybody stocks in: min_spawn_kg is kilograms, the Sorten tile is
  // kilograms, and now so is this.
  batches.filter((b) => b.batchType === 'grain').forEach((b) => (counts.GS += _grainKgOf(b)));
  return counts;
}
// Which Sorten the lab has to hold stock for.
//
// This used to read "every Sorte with a live batch", which is circular in the
// one case that matters: a Sorte that has run out has no live batch, so it fell
// off this list and its zero-stock row disappeared at exactly the moment the
// row was worth having. The same shape of bug the supply light had.
//
// The programme (v78) is the farm's own statement about what it grows, so it is
// the right basis. Sorten with live batches are unioned in rather than replaced
// — one being grown but never written down is still being grown, and going
// quiet about it would hide real work.
function strainsInProduction() {
  const out = new Map();
  for (const ms of mushroomStrains || []) {
    if (ms.imProgramm === false) continue;
    out.set(_labKey(ms.name, ms.kuerzel), {
      name: ms.name || 'Unknown',
      kz: ms.kuerzel || '',
      desc: ms.description || ''
    });
  }
  // Matched through _spKey, which is what strips the " (KZ)" a block batch
  // carries in its species. A hand-rolled trim().toLowerCase() left the suffix
  // on, so "shiitake (sh)" never matched a parked "shiitake": the Sorte came
  // straight back as long as one live batch remained, and arrived under a second
  // map key beside its own — one mushroom, two rows, on all four tiles, the
  // spare one at zero and raising a task every day forever.
  const parked = new Set((mushroomStrains || []).filter((m) => m.imProgramm === false).map((m) => _spKey(m.name)));
  for (const b of batches || []) {
    if (isArchivedStatus(getStatus(b.batchId).status)) continue;
    const name = b.strainName || b.species || 'Unknown';
    // A Sorte taken out of the programme keeps its remaining batches; that is
    // not a reason to start asking for stock of it again.
    if (parked.has(_spKey(name))) continue;
    const kz = b.strainKuerzel || b.strain || '';
    out.set(_labKey(name, kz), { name: _labName(b), kz, desc: b.strainDescriptor || '' });
  }
  return out;
}

// Welche Spalte einer Pilzsorte die Untergrenze eines Kulturtyps traegt.
//
// GS heisst min_spawn_kg und nicht min_gs, weil die Spalte aus v69 stammt; die
// Tabelle bruecht den Unterschied, damit ihn sonst niemand kennen muss.
const STRAIN_MIN_FIELD = { GS: 'minSpawnKg', LC: 'minLc', MC: 'minMc', PD: 'minPd' };
// Die Pilzsorten-Zeile hinter einem Eintrag der Aufschlüsselung.
//
// Über das Kürzel zuerst, dann über den bereinigten Namen — `m.name === entry.name`
// verglich zwei Rohnamen, und einer der beiden kann das " (KZ)" einer Block-
// Charge tragen. Die Karte braucht außerdem die Id, nicht nur die Zahl, um die
// Untergrenze von hier aus setzen zu können.
function _strainOfEntry(entry) {
  return (
    (mushroomStrains || []).find(
      (m) => (entry.kz && m.kuerzel === entry.kz) || _spKey(m.name) === _spKey(entry.name)
    ) || null
  );
}

// One key for one Sorte, everywhere the Labor card groups by it.
//
// It was `name + '|' + kz` built from whatever string each source happened to
// carry — and a block batch carries "Shiitake (SH)" where the Pilzsorten row
// carries "Shiitake", so one mushroom got two rows on every tile, the seeded one
// at zero and in red. _spKey() is what strips that suffix; stripping it here is
// the whole reason it exists.
function _labKey(name, kz) {
  return (
    _spKey(name) +
    '|' +
    String(kz || '')
      .trim()
      .toLowerCase()
  );
}
// The name to show on such a row, suffix removed, keeping the same 'Unknown' the
// counters have always fallen back to.
function _labName(rec) {
  return rec.strainName || rec.species ? sorteName(rec) : 'Unknown';
}

function getLabStrainBreakdown() {
  const breakdown = { MC: {}, PD: {}, LC: {}, G2G: {}, GS: {}, SY: {} };
  cultures
    .filter((c) => c.status === 'active')
    .forEach((c) => {
      if (!breakdown[c.type]) return;
      const name = c.strainName || c.species || 'Unknown';
      const kz = c.strainKuerzel || c.strain || '';
      const desc = c.strainDescriptor || '';
      const key = _labKey(name, kz);
      if (!breakdown[c.type][key])
        breakdown[c.type][key] = { name: _labName(c), kz, desc, count: 0, color: spColor(name) };
      breakdown[c.type][key].count++;
    });
  batches
    .filter((b) => b.batchType === 'grain')
    .forEach((b) => {
      // _grainKgOf() is the one place the weight rule lives, so the Sorten tile,
      // this card and min_spawn_kg agree by construction. Two identical copies
      // agreed only by coincidence, and one edit to either default ended it —
      // including the archived check, which this had spelled out a third time.
      const kg = _grainKgOf(b);
      if (!kg) return;
      const name = b.strainName || b.species || 'Unknown';
      const kz = b.strainKuerzel || b.strain || '';
      const desc = b.strainDescriptor || '';
      const key = _labKey(name, kz);
      if (!breakdown.GS[key]) breakdown.GS[key] = { name: _labName(b), kz, desc, count: 0, color: spColor(name) };
      breakdown.GS[key].count += kg;
    });
  // Every Sorte being grown right now gets a row for each thing it cannot be
  // grown without, even at zero — a missing row reads as "fine" and is the exact
  // opposite. Four types now rather than two: slants and plates carry minimums
  // of their own since v79.
  for (const [key, sp] of strainsInProduction()) {
    for (const type of MIN_TYPES) {
      if (!breakdown[type][key]) {
        breakdown[type][key] = { name: sp.name, kz: sp.kz, desc: sp.desc, count: 0, color: spColor(sp.name) };
      }
    }
  }
  for (const type of MIN_TYPES) {
    for (const entry of Object.values(breakdown[type])) {
      const ms = _strainOfEntry(entry);
      entry.msId = ms ? ms.id : null;
      entry.min = ms ? ms[STRAIN_MIN_FIELD[type]] || 0 : 0;
    }
  }
  return breakdown;
}
// ── Laborbestand je Sorte ──
// Ein Bild für das ganze Labor: je Art, was da ist, was fehlt, und was ein Shop
// davon verkauft. Es ersetzt die Kacheln je Ansatz und die Karte
// Verkaufsbestand, die vorher übereinander standen und dieselben Petrischalen
// und dieselbe Körnerbrut verschieden zählten, mit zwei Untergrenzen für ein
// Regal. Gezählt wird einmal, auf dem Server (db.labStock), für die Laborseite,
// die Zeile in Arbeitsgänge und die Laboraufgaben der Tagesliste.
//
// Nach Art sortiert, nicht nach Ansatz: aus einer Quelle setzt man vieles an
// (Laborarbeit → Mehrere), und genau das fragt eine Zeile ab.
let _lbData = null;
async function loadLabStock() {
  try {
    _lbData = await apiGet('/api/lab-stock');
  } catch (e) {
    return; // offline, or a server without the route: the cards keep what they had
  }
  renderLabStock();
  if (_lbSheet) lbSheetRender();
  // Die Tagesliste nimmt ihre Laboraufgaben aus denselben Zahlen
  // (buildLabMinTasks); sie kamen gerade erst an.
  const work = document.getElementById('p-work');
  if (work && work.classList.contains('active')) renderDashBatchTasks();
}
const _lbSpecies = () => (_lbData && _lbData.species) || [];
const _lbFehlt = (sp) => sp.items.filter((i) => i.make > 0);
const _lbDringend = (sp) => sp.items.some((i) => i.urgency === 'now');
const _lbIstShop = (i) => !!i.shop;
// Ein Feld kurz, wie es in einer Zeile steht, und lang, wie im Blatt.
function _lbKurz(i) {
  if (i.key === 'MC' || i.key === 'LC' || i.key === 'PD' || i.key === 'GSKG') return t('lb.short.' + i.key);
  if (i.key.startsWith('SY')) return t('lb.short.SY', { ml: i.ml });
  return t('lb.short.kb', { kg: i.kg });
}
function _lbLang(i) {
  if (i.key === 'MC' || i.key === 'LC' || i.key === 'PD' || i.key === 'GSKG') return t('lb.long.' + i.key);
  if (i.key.startsWith('SY')) return t('lb.long.SY', { ml: i.ml });
  return t('lb.long.kb', { kg: i.kg });
}
// Körnerbrut-Vorrat wiegt, alles andere zählt.
const _lbZahl = (i, n) => (i.key === 'GSKG' ? fmtKg(n, n % 1 ? 1 : 0) : String(n));
// Was fehlt, als Stichwort: "3 Petri", "2 × 10 ml", "10 kg KB".
function _lbChip(i) {
  if (i.key.startsWith('SY')) return t('lb.chip.SY', { n: i.make, ml: i.ml });
  if (i.key.startsWith('kb')) return t('lb.chip.kb', { n: i.make, kg: i.kg });
  return t('lb.chip.' + i.key, { n: _lbZahl(i, i.make) });
}

// ── Nachproduzieren: je Art, was ihr fehlt ──
// Rot ist nur eine Bestellung, die gerade nicht aus dem Regal gehen kann; alles
// unter dem Soll ist gelb (db.saleNeed). Die Arten mit Rot zuerst, dann die mit
// den meisten Lücken. Sechs stehen da, der Rest auf einen Tipp: bei vierzig
// Lücken wäre die Laborseite sonst nur diese Liste.
const NP_ZEIGEN = 6;
let _npAlle = false;
function renderNachproduzieren(species) {
  const card = document.getElementById('np-card');
  if (!card) return;
  const offen = species
    .map((sp) => ({ sp, fehlt: _lbFehlt(sp) }))
    .filter((x) => x.fehlt.length)
    .sort(
      (a, b) =>
        Number(_lbDringend(b.sp)) - Number(_lbDringend(a.sp)) ||
        b.fehlt.length - a.fehlt.length ||
        a.sp.name.localeCompare(b.sp.name)
    );
  card.hidden = !offen.length;
  if (!offen.length) return;
  const zeigen = _npAlle ? offen : offen.slice(0, NP_ZEIGEN);
  document.getElementById('np-rows').innerHTML =
    zeigen
      .map(({ sp, fehlt }) => {
        const rot = _lbDringend(sp);
        return (
          '<div class="np-row">' +
          `<i class="np-dot np-${rot ? 'now' : 'low'}" role="img" aria-label="${esc(t(rot ? 'np.now' : 'np.low'))}"></i>` +
          `<div class="np-main"><div class="np-what">${esc(sp.name)}</div><div class="np-chips">` +
          fehlt.map((i) => `<span class="np-chip np-${esc(i.urgency)}">${esc(_lbChip(i))}</span>`).join('') +
          '</div></div>' +
          `<button type="button" class="btn btn-sm btn-p np-go" data-np-strain="${sp.strainId}">${esc(t('np.go'))}</button></div>`
        );
      })
      .join('') +
    (offen.length > NP_ZEIGEN
      ? `<button type="button" class="btn btn-sm np-more" data-np-more>${esc(t(_npAlle ? 'np.less' : 'np.more', { n: offen.length - NP_ZEIGEN }))}</button>`
      : '');
}
// Oben in Arbeitsgänge, wo die App aufgeht: nur was rot ist, eine Bestellung,
// die nicht rausgehen kann. Das Gelbe steht in der Tagesliste darunter
// (buildLabMinTasks); hier ein zweites Mal wäre dieselbe Liste doppelt.
function renderWorkNachproduzieren(species) {
  const el = document.getElementById('wk-np');
  if (!el) return;
  const rot = [];
  for (const sp of species) for (const i of sp.items) if (i.urgency === 'now') rot.push(sp.name + ' ' + _lbKurz(i));
  el.hidden = !rot.length;
  if (!rot.length) return;
  el.classList.add('wk-np-now');
  const namen = rot.slice(0, 2);
  if (rot.length > 2) namen.push(t('work.npMore', { n: rot.length - 2 }));
  el.textContent = t('work.npOrders', { n: rot.length }) + ' · ' + namen.join(', ');
}

// ── Die Liste je Art ──
// Fünf Felder je Zeile, immer dieselben an derselben Stelle: Slant, FK, Petri,
// Spritzen (die Größen, die es gibt), Körnerbrut in kg. Gelb unter dem Soll,
// rot bei einer Bestellung, die nicht gedeckt ist. Ein Tipp öffnet die Art.
function _lbStat(label, have, soll, cls, shop) {
  return (
    `<span class="lb-st${cls ? ' ' + cls : ''}"><small>${esc(label)}${shop ? '<i class="lb-shopdot" aria-hidden="true"></i>' : ''}</small>` +
    `<b>${esc(have)}${soll ? '<em>/' + esc(soll) + '</em>' : ''}</b></span>`
  );
}
function _lbStatCls(items) {
  if (items.some((i) => i.urgency === 'now')) return 'lb-now';
  if (items.some((i) => i.make > 0)) return 'lb-under';
  return items.every((i) => !i.have) ? 'lb-zero' : '';
}
function _lbZeile(sp) {
  const by = (k) => sp.items.find((i) => i.key === k);
  const one = (k) => {
    const i = by(k);
    return _lbStat(_lbKurz(i), _lbZahl(i, i.have), i.soll ? _lbZahl(i, i.soll) : '', _lbStatCls([i]), _lbIstShop(i));
  };
  const sy = sp.items.filter((i) => i.key.startsWith('SY'));
  const kb = sp.items.filter((i) => i.key === 'GSKG' || i.key.startsWith('kb'));
  const gskg = by('GSKG');
  return (
    `<button type="button" class="lb-sp" data-lb-strain="${sp.strainId}">` +
    `<span class="lb-sp-h"><b>${esc(sp.name)}</b>` +
    (sp.imProgramm ? '' : `<small class="lb-paused">${esc(t('lb.paused'))}</small>`) +
    '<span class="lb-chev" aria-hidden="true">›</span></span><span class="lb-row">' +
    one('MC') +
    one('LC') +
    one('PD') +
    _lbStat(t('lb.short.SYall'), sy.length ? sy.map((i) => i.have).join('·') : '–', '', sy.length ? _lbStatCls(sy) : 'lb-zero', sy.some(_lbIstShop)) +
    _lbStat(
      t('lb.short.GSKG'),
      _lbZahl(gskg, gskg.have),
      gskg.soll ? _lbZahl(gskg, gskg.soll) : '',
      _lbStatCls(kb),
      kb.some(_lbIstShop)
    ) +
    '</span></button>'
  );
}
let _lbRuhenOffen = false;
function renderLabStock() {
  const d = _lbData;
  if (!d) return;
  const species = _lbSpecies();
  renderNachproduzieren(species);
  renderWorkNachproduzieren(species);
  const card = document.getElementById('lb-card');
  if (!card) return;
  card.hidden = !species.length;
  if (!species.length) return;
  // Eine Sorte, die ruht (außer Programm, nichts da), steht eingeklappt unten:
  // im Weg ist sie nicht, und einschalten lässt sie sich trotzdem hier.
  const ruhen = species.filter((sp) => sp.ruht);
  document.getElementById('lb-list').innerHTML =
    species
      .filter((sp) => !sp.ruht)
      .map(_lbZeile)
      .join('') +
    (ruhen.length
      ? `<button type="button" class="btn btn-sm lb-ruhen" data-lb-ruhen aria-expanded="${_lbRuhenOffen}">${esc(t(_lbRuhenOffen ? 'lb.restingHide' : 'lb.resting', { n: ruhen.length }))}</button>` +
        (_lbRuhenOffen ? ruhen.map(_lbZeile).join('') : '')
      : '');
  // Was ein Shop verkauft, geht an Billbee; eine Zeile sagt, wie es darum steht.
  const shop = [];
  for (const sp of species) for (const i of sp.items) if (i.shop) shop.push(i);
  const bb = document.getElementById('lb-bb');
  bb.hidden = !shop.length;
  if (!shop.length) return;
  const fehler = shop.filter((i) => i.shop.lastError).length;
  const wartet = shop.filter((i) => !i.shop.lastError && (!i.shop.pushedAt || i.shop.pushedCount !== i.have)).length;
  const zuletzt = shop.reduce((m, i) => (i.shop.pushedAt && i.shop.pushedAt > m ? i.shop.pushedAt : m), '');
  let text;
  if (!d.enabled) text = t('vb.off');
  else if (fehler) text = t('vb.errors', { n: fehler });
  else if (wartet) text = t('vb.waitingAll', { n: wartet });
  else text = t('vb.allSent', { n: shop.length, time: zuletzt ? fmtDtTime(zuletzt) : '–' });
  bb.textContent = text;
  bb.classList.toggle('vb-bb-warn', !d.enabled || fehler > 0);
}

// ── Ansetzen: Laborarbeit → Mehrere, mit allem, was der Art fehlt ──
// Slants, Petri und Flüssigkultur mit ihrer Anzahl, Spritzen und
// Verkaufsbeutel je Größe. Der Körnerbrut-Vorrat steht in kg, und welche
// Beutel ihn füllen, weiß die Zahl nicht: Körnerbrut ist dann angetippt, die
// Größen trägt man ein.
//
// Aus dem Blatt einer Art kommt statt dessen, was man dort eingetippt hat
// (menge: Feld → Anzahl, jede ab 0). Die Anzahl ist nie eine gemerkte Zahl,
// und alles endet wie immer im Etikettendialog.
function lbAnsetzen(strainId, menge) {
  const sp = _lbSpecies().find((x) => x.strainId === strainId);
  const ms = (mushroomStrains || []).find((x) => x.id === strainId);
  if (!sp || !ms) return;
  lbSheetClose();
  const n = { MC: 0, PD: 0, LC: 0 };
  const sy = {};
  const kb = {};
  const arten = new Set();
  const quelle = menge
    ? sp.items.filter((i) => menge[i.key] > 0).map((i) => ({ ...i, make: menge[i.key] }))
    : _lbFehlt(sp);
  for (const i of quelle) {
    if (MSQ_STUECK.includes(i.key)) {
      n[i.key] = Math.ceil(i.make);
      arten.add(i.key);
    } else if (i.key.startsWith('SY')) {
      sy[i.ml] = i.make;
      arten.add('SY');
    } else if (i.key.startsWith('kb')) {
      kb[i.kg] = i.make;
      arten.add('KB');
    } else if (i.key === 'GSKG') arten.add('KB');
  }
  msQuickOpen('labor', ms);
  if (!arten.size) return;
  msqMehrereUmschalten();
  _msQuickCtx.arten = MSQ_MEHRERE.filter((a) => arten.has(a));
  _msQuickCtx.n = n;
  document.getElementById('ms-q-sy').innerHTML = syMengenHtml('ms-q', sy);
  document.getElementById('ms-q-sizes').innerHTML = kbMengenHtml('ms-q', kb);
  msQuickRender();
  msQuickPreview();
}

// ── Eine Art im Einzelnen ──
// Jedes Feld mit seinem Bestand, seinem Soll und dem, was man ansetzen will.
// Der Bestand ist gezählt, aus den Scans, und steht nur da: ändern tut ihn
// Ansetzen, Verbrauchen und Rausscannen, nie eine Hand im Blatt. Die große
// Zahl mit − und + ist, was man jetzt ansetzt; sie fängt bei 0 an, und "N
// ansetzen" öffnet Laborarbeit damit. Vorher war das die Stelle des Solls,
// und ein Soll von 2 neben 2 Schalen im Regal las sich wie ein Bestand, den
// man von Hand verstellt.
//
// Das Soll steht klein unter dem Bestand und geht auf einen Tipp mit eigenem
// − und + auf. Ein Tipp gilt sofort, ohne Rückfrage, und wird kurz nach dem
// letzten gespeichert. Es steht, wo es immer stand: an der Sorte für Slants,
// Flüssigkultur, Petrischale und den kg-Vorrat (dieselben Felder wie auf der
// Pilzsorten-Seite), an der SKU für eine Verkaufsgröße. "Im Programm" aus
// heißt: die Art fehlt nirgends, nur ihre offenen Bestellungen zählen noch.
//
// Der kg-Vorrat hat keinen Zähler zum Ansetzen: in welche Beutel er geht,
// weiß die Zahl nicht. Die Beutel, die ein Shop verkauft, haben ihren.
const LB_SORTE_FELD = { MC: 'minMc', LC: 'minLc', PD: 'minPd', GSKG: 'minSpawnKg' };
let _lbSheet = null;
const _lbTimer = {};
const _lbAnsetzbar = (i) => i.key !== 'GSKG';
const _lbMengeSumme = () =>
  _lbSheet ? Object.values(_lbSheet.make).reduce((s, n) => s + n, 0) : 0;
function lbSheetOpen(strainId) {
  _lbSheet = { strainId, make: {}, sollOffen: null, wegOffen: null, weg: new Set() };
  lbSheetRender();
  if (_lbSheet) document.getElementById('m-lb').classList.add('open');
}
function lbSheetClose() {
  const m = document.getElementById('m-lb');
  if (m) m.classList.remove('open');
  _lbSheet = null;
}
function _lbSub(i) {
  const teile = [t('lb.have', { n: _lbZahl(i, i.have) })];
  if (i.growing) teile.push(t('lb.growing', { n: _lbZahl(i, i.growing), date: i.readyAt ? fmtDtShort(i.readyAt) : '–' }));
  if (i.ordered) teile.push(t('vb.ordered', { n: i.ordered }));
  if (i.shop) {
    if (i.shop.lastError) teile.push(t('vb.notSent'));
    else if (i.shop.pushedAt)
      teile.push(
        t('lb.billbee', {
          n: i.shop.billbeeStock != null ? i.shop.billbeeStock : i.shop.pushedCount,
          time: fmtDtTime(i.shop.pushedAt)
        })
      );
  }
  return teile.join(' · ');
}
function lbSheetRender() {
  const sp = _lbSheet && _lbSpecies().find((x) => x.strainId === _lbSheet.strainId);
  if (!sp) {
    lbSheetClose();
    return;
  }
  document.getElementById('m-lb-title').textContent = sp.name;
  document.getElementById('m-lb-prog').checked = !!sp.imProgramm;
  document.getElementById('m-lb-items').innerHTML = sp.items.map((i) => _lbSheetZeile(i, sp)).join('');
  lbSheetKnopf(sp);
}
// "Soll 2 ›", oder "Kein Soll ›": der Knopf, der das Soll aufklappt.
const _lbSollText = (i) =>
  i.soll ? t('lb.soll', { n: _lbZahl(i, i.soll) + (i.key === 'GSKG' ? ' kg' : '') }) : t('lb.sollNone');
function _lbSheetZeile(i, sp) {
  const k = esc(i.key);
  const offen = _lbSheet.sollOffen === i.key;
  const soll =
    `<button type="button" class="lb-soll-btn" data-lb-soll="${k}" aria-expanded="${offen}">` +
    `<span id="m-lb-sollt-${k}">${esc(_lbSollText(i))}</span> <span aria-hidden="true">${offen ? '‹' : '›'}</span></button>` +
    (offen
      ? `<div class="lb-step lb-step-soll"><button type="button" class="btn btn-sm" data-lb-step="-1" data-lb-key="${k}" aria-label="${esc(t('vb.sollLess'))}">−</button>` +
        `<b id="m-lb-soll-${k}" aria-live="polite">${esc(_lbZahl(i, i.soll || 0))}${i.key === 'GSKG' ? ' kg' : ''}</b>` +
        `<button type="button" class="btn btn-sm" data-lb-step="1" data-lb-key="${k}" aria-label="${esc(t('vb.sollMore'))}">+</button></div>`
      : '');
  const n = _lbSheet.make[i.key] || 0;
  const make = _lbAnsetzbar(i)
    ? `<div class="lb-step"><button type="button" class="btn" data-lb-make="-1" data-lb-key="${k}" aria-label="${esc(t('lb.makeLess'))}">−</button>` +
      `<b id="m-lb-make-${k}" class="${n ? '' : 'lb-null'}" aria-live="polite">${n}</b>` +
      `<button type="button" class="btn" data-lb-make="1" data-lb-key="${k}" aria-label="${esc(t('lb.makeMore'))}">+</button></div>`
    : '';
  const wegOffen = _lbSheet.wegOffen === i.key;
  const weg =
    sp && i.have > 0 && _lbWegTyp(i.key)
      ? `<button type="button" class="lb-soll-btn lb-weg-btn" data-lb-weg="${k}" aria-expanded="${wegOffen}">` +
        `${esc(t('lb.delete'))} <span aria-hidden="true">${wegOffen ? '‹' : '›'}</span></button>`
      : '';
  return (
    `<div class="lb-line${i.urgency === 'now' ? ' lb-now' : i.make > 0 ? ' lb-under' : ''}">` +
    `<div class="lb-line-l"><b>${esc(_lbLang(i))}</b>${i.shop ? ` <small class="lb-shop">${esc(t('lb.shop'))}</small>` : ''}` +
    `<small class="lb-info">${esc(_lbSub(i))}</small>${soll}${weg}</div>${make}</div>` +
    (wegOffen && sp ? _lbWegListe(sp, i.key) : '')
  );
}

// ── Löschen, was nicht mehr da ist ──
// Eine Schale, die runtergefallen ist oder sich nicht mehr findet, stand sonst
// im Bestand, bis jemand sie in der Kulturenliste suchte. Unter jeder Zeile
// klappt die Liste ihrer Kulturen auf, älteste zuerst; was weg ist, antippen,
// ein Knopf löscht. Kein Rückfragefenster: die Leiste unten bietet Rückgängig,
// und zum Server geht das Löschen erst, wenn ihre Zeit um ist. Eine Kultur, aus
// der schon etwas angesetzt ist, löscht nur ein Admin (der Server ebenso).
const LB_WEG_MS = 8500;
function _lbWegTyp(key) {
  if (key === 'MC' || key === 'LC' || key === 'PD') return { type: key, ml: null };
  if (/^SY\d+$/.test(key)) return { type: 'SY', ml: Number(key.slice(2)) };
  return null;
}
function _lbKulturen(sp, key) {
  const f = _lbWegTyp(key);
  if (!f) return [];
  return cultures
    .filter(
      (c) =>
        c.type === f.type &&
        (c.status === 'active' || c.status === 'stored') &&
        (f.ml == null || syMl(c) === f.ml) &&
        (c.strainId === sp.strainId || (!c.strainId && c.species === sp.name))
    )
    .sort((a, b) => String(a.created).localeCompare(String(b.created)));
}
function _lbDarfWeg(c) {
  if (currentUser && currentUser.role === 'admin') return true;
  return !cultures.some((x) => x.parentId === c.id) && !batches.some((b) => b.sourceId === c.id);
}
function _lbWegListe(sp, key) {
  const n = _lbSheet.weg.size;
  const zeilen = _lbKulturen(sp, key)
    .map((c) => {
      const darf = _lbDarfWeg(c);
      const an = _lbSheet.weg.has(c.id);
      return (
        `<button type="button" class="lb-weg-id${an ? ' on' : ''}" data-lb-wegid="${esc(c.id)}" aria-pressed="${an}"${darf ? '' : ' disabled'}>` +
        `<span>${esc(c.id)}</span><small>${esc(darf ? fmtDt(c.created) : t('lb.deleteAdminOnly'))}</small></button>`
      );
    })
    .join('');
  return (
    `<div class="lb-weg"><p class="lb-tap">${esc(t('lb.deleteHelp'))}</p>${zeilen}` +
    `<button type="button" class="btn btn-sm btn-r" data-lb-act="weg"${n ? '' : ' disabled'}>${esc(t('lb.deleteN', { n }))}</button></div>`
  );
}
function lbWegZeigen(key) {
  if (!_lbSheet) return;
  _lbSheet.wegOffen = _lbSheet.wegOffen === key ? null : key;
  _lbSheet.weg = new Set();
  lbSheetRender();
}
function lbWegWaehlen(id) {
  if (!_lbSheet) return;
  if (_lbSheet.weg.has(id)) _lbSheet.weg.delete(id);
  else _lbSheet.weg.add(id);
  lbSheetRender();
}
// Der Bestand im Blatt folgt sofort; die Zahl vom Server kommt nach dem Löschen.
function _lbHaveAendern(strainId, key, d) {
  const sp = _lbSpecies().find((x) => x.strainId === strainId);
  const i = sp && sp.items.find((x) => x.key === key);
  if (i) i.have = Math.max(0, i.have + d);
}
function lbWegLoeschen() {
  if (!_lbSheet || !_lbSheet.weg.size) return;
  const { strainId, wegOffen: key } = _lbSheet;
  const ids = new Set(_lbSheet.weg);
  const weg = cultures.filter((c) => ids.has(c.id));
  _lbHaveAendern(strainId, key, -weg.length);
  _lbSheet.weg = new Set();
  _lbSheet.wegOffen = null;
  kulturenLoeschen(weg, () => _lbHaveAendern(strainId, key, weg.length));
}
// Kulturen löschen, mit Rückgängig statt Rückfrage: sie gehen gleich aus jeder
// Liste, zum Server erst, wenn die Leiste unten weg ist. `zurueck` läuft, wenn
// Rückgängig getippt wird. Das Laborblatt und das Kultur-Fenster teilen sich das.
function kulturenLoeschen(weg, zurueck) {
  const ids = new Set(weg.map((c) => c.id));
  cultures = cultures.filter((c) => !ids.has(c.id));
  const neu = () => {
    renderLabLog();
    renderLabStock();
    renderCultures();
    if (_lbSheet) lbSheetRender();
  };
  neu();
  const timer = setTimeout(async () => {
    for (const c of weg) {
      const r = await apiDelete('/api/cultures/' + encodeURIComponent(c.id));
      if (r && r.error) {
        cultures.push(c);
        toast(t('lb.deleteFailed', { id: c.id, msg: r.error }), 'err');
        renderCultures();
      }
    }
    loadLabStock();
  }, LB_WEG_MS);
  showUndoBar(t('lb.deleted', { n: weg.length }), () => {
    clearTimeout(timer);
    cultures.push(...weg);
    if (zurueck) zurueck();
    neu();
  });
}
// Unten ein Knopf: "N ansetzen" mit dem, was eingetippt ist; ist nichts
// eingetippt und fehlt etwas, wie bisher "Alles ansetzen" mit dem, was fehlt.
function lbSheetKnopf(sp) {
  const go = document.getElementById('m-lb-make');
  const summe = _lbMengeSumme();
  const fehlt = _lbFehlt(sp);
  go.hidden = !summe && !fehlt.length;
  go.textContent = summe ? t('lb.goN', { n: summe }) : fehlt.length ? t('np.goAll') : '';
}
function lbMakeStep(key, d) {
  const sp = _lbSheet && _lbSpecies().find((x) => x.strainId === _lbSheet.strainId);
  if (!sp || !sp.items.some((x) => x.key === key)) return;
  const neu = Math.max(0, Math.min(500, (_lbSheet.make[key] || 0) + d));
  if (neu) _lbSheet.make[key] = neu;
  else delete _lbSheet.make[key];
  const el = document.getElementById('m-lb-make-' + key);
  if (el) {
    el.textContent = String(neu);
    el.classList.toggle('lb-null', !neu);
  }
  lbSheetKnopf(sp);
}
function lbSollZeigen(key) {
  if (!_lbSheet) return;
  _lbSheet.sollOffen = _lbSheet.sollOffen === key ? null : key;
  lbSheetRender();
}
function lbSollStep(key, d) {
  const sp = _lbSheet && _lbSpecies().find((x) => x.strainId === _lbSheet.strainId);
  const i = sp && sp.items.find((x) => x.key === key);
  if (!i) return;
  const neu = Math.max(0, Math.min(500, (i.soll || 0) + d));
  i.soll = neu || null;
  const el = document.getElementById('m-lb-soll-' + key);
  if (el) el.textContent = _lbZahl(i, neu) + (key === 'GSKG' ? ' kg' : '');
  const txt = document.getElementById('m-lb-sollt-' + key);
  if (txt) txt.textContent = _lbSollText(i);
  clearTimeout(_lbTimer[key]);
  _lbTimer[key] = setTimeout(() => lbSollSave(sp.strainId, i, neu), 500);
}
async function lbSollSave(strainId, i, soll) {
  const feld = LB_SORTE_FELD[i.key];
  let r;
  if (feld) {
    r = await apiPatch('/api/mushroom-strains/' + strainId, { [feld]: soll });
    // Die Pilzsorten-Seite zeigt dieselbe Zahl; sie soll nicht bis zum nächsten
    // Abgleich die alte zeigen.
    const ms = !r.error && (mushroomStrains || []).find((x) => x.id === strainId);
    if (ms) ms[feld] = soll;
  } else {
    const slot = i.key.startsWith('SY') ? i.ml : 'kb' + i.kg;
    r = await apiPut('/api/sale-stock/' + strainId + '/' + slot, { soll });
  }
  if (!r || r.error) setFb('err', (r && r.error) || t('common.error'));
  loadLabStock();
}
async function lbProgramm(an) {
  if (!_lbSheet) return;
  const id = _lbSheet.strainId;
  const r = await apiPatch('/api/mushroom-strains/' + id, { imProgramm: an });
  if (!r || r.error) {
    setFb('err', (r && r.error) || t('common.error'));
  } else {
    const ms = (mushroomStrains || []).find((x) => x.id === id);
    if (ms) ms.imProgramm = an;
  }
  loadLabStock();
}

// ─── RACKS ───────────────────────────────────────────────────
function getRackBags(rackId) {
  const bags = {};
  scanLog.forEach((e) => {
    if (e.action === 'ADD' && e.to === rackId && e.bag)
      bags[e.bag] = { batchId: e.batch, species: e.species, strain: e.strain };
    if (e.action === 'MOVE' || e.action === 'MOVE_BATCH') {
      if (e.to === rackId && e.bag) bags[e.bag] = { batchId: e.batch, species: e.species, strain: e.strain };
      if (e.from === rackId && e.bag) delete bags[e.bag];
    }
    if (e.action === 'REMOVE' && e.from === rackId && e.bag) delete bags[e.bag];
  });
  return bags;
}
// ─── LOCATION BAG INTERACTIONS ──────────────────────────────
const selectedLocBags = new Map(); // bagId → {batchId, loc}
function getZoneBags(zone) {
  const bags = {};
  // bag → its since when it last left this zone, for a move that is undone.
  const left = {};
  scanLog.forEach((e) => {
    const tz = toZone(e.to),
      fz = toZone(e.from);
    // since: when the bag came into this zone. A rack-to-rack move inside the
    // zone keeps it — the bag did not arrive again. Neither did a bag whose
    // move out was taken back with Rückgängig: _undoMove() writes the way back
    // with reason 'undo', and the bag gets the date it left with.
    if (e.action === 'ADD' && tz === zone && e.bag)
      bags[e.bag] = { batchId: e.batch, species: e.species, strain: e.strain, loc: e.to, since: e.time };
    if (e.action === 'MOVE' || e.action === 'MOVE_BATCH') {
      if (tz === zone && e.bag) {
        let since = e.time;
        if (fz === tz && bags[e.bag]) since = bags[e.bag].since;
        else if (e.reason === 'undo' && left[e.bag]) since = left[e.bag];
        bags[e.bag] = { batchId: e.batch, species: e.species, strain: e.strain, loc: e.to, since: since };
      }
      // fz !== tz: a move WITHIN this zone (rack to rack — 'INC' to 'INC_R1',
      // which toZone() maps back to 'INC') inserted the bag and then deleted it
      // on the very next line, so the zone card, the fruiting summary and the
      // dashboard zone count all read 0 right after a successful move. It also
      // emptied the stocktake's expected list, so every bag scanned on the walk
      // was judged "recorded elsewhere" and got a spurious correcting MOVE.
      if (fz === zone && fz !== tz && e.bag) {
        if (bags[e.bag]) left[e.bag] = bags[e.bag].since;
        delete bags[e.bag];
      }
    }
    if (e.action === 'REMOVE' && fz === zone && e.bag) delete bags[e.bag];
  });
  return bags;
}
function toggleLocBag(bagId, batchId, loc) {
  if (selectedLocBags.has(bagId)) selectedLocBags.delete(bagId);
  else selectedLocBags.set(bagId, { batchId, loc });
  // Toggle chip class
  const el = document.querySelector(`.bag-chip[data-bag="${CSS.escape(bagId)}"]`);
  if (el) el.classList.toggle('selected', selectedLocBags.has(bagId));
  updateActionBar();
}
// Most-recently-used move/placement destinations, newest-first and de-duped,
// so the common moves (Inkubation → Fruchtung / Kontamination) are one tap
// instead of a scroll through every zone + rack. Sourced from scanLog, which
// already records every move — no schema change or extra request. The last
// pick is persisted so it survives a reload and leads even on a fresh log.
// Recent destinations for the picker shortcut row. Defaults to actual moves
// (MOVE/MOVE_BATCH), seeded by the persisted last move destination — ADD is
// excluded there because initial placement is nearly always Inkubation and
// would bury the real move targets (Fruchtung / Kontam). The placement picker
// passes { actions: ['ADD'], lastKey: null } to get placement history instead.
function recentDestinations(limit, opts) {
  limit = limit || 4;
  opts = opts || {};
  const actions = opts.actions || ['MOVE', 'MOVE_BATCH'];
  const lastKey = 'lastKey' in opts ? opts.lastKey : 'mp-last-dest';
  const seen = new Set();
  const out = [];
  if (lastKey) {
    let last = null;
    try {
      last = localStorage.getItem(lastKey);
    } catch (e) {
      /* storage disabled (private mode) — fall back to scanLog only */
    }
    if (last && LOCS.includes(last)) {
      seen.add(last);
      out.push(last);
    }
  }
  for (let i = scanLog.length - 1; i >= 0 && out.length < limit; i--) {
    const e = scanLog[i];
    if (!actions.includes(e.action)) continue;
    const to = e.to;
    if (!to || seen.has(to) || !LOCS.includes(to)) continue;
    seen.add(to);
    out.push(to);
  }
  return out;
}
function rememberDest(loc) {
  if (!loc) return;
  try {
    localStorage.setItem('mp-last-dest', loc);
  } catch (e) {
    /* storage disabled — recents still work from scanLog */
  }
}
// Destination picker for the bags selected on the dashboard. Uses the shared
// _openZonePicker (same list as the batch-move and placement pickers) instead of
// the old bespoke grid + two-step confirm: picking a destination moves straight
// away, and the Undo in the feedback bar covers a mistap. Destinations the
// selected bags already sit at are dropped from the shortcut row (no-op moves).
function openLocMovePopup() {
  if (!selectedLocBags.size) return;
  const srcLocs = new Set([...selectedLocBags.values()].map((d) => d.loc));
  _openZonePicker(t('dash.moveBags', { n: selectedLocBags.size }), (dest) => locMoveTo(dest), {
    excludeLocs: srcLocs
  });
}
// Event delegation for bag chip clicks
document.getElementById('dash-locations').addEventListener('click', function (e) {
  // The sort chips sit above the zones, so handle them before anything that
  // treats a click as landing inside a room.
  const ls = e.target.closest('[data-action="loc-sort"]');
  if (ls) {
    e.preventDefault();
    e.stopPropagation();
    setLocSort(ls.dataset.key);
    return;
  }
  // Stocktake button sits inside the zone header, whose own click toggles the
  // section — stop the event so opening the check doesn't also collapse it.
  const zc = e.target.closest('[data-zone-check]');
  if (zc) {
    e.preventDefault();
    e.stopPropagation();
    openZoneCheck(zc.dataset.zoneCheck);
    return;
  }
  const chip = e.target.closest('.bag-chip[data-bag]');
  if (!chip) return;
  e.preventDefault();
  e.stopPropagation();
  toggleLocBag(chip.dataset.bag, chip.dataset.batch, chip.dataset.loc);
});
let lastLocUndoEntries = [];
function locMoveTo(toLoc) {
  if (!selectedLocBags.size) return;
  rememberDest(toLoc);
  const now = new Date().toISOString();
  const n = selectedLocBags.size;
  const entries = [];
  selectedLocBags.forEach((d, bagId) => {
    const b = batches.find((x) => x.batchId === d.batchId);
    const entry = {
      time: now,
      action: 'MOVE',
      batch: d.batchId,
      bag: bagId,
      from: d.loc,
      to: toLoc,
      species: b?.species || null,
      strain: b?.strain || null,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      // I-12: optimistic concurrency snapshot for offline-queue replays.
      expected_current_zone: d.loc ? toZone(d.loc) : null
    };
    scanLog.push(entry);
    movements.push(entry);
    entries.push(entry);
    scan.count++;
  });
  lastLocUndoEntries = entries;
  selectedLocBags.clear();
  document.getElementById('m-locmove').classList.remove('open');
  postScanEntries(entries); // I-12 zone check applies: these are MOVEs
  updateSD();
  renderStatus();
  setLocFb(t('scanFb.moved', { n: n, loc: toLoc }));
}
// ─── ZONE CHECK (stocktake) ─────────────────────────────────
// Bag locations are derived from the scan log, so if bags get moved without
// being scanned the records drift silently and there is no way to notice. This
// walks one zone: it lists what the app still expects to be there, you tick off
// what you actually find, and whatever is left over is the drift. The leftovers
// feed the normal move/remove flows (via selectedLocBags) so they reuse the same
// scan entries, undo and sync as every other correction.
let _zcZone = null;
let _zcMode = 'zone'; // 'zone' = bags in a zone, 'culture' = lab cultures
let _zcScanMode = false;
let _zcMoved = 0; // bags found here that the records had somewhere else
const _zcFound = new Set();
// Camera stocktake: keep the scanner open and walk the zone bag by bag. Each
// scan ticks the bag off; a bag that is here but recorded elsewhere is corrected
// to this zone on the spot (the drift the expected-list alone can never see).
// Closing the camera returns to the check sheet — see closeCamScan.
function zoneCheckStartScan() {
  if (_zcMode === 'zone' && !_zcZone) return;
  _zcScanMode = true;
  document.getElementById('m-zonecheck').classList.remove('open');
  scan.action = null;
  scan.to = null;
  scan.from = null;
  scan.harvestBag = null;
  updateSD();
  openCamScan();
}
// Deliberately lighter than setFb: a stocktake fires one of these per bag, and
// setFb also writes a scan-log entry and re-renders the success list, which is
// wasted work here. Flash the camera view (the scan-overlay flash is invisible
// behind the camera), beep, and drop a one-line HUD toast — no window.
function _zcFeedback(type, msg) {
  const el = document.getElementById('m-camscan');
  if (el) {
    el.classList.remove('cam-flash-ok', 'cam-flash-err');
    void el.offsetWidth; // restart the animation for back-to-back scans
    el.classList.add(type === 'ok' ? 'cam-flash-ok' : 'cam-flash-err');
  }
  if (type === 'ok') _scanBeepOk();
  else _scanBeepErr();
  _showCamHudToast(type, msg);
}
function zoneCheckScanned(bagId, batchId) {
  const expected = getZoneBags(_zcZone);
  const total = Object.keys(expected).length;
  if (expected[bagId]) {
    if (_zcFound.has(bagId)) {
      _zcFeedback('info', t('zoneCheck.scanDup', { bag: bagId }));
      return;
    }
    _zcFound.add(bagId);
    _zcFeedback('ok', t('zoneCheck.scanOk', { found: _zcFound.size, total: total }));
    return;
  }
  // Not expected here, but it is physically in the zone — correct the record.
  const b = batches.find((x) => x.batchId && x.batchId.toUpperCase() === (batchId || '').toUpperCase());
  if (!b) {
    _zcFeedback('err', t('zoneCheck.scanUnknown', { bag: bagId }));
    return;
  }
  moveBagsTo(b, [bagId], _zcZone, function (moved) {
    if (!moved) {
      _zcFeedback('err', t('zoneCheck.scanUnknown', { bag: bagId }));
      return;
    }
    _zcFound.add(bagId);
    _zcMoved++;
    _zcFeedback('ok', t('zoneCheck.scanMoved', { bag: bagId, zone: zoneDisplayName(_zcZone) }));
  });
}
function openZoneCheck(zoneId) {
  _zcMode = 'zone';
  _zcZone = zoneId;
  _zcFound.clear();
  _zcMoved = 0;
  renderZoneCheck();
  document.getElementById('m-zonecheck').classList.add('open');
}
// Lab stocktake. Cultures have no location, so "expected" means every culture
// the records still say you hold (aktiv / eingelagert). Scan what is really on
// the shelf; whatever is left over is gone and gets marked aufgebraucht.
function openLabCheck() {
  _zcMode = 'culture';
  _zcZone = null;
  _zcFound.clear();
  _zcMoved = 0;
  renderZoneCheck();
  document.getElementById('m-zonecheck').classList.add('open');
}
function _zcExpected() {
  if (_zcMode === 'culture') {
    return cultures
      .filter((c) => c.status === 'active' || c.status === 'stored')
      .map((c) => [c.id, { batchId: (c.species || '') + (c.strainText ? ' · ' + c.strainText : '') }])
      .sort((a, b) => a[0].localeCompare(b[0]));
  }
  return Object.entries(getZoneBags(_zcZone)).sort((a, b) => a[0].localeCompare(b[0]));
}
function renderZoneCheck() {
  const expected = _zcExpected();
  document.getElementById('zc-title').textContent =
    _zcMode === 'culture' ? t('labCheck.title') : t('zoneCheck.title', { zone: zoneDisplayName(_zcZone) });
  document.getElementById('zc-count').textContent =
    t('zoneCheck.count', { found: _zcFound.size, total: expected.length }) +
    (_zcMoved ? ' · ' + t('zoneCheck.corrected', { n: _zcMoved }) : '');
  const body = document.getElementById('zc-body');
  if (!expected.length) {
    body.innerHTML =
      '<div style="color:var(--c-text-muted);font-style:italic;padding:14px 0">' + esc(t('zoneCheck.empty')) + '</div>';
    document.getElementById('zc-foot').innerHTML = '';
    return;
  }
  body.innerHTML = expected
    .map(([bagId, d]) => {
      const on = _zcFound.has(bagId);
      return (
        `<div data-zc-bag="${esc(bagId)}" style="display:flex;align-items:center;gap:10px;padding:11px 8px;border-bottom:0.5px solid var(--c-border);cursor:pointer;${on ? 'opacity:.5' : ''}">` +
        `<span class="fs-floor" style="width:22px;height:22px;flex:none;border-radius:6px;border:2px solid ${on ? 'var(--c-primary,#16a34a)' : 'var(--c-border)'};background:${on ? 'var(--c-primary,#16a34a)' : 'transparent'};color:#fff;display:grid;place-items:center;--fs-own:0.875rem;font-weight:700">${on ? '✓' : ''}</span>` +
        `<span class="fs-sm" style="font-family:monospace;font-weight:600;${on ? 'text-decoration:line-through' : ''}">${esc(bagId)}</span>` +
        `<span class="fs-meta" style="flex:1;min-width:0;color:var(--c-text-sec);overflow:hidden;text-overflow:ellipsis;white-space:nowrap">${esc(d.batchId || '')}</span>` +
        `</div>`
      );
    })
    .join('');
  const missing = expected.length - _zcFound.size;
  // The size lives on a class at each use rather than in this string: an
  // inline font-size beats every rule in the sheet, and the scan button next
  // to these wants the step above.
  const btn =
    'flex:1;min-width:130px;padding:11px;border-radius:10px;font-weight:600;cursor:pointer;border:1px solid var(--c-border)';
  // Scanning is the primary way to work through a zone; tapping rows is the
  // fallback for a bag whose label won't read.
  const scanBtn = `<button type="button" data-zc-act="scan" class="fs-base" style="${btn};flex-basis:100%;background:var(--c-primary,#16a34a);color:#fff;border-color:transparent;padding:13px">📷 ${esc(t('zoneCheck.scanBtn'))}</button>`;
  const missingBtns =
    _zcMode === 'culture'
      ? `<button type="button" data-zc-act="used" class="fs-sm" style="${btn};background:var(--c-surface);color:var(--c-red-dark)">${esc(t('labCheck.missingUsed', { n: missing }))}</button>`
      : `<button type="button" data-zc-act="move" class="fs-sm" style="${btn};background:var(--c-primary,#16a34a);color:#fff;border-color:transparent">${esc(t('zoneCheck.missingMove', { n: missing }))}</button>` +
        `<button type="button" data-zc-act="remove" class="fs-sm" style="${btn};background:var(--c-surface);color:var(--c-red-dark)">${esc(t('zoneCheck.missingRemove', { n: missing }))}</button>`;
  document.getElementById('zc-foot').innerHTML =
    scanBtn +
    (missing
      ? missingBtns
      : `<div class="fs-sm" style="flex:1;text-align:center;padding:10px;font-weight:600;color:var(--c-primary,#16a34a)">${esc(t('zoneCheck.allFound'))}</div>`);
}
// A culture scanned during a lab check is physically on the shelf: tick it off,
// and if the records had already written it off (aufgebraucht/kontaminiert),
// put it back to aktiv — the same "found where the records didn't expect it"
// correction the zone check does for bags.
function labCheckScanned(cultureId) {
  const c = cultures.find((x) => x.id && x.id.toUpperCase() === cultureId.toUpperCase());
  if (!c) {
    _zcFeedback('err', t('labCheck.scanUnknown', { id: cultureId }));
    return;
  }
  if (_zcFound.has(c.id)) {
    _zcFeedback('info', t('zoneCheck.scanDup', { bag: c.id }));
    return;
  }
  const total = _zcExpected().length;
  if (c.status === 'active' || c.status === 'stored') {
    _zcFound.add(c.id);
    _zcFeedback('ok', t('zoneCheck.scanOk', { found: _zcFound.size, total: total }));
    return;
  }
  setCultureStatus(c.id, 'active');
  _zcFound.add(c.id);
  _zcMoved++;
  _zcFeedback('ok', t('labCheck.scanRevived', { id: c.id }));
}
// Mark every culture that wasn't found as used up.
function _zcMarkMissingUsed() {
  const missing = _zcExpected()
    .map(([id]) => id)
    .filter((id) => !_zcFound.has(id));
  if (!missing.length) return;
  confirm2(t('labCheck.confirmTitle'), t('labCheck.confirmMsg', { n: missing.length }), t('lab.usedUp'), () => {
    missing.forEach((id) => setCultureStatus(id, 'used'));
    document.getElementById('m-zonecheck').classList.remove('open');
    setFb('ok', t('labCheck.done', { n: missing.length }));
  });
}
// Load the not-found bags into the shared selection, then hand off to the normal
// move picker / remove flow so the correction is an ordinary scan entry.
function _zcSelectMissing() {
  selectedLocBags.clear();
  _zcExpected().forEach(([bagId, d]) => {
    if (!_zcFound.has(bagId)) selectedLocBags.set(bagId, { batchId: d.batchId, loc: d.loc });
  });
  document.getElementById('m-zonecheck').classList.remove('open');
  return selectedLocBags.size;
}
async function locRemoveSelected() {
  if (!selectedLocBags.size) return;
  const n = selectedLocBags.size;
  if (!(await askConfirm(t('dash.remove'), t('scanFb.confirmRemove', { n: n }), t('dash.remove')))) return;
  const now = new Date().toISOString();
  const entries = [];
  selectedLocBags.forEach((d, bagId) => {
    const b = batches.find((x) => x.batchId === d.batchId);
    const entry = {
      time: now,
      action: 'REMOVE',
      batch: d.batchId,
      bag: bagId,
      from: d.loc,
      to: null,
      species: b?.species || null,
      strain: b?.strain || null,
      user: currentUser?.username || null,
      client_uuid: newScanUuid()
    };
    scanLog.push(entry);
    movements.push(entry);
    entries.push(entry);
    scan.count++;
  });
  lastLocUndoEntries = entries;
  selectedLocBags.clear();
  document.getElementById('m-locmove').classList.remove('open');
  apiPost('/api/scan-log', { entries }).then(function (r) {
    if (r && r.ids)
      entries.forEach((e, i) => {
        setEntryServerId(e, r.ids[i]);
      });
  });
  updateSD();
  renderStatus();
  setLocFb(t('scanFb.removed', { n: n }));
}
// The same element and the same skin setFb uses. It said `scan-toast` for a
// long time, which is not a class this sheet defines — the styling, the green,
// and `display:none` all hang off `.scan-toast-inline`. Writing the wrong base
// name dropped every one of them: the confirmation came out as bare text on the
// page, and because the hiding rule is `.scan-toast-inline` too, removing
// `visible` five seconds later hid nothing and it stayed there.
function setLocFb(msg) {
  const el = document.getElementById('scan-toast');
  el.className = 'scan-toast-inline fb-ok visible';
  el.innerHTML =
    msg +
    ' <button class="fs-xs" onclick="locUndo()" style="margin-left:8px;padding:2px 10px;border:1px solid var(--c-border);border-radius:4px;background:var(--c-surface);cursor:pointer;font-weight:600;pointer-events:auto">' +
    esc(t('dash.undo')) +
    '</button>';
  clearTimeout(_toastTimer);
  _toastTimer = setTimeout(() => el.classList.remove('visible'), 5000);
}
function locUndo() {
  if (!lastLocUndoEntries.length) return;
  const toUndo = lastLocUndoEntries;
  lastLocUndoEntries = [];
  // Remove exactly these entries by identity — NOT by position. A background
  // pollSync may have appended other users' rows since the move, so
  // splice(length - n, n) could drop the wrong local entries.
  for (const e of toUndo) {
    const si = scanLog.indexOf(e);
    if (si !== -1) scanLog.splice(si, 1);
    const mi = movements.indexOf(e);
    if (mi !== -1) movements.splice(mi, 1);
  }
  updateSD();
  renderStatus();
  // Delete each persisted row by its own id (owner-or-admin ACL) instead of the
  // admin-only DELETE /scan-log/last/N, which 403'd for workers (yet still
  // showed "success") and for admins deleted the globally-newest N rows —
  // possibly another user's scans. Report the real outcome.
  Promise.all(
    toUndo.map((e) =>
      e._serverId ? apiDelete('/api/scan-log/' + e._serverId).then((r) => !!r && !r.error) : Promise.resolve(false)
    )
  ).then((results) => {
    if (results.length && results.every(Boolean)) {
      setFb('ok', t('scanFb.undoOk'));
    } else {
      setFb('err', t('scanFb.undoFail'));
      refresh(); // re-sync so the UI reflects what actually persisted
    }
  });
}

// The number field and the buttons used to sit on top of each other, both
// setting the same value, and nothing said which one counted. The buttons now
// carry the sizes actually used; the field only appears for a weight that is
// none of them, and says so by being labelled "anderes".
//
// Das Gewicht eines Blocks, wo keins hergeleitet werden kann.
//
// Es gibt mehrere Größen, und eine davon ist die, die läuft. Die Zahl
// stand als 5 im Assistenten, als 3 im langen Formular und noch einmal als
// Rückfall in getAvgComp(), also drei Vorgaben für dieselbe Frage. Hergeleitet
// wird sie weiterhin, wo es geht: aus dem Rezept der Sorte, sonst aus dem
// Schnitt über alle Rezepte. Das hier ist der Boden darunter.
const NB_BAG_KG_DEFAULT = 3.8;
// Welche Gewichte angeboten werden, steht an den Knöpfen — nicht hier.
//
// Vorher stand die Liste zweimal im Code ('wbtn-3', 'wbtn-5') und ein drittes
// Mal als `kg === 3 || kg === 5`, und die Beschriftung war die Quelle der Zahl.
// Beim Wechsel auf Gewichte mit Komma wäre beides gebrochen: drei Stellen, die
// mitgeführt werden müssen, und parseFloat('2,5 kg') ist 2.
function nbWeightButtons() {
  return Array.from(document.querySelectorAll('#nb-weight-btns [data-kg]'));
}
function setBagWeight(kg) {
  const field = document.getElementById('nb-weight');
  if (!field) return;
  field.value = kg;
  let preset = false;
  nbWeightButtons().forEach((btn) => {
    const an = parseFloat(btn.dataset.kg) === kg;
    if (an) preset = true;
    btn.className = 'btn btn-sm' + (an ? ' btn-p' : '');
  });
  const other = document.getElementById('wbtn-other');
  if (other) other.className = 'btn btn-sm' + (preset ? '' : ' btn-p');
  field.style.display = preset ? 'none' : '';
  nbPreview();
}
// "anderes": show the field and let the worker type, whatever it says now.
function nbOtherWeight() {
  const field = document.getElementById('nb-weight');
  if (!field) return;
  field.style.display = '';
  nbWeightButtons().forEach((btn) => {
    btn.className = 'btn btn-sm';
  });
  const other = document.getElementById('wbtn-other');
  if (other) other.className = 'btn btn-sm btn-p';
  field.focus();
  field.select();
}
// Charge form ← product: fill the substrate/grain fields from a saved product
// spec so a charge can be made straight from "what was ordered". The product
// drives an internally-block batch that also deducts coir + raw grain.
let _nbProducts = [];
function _fillNbProducts() {
  const sel = document.getElementById('nb-product');
  if (!sel) return;
  apiGet('/api/products?active=1')
    .then((d) => {
      _nbProducts = (d.items || []).filter((p) => (p.prodType || 'buy') !== 'buy');
      const cur = sel.value;
      sel.innerHTML =
        `<option value="">${esc(t('batch.noProduct'))}</option>` +
        _nbProducts.map((p) => `<option value="${p.id}">${esc(p.name)}</option>`).join('');
      sel.value = cur;
    })
    .catch(() => {});
}
function _nbProductChanged() {
  const sel = document.getElementById('nb-product');
  const id = sel && sel.value ? parseInt(sel.value, 10) : null;
  if (!id) {
    nbPreview();
    return;
  }
  apiGet('/api/products/' + id)
    .then((p) => {
      if (!p || p.error) return;
      const set = (eid, val) => {
        const el = document.getElementById(eid);
        if (el) el.value = val;
      };
      const isCvg = (p.prodSubstrate || 'holzkleie') === 'cvg';
      // Über setBagWeight, sonst bleibt das Feld unsichtbar und ein Knopf
      // behauptet ein Gewicht, das nicht gebucht wird.
      if (p.prodBagKg != null) setBagWeight(parseDecimal(p.prodBagKg) || 0);
      set('nb-rh', p.prodRhPct != null ? p.prodRhPct : 0);
      set('nb-hw', isCvg ? 0 : p.prodHardwoodPct || 0);
      set('nb-wb', isCvg ? 0 : p.prodWheatbranPct || 0);
      set('nb-coir', isCvg ? p.prodCoirPct || 100 : 0);
      set('nb-grainkg', p.prodGrainKg || 0);
      set('nb-grainrh', p.prodGrainRhPct != null ? p.prodGrainRhPct : 52);
      const gyp = document.getElementById('nb-gyp');
      if (gyp) gyp.checked = !!p.prodGypsum;
      nbSubSum();
    })
    .catch(() => {});
}
function nbPreview() {
  const strainSel = document.getElementById('nb-strain-sel');
  const strainId = strainSel ? parseInt(strainSel.value) || null : null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  const sp = ms ? ms.name : '',
    st = ms ? ms.kuerzel : '';
  const qty = parseInt(document.getElementById('nb-qty').value) || 0;
  document.getElementById('nb-prev').textContent = sp && st ? genBatchId(sp) + ' (' + qty + ' bags)' : '—';
  const bagKg = parseDecimal(document.getElementById('nb-weight').value) || 0;
  if (!qty || !bagKg) {
    document.getElementById('nb-mat-preview').style.display = 'none';
    return;
  }
  // A Charge portioned out of a mix takes finished substrate, not pellets and
  // bran: db.js reverses such a Charge against the mix, never against the shelf.
  // Quoting a raw-material shortfall here warns about stock this Charge will not
  // touch, and nb-substrate-info already states the real draw. The raw-material
  // figures stay for the mixless path, which does still book off the shelf.
  if ((document.getElementById('nb-substrate-batch') || {}).value) {
    document.getElementById('nb-mat-preview').style.display = 'none';
    return;
  }
  const lines = [];
  // Eine Zeile je Zutat: was gebraucht wird, was da ist, und ob es reicht.
  const matLine = (label, pct, need, have) =>
    '<strong>' +
    esc(label) +
    (pct != null ? ' (' + pct + ' %)' : '') +
    ':</strong> ' +
    t('batch.matNeed', { need: fmtKg(need, 2), have: fmtKg(have, 1) }) +
    ' ' +
    (have >= need ? '\u2713' : t('batch.matShort', { kg: fmtKg(need - have, 1) }));
  {
    const hw = parseDecimal(document.getElementById('nb-hw').value) || 0;
    const wb = parseDecimal(document.getElementById('nb-wb').value) || 0;
    const coir = parseDecimal((document.getElementById('nb-coir') || {}).value) || 0;
    const rh = parseDecimal(document.getElementById('nb-rh').value) || 0;
    const gyp = document.getElementById('nb-gyp').checked;
    const grainKg = parseDecimal((document.getElementById('nb-grainkg') || {}).value) || 0;
    const grainRh = parseDecimal((document.getElementById('nb-grainrh') || {}).value) || 0;
    if (hw || wb || coir) {
      // Correct calculation: subtract water first, then split dry matter
      // dryKg = bagKg × (1 - rh/100)
      const dryKg = mtDryKg(bagKg, rh);
      const hwKg = qty * dryKg * (hw / 100);
      const wbKg = qty * dryKg * (wb / 100);
      const coirKg = qty * dryKg * (coir / 100);
      const gypKg = gyp ? qty * dryKg * 0.01 : 0;
      const hwStock = inventory.stock?.hardwood || 0;
      const wbStock = inventory.stock?.wheatbran || 0;
      const coirStock = inventory.stock?.coir || 0;
      const gypStock = inventory.stock?.gypsum || 0;
      if (rh > 0)
        lines.push(
          t('batch.matBag', { kg: fmtKg(bagKg, 1), dry: fmtKg(dryKg, 2), rh: rh })
        );
      if (hw) lines.push(matLine(t('batch.matHardwood'), hw, hwKg, hwStock));
      if (wb) lines.push(matLine(t('batch.matBran'), wb, wbKg, wbStock));
      if (coir) lines.push(matLine(t('batch.matCoir'), coir, coirKg, coirStock));
      if (gyp) lines.push(matLine(t('batch.matGypsum'), null, gypKg, gypStock));
      lines.push('<strong>' + esc(t('batch.matDryTotal')) + ':</strong> ' + fmtKg(dryKg, 2) + ' kg');
    }
    if (grainKg > 0) {
      const grainUsed = qty * mtDryKg(grainKg, grainRh);
      const grainStock = inventory.stock?.grain || 0;
      lines.push(matLine(t('batch.matGrain'), null, grainUsed, grainStock));
    }
  }
  const el = document.getElementById('nb-mat-preview');
  if (lines.length) {
    el.innerHTML = lines.join('<br>');
    el.style.display = 'block';
  } else el.style.display = 'none';
}
// ── "Beimpft mit" — what a new batch was inoculated from ─────
// One list for both kinds of inoculant, because the worker does not care which
// table it lives in: cultures (MC/PD/LC/G2G/GS) sit in `cultures`, grain spawn
// sits in `batches` as G-… with barcoded bags. Two separate fields asked them to
// know the difference; scanning does not.
//
// A grain bag always goes whole into the blocks, so it is written off when the
// batch saves. A liquid culture or petri is used many times over and stays in the
// system untouched — it leaves only when someone marks it used or contaminated.
// [{ kind: 'culture' | 'bag', id }]
let _inoc = [];
function inocAvailable() {
  const out = cultures
    .filter((c) => c.status === 'active' || c.status === 'stored')
    .map((c) => ({
      kind: 'culture',
      id: c.id,
      strainId: c.strainId || null,
      label: c.id + ' — ' + (c.strainName || c.species || '') + ' (' + c.type + ')'
    }));
  nbAvailableSpawnBags().forEach((b) =>
    out.push({
      kind: 'bag',
      id: b.bag,
      strainId: b.strainId || null,
      label: b.bag + ' — ' + b.species + ' (' + (b.loc ? zoneDisplayName(b.loc) : t('bagInfo.notPlaced')) + ')'
    })
  );
  return out;
}
// null when accepted, else the reason. Accepts a culture id or a grain bag id in
// any case, which is what a scanner hands over.
function inocAdd(rawId) {
  const id = String(rawId || '').trim();
  if (!id) return t('inoc.notUsable', { id: rawId });
  if (_inoc.some((x) => x.id.toUpperCase() === id.toUpperCase())) return t('inoc.already', { id });
  const hit = inocAvailable().find((x) => x.id.toUpperCase() === id.toUpperCase());
  if (!hit) {
    // Distinguish "known but spent" from "never heard of it" — the first is a
    // real answer, the second is probably a mis-scan.
    const c = cultures.find((x) => x.id.toUpperCase() === id.toUpperCase());
    if (c) return t('scanFb.cultureNotUsable', { id: c.id, status: c.status });
    return t('inoc.notUsable', { id });
  }
  _inoc.push({ kind: hit.kind, id: hit.id });
  return null;
}
function inocRemove(id) {
  _inoc = _inoc.filter((x) => x.id !== id);
}
// A batch's source_id column takes a culture. Grain bags are not cultures and are
// recorded in the scan log instead (inocVerbrauchtBuchen), so only the first culture
// in the list lands there — the full list still drives what gets written off.
function inocCultureId() {
  const c = _inoc.find((x) => x.kind === 'culture');
  return c ? c.id : '';
}
// Renders chips + the fallback picker into whichever prefix is on screen.
function inocRender(prefix) {
  const chips = document.getElementById(prefix + '-inoc-chips');
  if (chips)
    chips.innerHTML = _inoc
      .map(
        (x) =>
          `<span class="fs-xs" style="display:inline-flex;align-items:center;gap:5px;font-family:monospace;background:var(--c-bg);border:1px solid var(--c-border);border-radius:5px;padding:2px 4px 2px 7px">${esc(x.id)}<button type="button" data-action="inoc-drop" data-id="${esc(x.id)}" class="fs-sm" style="border:0;background:none;cursor:pointer;line-height:1;padding:0 3px;color:var(--c-text-muted)">✕</button></span>`
      )
      .join('');
  const sel = document.getElementById(prefix + '-inoc-pick');
  if (sel) {
    // Im geführten Ablauf nur, was zur gewählten Sorte passt: alle Kulturen und
    // Körnerbeutel des Betriebs in einer Liste liest am Telefon niemand.
    // In der Laborarbeit ebenso, und dazu nur, woraus diese Art angesetzt
    // werden darf (Körnerbeutel nur für Körnerbrut).
    const art = prefix === 'ms-q' ? msqParentTypes() : null;
    const sorte = prefix === 'wkb' ? WKB.strainId : art && _msQuickCtx.ms ? _msQuickCtx.ms.id : null;
    const passtZurArt = (x) => {
      if (!art) return true;
      if (x.kind === 'bag') return kornAlsHerkunft(art);
      const c = cultures.find((y) => y.id === x.id);
      return !!c && art.includes(c.type);
    };
    const free = inocAvailable().filter(
      (x) => !_inoc.some((y) => y.id === x.id) && (!sorte || !x.strainId || x.strainId === sorte) && passtZurArt(x)
    );
    sel.innerHTML =
      `<option value="">${esc(t('inoc.pick'))}</option>` +
      free.map((x) => `<option value="${esc(x.id)}">${esc(x.label)}</option>`).join('');
    sel.value = '';
  }
}
function inocPicked(prefix) {
  const sel = document.getElementById(prefix + '-inoc-pick');
  if (!sel || !sel.value) return;
  const err = prefix === 'ms-q' ? msqInocAdd(sel.value) : inocAdd(sel.value);
  if (err) setFb('err', err, { noModal: true });
  if (prefix === 'ms-q') msQuickRender();
  else inocRender(prefix);
}
// After the batch is safely saved. Ein Körnerbeutel geht immer ganz in die
// Blöcke — gescannt ist er
// verbraucht, auf jedem Weg und ohne Frage. Flüssigkultur und Petrischale werden
// viele Male benutzt: sie bleiben im System, und es wird auch nicht gefragt.
// Leer oder verunreinigt bucht sie aus, wer sie in der Hand hat.
function inocAskConsume(batchObj, list) {
  if (!list.length) return;
  const n = inocVerbrauchtBuchen(batchObj, list);
  if (n) toast(t('batch.spawnConsumed', { n: n, id: batchObj.batchId }));
}
// Die Körnerbeutel der Liste ausbuchen, mit der neuen Charge als Grund — alle,
// ohne Frage. Kein eigenes Rückgängig: die Leiste unten gehört dann der Meldung
// über die Charge. Zurück kommt, wieviele Körnerbeutel es waren.
function inocVerbrauchtBuchen(batchObj, list) {
  const bags = list.filter((x) => x.kind === 'bag').map((x) => x.id);
  return bags.length ? spawnBuchen(bags, 'spawn:' + batchObj.batchId).length : 0;
}
// ── Grain spawn consumed by a new block batch ────────────────
// Grain spawn lives in `batches` (G-… with barcoded bags), never in `cultures`,
// so nb-culture — which lists PD/LC/G2G/GS cultures — can never reference one.
// That left the grain generation missing from every lineage. Bags picked here are
// written off on create: a REMOVE carrying reason "spawn:<new batch id>", so the
// link lives in the scan log rather than needing a column, and it is naturally
// multi-valued (a 20-bag batch may take two grain bags).
// Which UI prefix ('nb' | 'ms-q' | 'wkb') has the camera open for a "Beimpft
// mit" scan, so the read lands in that field instead of opening the bag sheet or
// the lineage view. Cleared when the camera closes, or every later scan would be
// swallowed by a form the worker has moved on from.
let _inocScanPrefix = null;
// Ein Körnerbeutel ist verfügbar, solange er im Bestand zählt — dieselbe Regel
// wie in _grainKgOf(): kein REMOVE als letzter Scan, nicht in einer
// Kontaminationszone. Auch einer, der nie eingelagert wurde; er zählt dort mit,
// also muss man ihn auch verbrauchen können. Vorher fehlte er hier, und ein
// kontaminierter stand zur Auswahl.
function nbAvailableSpawnBags() {
  const placed = buildLastPlacementByBag();
  const out = [];
  batches.forEach((b) => {
    if (b.batchType !== 'grain') return;
    (b.bags || []).forEach((bag) => {
      const last = placed.get(String(bag).toUpperCase());
      if (last && last.action === 'REMOVE') return;
      const loc = (last && last.to) || null;
      const zone = loc ? ZONE_BY_ID[toZone(loc)] : null;
      if (zone && zone.role === 'contaminated') return;
      out.push({
        bag,
        loc,
        species: b.strainName || b.species || '',
        strainId: b.strainId || null,
        strainText: (b.strainText || '').trim()
      });
    });
  });
  return out.sort((a, z) => a.bag.localeCompare(z.bag));
}
// Ist dieser REMOVE ein verbrauchter Körnerbeutel — "spawn" vom Scanner, oder
// "spawn:<Charge>" vom Anlegen einer Charge —, und kein entsorgter Beutel?
function istVerbraucht(entry) {
  const r = entry && entry.reason;
  return !!entry && entry.action === 'REMOVE' && typeof r === 'string' && (r === 'spawn' || r.startsWith('spawn:'));
}
// Bucht Körnerbeutel als verbraucht aus: je Beutel ein REMOVE von dem Platz, an
// dem er stand — ohne Platz, wenn er nie eingelagert war —, mit dem Grund
// `reason`. Ein Beutel, der schon draußen ist, bekommt keinen zweiten Eintrag.
// opts.sitzung: die Einträge gehören zur laufenden Scan-Runde, ↩ in der Kamera
// nimmt sie zurück. Zurück kommen die Einträge, die gebucht wurden.
function spawnBuchen(bags, reason, opts) {
  const placed = buildLastPlacementByBag();
  const now = new Date().toISOString();
  const entries = [];
  bags.forEach((bag) => {
    const last = placed.get(String(bag).toUpperCase());
    if (last && last.action === 'REMOVE') return;
    const src = batches.find((b) => (b.bags || []).some((x) => x.toUpperCase() === String(bag).toUpperCase()));
    const entry = {
      time: now,
      action: 'REMOVE',
      batch: src ? src.batchId : null,
      bag,
      from: (last && last.to) || null,
      to: null,
      species: src ? src.species : null,
      strain: src ? src.strain : null,
      reason,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      _tempId: 's' + ++_scanTempIdCounter
    };
    scanLog.push(entry);
    movements.push(entry);
    if (opts && opts.sitzung) {
      if (!sessionStartTime) sessionStartTime = Date.now();
      sessionEntries.push(entry);
      scan.count++;
    }
    entries.push(entry);
  });
  if (!entries.length) return entries;
  _statusByBatch = null; // the grain batch may now be DONE
  _placementByBag = null; // and those jars are off the shelf
  _rhythmIndex = null;
  postScanEntries(entries, { zoneCheck: false });
  return entries;
}
// Rückgängig für spawnBuchen(): die Einträge gehen aus dem Log auf dem Telefon
// und auf dem Server wieder heraus, die Beutel stehen wieder im Bestand.
function spawnZuruecknehmen(entries) {
  entries.forEach(scanEintragZuruecknehmen);
  _statusByBatch = null;
  _placementByBag = null;
  _rhythmIndex = null;
  updateSD();
  renderStatus();
  // Dieselbe Leiste, auf der eben noch Rückgängig stand: dort schaut man hin.
  toast(t('batch.spawnBack', { n: entries.length }));
}
// Grain bags written off for a batch, read back out of the scan log.
function spawnSourceFor(batchId) {
  const key = 'spawn:' + batchId;
  return scanLog.filter((e) => e.action === 'REMOVE' && e.reason === key && e.bag).map((e) => e.bag);
}
function nbSubSum() {
  const hw = parseDecimal(document.getElementById('nb-hw').value) || 0,
    wb = parseDecimal(document.getElementById('nb-wb').value) || 0,
    s = hw + wb;
  document.getElementById('nb-subsum').textContent =
    hw || wb ? 'Total: ' + s + '%' + (s !== 100 ? ' — should add up to 100%' : '') : '';
  // Mirror the composition into the collapsed summary. Empty inputs read as 0
  // and deduct nothing, which is invisible with the section closed — so say so
  // there rather than letting the placeholders imply a value is set.
  const head = document.getElementById('nb-sub-head');
  if (head) {
    const coir = parseDecimal((document.getElementById('nb-coir') || {}).value) || 0;
    const rh = parseDecimal((document.getElementById('nb-rh') || {}).value) || 0;
    if (coir) head.textContent = '— CVG ' + coir + '%' + (rh ? ' @ ' + rh + '% RH' : '');
    else if (hw || wb) head.textContent = '— ' + hw + '/' + wb + (rh ? ' @ ' + rh + '% RH' : '');
    else head.textContent = '— ' + t('batch.noDeduction');
  }
  nbPreview();
}
// Remember the reusable new-batch inputs across batches and reloads, so a
// Charge opens with the same bag count / incubation days / weight / substrate
// mix instead of retyping them. Strain, culture and notes are intentionally
// NOT remembered — they are per-batch decisions and a stale strain carried
// over would be a silent mislabel.
let _nbDefaultsApplied = false;
// Das lange Chargenformular, bevor jemand hineinschreibt: Produkte laden, beim
// ersten Mal in einer Sitzung die gemerkten Vorgaben setzen, die Beimpfungsliste
// auffrischen (Beutel werden zwischen zwei Chargen verbraucht und angelegt).
//
// Das stand in openStab('batch', 'new') und war der einzige Grund, warum der
// Schnelldialog und der geführte Ablauf erst auf die Chargenseite wechselten,
// bevor sie das Rezept eintrugen — sonst hätte der erste Besuch der Sitzung
// überschrieben, was sie gerade gesetzt hatten. Jetzt bleiben sie, wo sie sind:
// das Formular ist ihre Ablage, nicht ihr Ziel.
function nbEnsureReady() {
  _fillNbProducts();
  if (!_nbDefaultsApplied) {
    nbApplyDefaults();
    _nbDefaultsApplied = true;
  }
  inocRender('nb');
}
// Hochzählen, wenn sich die angebotenen Beutelgewichte ändern: nbApplyDefaults
// verwirft ein gespeichertes Gewicht mit älterem Stempel genau einmal, damit die
// neue Vorgabe auf einem Gerät ankommt, das die App schon kennt.
const NB_DEFAULTS_WEIGHT_V = 3;
function nbSaveDefaults() {
  try {
    const g = (id) => (document.getElementById(id) || {}).value;
    localStorage.setItem(
      'mp-nb-defaults',
      JSON.stringify({
        qty: g('nb-qty'),
        days: g('nb-days'),
        weight: g('nb-weight'),
        wv: NB_DEFAULTS_WEIGHT_V,
        hw: g('nb-hw'),
        wb: g('nb-wb'),
        coir: g('nb-coir'),
        rh: g('nb-rh'),
        grainkg: g('nb-grainkg'),
        grainrh: g('nb-grainrh'),
        gyp: !!(document.getElementById('nb-gyp') || {}).checked
      })
    );
  } catch (e) {
    /* storage disabled — nothing persisted, form just keeps HTML defaults */
  }
}
// Strip keys whose stored value is empty/null so they fall through to the seed
// below rather than blanking a field that has a sensible default.
function _dropEmpty(obj) {
  const out = {};
  Object.keys(obj || {}).forEach((k) => {
    const v = obj[k];
    if (v !== undefined && v !== null && v !== '') out[k] = v;
  });
  return out;
}
function nbApplyDefaults() {
  let d = null;
  try {
    d = JSON.parse(localStorage.getItem('mp-nb-defaults') || 'null');
  } catch (e) {
    d = null;
  }
  // The composition inputs carry only placeholders, never a value attribute, so
  // an untouched form reads as 0/0 — and createBatch treats "no composition" as
  // "consumes no material" and silently deducts nothing. Seed them from the
  // configured average composition so a fresh device (or a cleared storage)
  // starts from the real recipe instead of blank. Saved values still win; the
  // seed only fills what is missing or was stored empty.
  const _avg = getAvgComp();
  const seeded = {
    hw: _avg.hwPct,
    wb: _avg.wbPct,
    rh: _avg.rhPct,
    grainrh: _avg.grainRhPct,
    // Das Gewicht wurde nur gespeichert, nie gesät: ein Gerät ohne Vorrat fiel
    // auf das value-Attribut im HTML zurück, und das war eine vierte Vorgabe.
    weight: _avg.bagKg
  };
  // Ein Gewicht, das ein Benutzer gewählt hat, bleibt stehen — das ist der Sinn
  // dieses Vorrats. Ein Gewicht, das er nur geerbt hat, weil damals 3 bzw. 5 kg
  // in den Knöpfen standen, ist keine Wahl, und es überstimmte sonst die neue
  // Vorgabe auf jedem Gerät, das die App schon einmal offen hatte. Einmal
  // verworfen, danach merkt sich das Feld wieder, was zuletzt gewählt wurde.
  if (d && d.wv !== NB_DEFAULTS_WEIGHT_V) delete d.weight;
  d = d ? Object.assign(seeded, _dropEmpty(d)) : seeded;
  const put = (id, v) => {
    if (v === undefined || v === null || v === '') return;
    const el = document.getElementById(id);
    if (el) el.value = v;
  };
  put('nb-qty', d.qty);
  put('nb-days', d.days);
  // Siehe _nbProductChanged: das Gewicht geht immer durch setBagWeight, damit
  // Knopf, Feld und gebuchter Wert dasselbe sagen.
  if (d.weight != null && d.weight !== '') setBagWeight(parseDecimal(d.weight) || 0);
  put('nb-hw', d.hw);
  put('nb-wb', d.wb);
  put('nb-coir', d.coir);
  put('nb-rh', d.rh);
  put('nb-grainkg', d.grainkg);
  put('nb-grainrh', d.grainrh);
  const gyp = document.getElementById('nb-gyp');
  if (gyp) gyp.checked = !!d.gyp;
  renderNbGrainBanner();
  nbSubSum(); // also refreshes the material preview
}
// async since the two warnings inside became dialogs rather than window.confirm().
// Both internal callers invoke it as their last statement and ignore the result,
// and $('btn-24') is a click handler, so nothing was waiting on it before either.
// pH aus einem Feld: null für leer, undefined für nicht lesbar oder außerhalb
// 0–14. Zwei verschiedene Antworten, weil leer erlaubt ist und vertippt nicht.
function phLesen(raw) {
  const s = String(raw == null ? '' : raw).trim();
  if (s === '') return null;
  const v = parseDecimal(s);
  return Number.isFinite(v) && v >= 0 && v <= 14 ? v : undefined;
}
function nbPhLesen() {
  const el = document.getElementById('nb-ph');
  return el ? phLesen(el.value) : null;
}

async function createBatch() {
  // Angesetzt am: gesetzt nur von dem Arbeitsgang, der hierher übergibt, und
  // gelesen als Erstes — auch wenn gleich eine Prüfung abbricht, soll kein Datum
  // für die nächste Charge stehen bleiben.
  const angesetzt = anlageNehmen(document.getElementById('nb-created'));
  const wann = anlageZeitpunkt(angesetzt);
  // Ein früherer Tag ist Bestand aus der Inventur: angelegt wird die Charge, mit
  // ihrer Mischung, aber vom Lager geht nichts ab. Das Material ist längst
  // verbraucht, und das Regal wird bei der Inventur gezählt (anlageFrueher).
  const bucht = !angesetzt;
  const strainSel = document.getElementById('nb-strain-sel');
  const strainId = strainSel ? parseInt(strainSel.value) || null : null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  if (!strainId || !ms) {
    if (!mushroomStrains.length) {
      confirm2(t('strains.noStrainsHint'), '', t('strains.createNow'), goCreateStrain);
    } else {
      toast(t('strains.noStrainsHint'), 'err');
    }
    return;
  }
  const sp = ms.name + ' (' + ms.kuerzel + ')';
  const strainText = (document.getElementById('nb-strain-text') || {}).value?.trim() || '';
  const st = strainText || 'XXX';
  const qty = parseInt(document.getElementById('nb-qty').value) || 0,
    days = parseInt(document.getElementById('nb-days').value) || 14;
  const bagKg = parseDecimal(document.getElementById('nb-weight').value) || 0;
  if (qty < 1) {
    fieldError('nb-qty', t('batch.fillQty'));
    return;
  }
  // Gemessen beim Beimpfen, freiwillig. Für beide Wege unten geprüft: aus dem
  // Ansatz liest createBatchFromSubstrate dasselbe Feld.
  const ph = nbPhLesen();
  if (ph === undefined) {
    fieldError('nb-ph', t('batch.phNaN'));
    return;
  }
  // v67: portioned out of an existing mix. None of the composition and delta
  // machinery below applies — that substrate was booked when it was mixed, and
  // the server takes the kilograms out of the mix and charges only the spawn.
  const _sbSel = document.getElementById('nb-substrate-batch');
  if (_sbSel && _sbSel.value) {
    createBatchFromSubstrate(
      genBatchId(ms.name, wann),
      _sbSel.value,
      strainId,
      qty,
      bagKg || ms.recBagKg || NB_BAG_KG_DEFAULT,
      days,
      st,
      strainText,
      angesetzt ? { created: wann.toISOString() } : undefined
    );
    return;
  }
  if (!bagKg) {
    fieldError('nb-weight', t('batch.enterWeight'));
    return;
  }
  const hw = parseDecimal(document.getElementById('nb-hw').value) || 0,
    wb = parseDecimal(document.getElementById('nb-wb').value) || 0;
  // All-in-One / CVG fields (0 for plain holz+kleie blocks → no effect).
  const coir = parseDecimal((document.getElementById('nb-coir') || {}).value) || 0;
  const grainKg = parseDecimal((document.getElementById('nb-grainkg') || {}).value) || 0;
  const grainRh = parseDecimal((document.getElementById('nb-grainrh') || {}).value) || 0;
  // I-19: substrate must total exactly 100% (within rounding). Previously the
  // check only fired on > 100; a 70/20 split silently consumed 90% of the dry
  // mass and the remaining 10% went unaccounted. Now we reject any drift in
  // either direction. Skip when both fields are zero (no substrate composition,
  // e.g. grain-spawn batches or batches that opt out of detailed tracking).
  // coir counts toward the same 100%. It is deducted alongside hardwood and
  // wheatbran below, but was left out of this sum — and nb-coir persists across
  // batches (nbSaveDefaults/nbApplyDefaults, and createBatch keeps the fields
  // populated after submit). So after one CVG batch left coir at 100, entering a
  // normal 70/30 block passed the check and then deducted 70% hardwood + 30%
  // wheatbran + 100% coir: 200 kg of raw material booked against 100 kg of actual
  // dry substrate. The mirror case (0/0/50) skipped the check entirely and
  // under-deducted by half.
  const subTotal = hw + wb + coir;
  if ((hw || wb || coir) && Math.abs(subTotal - 100) > 0.01) {
    // The sum is of three fields; the first that carries a number is the one
    // the cursor lands in, because a ring on an empty field explains nothing.
    fieldError(hw ? 'nb-hw' : wb ? 'nb-wb' : 'nb-coir', t('batch.substrateExceeds', { sum: subTotal }));
    return;
  }
  // Nothing to deduct at all: the substrate block below is skipped and the batch
  // consumes no material on paper. That is a legitimate choice for batches that
  // opt out of material tracking, but it used to be indistinguishable from an
  // untouched form — the inputs only carry placeholders, so a collapsed
  // "Substrat" section read as 70/30 while actually submitting 0/0, and stock
  // drifted with no signal. Make the no-op explicit instead of silent.
  // Bei Bestand aus der Inventur bucht die Charge ohnehin nichts ab — die Frage,
  // ob wirklich nichts abgebucht werden soll, hat dann keine andere Antwort.
  if (bucht && !hw && !wb && !coir && !grainKg) {
    const weiter = await askConfirm(t('batch.noSubstrateTitle'), t('batch.noSubstrateWarn'), t('common.proceed'));
    if (!weiter) return;
  }
  const substrate =
    hw || wb || coir
      ? {
          hardwood: hw,
          wheatbran: wb,
          coir,
          rh: parseDecimal(document.getElementById('nb-rh').value) || null,
          gypsum: document.getElementById('nb-gyp').checked
        }
      : null;
  // Pre-flight inventory check — warn before silently draining substrate.
  // The deduction code below uses Math.max(0, stock - used), which means an
  // over-commit silently clamps to zero with no signal to the worker. They
  // walk away thinking everything's fine, then run out mid-week. Prompt
  // first so they can either top up before submitting or knowingly proceed.
  // Not for stocktake entries: they take nothing, so nothing can run short.
  if (bucht) {
    const _rhPct = (substrate && substrate.rh) || 0;
    const _dryKg = mtDryKg(bagKg, _rhPct);
    const _hwUsed = qty * _dryKg * (hw / 100);
    const _wbUsed = qty * _dryKg * (wb / 100);
    const _coirUsed = qty * _dryKg * (coir / 100);
    const _gypUsed = substrate && substrate.gypsum ? qty * _dryKg * 0.01 : 0;
    const _grainUsed = grainKg > 0 ? qty * mtDryKg(grainKg, grainRh) : 0;
    const _stock = inventory.stock || {};
    const _shortages = [];
    if (_hwUsed > (_stock.hardwood || 0))
      _shortages.push(
        'Hardwood: ' + (_stock.hardwood || 0).toFixed(1) + ' kg vorhanden, ' + _hwUsed.toFixed(1) + ' kg nötig'
      );
    if (_wbUsed > (_stock.wheatbran || 0))
      _shortages.push(
        'Wheat bran: ' + (_stock.wheatbran || 0).toFixed(1) + ' kg vorhanden, ' + _wbUsed.toFixed(1) + ' kg nötig'
      );
    if (_coirUsed > (_stock.coir || 0))
      _shortages.push(
        'Kokos/CVG: ' + (_stock.coir || 0).toFixed(1) + ' kg vorhanden, ' + _coirUsed.toFixed(1) + ' kg nötig'
      );
    if (_gypUsed > (_stock.gypsum || 0))
      _shortages.push(
        'Gypsum: ' + (_stock.gypsum || 0).toFixed(1) + ' kg vorhanden, ' + _gypUsed.toFixed(1) + ' kg nötig'
      );
    if (_grainUsed > (_stock.grain || 0))
      _shortages.push(
        'Grain: ' + (_stock.grain || 0).toFixed(1) + ' kg vorhanden, ' + _grainUsed.toFixed(1) + ' kg nötig'
      );
    if (_shortages.length) {
      const weiter = await askConfirm(
        t('inv.shortageTitle'),
        t('inv.shortageWarn') + '\n\n' + _shortages.join('\n') + '\n\n' + t('inv.shortageProceed'),
        t('common.proceed')
      );
      if (!weiter) return;
    }
  }
  const batchId = genBatchId(ms.name, wann);
  spColor(ms.name);
  // Fällig ab dem Tag, an dem angesetzt wurde — bei einer Charge aus der
  // Inventur kann das schon vorbei sein, und dann ist sie es eben.
  const due = new Date(wann);
  due.setDate(due.getDate() + days);
  const bags = Array.from({ length: qty }, (_, i) => batchId + '-' + String(i + 1).padStart(2, '0'));
  const batchType = 'block';
  batches.push({
    batchId,
    species: sp,
    strain: st,
    strainId,
    strainName: ms.name,
    strainKuerzel: ms.kuerzel,
    qty,
    days,
    substrate,
    bagKg,
    batchType,
    grainKg,
    grainRh,
    sourceId: inocCultureId() || document.getElementById('nb-culture').value || null,
    notes: document.getElementById('nb-notes').value.trim(),
    ph,
    strainText,
    created: wann.toISOString(),
    due: due.toISOString(),
    bags
  });

  // Compute inventory deltas up front so they can travel with the POST and be
  // applied atomically on the server (I-02).
  if (!inventory.stock) inventory.stock = { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0, coir: 0 };
  const deltas = [];
  const stockSnapshot = { ...inventory.stock };
  // Ohne Buchung (Inventur) bleiben die Deltas leer und der Bestand auf dem
  // Bildschirm, wie er ist — die Mischung steht trotzdem an der Charge.
  if (substrate && bucht) {
    const rh = parseDecimal(document.getElementById('nb-rh').value) || 0;
    const dryKgPerBag = mtDryKg(bagKg, rh);
    const hwUsed = qty * dryKgPerBag * (hw / 100);
    const wbUsed = qty * dryKgPerBag * (wb / 100);
    const coirUsed = qty * dryKgPerBag * (coir / 100);
    if (hwUsed > 0) {
      inventory.stock.hardwood = Math.max(0, inventory.stock.hardwood - hwUsed);
      deltas.push({ mat: 'hardwood', deltaKg: -hwUsed, type: 'batch', ref: batchId });
    }
    if (wbUsed > 0) {
      inventory.stock.wheatbran = Math.max(0, inventory.stock.wheatbran - wbUsed);
      deltas.push({ mat: 'wheatbran', deltaKg: -wbUsed, type: 'batch', ref: batchId });
    }
    if (coirUsed > 0) {
      inventory.stock.coir = Math.max(0, (inventory.stock.coir || 0) - coirUsed);
      deltas.push({ mat: 'coir', deltaKg: -coirUsed, type: 'batch', ref: batchId });
    }
    if (substrate.gypsum) {
      const gypUsed = qty * dryKgPerBag * 0.01;
      inventory.stock.gypsum = Math.max(0, inventory.stock.gypsum - gypUsed);
      deltas.push({ mat: 'gypsum', deltaKg: -gypUsed, type: 'batch', ref: batchId });
    }
  }
  // All-in-One raw-grain portion mixed into the block (independent of substrate).
  if (grainKg > 0 && bucht) {
    const grainUsed = qty * mtDryKg(grainKg, grainRh);
    if (grainUsed > 0) {
      inventory.stock.grain = Math.max(0, (inventory.stock.grain || 0) - grainUsed);
      deltas.push({ mat: 'grain', deltaKg: -grainUsed, type: 'batch', ref: batchId });
    }
  }

  // Save batch + inventory deltas atomically on the server
  const batchObj = batches[batches.length - 1];
  // Snapshot the grain bags now: the form is cleared below, well before the POST
  // resolves, and they are only written off once the batch is known to be saved.
  let _inocUsed = _inoc.slice();
  const createBtn = document.getElementById('btn-24');
  if (createBtn) createBtn.disabled = true;
  apiPost('/api/batches', { ...batchObj, deltas })
    .then((r) => {
      if (r && r.error) {
        // Rollback local state so UI reflects server truth (e.g. duplicate batchId)
        const i = batches.findIndex((b) => b.batchId === batchObj.batchId);
        if (i >= 0) batches.splice(i, 1);
        // Roll back the optimistic stock mutation too — server didn't apply the deltas.
        inventory.stock = stockSnapshot;
        toast(t('batch.saveFailed') + r.error, 'err');
        renderBatches();
        renderStatus();
        return;
      }
      // Register new barcode numbers from server response
      if (r && r.bagBarcodes) {
        for (const [id, bc] of Object.entries(r.bagBarcodes)) {
          barcodeRegistry.set(bc, { type: 'bag', id });
          barcodeByEntity.set('bag:' + id, bc);
        }
      }
      // Grain bag (G2G/GS) is fully consumed by one inoculation — mark it used
      if (batchObj.sourceId) {
        const src = cultures.find((c) => c.id === batchObj.sourceId);
        if (src && (src.type === 'G2G' || src.type === 'GS') && src.status !== 'used') {
          setCultureStatus(src.id, 'used');
        }
      }
      // Same idea for real grain-spawn bags, which are batches rather than
      // cultures. Only after the batch is known to have saved — writing the bags
      // off first would strip spawn inventory for a batch that then failed.
      inocAskConsume(batchObj, _inocUsed);
      _inocUsed = [];
      renderBatches();
      renderStatus();
    })
    .finally(() => {
      if (createBtn) createBtn.disabled = false;
    });
  nbSaveDefaults();
  if (document.getElementById('nb-strain-sel')) document.getElementById('nb-strain-sel').value = '';
  const nbStrainTextEl = document.getElementById('nb-strain-text');
  if (nbStrainTextEl) nbStrainTextEl.value = '';
  const nbCultureEl = document.getElementById('nb-culture');
  if (nbCultureEl) nbCultureEl.value = '';
  _inoc = [];
  inocRender('nb');
  renderNbGrainBanner();
  // qty/days/weight/substrate intentionally kept (persisted via nbSaveDefaults
  // above) so the next batch reuses them; only per-batch fields are cleared.
  document.getElementById('nb-notes').value = '';
  if (document.getElementById('nb-ph')) document.getElementById('nb-ph').value = '';
  document.getElementById('nb-mat-preview').style.display = 'none';
  nbPreview();
  updateTodoBadge();
  // Show zone picker — required before print
  nbPlaceAndPrint(batchObj, bags);
}

// Der Schluss jedes Weges, der Beutel anlegt: erst einlagern, dann Etiketten.
//
// Das stand als Rumpf am Ende von createBatch, und der geführte Ablauf kam gar
// nicht hier vorbei — er zieht über createBatchFromSubstrate und endete mit
// seiner Quittung. So konnten Chargen entstehen, die kein einziger ADD-Scan
// je berührt hat: für getStatus sind sie EMPTY, das Dashboard zeigt sie nicht,
// jeder Umzug überspringt sie, und Etiketten hat auch niemand gedruckt. Die
// Zonenwahl ist ein Tor, kein Angebot — deshalb liegt sie jetzt an einer
// Stelle, die alle Wege durchlaufen, statt an einer, die einer davon umgeht.
//
// Der Aufrufer muss vorher sein eigenes Fenster schließen. m-move-batch und
// m-batch-print stehen in index.html VOR m-work-flow und teilen sich dessen
// z-index, also läge beides hinter dem Ablauffenster — derselbe Fehler wie in
// #592.
function nbPlaceAndPrint(batchObj, bags) {
  openZonePickModal(batchObj, bags, function () {
    const liste = document.getElementById('nb-bags');
    if (liste)
      liste.innerHTML = bags
        .map(
          (b) =>
            `<span class="fs-micro" style="font-family:monospace;background:var(--c-bg);padding:2px 6px;border-radius:4px;color:var(--c-text-sec)">${esc(b)}</span>`
        )
        .join('');
    // printBatchLabelsInline liest die Charge von hier, auch wenn die
    // Chargenseite gar nicht im Bild ist.
    const _res = document.getElementById('nb-result');
    if (_res) _res.dataset.batchId = batchObj.batchId;
    const kopf = document.getElementById('nbp-head');
    if (kopf) kopf.textContent = t('batch.printFor', { id: batchObj.batchId, n: bags.length });
    nbpOpen();
  });
}
// ─── SUBSTRATE BATCHES (v67) ─────────────────────────────────
// Two cards, because there are two steps and they cost different things. The
// mix card turns kilograms of finished substrate into a shopping list and books
// it against the shelf. The Charge card spends kilograms of an existing mix and
// books only the spawn. Neither computes anything the server does not: the
// browser posts a recipe and an amount, and the figures come back.
let _sbTimer = null;
let _sbLast = null;
let _sbList = [];

// Wie lange der Hahn laufen muss, als mm:ss.
//
// Die Literzahl allein beantwortet die Frage nicht, die man am Hahn hat. Der
// Durchfluss steht in inventory.water_flow_lmin (Vorgabe 10 L/min), und db.js
// legt waterMinutes damit schon jedem Ansatz bei — angezeigt wurde es nur in
// der Rechner-Vorschau, nicht im Arbeitsgang, also genau dort nicht, wo man
// davorsteht.
//
// Auf ganze Sekunden runden und DANN teilen: gegen eine getrennt abgerundete
// Minute gerechnet, druckt alles knapp unter der vollen Minute "10:60".
function waterTimeText(minutes) {
  const n = Number(minutes);
  if (!Number.isFinite(n) || n <= 0) return '–';
  const s = Math.round(n * 60);
  return Math.floor(s / 60) + ':' + String(s % 60).padStart(2, '0') + ' min';
}
function sbPreviewSoon() {
  clearTimeout(_sbTimer);
  _sbTimer = setTimeout(sbPreview, 250);
}

// ── Die Mischung im Ansatz-Formular ──────────────────────────
// Das Rezept der Sorte belegt die Felder, danach gehören sie diesem einen
// Ansatz. Wer 70/30 mischen will, tippt hier 70 — vorher hätte er dafür das
// Rezept der Sorte umschreiben müssen, und damit jeden künftigen Ansatz mit.
const SB_BLEND_FIELDS = ['sb-hw', 'sb-wb', 'sb-corn', 'sb-gyp', 'sb-ca', 'sb-rh'];
function _sbNum(id) {
  const el = document.getElementById(id);
  if (!el || el.value === '') return null;
  const v = parseDecimal(el.value);
  return Number.isFinite(v) ? v : null;
}
function _sbSet(id, v) {
  const el = document.getElementById(id);
  if (el) el.value = v == null ? '' : String(Math.round(v * 100) / 100);
}
// Die Mischungen, aus denen ein Ansatz gewählt wird. Ein Ansatz ist
// sortenneutral, also wählt man die Mischung, nicht die Sorte. Was es gibt,
// steht in der Datenbank (Tabelle recipes), nicht hier.
let _sbRecipes = [];
let _sbRecipesLoaded = false;
// Angesetzt wird in Beuteln: Anzahl mal Beutelgröße ergibt die Kilo, die der
// Server rechnet. Die zuletzt gewählte Größe merkt sich das Gerät, damit nach
// dem Wechsel auf die größeren Beutel nicht jedes Mal umgetippt werden muss.
const SB_BAG_SIZES = [3.8, 5];
let _sbBagKg = null;
function sbBagKg() {
  if (_sbBagKg == null) {
    let v = NaN;
    try {
      v = parseFloat(localStorage.getItem('mp-sb-bagkg'));
    } catch (e) {}
    _sbBagKg = SB_BAG_SIZES.includes(v) ? v : NB_BAG_KG_DEFAULT;
  }
  return _sbBagKg;
}
function sbSetBagKg(v) {
  if (!SB_BAG_SIZES.includes(v)) return;
  _sbBagKg = v;
  try {
    localStorage.setItem('mp-sb-bagkg', String(v));
  } catch (e) {}
}
function sbBagChips(attr) {
  const cur = sbBagKg();
  return SB_BAG_SIZES.map(
    (k) =>
      `<button type="button" class="wkf-w${k === cur ? ' on' : ''}" ${attr}="${k}">${esc(fmtKg(k, k % 1 ? 1 : 0))} kg</button>`
  ).join('');
}
function sbRenderBagChips() {
  const box = document.getElementById('sb-bagkg-btns');
  if (box) box.innerHTML = sbBagChips('data-sb-bagkg');
}
// Auf Gramm gerundet: 3,8 × 3 ist in Gleitkomma 11,399999…
function sbTargetKg(bags, bagKg) {
  return Math.round(bags * bagKg * 1000) / 1000;
}
// Ganze Beutel; alles andere zählt als keine Angabe.
function sbParseBags(v) {
  const n = Number(String(v == null ? '' : v).trim());
  return Number.isInteger(n) && n > 0 ? n : 0;
}
(function wireSbBagChips() {
  const box = document.getElementById('sb-bagkg-btns');
  if (!box) return;
  sbRenderBagChips();
  box.addEventListener('click', (e) => {
    const b = e.target.closest('[data-sb-bagkg]');
    if (!b) return;
    sbSetBagKg(parseFloat(b.dataset.sbBagkg));
    sbRenderBagChips();
    sbPreview();
  });
})();

// Das Wasser, wie es am Hahn gebraucht wird: erst `nowL`, dann messen, dann
// höchstens `restL`. Der Server rechnet Lernfaktor und Rückhalt; ein älterer
// Server ohne `water` bekommt hier dieselbe Form mit der reinen Rechnung.
function sbWater(r) {
  if (r && r.water) return r.water;
  const m = (r && r.mix) || {};
  return {
    calcL: m.waterL || 0,
    factor: 1,
    n: 0,
    plannedL: m.waterL || 0,
    holdbackPct: 0,
    nowL: m.waterL || 0,
    restL: 0,
    nowMinutes: m.waterMinutes || 0
  };
}
// Woher die Zahl kommt, in einer Zeile: gerechnet, was gelernt ist, was
// zurückgehalten wird.
function sbWaterHint(w) {
  const pct = Math.round((w.factor - 1) * 100);
  return t(w.n ? 'sub.waterHintLearned' : 'sub.waterHintNone', {
    calc: fmtKg(w.calcL, 1),
    n: w.n,
    pct: (pct > 0 ? '+' : pct < 0 ? '−' : '±') + Math.abs(pct),
    hold: fmtKg(w.holdbackPct, w.holdbackPct % 1 ? 1 : 0)
  });
}

// Restfeuchte der Sackware: was Pellets und Kleie an Wasser schon mitbringen.
// Der Server rechnet damit; hier wird sie nur gezeigt und geändert.
async function loadResidualMoisture() {
  const r = await apiGet('/api/substrate-moisture');
  if (!r || r.error) return;
  const hw = document.getElementById('sb-resid-hw');
  const wb = document.getElementById('sb-resid-wb');
  const sum = document.getElementById('sb-resid-sum');
  const pct = (v) => fmtKg(v, v % 1 ? 1 : 0) + ' %';
  if (hw) hw.value = String(r.pelletsPct).replace('.', ',');
  // Leer heißt: wie die Pellets. Das Feld zeigt es dann auch so, statt leer zu
  // bleiben und nach "nicht berücksichtigt" auszusehen.
  const bran = r.branPct == null ? r.pelletsPct : r.branPct;
  if (wb) wb.value = String(bran).replace('.', ',');
  const hold = document.getElementById('sb-resid-hold');
  if (hold) hold.value = String(r.holdbackPct).replace('.', ',');
  if (sum)
    sum.textContent = ' · ' + t('sub.pellets') + ' ' + pct(r.pelletsPct) + ', ' + t('sub.bran') + ' ' + pct(bran) + ', ' + t('sub.holdback') + ' ' + pct(r.holdbackPct);
}
async function sbSaveResidual() {
  const val = (id) => {
    const raw = ((document.getElementById(id) || {}).value || '').trim();
    return raw === '' ? null : parseDecimal(raw);
  };
  const r = await apiPost('/api/substrate-moisture', {
    pelletsPct: val('sb-resid-hw'),
    branPct: val('sb-resid-wb'),
    holdbackPct: val('sb-resid-hold')
  });
  if (!r || r.error) {
    toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
    return;
  }
  toast(t('sub.residSaved'));
  await loadResidualMoisture();
  sbPreview();
}

async function loadSubstrateRecipes(force) {
  if (_sbRecipesLoaded && !force) return;
  loadResidualMoisture();
  const r = await apiGet('/api/recipes');
  if (!Array.isArray(r)) return;
  _sbRecipes = r;
  _sbRecipesLoaded = true;
  fillSbRecipeSelect();
}
function sbRecipeOptions(selectedId) {
  return _sbRecipes
    .map((x) => `<option value="${x.id}"${x.id === selectedId ? ' selected' : ''}>${esc(x.name)}</option>`)
    .join('');
}
function fillSbRecipeSelect() {
  const el = document.getElementById('sb-recipe');
  if (!el) return;
  const cur = parseInt(el.value, 10);
  const opts = '<option value="">' + esc(t('sub.pickMix')) + '</option>' + sbRecipeOptions(cur);
  if (el.innerHTML === opts) return;
  el.innerHTML = opts;
  sbFillBlendFromRecipe();
}
// Die gewählte Mischung, so wie die Mischrechnung sie liest. Der Pelletanteil
// steht nicht darin: er ist der Rest, und zwei Zahlen für dieselbe Größe
// driften auseinander.
function sbRecipeOf(recipeId) {
  const r = _sbRecipes.find((x) => x.id === recipeId);
  if (!r) return null;
  return {
    branPct: +r.wheatbranPct || 0,
    cornPct: 0,
    gypsumPct: +r.gypsumPct || 0,
    // Gespeicherte Mischungen kennen kein Calciumcarbonat; es kommt pro Ansatz dazu.
    calciumPct: 0,
    moisturePct: +r.rhPct || 0
  };
}
// Mischung gewechselt: die Felder kommen frisch aus deren Rezept. Eine
// Abweichung, die für den vorigen Ansatz getippt wurde, still auf die nächste
// Mischung mitzunehmen, wäre die unangenehmere Überraschung.
function sbRecipeChanged() {
  sbFillBlendFromRecipe();
  sbPreview();
}
function sbFillBlendFromRecipe() {
  const rec = sbRecipeOf(parseInt(document.getElementById('sb-recipe').value, 10));
  const cornWrap = document.getElementById('sb-corn-wrap');
  if (!rec) {
    SB_BLEND_FIELDS.forEach((id) => _sbSet(id, null));
    if (cornWrap) cornWrap.style.display = 'none';
    sbBlendDirty();
    return;
  }
  _sbSet('sb-wb', rec.branPct);
  _sbSet('sb-corn', rec.cornPct);
  _sbSet('sb-hw', 100 - rec.branPct - rec.cornPct);
  _sbSet('sb-gyp', rec.gypsumPct);
  _sbSet('sb-ca', rec.calciumPct);
  _sbSet('sb-rh', rec.moisturePct);
  // Maismehl steht nur da, wo das Rezept welches vorsieht — sonst wäre es ein
  // Feld, das bei den meisten Sorten 0 sagt und nur Platz kostet.
  if (cornWrap) cornWrap.style.display = rec.cornPct > 0 ? '' : 'none';
  sbBlendDirty();
}
// Pellets und Kleie sind eine Zahl in zwei Feldern: was nicht Kleie (und Mais)
// ist, ist Pellets. Wer eines tippt, hat das andere mitgesagt — sonst stünde da
// eine Mischung, die nicht 100 % ergibt, und die Rechnung nähme stillschweigend
// eine andere.
function sbBlendEdited(which) {
  const corn = _sbNum('sb-corn') || 0;
  const rest = Math.max(0, 100 - corn);
  if (which === 'hw') {
    const hw = Math.min(rest, Math.max(0, _sbNum('sb-hw') || 0));
    _sbSet('sb-wb', rest - hw);
  } else if (which === 'wb' || which === 'corn') {
    const wb = Math.min(rest, Math.max(0, _sbNum('sb-wb') || 0));
    _sbSet('sb-hw', rest - wb);
  }
  sbBlendDirty();
  sbPreviewSoon();
}
// Weicht die Mischung vom Rezept ab? Steuert den Rückweg — und nur den; was
// wirklich angesetzt wird, entscheidet der Server anhand derselben Zahlen.
function sbBlendAdjusted() {
  const rec = sbRecipeOf(parseInt(document.getElementById('sb-recipe').value, 10));
  if (!rec) return false;
  const gleich = (a, b) => Math.abs((a == null ? 0 : a) - b) < 1e-9;
  return !(
    gleich(_sbNum('sb-wb'), rec.branPct) &&
    gleich(_sbNum('sb-corn'), rec.cornPct) &&
    gleich(_sbNum('sb-gyp'), rec.gypsumPct) &&
    gleich(_sbNum('sb-ca'), rec.calciumPct) &&
    gleich(_sbNum('sb-rh'), rec.moisturePct)
  );
}
function sbBlendDirty() {
  const btn = document.getElementById('sb-blend-reset');
  if (btn) btn.style.display = sbBlendAdjusted() ? '' : 'none';
}
function sbResetBlend() {
  sbFillBlendFromRecipe();
  sbPreview();
}
// Was an den Server geht: nur die vier Zahlen, die die Mischrechnung liest.
function sbBlend() {
  const o = {};
  const wb = _sbNum('sb-wb');
  if (wb != null) o.branPct = wb;
  const corn = _sbNum('sb-corn');
  if (corn != null) o.cornPct = corn;
  const gyp = _sbNum('sb-gyp');
  if (gyp != null) o.gypsumPct = gyp;
  const ca = _sbNum('sb-ca');
  if (ca != null) o.calciumPct = ca;
  const rh = _sbNum('sb-rh');
  if (rh != null) o.moisturePct = rh;
  return o;
}

async function sbPreview() {
  const out = document.getElementById('sb-out');
  const btn = document.getElementById('sb-go');
  if (!out) return;
  const recipeId = parseInt(document.getElementById('sb-recipe').value, 10);
  const bags = sbParseBags(document.getElementById('sb-bags').value);
  const bagKg = sbBagKg();
  const kg = sbTargetKg(bags, bagKg);
  _sbLast = null;
  if (btn) btn.disabled = true;
  if (!recipeId || kg <= 0) {
    out.innerHTML = '<div class="fs-meta" style="color:var(--c-text-muted)">' + esc(t('sub.pickBoth')) + '</div>';
    return;
  }
  const blend = sbBlend();
  const r = await apiPost('/api/substrate-batches/preview', { recipeId, targetKg: kg, mix: blend });
  if (!r || r.error) {
    out.innerHTML = '<div class="fs-meta" style="color:var(--c-red-dark)">' + esc((r && r.error) || '?') + '</div>';
    return;
  }
  if (!r.hasRecipe) {
    out.innerHTML = '<div class="fs-meta" style="color:var(--c-red-dark)">' + esc(t('sub.noRecipe')) + '</div>';
    return;
  }
  const m = r.mix;
  // Die Beschriftung, die der Server dem Ansatz geben wird (mixLabel), damit
  // der Bestätigungsdialog sagt, was gleich in der Liste steht.
  const label = r.label || r.recipeLabel;
  _sbLast = { recipeId, kg, bags, bagKg, mix: m, label: label, blend: blend };
  if (btn) btn.disabled = false;
  const stock = (inventory && inventory.stock) || {};
  // Red when the shelf cannot cover the line. The server clamps a deduction to
  // what is actually there, so an unnoticed shortfall does not merely mean a
  // short mix — the missing kilos are never booked at all.
  // Every line the shelf cannot cover, collected while the table is built. The
  // server clamps a deduction to what is actually there, so a mix started while
  // short is recorded at full weight and quietly takes less — the gap has to be
  // said out loud before it is booked, not inferred from a red number.
  const shortfalls = [];
  const row = (label, val, unit, mat, dec) => {
    const short = mat && val > (stock[mat] || 0) + 1e-9;
    if (short) shortfalls.push({ label, need: val, have: stock[mat] || 0 });
    return (
      '<tr><td style="padding:2px 10px 2px 0;color:var(--c-text-sec)">' +
      esc(label) +
      '</td><td style="padding:2px 0;text-align:right;font-weight:600' +
      (short ? ';color:var(--c-red-dark)' : '') +
      '">' +
      val.toFixed(dec == null ? 1 : dec) +
      ' ' +
      unit +
      (short ? ' ⚠' : '') +
      '</td></tr>'
    );
  };
  out.innerHTML =
    '<table class="fs-sm" style="border-collapse:collapse">' +
    row(t('sub.totalKg'), kg, 'kg') +
    row(t('sub.dryMix'), m.dryKg, 'kg') +
    row(t('sub.pellets'), m.pelletsKg, 'kg', 'hardwood') +
    row(t('sub.bran'), m.branKg, 'kg', 'wheatbran') +
    (m.cornKg > 0.005 ? row(t('sub.corn'), m.cornKg, 'kg', 'corn') : '') +
    row(t('sub.gypsum'), m.gypsumKg, 'kg', 'gypsum', 2) +
    (m.calciumKg > 0.005 ? row(t('sub.calcium'), m.calciumKg, 'kg', 'calcium', 2) : '') +
    row(t('sub.waterNow'), sbWater(r).nowL, 'L') +
    '<tr><td style="padding:2px 10px 2px 0;color:var(--c-text-sec)">' +
    esc(t('sub.waterTime')) +
    '</td><td style="padding:2px 0;text-align:right;font-weight:600">' +
    esc(waterTimeText(sbWater(r).nowMinutes)) +
    '</td></tr>' +
    row(t('sub.waterRest'), sbWater(r).restL, 'L') +
    row(t('sub.moisture'), m.moisturePct, '%') +
    '</table>' +
    '<div class="fs-xs" style="color:var(--c-text-muted);margin-top:6px">' +
    esc(sbWaterHint(sbWater(r))) +
    '</div>' +
    '<div class="fs-xs" style="color:var(--c-text-muted);margin-top:4px">' +
    esc(t('sub.noSpawnHint')) +
    '</div>';
  _sbLast.shortfalls = shortfalls;
  if (shortfalls.length) {
    const list = shortfalls
      .map((x) => esc(t('sub.shortLine', { mat: x.label, need: x.need.toFixed(1), have: x.have.toFixed(1) })))
      .join('<br>');
    out.innerHTML =
      '<div class="fs-floor" style="--fs-own:12.5px;background:var(--c-red-light);border:1px solid var(--c-red-border);color:var(--c-red-dark);' +
      'border-radius:8px;padding:9px 11px;margin-bottom:10px;line-height:1.55">' +
      '<b>' + esc(t('sub.shortTitle')) + '</b><br>' + list + '<br>' + esc(t('sub.shortHint')) +
      '</div>' +
      out.innerHTML;
  }
}

// Anzahl, Größe und Kilo für die Texte, die einen Ansatz nennen.
function sbMengeParams(menge, extra) {
  return Object.assign(
    {
      bags: menge.bags,
      bagKg: fmtKg(menge.bagKg, menge.bagKg % 1 ? 1 : 0),
      kg: fmtKg(menge.kg, menge.kg % 1 ? 1 : 0)
    },
    extra || {}
  );
}

// Der Torbogen vor jedem Substrat-Ansatz: einmal bestätigen, und wenn das
// Lager nicht reicht, steht die Frage ausdrücklich dabei. Das Formular und der
// geführte Dialog bauten diesen Text getrennt zusammen — das Formular schrieb
// die Kilo dabei ohne Tausenderpunkt, weil es toFixed statt fmtKg nahm.
function sbConfirmMix(subId, menge, label, knapp, dann) {
  confirm2(
    t('sub.confirmTitle'),
    t('sub.confirmMsg', sbMengeParams(menge, { recipe: label, id: subId })) + (knapp ? '\n\n' + t('sub.shortConfirm') : ''),
    t('sub.create'),
    dann
  );
}

async function createSubstrateBatchUI() {
  const st = document.getElementById('sb-status');
  if (!_sbLast) {
    setStatus(st, t('sub.pickBoth'), false);
    return;
  }
  // Ein Zahlenfeld, in dem keine Zahl steht, meldet der Browser als leer —
  // gebucht würde dann still das Rezept oder keine Zeit. badInput verrät es.
  const unlesbar = SB_BLEND_FIELDS.concat('sb-steri')
    .map((id) => document.getElementById(id))
    .find((el) => el && el.validity && el.validity.badInput);
  if (unlesbar) {
    const lab = unlesbar.parentElement.querySelector('label');
    setStatus(st, t('work.mNotNumber', { feld: lab ? lab.textContent.replace(/%|min/g, '').trim() : '' }), false);
    return;
  }
  const steriMin = _sbNum('sb-steri');
  if (steriMin != null && !(steriMin >= 0 && steriMin <= 1440)) {
    setStatus(st, t('sub.steriNaN'), false);
    return;
  }
  const subId = sbGenId();
  sbConfirmMix(
    subId,
    { bags: _sbLast.bags, bagKg: _sbLast.bagKg, kg: _sbLast.kg },
    _sbLast.label,
    !!(_sbLast.shortfalls && _sbLast.shortfalls.length),
    async () => {
      setStatus(st, t('sub.running'), true);
      const r = await apiPost('/api/substrate-batches', {
        subId,
        recipeId: _sbLast.recipeId,
        targetKg: _sbLast.kg,
        // Dieselben Zahlen, die die Vorschau gerechnet hat. Sie hier wegzulassen
        // hieße, etwas anderes anzulegen als das, was auf dem Schirm stand.
        mix: _sbLast.blend,
        steriMin,
        notes: (document.getElementById('sb-notes').value || '').trim()
      });
      if (!r || r.error) {
        setStatus(st, t('sub.failed', { err: (r && r.error) || '?' }), false);
        return;
      }
      setStatus(st, t('sub.done', sbMengeParams(_sbLast, { id: r.subId })), true);
      document.getElementById('sb-notes').value = '';
      _sbSet('sb-steri', null);
      await loadData();
      await refreshSubstrateBatches();
      sbPreview();
    }
  );
}

// SUB-<ddmmyy>-<nn>, counted against the mixes already made today so two mixes
// on one day cannot collide.
function sbGenId() {
  const dt = todayStr();
  const n = _sbList.filter((s) => s.subId.startsWith('SUB-' + dt)).length;
  return 'SUB-' + dt + '-' + String(n + 1).padStart(2, '0');
}

// The mixes ride along in /api/data, which is already fetched on every sync, so
// this only goes to the network when something asks for them out of band (after
// a write, before loadData has caught up).
async function refreshSubstrateBatches(fromPayload) {
  const r = fromPayload || (await apiGet('/api/substrate-batches'));
  _sbList = Array.isArray(r) ? r : [];
  fillSubstrateSelect();
  renderSubstrateTab();
  loadSubstrateRecipes();
}

// Die einzige Antwort auf "aus welchem Ansatz lässt sich noch ziehen": genug
// Restmenge und nicht abgeschrieben. Die zweite Bedingung fehlte in der Auswahl
// und im geführten Ablauf, so dass ein als verdorben abgeschriebener Ansatz mit
// Restmenge sich weiter bebuchen ließ.
function wkOpenMixes() {
  return (_sbList || []).filter((x) => x.status === 'open' && x.remainingKg > 0.0001);
}

function fillSubstrateSelect() {
  const sel = document.getElementById('nb-substrate-batch');
  if (!sel) return;
  const open = wkOpenMixes();
  const opts =
    '<option value="">' +
    t('sub.selectNone') +
    '</option>' +
    open
      .map(
        (s) =>
          `<option value="${esc(s.subId)}">${esc(s.subId)} — ${esc(s.recipeLabel)} — ${s.remainingKg.toFixed(1)} kg</option>`
      )
      .join('');
  if (sel.innerHTML === opts) return;
  const cur = sel.value;
  sel.innerHTML = opts;
  if (cur) sel.value = cur;
  nbSubstrateChanged();
}

// Picking a mix switches the Charge form into "portion out of this" mode: the
// substrate section is no longer an input, because the bags are made of what was
// actually mixed and not of whatever the Sorte's recipe says today.
function nbSubstrateChanged() {
  const sel = document.getElementById('nb-substrate-batch');
  const box = document.getElementById('nb-substrate-info');
  if (!sel || !box) return;
  const s = _sbList.find((x) => x.subId === sel.value);
  const subSection = document.getElementById('nb-sub-section');
  if (subSection) subSection.style.display = s ? 'none' : '';
  if (!s) {
    box.style.display = 'none';
    box.innerHTML = '';
    return;
  }
  box.style.display = '';
  nbSubstrateNeed();
}

// Live "this many bags eats this much of the mix" line.
function nbSubstrateNeed() {
  const sel = document.getElementById('nb-substrate-batch');
  const box = document.getElementById('nb-substrate-info');
  if (!sel || !box) return;
  const s = _sbList.find((x) => x.subId === sel.value);
  if (!s) return;
  const qty = parseInt(document.getElementById('nb-qty').value, 10) || 0;
  const strainId = parseInt(document.getElementById('nb-strain-sel').value, 10);
  const ms = mushroomStrains.find((x) => x.id === strainId);
  // The same field createBatch submits, not the recipe behind it. Reading the
  // recipe here while the form carries a different weight quoted one draw and
  // booked another — 20 bags read as 100 kg and took 60.
  const bagKg = parseDecimal(document.getElementById('nb-weight').value) || (ms && ms.recBagKg) || 5;
  const need = qty * bagKg;
  const left = s.remainingKg - need;
  const spawn = need * (((ms && ms.recSpawnPct) || 0) / 100);
  box.innerHTML =
    '<div class="fs-meta" style="line-height:1.7">' +
    '<div>' +
    esc(t('sub.mixComposition', { hw: s.composition.hardwoodPct, wb: s.composition.wheatbranPct, rh: s.composition.rhPct })) +
    '</div>' +
    '<div>' +
    esc(t('sub.drawLine', { qty: qty, bagKg: bagKg, need: need.toFixed(1) })) +
    '</div>' +
    '<div style="font-weight:600' +
    (left < -0.0001 ? ';color:var(--c-red-dark)' : '') +
    '">' +
    esc(
      left < -0.0001
        ? t('sub.overdraw', { over: Math.abs(left).toFixed(1) })
        : t('sub.leftAfter', { left: left.toFixed(1) })
    ) +
    '</div>' +
    (spawn > 0 ? '<div>' + esc(t('sub.spawnLine', { kg: spawn.toFixed(2) })) + '</div>' : '') +
    '</div>';
}

// Post a Charge that is portioned out of a mix. Separate from createBatch's main
// body because none of it applies: no composition to validate, no deltas to
// compute, and the substrate comes out of a named mix rather than off the shelf.
function createBatchFromSubstrate(batchId, subId, strainId, qty, bagKg, days, strain, strainText, opts) {
  const s = _sbList.find((x) => x.subId === subId);
  const need = qty * bagKg;
  // Ein Tag wird nur für Bestand aus der Inventur mitgegeben, und der bucht
  // nichts: keine Kilogramm aus dem Ansatz, keine Körnerbrut vom Lager.
  const frueher = !!(opts && opts.created);
  const go = async () => {
    const r = await apiPost('/api/batches/from-substrate', {
      batchId,
      subId,
      strainId,
      qty,
      bagKg,
      days,
      strain,
      strainText,
      // Der geführte Ablauf bringt seine eigene Notiz mit; das lange Formular
      // liest weiter sein Feld.
      notes: opts && opts.notes != null ? opts.notes : (document.getElementById('nb-notes').value || '').trim(),
      // Ebenso der pH: der Ablauf bringt ihn mit, das Formular hat sein Feld.
      // Geprüft ist er an beiden Stellen schon, bevor es hierher geht.
      ph: opts && opts.ph !== undefined ? opts.ph : nbPhLesen() == null ? null : nbPhLesen(),
      // Nur bei einer Charge aus der Inventur; sonst setzt der Server jetzt, und
      // die Fälligkeit rechnet er in beiden Fällen selbst davon aus.
      ...(frueher ? { created: opts.created, noBooking: true } : {}),
      // Die Kultur, mit der beimpft wurde, als Herkunft der Charge. Körnerbrut
      // steht nicht hier, sondern im Scan-Log (spawnSourceFor).
      ...(opts && opts.sourceId ? { sourceId: opts.sourceId } : {})
    });
    if (!r || r.error) {
      toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
      return;
    }
    // Ein gemessener pH gehört zu dieser Charge, nicht zur nächsten.
    if (!(opts && opts.ph !== undefined) && document.getElementById('nb-ph')) document.getElementById('nb-ph').value = '';
    await loadData();
    await refreshSubstrateBatches();
    nbSubstrateNeed();
    // Der Ablauf zeigt statt des Hinweisfensters seine Quittung.
    if (opts && opts.onDone) return opts.onDone(r);
    toast(t('sub.batchDone', { id: r.batchId, kg: r.drawKg.toFixed(1), left: r.remainingKg.toFixed(1) }));
  };
  // A mix can come out heavier than the arithmetic said, so this warns rather
  // than blocks — but it has to be said out loud, because the leftover figure is
  // what the next Charge will be planned against. A stocktake entry draws
  // nothing, so there is nothing to overdraw.
  if (!frueher && s && need > s.remainingKg + 1e-9) {
    confirm2(
      t('sub.overdrawTitle'),
      t('sub.overdrawMsg', { need: need.toFixed(1), left: s.remainingKg.toFixed(1) }),
      t('batch.create'),
      go
    );
    return;
  }
  go();
}

// ─── SUBSTRATE MIX: LIST AND DETAIL (v67) ────────────────────
// The mix card on "Neue Charge" shows what is still usable, because that is what
// you plan against. This tab shows all of them, spent ones included, because
// that is what you count and where you look when one has gone wrong.
const SB_STATUS = { open: 'sub.stOpen', used: 'sub.stUsed', written_off: 'sub.stBad' };
const SB_STATUS_COLOR = { open: 'var(--c-accent)', used: 'var(--c-text-muted)', written_off: 'var(--c-red)' };

function renderSubstrateTab() {
  const box = document.getElementById('sb-tab-list');
  const sum = document.getElementById('sb-tab-summary');
  if (!box) return;
  const showSpent = (document.getElementById('sb-show-spent') || {}).checked;
  _sbBuildCounts();
  const all = _sbList;
  const rows = showSpent ? all : all.filter((s) => s.status === 'open' && s.remainingKg > 0.0001);
  if (sum) {
    const open = all.filter((s) => s.status === 'open' && s.remainingKg > 0.0001);
    const bad = all.filter((s) => s.status === 'written_off');
    // Die Bilanz über alle Ansätze, nicht über die gefilterte Ansicht: "wie oft
    // platzt uns etwas" ist eine Frage über die Zeit, und sie darf nicht davon
    // abhängen, ob gerade die verbrauchten eingeblendet sind.
    const geplatzt = all.reduce((a, s) => a + (s.burstBags || 0), 0);
    const betroffen = all.filter((s) => s.burstBags > 0).length;
    sum.textContent =
      t('sub.summary', {
        total: all.length,
        open: open.length,
        kg: open.reduce((a, s) => a + s.remainingKg, 0).toFixed(1),
        bad: bad.length
      }) +
      // Nur wenn es etwas zu melden gibt. Eine Zeile, die bei jedem Blick "0
      // geplatzt" sagt, wird gelesen wie Tapete und dann auch dann übersehen,
      // wenn eine Zahl darin steht.
      (geplatzt ? ' · ' + t('sub.burstSummary', { n: geplatzt, m: betroffen }) : '');
  }
  if (!rows.length) {
    box.innerHTML = '<div class="fs-meta" style="color:var(--c-text-muted)">' + esc(t('sub.noneAtAll')) + '</div>';
    return;
  }
  const head = ['sub.thId', 'sub.thRecipe', 'sub.thSteriPh', 'sub.thMade', 'sub.thRh', 'sub.thUsed', 'sub.thLeft', 'sub.thStatus', 'sub.thBatches']
    .map((k) => '<th style="padding:4px 8px 4px 0;font-weight:600">' + esc(t(k)) + '</th>')
    .join('');
  box.innerHTML =
    '<div style="overflow-x:auto"><table class="fs-meta" style="width:100%;border-collapse:collapse">' +
    '<thead><tr style="text-align:left;color:var(--c-text-sec)">' +
    head +
    '</tr></thead><tbody>' +
    rows.map(_sbRowHtml).join('') +
    '</tbody></table></div>';
}

function _sbRowHtml(s) {
  const pct = s.targetKg > 0 ? Math.max(0, Math.min(100, (s.remainingKg / s.targetKg) * 100)) : 0;
  const col = SB_STATUS_COLOR[s.status] || 'var(--c-text-muted)';
  const cell = (inner, extra) => '<td style="padding:6px 8px 6px 0;' + (extra || '') + '">' + inner + '</td>';
  return (
    '<tr style="border-top:1px solid var(--c-border);cursor:pointer" onclick="openSubstrateInfo(' +
    JSON.stringify(s.subId).replace(/"/g, '&quot;') +
    ')">' +
    // Als Marke neben der Kennung, nicht als achte Spalte: die Tabelle scrollt
    // auf dem Handy ohnehin seitwärts, und eine Spalte, die meistens leer ist,
    // schiebt die vollen aus dem Bild.
    cell(
      esc(s.subId) +
        (s.burstBags
          ? ' <span class="fs-micro" style="font-weight:600;color:var(--c-red-dark)" title="' +
            esc(t('sub.burst')) +
            '">⚠' +
            s.burstBags +
            '</span>'
          : ''),
      'font-family:monospace;font-weight:600'
    ) +
    cell(esc(s.recipeLabel), 'color:var(--c-text-sec)') +
    // Gleich neben der Mischung, nicht hinter der Feuchte: am Telefon scrollt
    // die Tabelle seitwärts, und der Vergleich Mischung – Zeit – pH ist der
    // Grund, diese Liste gerade anzusehen. Weiter hinten stand er außer Sicht.
    cell(_sbSteriPhCell(s), 'white-space:nowrap') +
    cell(fmtDtShort(s.created), 'white-space:nowrap') +
    // Direkt in der Zeile eintragbar: die Messung kommt nach dem Mischen, und
    // der Weg über die Karte des Ansatzes war zu weit, um es zu tun.
    cell(
      '<button type="button" class="btn-xs" onclick="event.stopPropagation();measureSubstrateRhById(' +
        JSON.stringify(s.subId).replace(/"/g, '&quot;') +
        ')">' +
        _subRhCell(s) +
        '</button>',
      'white-space:nowrap'
    ) +
    cell(s.usedKg.toFixed(1) + ' kg', 'white-space:nowrap') +
    cell(
      s.remainingKg.toFixed(1) +
        ' kg<div style="height:4px;border-radius:2px;background:rgba(0,0,0,.08);overflow:hidden;margin-top:2px;width:60px">' +
        '<div style="height:100%;border-radius:2px;background:' +
        col +
        ';width:' +
        pct.toFixed(0) +
        '%"></div></div>',
      'white-space:nowrap'
    ) +
    cell(
      '<span class="fs-micro" style="padding:2px 7px;border-radius:99px;font-weight:600;color:#fff;background:' +
        col +
        '">' +
        esc(t(SB_STATUS[s.status] || s.status)) +
        '</span>'
    ) +
    cell(_sbDrawnCount(s.subId), 'color:var(--c-text-muted)') +
    '</tr>'
  );
}

// The Chargen already loaded carry the link, so counting them costs no request —
// but counting them per row walked the whole list once per mix. One pass, built
// when the table renders, answers every row.
let _sbCounts = new Map();
function _sbBuildCounts() {
  _sbCounts = new Map();
  for (const b of batches || []) {
    if (!b.substrateSubId) continue;
    _sbCounts.set(b.substrateSubId, (_sbCounts.get(b.substrateSubId) || 0) + 1);
  }
}
function _sbDrawnCount(subId) {
  return _sbCounts.get(subId) || '—';
}

// Die gemessene Feuchte, und daneben ausgerechnet, wie weit sie vom Rezept
// abliegt. Die Abweichung ist der Grund, aus dem überhaupt nachgemessen wird —
// sie erst im Kopf bilden zu lassen, hiesse die Antwort neben die Frage zu legen
// und den letzten Schritt dem Leser zu überlassen.
function _subRhCell(s) {
  if (s.actualRhPct == null) {
    return '<span style="font-weight:400;color:var(--c-text-muted)">' + esc(t('sub.rhNotMeasured')) + '</span>';
  }
  const diff = s.actualRhPct - s.moisturePct;
  const cell = esc(s.actualRhPct.toFixed(1)) + ' %';
  // Unter 0,05 rundet die Anzeige auf (0.0) und eine Klammer, die "keine
  // Abweichung" sagt, ist lauter als keine Klammer.
  if (Math.abs(diff) < 0.05) return cell;
  return (
    cell +
    ' <span style="font-weight:400;color:var(--c-text-sec)">(' +
    (diff > 0 ? '+' : '−') +
    esc(Math.abs(diff).toFixed(1)) +
    ')</span>'
  );
}

// Geplatzte Beutel: 0 ist eine Antwort, keine Lücke.
//
// Anders als die Ist-Feuchte daneben, die "noch nicht gemessen" sagt, solange
// niemand gemessen hat. Hier wird ein Ereignis gezählt, und wo nichts steht, ist
// nichts passiert — sonst ließe sich die Frage, die diese Zahl beantworten soll
// ("wie oft platzt uns etwas im Autoklav"), gar nicht stellen.
function _subBurstCell(s) {
  if (!s.burstBags) return '<span style="font-weight:400;color:var(--c-text-muted)">' + esc(t('sub.burstNone')) + '</span>';
  return '<span style="color:var(--c-red-dark)">' + esc(t('sub.burstN', { n: s.burstBags })) + '</span>';
}
// Nachgetragen wie die Feuchte, und aus demselben Grund vor dem Prompt zu: der
// Prompt läge sonst hinter der Karte (siehe measureSubstrateRh).
function recordBurstBags(s) {
  closeSubstrateInfo();
  prompt2(
    t('sub.burstPrompt', { id: s.subId }),
    t('sub.burstHint'),
    async (v) => {
      const raw = (v || '').trim();
      const n = raw === '' ? 0 : Number(raw);
      if (!Number.isInteger(n) || n < 0) {
        toast(t('sub.burstNaN'), 'err');
        return;
      }
      const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(s.subId) + '/burst', { burstBags: n });
      if (!r || r.error) {
        toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
        return;
      }
      toast(n === 0 ? t('sub.burstCleared') : t('sub.burstSaved', { n }));
      await refreshSubstrateBatches();
      openSubstrateInfo(s.subId);
    },
    { inputmode: 'numeric', value: s.burstBags ? String(s.burstBags) : '' }
  );
}

// Sterilisierzeit und pH stehen nebeneinander, weil die eine Zahl die andere
// erklären soll: wie lange sterilisiert wurde, und welcher pH beim Beimpfen der
// Chargen aus diesem Ansatz gemessen wurde. Fehlt eins, steht ein Strich da.
function _subSteriText(s) {
  return s.steriMin == null ? '–' : fmtKg(s.steriMin, 0) + ' min';
}
function _subPhText(s) {
  if (s.phAvg == null) return '–';
  return 'pH ' + fmtKg(s.phAvg, 1) + (s.phN > 1 ? ' (' + s.phN + ')' : '');
}
// Die Zelle in der Liste. Fehlt beides, ein Strich statt "– · –"; die Zahl in
// Klammern erklärt sich im Tooltip, weil "(3)" allein nicht sagt, wovon drei.
function _sbSteriPhCell(s) {
  if (s.steriMin == null && s.phAvg == null) return '<span style="color:var(--c-text-muted)">–</span>';
  const title = s.phN > 1 ? ' title="' + esc(t('sub.phAvgOf', { n: s.phN })) + '"' : '';
  return '<span' + title + '>' + esc(_subSteriText(s)) + ' · ' + esc(_subPhText(s)) + '</span>';
}

// Nachgetragen wie die geplatzten Beutel: sterilisiert wird nach dem Mischen.
// Leer löscht die Angabe.
function recordSteriMin(s) {
  closeSubstrateInfo();
  prompt2(
    t('sub.steriPrompt', { id: s.subId }),
    t('sub.steriHint'),
    async (v) => {
      const raw = (v || '').trim();
      const n = raw === '' ? null : parseDecimal(raw);
      if (n != null && !(Number.isFinite(n) && n >= 0 && n <= 1440)) {
        toast(t('sub.steriNaN'), 'err');
        return;
      }
      const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(s.subId) + '/steri', { steriMin: n });
      if (!r || r.error) {
        toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
        return;
      }
      toast(n == null ? t('sub.steriCleared') : t('sub.steriSaved', { n: fmtKg(n, 0) }));
      await refreshSubstrateBatches();
      openSubstrateInfo(s.subId);
    },
    { inputmode: 'numeric', value: s.steriMin == null ? '' : String(s.steriMin) }
  );
}

// Gemessen wird nach dem Mischen, nicht beim Anlegen: da ist der Ansatz längst
// gebucht, und die Zahl kommt aus dem Messgerät statt aus dem Rezept.
//
// Ein leeres Feld löscht die Messung. Das ist der Weg zurück, wenn sie am
// falschen Ansatz landete, und er braucht keinen zweiten Knopf, der danebensteht
// und nur an dem einen Tag gebraucht wird, an dem jemand sich vertippt hat.
function measureSubstrateRhById(subId) {
  const s = (_sbList || []).find((x) => x.subId === subId);
  if (s) measureSubstrateRh(s, { stay: true });
}
// stay: nach dem Speichern nicht die Karte des Ansatzes öffnen — wer aus der
// Liste oder dem Arbeitsgang kommt, will dort bleiben.
function measureSubstrateRh(s, opts) {
  // Erst die Ansatz-Karte zu, dann den Prompt auf - dieselbe Reihenfolge wie bei
  // Loeschen und Verwerfen nebenan, und hier ist sie nicht Geschmackssache: beide
  // Dialoge sind .modal-bg auf z-index 200, #m-confirm hebt sich per eigener Regel
  // auf 210 und liegt deshalb oben, #m-prompt hat keine solche Regel. Bei gleichem
  // z-index gewinnt, was spaeter im DOM steht, und #m-subinfo steht 680 Zeilen
  // hinter #m-prompt. Der Prompt ging also auf und lag unsichtbar hinter der
  // Karte - von aussen sieht das aus wie ein Knopf, der nichts tut.
  closeSubstrateInfo();
  prompt2(
    t('sub.rhPrompt', { id: s.subId }),
    s.moisturePct.toFixed(1),
    async (v) => {
      // Komma wie auf der Tastatur, Punkt wie in der Zahl: 62,5 ist das, was
      // hier jemand tippt, und Number() macht daraus sonst NaN.
      const raw = (v || '').replace(',', '.').trim();
      const payload = { actualRhPct: raw === '' ? null : Number(raw) };
      if (raw !== '' && !Number.isFinite(payload.actualRhPct)) {
        toast(t('sub.rhNaN'), 'err');
        return;
      }
      const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(s.subId) + '/moisture', payload);
      if (!r || r.error) {
        toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
        return;
      }
      toast(raw === '' ? t('sub.rhCleared') : t('sub.rhSaved', { pct: payload.actualRhPct.toFixed(1) }));
      await refreshSubstrateBatches();
      // Gleich danach das Wasser: erst beide Zahlen zusammen sagen, wie weit die
      // Rechnung daneben lag, und nur so lernt der nächste Vorschlag daraus.
      if (raw !== '') {
        measureSubstrateWater((_sbList || []).find((x) => x.subId === s.subId) || s, opts);
        return;
      }
      if (!(opts && opts.stay)) openSubstrateInfo(s.subId);
    },
    { inputmode: 'decimal', value: s.actualRhPct == null ? '' : String(s.actualRhPct) }
  );
}
// Wie viel Wasser insgesamt hineinging, Nachgegebenes mitgezählt. Vorbelegt mit
// dem, was schon eingetragen ist, sonst mit dem Vorschlag "jetzt zugeben".
function measureSubstrateWater(s, opts) {
  closeSubstrateInfo();
  const vor = s.actualWaterL != null ? s.actualWaterL : s.waterNowL != null ? Math.round(s.waterNowL) : '';
  prompt2(
    t('sub.waterPrompt', { id: s.subId }),
    t('sub.waterPromptPh'),
    async (v) => {
      const raw = (v || '').replace(',', '.').trim();
      const payload = { actualWaterL: raw === '' ? null : Number(raw) };
      if (raw !== '' && !(payload.actualWaterL > 0)) {
        toast(t('sub.waterNaN'), 'err');
        return;
      }
      const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(s.subId) + '/water', payload);
      if (!r || r.error) {
        toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
        return;
      }
      toast(raw === '' ? t('sub.waterCleared') : t('sub.waterSaved', { l: fmtKg(payload.actualWaterL, 1) }));
      await refreshSubstrateBatches();
      if (!(opts && opts.stay)) openSubstrateInfo(s.subId);
    },
    { inputmode: 'decimal', value: vor === '' ? '' : String(vor) }
  );
}

// Der Kommentar wird nachgetragen, nicht beim Anlegen getippt: er entsteht, wenn
// jemandem drei Tage spaeter etwas auffaellt.
//
// Der bestehende Text wird vorgelegt statt eines leeren Feldes. Das Verwerfen
// haengt seinen Stempel an dasselbe Feld, und der soll beim Bearbeiten sichtbar
// sein, statt unbemerkt ueberschrieben zu werden.
//
// closeSubstrateInfo() zuerst, aus demselben Grund wie bei der Messung: #m-prompt
// und #m-subinfo teilen sich z-index 200, und der spaetere im DOM gewinnt.
function editSubstrateComment(s) {
  closeSubstrateInfo();
  prompt2(
    t('sub.commentPrompt', { id: s.subId }),
    t('sub.commentPlaceholder'),
    async (v) => {
      const text = (v || '').trim();
      const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(s.subId) + '/notes', { notes: text });
      if (!r || r.error) {
        toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
        return;
      }
      toast(text === '' ? t('sub.commentCleared') : t('sub.commentSaved'));
      await refreshSubstrateBatches();
      openSubstrateInfo(s.subId);
    },
    { value: s.notes || '' }
  );
}

async function openSubstrateInfo(subId) {
  const body = document.getElementById('si-body');
  const acts = document.getElementById('si-actions');
  document.getElementById('si-title').textContent = subId;
  body.innerHTML = '<div class="fs-meta" style="color:var(--c-text-muted)">…</div>';
  acts.innerHTML = '';
  document.getElementById('m-subinfo').classList.add('open');
  const s = await apiGet('/api/substrate-batches/' + encodeURIComponent(subId));
  if (!s || s.error) {
    body.innerHTML = '<div class="fs-meta" style="color:var(--c-red-dark)">' + esc((s && s.error) || '?') + '</div>';
    return;
  }
  const line = (label, val) =>
    '<tr><td style="padding:2px 12px 2px 0;color:var(--c-text-sec)">' +
    esc(label) +
    '</td><td style="padding:2px 0;font-weight:600">' +
    val +
    '</td></tr>';
  const kg = (v, d) => v.toFixed(d == null ? 1 : d) + ' kg';
  const c = s.composition;
  let html =
    '<div class="fs-xs" style="color:var(--c-text-muted);margin-bottom:8px">' +
    esc(t('sub.madeOn', { date: fmtDt(s.created), recipe: s.recipeLabel })) +
    '</div>' +
    '<div class="fs-meta" style="font-weight:600;margin-bottom:4px">' +
    esc(t('sub.howMade')) +
    '</div>' +
    '<table class="fs-sm" style="border-collapse:collapse;margin-bottom:10px">' +
    line(t('sub.targetKg'), kg(s.targetKg, 0)) +
    line(t('sub.blend'), c.hardwoodPct + ' / ' + c.wheatbranPct + (c.cornPct ? ' / ' + c.cornPct : '') + ' %') +
    line(t('sub.dryMix'), kg(s.dryKg)) +
    line(t('sub.pellets'), kg(s.pelletsKg)) +
    line(t('sub.bran'), kg(s.branKg)) +
    (s.cornKg > 0.005 ? line(t('sub.corn'), kg(s.cornKg)) : '') +
    line(t('sub.gypsum'), kg(s.gypsumKg, 2)) +
    (s.calciumKg > 0.005 ? line(t('sub.calcium'), kg(s.calciumKg, 2) + ' (' + c.calciumPct + ' %)') : '') +
    line(t('sub.waterCalc'), s.waterL.toFixed(1) + ' L') +
    (s.waterNowL != null ? line(t('sub.waterNow'), s.waterNowL.toFixed(1) + ' L') : '') +
    line(
      t('sub.waterActual'),
      s.actualWaterL == null
        ? '<span style="font-weight:400;color:var(--c-text-muted)">' + esc(t('sub.rhNotMeasured')) + '</span>'
        : esc(s.actualWaterL.toFixed(1)) + ' L'
    ) +
    line(t('sub.moisture'), s.moisturePct.toFixed(1) + ' %') +
    line(t('sub.moistureActual'), _subRhCell(s)) +
    // Was dieser Ansatz dem Vorschlag beibringt: welcher Anteil der Rechnung das
    // Ziel getroffen hätte.
    (s.waterFactor != null
      ? line(t('sub.waterLearned'), esc(fmtKg(s.waterFactor * 100, 0)) + ' %')
      : '') +
    // Immer da, auch auf 0 — wie die Kommentarzeile weiter unten. Eine Zeile,
    // die erst erscheint, wenn schon etwas kaputt ist, sieht aus wie keine, und
    // dann trägt sie niemand nach.
    line(t('sub.burst'), _subBurstCell(s)) +
    line(t('sub.steri'), esc(_subSteriText(s))) +
    line(t('sub.phAtInoc'), esc(_subPhText(s))) +
    '</table>';
  // Wer gemessen hat und wann, unter die Tabelle statt in die Zeile: in der
  // Zeile stünde es neben der Zahl und läse sich wie ein Teil von ihr.
  if (s.actualRhPct != null && s.actualRhAt) {
    // Ohne Namen die kürzere Zeile, statt eines Fragezeichens an der Stelle, an
    // der ein Name stünde: eine Messung aus einer Sitzung ohne Benutzer ist
    // vollständig, sie hat nur niemanden.
    html +=
      '<div class="fs-meta" style="margin-top:-6px;margin-bottom:10px;color:var(--c-text-muted)">' +
      esc(
        s.actualRhBy
          ? t('sub.rhMeasuredBy', { when: fmtDt(s.actualRhAt), who: s.actualRhBy })
          : t('sub.rhMeasuredAt', { when: fmtDt(s.actualRhAt) })
      ) +
      '</div>';
  }
  // What the shelf actually gave up, read from the ledger rather than recomputed.
  // A mix made while stock was short booked less than the recipe asked for, and
  // that gap is exactly what somebody looking at a bad batch needs to see.
  if (s.ledger && s.ledger.length) {
    html +=
      '<div class="fs-meta" style="font-weight:600;margin-bottom:4px">' +
      esc(t('sub.booked')) +
      '</div><div class="fs-meta" style="color:var(--c-text-sec);margin-bottom:10px">' +
      s.ledger.map((l) => esc(_ohMatName(l.mat)) + ' ' + Math.abs(l.deltaKg).toFixed(2) + ' kg').join(' · ') +
      '</div>';
  }
  html += '<div class="fs-meta" style="font-weight:600;margin-bottom:4px">' + esc(t('sub.drawnBy')) + '</div>';
  if (!s.drawn.length) {
    html += '<div class="fs-meta" style="color:var(--c-text-muted)">' + esc(t('sub.drawnNone')) + '</div>';
  } else {
    html +=
      '<table class="fs-meta" style="width:100%;border-collapse:collapse">' +
      s.drawn
        .map(
          (b) =>
            '<tr style="border-top:1px solid var(--c-border)">' +
            '<td style="padding:4px 8px 4px 0;font-family:monospace">' +
            esc(b.batchId) +
            '</td><td style="padding:4px 8px 4px 0">' +
            esc(b.species) +
            '</td><td style="padding:4px 8px 4px 0;white-space:nowrap">' +
            b.qty +
            ' × ' +
            b.bagKg +
            ' kg</td><td style="padding:4px 8px 4px 0;white-space:nowrap;font-weight:600">' +
            b.substrateKg.toFixed(1) +
            ' kg</td><td style="padding:4px 0;white-space:nowrap;color:var(--c-text-sec)">' +
            (b.ph == null ? '' : 'pH ' + esc(fmtKg(b.ph, 1))) +
            '</td></tr>'
        )
        .join('') +
      '</table>';
  }
  html +=
    '<div class="fs-sm" style="margin-top:10px;font-weight:600">' +
    esc(t('sub.leftNow', { kg: s.remainingKg.toFixed(1), of: s.targetKg.toFixed(0) })) +
    '</div>';
  // Die Zeile steht immer da, auch leer. Ein Kommentarfeld, das erst erscheint,
  // wenn schon etwas drinsteht, sieht aus wie keins - und der Knopf darunter
  // waere dann der einzige Hinweis darauf, dass es ihn ueberhaupt gibt.
  html +=
    '<div class="fs-meta" style="margin-top:10px">' +
    '<span style="color:var(--c-text-sec)">' +
    esc(t('sub.comment')) +
    ': </span>' +
    (s.notes
      ? esc(s.notes)
      : '<span style="color:var(--c-text-muted)">' + esc(t('sub.commentNone')) + '</span>') +
    '</div>';
  body.innerHTML = html;
  // Two different mistakes need two different answers, and offering both at once
  // invites the wrong one. Nothing made from it yet: it can be removed cleanly,
  // materials back on the shelf — that is a mis-entry. Something already made
  // from it: the pellets are gone whatever happens, so the honest action is to
  // stop it being offered, not to pretend it never existed.
  const act = (label, cls, fn) => {
    const b = document.createElement('button');
    b.className = 'btn btn-sm ' + cls;
    b.textContent = label;
    b.onclick = fn;
    acts.appendChild(b);
  };
  // Vor den roten: Nachmessen ist die Handlung, die bei fast jedem Ansatz
  // vorkommt, und die beiden darunter sind die seltenen und endgültigen. Auch
  // bei einem verworfenen Ansatz noch erlaubt — warum er verworfen wurde, ist
  // genau die Frage, auf die eine gemessene Feuchte antwortet.
  act(s.actualRhPct == null ? t('sub.rhAdd') : t('sub.rhEdit'), 'btn-p', () => measureSubstrateRh(s));
  act(s.actualWaterL == null ? t('sub.waterAdd') : t('sub.waterEdit'), 'btn-p', () => measureSubstrateWater(s));
  // Auch bei einem verworfenen Ansatz: geplatzte Beutel sind oft genau der
  // Grund, aus dem er verworfen wurde, und dann wird die Zahl danach eingetragen.
  act(s.burstBags ? t('sub.burstEdit') : t('sub.burstAdd'), 'btn-p', () => recordBurstBags(s));
  act(s.steriMin == null ? t('sub.steriAdd') : t('sub.steriEdit'), 'btn-p', () => recordSteriMin(s));
  act(s.notes ? t('sub.commentEdit') : t('sub.commentAdd'), 'btn-p', () => editSubstrateComment(s));
  if (!s.drawn.length) {
    act(t('sub.delete'), 'btn-r', () => deleteSubstrate(s.subId));
  } else if (s.status === 'open' && s.remainingKg > 0.0001) {
    act(t('sub.writeOff'), 'btn-r', () => writeOffSubstrate(s.subId, s.remainingKg.toFixed(1)));
  }
}

// No Charge was ever made from this mix, so removing it is a clean reversal: the
// pellets, bran and gypsum go back on the shelf exactly as the ledger booked
// them out. The right answer for a mix entered by mistake or as a test.
function deleteSubstrate(subId) {
  closeSubstrateInfo();
  confirm2(t('sub.deleteTitle'), t('sub.deleteMsg', { id: subId }), t('sub.delete'), async () => {
    const r = await apiDelete('/api/substrate-batches/' + encodeURIComponent(subId));
    if (!r || r.error) {
      toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
      return;
    }
    await loadData();
    await refreshSubstrateBatches();
  });
}

function closeSubstrateInfo() {
  document.getElementById('m-subinfo').classList.remove('open');
}

// A mix that soured, or a remainder that got thrown out. Nothing goes back to
// the shelf — the pellets were mixed and are gone either way. What changes is
// that it stops being offered and stops counting as substrate anyone can use.
function writeOffSubstrate(subId, leftKg) {
  closeSubstrateInfo();
  confirm2(t('sub.writeOffTitle'), t('sub.writeOffMsg', { id: subId, kg: leftKg }), t('sub.writeOff'), async () => {
    const r = await apiPost('/api/substrate-batches/' + encodeURIComponent(subId) + '/write-off', {
      note: t('sub.writeOffNote')
    });
    if (!r || r.error) {
      toast(t('sub.failed', { err: (r && r.error) || '?' }), 'err');
      return;
    }
    await refreshSubstrateBatches();
  });
}

// Print all labels for the just-created batch straight from the success panel,
// so the common "create → print everything" path skips the hop to the Print
// page. Uses the current default label mode + QR from the Print controls; the
// "Druckoptionen…" button still opens the full Print page for ranges/formats.
// Falls back to a ZPL download (same as printBagLabels) when the printer is
// unreachable.
// Der Etiketten-Dialog. Er kommt von selbst, sobald eine Charge steht — die
// Etiketten sind der nächste Handgriff, und vorher lagen sie am Seitenende.
function nbpOpen() {
  const m = document.getElementById('m-batch-print');
  if (m) m.classList.add('open');
}
function nbpClose() {
  const m = document.getElementById('m-batch-print');
  if (m) m.classList.remove('open');
}

async function printBatchLabelsInline() {
  const res = document.getElementById('nb-result');
  const id = res ? res.dataset.batchId : null;
  const b = batches.find((x) => x.batchId === id) || batches[batches.length - 1];
  if (!b) {
    toast(t('print.selectBatchFirst'), 'err');
    return;
  }
  const modeEl = document.getElementById('print-mode');
  const qrEl = document.getElementById('bag-qr');
  await ensureBagBarcodes(b.bags);
  const zpl = makeBagZPL(b.bags, b, modeEl ? modeEl.value : 'full', qrEl ? qrEl.checked : true);
  if (!zpl || !zpl.includes('^XA')) {
    toast(t('print.noLabels'), 'err');
    return;
  }
  const err = await sendToPrinter(zpl);
  if (err) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = b.batchId + '_labels.zpl';
    a.click();
  } else {
    printedFb(t('print.printedBatch', { n: b.bags.length, id: b.batchId }));
    nbpClose();
  }
}
// Gedruckt ist keine Buchung, und schon gar kein Scan.
//
// Alle vier Druckwege meldeten ihren Erfolg mit setFb('ok', …) ohne noModal,
// und setFb ruft dann openScanModal(). Nach "Charge anlegen → drucken" stand
// deshalb das Scan-Fenster offen — und weil sein Hinweis nach drei Sekunden
// verblasst, stand es leer da und musste weggetippt werden. Der Fehlerzweig
// derselben Funktionen war längst ein Toast; nur der Erfolg riss den Bildschirm
// an sich.
//
// noModal behält, was daran wert ist behalten zu werden: Ton, Aufblitzen und
// den Eintrag im Verlauf. Sichtbar wird die Meldung über den Toast, wie beim
// Fehlschlag daneben.
function printedFb(msg) {
  setFb('ok', msg, { noModal: true });
  toast(msg);
}
function goToPrintBatch() {
  go('print', 'n-print');
  setTimeout(() => {
    openStab('print', 'bags');
    document.getElementById('print-batch-search').value = '';
    fillBatchSelect('');
    const s = document.getElementById('print-batch'),
      last = batches[batches.length - 1];
    if (last) {
      s.value = last.batchId;
      renderBagPreview();
    }
  }, 100);
}
// Move a specific set of bags in a batch to a destination zone/rack.
// Skips bags that are unplaced, removed, or already at the destination.
// Calls back with (movedCount, skippedCount) when done.
// Persist a batch of scan entries, retrying once after 3s on server error.
// Every entry carries a stable client_uuid and the server upserts on the unique
// index, so replaying the POST is safe. opts.zoneCheck === false skips the I-12
// optimistic-concurrency handling for ADD, which has no expected zone and can
// never 409. Extracted because moveBagsTo, addBagsToLocation and locMoveTo each
// carried their own copy of this block — the drift between those copies is what
// let the grain path lose its inventory rollback.
function postScanEntries(entries, opts) {
  const zoneCheck = !(opts && opts.zoneCheck === false);
  const settle = (r, isRetry) => {
    if (zoneCheck && handleZoneMismatch(r, entries)) return;
    if (r && r.ids) {
      entries.forEach((e, i) => setEntryServerId(e, r.ids[i]));
      return;
    }
    // The service worker queued this offline: HTTP 200 {ok:true, queued:true},
    // no ids and no error. Without this branch settle() fell through both arms,
    // no _serverId ever arrived, and an undo could only set _undoPending — which
    // setEntryServerId is the sole consumer of, so the DELETE never fired. The
    // scan replayed on reconnect and the "undone" entry came back on the next
    // poll. Mark it so the undo path can pull it out of the queue instead.
    if (r && r.queued) {
      entries.forEach((e) => (e._queued = true));
      return;
    }
    if (r && r.error) {
      if (isRetry) {
        // Nicht gespeichert. Hier stand "Scan gespeichert lokal" — das stimmte
        // nie: einen Speicher dafür gibt es nur in der Warteschlange des Service
        // Workers, und die hätte mit {queued:true} geantwortet. Der Eintrag auf
        // dem Telefon war ein Trugbild, das die nächste Abfrage wegwischte. Also
        // gleich raus damit (wie bei handleZoneMismatch), und sagen, was hilft.
        for (const e of entries) {
          const i = scanLog.lastIndexOf(e);
          if (i >= 0) scanLog.splice(i, 1);
          const j = movements.lastIndexOf(e);
          if (j >= 0) movements.splice(j, 1);
          modeRunUntally(e);
        }
        const was =
          entries.length === 1 ? entries[0].bag || entries[0].batch : t('scanFb.nBags', { n: entries.length });
        setFb('err', t('scanFb.notSaved', { what: was, reason: r.error }));
        if (typeof renderStatus === 'function') renderStatus();
        updateSD();
        return;
      }
      console.warn('Scan log POST failed, retrying:', r.error);
      setTimeout(function () {
        apiPost('/api/scan-log', { entries }).then((r2) => settle(r2, true));
      }, 3000);
    }
  };
  apiPost('/api/scan-log', { entries }).then((r) => settle(r, false));
}
// bag → its last placement-relevant entry (ADD / MOVE / REMOVE). Built once per
// caller: the previous shape reverse-copied the entire scan log for every bag,
// so placing a 20-bag batch against a long log did 20 full array copies.
// Dieselbe Karte, einmal je Auffrischung gebaut.
//
// buildLastPlacementByBag() geht das ganze Scan-Log durch, und _grainKgOf()
// braucht sie jetzt je Körner-Charge — ohne Merker wäre das Log mal Chargen,
// bei jedem SSE-Ereignis. Verworfen wird sie, wo _statusByBatch verworfen wird,
// und an der einen Stelle, die das Log selbst fortschreibt.
let _placementByBag = null;
function placementByBag() {
  if (!_placementByBag) _placementByBag = buildLastPlacementByBag();
  return _placementByBag;
}
function buildLastPlacementByBag() {
  const m = new Map();
  for (const e of scanLog) {
    // MOVE_BATCH gehoert dazu. Ohne sie blieb der Umzug einer ganzen Charge
    // unsichtbar: wer sie ueber die Sammelaktion in die Kontamination schob,
    // liess jedes Glas mit seiner letzten Einzelplatzierung stehen, und
    // _grainKgOf() zaehlte die Kilogramm weiter mit.
    if (e.action !== 'ADD' && e.action !== 'MOVE' && e.action !== 'MOVE_BATCH' && e.action !== 'REMOVE') continue;
    const k = (e.bag || '').toUpperCase();
    if (k) m.set(k, e);
  }
  return m;
}
// opts.reason goes onto every entry. _undoMove() passes 'undo', which is how
// getZoneBags() tells a move taken back from a bag that really came back.
function moveBagsTo(batch, bagIds, dest, cb, opts) {
  rememberDest(dest);
  const now = new Date().toISOString();
  const entries = [];
  let skipped = 0;
  const lastPlacement = buildLastPlacementByBag();
  bagIds.forEach((bagId) => {
    const bagLast = lastPlacement.get(bagId.toUpperCase());
    if (!bagLast || bagLast.action === 'REMOVE') return;
    const curLoc = bagLast.to || null;
    if (curLoc && curLoc.toUpperCase() === dest.toUpperCase()) {
      skipped++;
      return;
    }
    const tempId = 's' + ++_scanTempIdCounter;
    const entry = {
      time: now,
      action: 'MOVE',
      batch: batch.batchId,
      bag: bagId,
      from: curLoc,
      to: dest,
      species: batch.species,
      strain: batch.strain,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      // I-12: optimistic concurrency snapshot for offline-queue replays.
      expected_current_zone: curLoc ? toZone(curLoc) : null,
      _tempId: tempId
    };
    if (opts && opts.reason) entry.reason = opts.reason;
    scanLog.push(entry);
    movements.push(entry);
    entries.push(entry);
    if (!sessionStartTime) sessionStartTime = Date.now();
    sessionEntries.push(entry);
  });
  if (!entries.length) {
    if (cb) cb(0, skipped);
    return;
  }
  if (scanChannel)
    entries.forEach((e) =>
      scanChannel.postMessage({ type: 'scan-entry', entry: { bag: e.bag, batch: e.batch, action: e.action, to: e.to } })
    );
  postScanEntries(entries); // I-12 zone check applies: these are MOVEs
  if (cb) cb(entries.length, skipped);
}

// Move all active bags in a batch to a destination zone/rack.
// Shared by the scan engine (MOVE_BATCH action) and the batch list dropdown.
// Bags that were never placed (no ADD/MOVE/REMOVE in the log) are ADDed at the
// destination instead of being skipped. Without this a batch whose placement
// picker was dismissed had no scan entries at all, so every move path reported
// "no bags to move" and the batch could not be recovered from the UI at all.
// Placing them here is also what the worker means: a whole-batch move to a zone
// says "this batch is now there", however it got created.
// A whole-batch move leaves the batch's contaminated bags where they are: moving
// the batch on would carry them out of the contamination zone and back into
// stock. Moving one of them on purpose is still a single-bag move.
function moveBatchTo(batch, dest, cb) {
  const lastPlacement = buildLastPlacementByBag();
  const unplaced = (batch.bags || []).filter((id) => !lastPlacement.get(id.toUpperCase()));
  const placed = (batch.bags || []).filter((id) => {
    const last = lastPlacement.get(id.toUpperCase());
    return last && !(isContamLoc(last.to) && !isContamLoc(dest));
  });
  if (!unplaced.length) return moveBagsTo(batch, placed, dest, cb);
  addBagsToLocation(batch, unplaced, dest, function (added) {
    if (!placed.length) {
      if (cb) cb(added, 0);
      return;
    }
    moveBagsTo(batch, placed, dest, function (moved, skipped) {
      if (cb) cb(added + moved, skipped);
    });
  });
}

// Add all bags in bagIds to a location (initial placement — ADD action, from=null).
function addBagsToLocation(batch, bagIds, dest, cb) {
  const now = new Date().toISOString();
  const entries = [];
  bagIds.forEach((bagId) => {
    const tempId = 's' + ++_scanTempIdCounter;
    const entry = {
      time: now,
      action: 'ADD',
      batch: batch.batchId,
      bag: bagId,
      from: null,
      to: dest,
      species: batch.species,
      strain: batch.strain,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      _tempId: tempId
    };
    scanLog.push(entry);
    movements.push(entry);
    entries.push(entry);
    if (!sessionStartTime) sessionStartTime = Date.now();
    sessionEntries.push(entry);
  });
  if (!entries.length) {
    if (cb) cb(0);
    return;
  }
  if (scanChannel)
    entries.forEach((e) =>
      scanChannel.postMessage({ type: 'scan-entry', entry: { bag: e.bag, batch: e.batch, action: e.action, to: e.to } })
    );
  // ADD never triggers a zone_mismatch (from=null), so no 409 handling here.
  postScanEntries(entries, { zoneCheck: false });
  if (cb) cb(entries.length);
}

// Zone picker modal — shown after batch creation, user must pick a destination.
// onDone() is called after a zone is picked so the caller can show print panel.
// After batch creation: pick where the new bags go. Delegates to the shared
// zone picker so placement uses the exact same flat zone/rack list as moving,
// with placement (ADD) history as the shortcut row (new batches nearly always
// go to Inkubation). Replaces the old bespoke zone-buttons + rack-dropdown UI;
// the m-zone-pick modal is now unused.
function openZonePickModal(batch, bags, onDone) {
  _openZonePicker(
    t('batch.whereGoInfo', { id: batch.batchId, n: bags.length }),
    function (dest) {
      addBagsToLocation(batch, bags, dest, function (added) {
        setFb('ok', batch.batchId + ': ' + added + ' Bags \u2192 ' + zoneDisplayName(dest), { noModal: true });
        updateSD();
        renderBatches();
        renderStatus();
      });
      if (onDone) onDone();
    },
    { recentOpts: { actions: ['ADD'], lastKey: null }, mandatory: true }
  );
}

// True while the zone picker is up as a mandatory placement gate — the cancel
// button, backdrop click and Escape key all consult this before dismissing.
function _zpMandatory() {
  const m = document.getElementById('m-move-batch');
  return !!(m && m.classList.contains('open') && m.dataset.mandatory === '1');
}
// Render zone/rack picker inside the m-move-batch modal.
// title: string shown at the top; onPick(destId): called when a zone or rack is chosen.
function _openZonePicker(title, onPick, opts) {
  opts = opts || {};
  const m = document.getElementById('m-move-batch');
  if (!m) return;
  // opts.mandatory: this picker is a gate, not an option — used for placing a
  // freshly created batch, where dismissing left the batch with no scan entry
  // at all. Such a batch is EMPTY for getStatus, hidden from the dashboard, and
  // its bags are skipped by every move path, so it could not be recovered from
  // the UI. Suppress all three dismiss routes (cancel button, backdrop, Escape)
  // while it is up; _zpMandatory() is what the handlers consult.
  // Never gate when there is nothing to pick — with no zones configured the
  // worker would be locked into a modal with no way out.
  const mandatory = !!opts.mandatory && zones.length > 0;
  m.dataset.mandatory = mandatory ? '1' : '';
  const cancelBtn = document.getElementById('mb-cancel-btn');
  if (cancelBtn) cancelBtn.style.display = mandatory ? 'none' : '';
  // Close + hand the destination to the caller. Clears the gate flag first so a
  // later non-mandatory picker is dismissible again.
  const pick = (dest) => {
    m.dataset.mandatory = '';
    m.classList.remove('open');
    onPick(dest);
  };
  document.getElementById('mb-title').textContent = title;
  const container = document.getElementById('mb-zones');
  container.innerHTML = '';
  // Shortcut row: most-recent destinations first, one tap each. moveBagsTo
  // already skips bags that are already at the chosen destination. The
  // placement caller passes recentOpts to surface ADD (placement) history.
  // opts.excludeLocs: destinations to drop from the shortcut row — the caller's
  // bags are already there, so offering them as a one-tap would be a no-op move.
  const _recents = recentDestinations(4, opts.recentOpts).filter(
    (loc) => !(opts.excludeLocs && opts.excludeLocs.has(loc))
  );
  if (_recents.length) {
    const hdr = document.createElement('div');
    hdr.className = 'fs-xs';
    hdr.style.cssText =
      'font-weight:600;color:var(--c-text-muted);text-transform:uppercase;letter-spacing:.05em;padding:4px 10px 2px';
    hdr.textContent = t('dash.recentDests');
    container.appendChild(hdr);
    _recents.forEach((loc) => {
      const row = document.createElement('button');
      row.type = 'button';
      row.className = 'fs-sm';
      row.style.cssText =
        'display:block;width:100%;text-align:left;background:var(--c-bg);border:0;padding:8px 10px;font:inherit;cursor:pointer;font-weight:600;border-radius:6px;margin-bottom:2px;border-left:3px solid ' +
        ((ZONE_BY_ID[toZone(loc)] && ZONE_BY_ID[toZone(loc)].color) || '#888');
      row.textContent = '★ ' + zoneDisplayName(loc);
      row.addEventListener('click', () => pick(loc));
      container.appendChild(row);
    });
    const sep = document.createElement('div');
    sep.style.cssText = 'height:1px;background:var(--c-border);margin:6px 0';
    container.appendChild(sep);
  }
  if (!zones.length) {
    container.innerHTML =
      '<div style="padding:8px 0;color:var(--c-text-muted);font-style:italic">' +
      esc(t('batch.noLocations')) +
      '</div>';
  } else {
    zones.forEach((z) => {
      const zRow = document.createElement('button');
      zRow.type = 'button';
      zRow.className = 'fs-sm';
      zRow.style.cssText =
        'display:block;width:100%;text-align:left;background:none;border:0;padding:8px 10px;font:inherit;cursor:pointer;font-weight:600;border-radius:6px;border-left:3px solid ' +
        (z.color || '#888');
      zRow.textContent = z.name || z.id;
      zRow.addEventListener('mouseenter', () => {
        zRow.style.background = 'var(--c-bg)';
      });
      zRow.addEventListener('mouseleave', () => {
        zRow.style.background = 'none';
      });
      zRow.addEventListener('click', () => pick(z.id));
      container.appendChild(zRow);
      (z.racks || []).forEach((r) => {
        const rRow = document.createElement('button');
        rRow.type = 'button';
        rRow.className = 'fs-meta';
        rRow.style.cssText =
          'display:block;width:100%;text-align:left;background:none;border:0;padding:5px 10px 5px 22px;font:inherit;cursor:pointer;font-family:monospace;border-radius:6px;color:var(--c-text-sec)';
        rRow.textContent = r.id.slice(z.id.length + 1) || r.id;
        rRow.title = r.id;
        rRow.addEventListener('mouseenter', () => {
          rRow.style.background = 'var(--c-bg)';
        });
        rRow.addEventListener('mouseleave', () => {
          rRow.style.background = 'none';
        });
        rRow.addEventListener('click', () => pick(r.id));
        container.appendChild(rRow);
      });
    });
  }
  m.classList.add('open');
}

// Move-batch modal — select destination for an entire batch from Alle Chargen.
function openMoveBatchModal(batchId) {
  const b = batches.find((x) => x.batchId === batchId);
  if (!b) return;
  _openZonePicker(t('batch.moveMenuTitle', { id: batchId }), function (dest) {
    const snap = _snapshotBeforeMove([b], dest, buildLastScanByBag());
    moveBatchTo(b, dest, function (moved, skipped) {
      if (!moved) {
        if (skipped > 0) {
          setFb('ok', t('batch.allAlreadyAt', { n: skipped, loc: zoneDisplayName(dest) }));
        } else {
          setFb('err', t('batch.noBagsToMove'));
        }
        return;
      }
      setFb(
        'ok',
        b.batchId +
          ': ' +
          moved +
          ' Bags \u2192 ' +
          zoneDisplayName(dest) +
          (skipped ? ' (' + skipped + ' \u00fcbersprungen)' : '')
      );
      updateSD();
      renderBatches();
      renderStatus();
      renderDashBatchTasks();
      // Same one-tap reversal the \u2192 Fruchtung buttons offer. Skipped when the
      // snapshot is empty (nothing had a prior location to restore).
      if (snap.length) showUndoBar(b.batchId + ': ' + moved + ' \u2192 ' + zoneDisplayName(dest), () => _undoMove(snap));
    });
  });
}

// Persisted so a chosen column/direction survives a reload instead of
// resetting every time the batches (or cultures) list is reopened.
// Every sortable table, and the tbody its rows land in. Adding a table here plus
// data-sort on its headers is the whole job — the click wiring, the arrows and
// the persistence are shared rather than copied per table, which is how batches
// and cultures ended up with two near-identical listeners.
const SORT_TABLES = { harvests: 'harvest-body' };
const tableSort = (() => {
  const empty = {};
  for (const k in SORT_TABLES) empty[k] = null;
  try {
    const s = JSON.parse(localStorage.getItem('mp-table-sort') || 'null');
    // Keep whatever was stored for a table still known; ignore the rest, so a
    // renamed or removed table cannot resurrect a sort nothing can clear.
    if (s && typeof s === 'object') for (const k in SORT_TABLES) empty[k] = s[k] || null;
  } catch (e) {
    /* storage disabled — fall back to no saved sort */
  }
  return empty;
})();
function sortCmp(a, b) {
  if (a == null && b == null) return 0;
  if (a == null) return 1;
  if (b == null) return -1;
  if (typeof a === 'number' && typeof b === 'number') return a - b;
  return String(a).localeCompare(String(b), undefined, { numeric: true, sensitivity: 'base' });
}
function applyTableSort(rows, state, keyFn) {
  if (!state) return rows;
  const sign = state.dir === 'desc' ? -1 : 1;
  return [...rows].sort((a, b) => sign * sortCmp(keyFn(a, state.key), keyFn(b, state.key)));
}
function cycleTableSort(table, key) {
  const cur = tableSort[table];
  tableSort[table] = !cur || cur.key !== key ? { key, dir: 'asc' } : cur.dir === 'asc' ? { key, dir: 'desc' } : null;
  try {
    localStorage.setItem('mp-table-sort', JSON.stringify(tableSort));
  } catch (e) {
    /* storage disabled — sort still works for this session */
  }
}
function updateSortIndicators(table, activeState) {
  // Was a two-way ternary, so any third table silently got the cultures header
  // row and wrote its arrows into the wrong table.
  const bodyId = SORT_TABLES[table];
  if (!bodyId) return;
  const body = document.getElementById(bodyId);
  if (!body) return;
  const thead = body.closest('table').tHead;
  if (!thead) return;
  thead.querySelectorAll('th[data-sort]').forEach((th) => {
    const active = activeState && activeState.key === th.dataset.sort;
    th.classList.toggle('active', !!active);
    let arrow = th.querySelector('.arrow');
    if (!arrow) {
      arrow = document.createElement('span');
      arrow.className = 'arrow';
      th.appendChild(arrow);
    }
    arrow.textContent = active ? (activeState.dir === 'asc' ? ' \u25B2' : ' \u25BC') : ' \u21C5';
  });
}
// Archived = terminal/wrapped-up states. CONTAM lands here once bags are moved
// to the contam zone (worker has acted; resolution is tracked in Contamination
// reports). DONE/EMPTY = no active bags left. Pipeline KPIs still count these
// — only the Batches list view filters them out by default.
const ARCHIVED_STATUSES = ['DONE', 'EMPTY', 'CONTAM'];
const isArchivedStatus = (s) => ARCHIVED_STATUSES.includes(s);

// ── Sortenliste ──
// Eine Liste für drei Seiten: Kulturbibliothek, Körnerbrut und Chargen. Eine
// Zeile je Sorte mit ihren Zahlen; ein Tipp klappt sie an Ort und Stelle auf,
// nach Gruppen (Art oder Phase), eine Zeile je Eintrag; ein Tipp auf einen
// Eintrag öffnet sein Fenster mit den Knöpfen. Oben der Scan-Knopf, was fertig
// ist, hinter "Archiv". Jede Seite sagt nur, was ihre Einträge sind (SL_KULTUREN,
// SL_KOERNER, SL_CHARGEN); wie die Liste aussieht und sich bedient, steht einmal
// hier, damit die drei nicht auseinanderlaufen.
//
// Vorher war jede der drei eine Tabelle: am Telefon Karten untereinander, mit
// Filtern und einer Suche davor, die am Telefon kaum half.
//
// Eine Beschreibung (spec) hat: id (Präfix der Elemente #<id>-list, -count,
// -archiv), find (Präfix für data-find), alle(), imArchiv(x), sorte(x) →
// { key, name }, gruppe(x, archiv), gruppen(archiv) → [{ key, titel }],
// ordnung und ordnungArchiv, chips(g), zeile(x, archiv) → { id, rechts },
// zaehler(), leer(archiv, gefiltert), oeffnen(id); dazu wahlweise filter() und
// unterzeile(g), und vorher(), das vor jedem Zeichnen läuft.
// So viele Einträge einer Gruppe stehen offen da; der Rest auf einen Tipp. Ein
// einzelner mehr wird nicht versteckt, ein "+ 1 weitere" spart nichts.
const SL_ZEIGEN = 6;
const _sl = {};
const _slStand = (spec) => (_sl[spec.id] = _sl[spec.id] || { offen: null, archiv: false, mehr: {} });
function slAlter(created) {
  const tage = Math.floor((Date.now() - new Date(created).getTime()) / 864e5);
  if (!Number.isFinite(tage) || tage < 1) return t('sl.today');
  if (tage < 14) return t('sl.days', { n: tage });
  return t('sl.weeks', { n: Math.floor(tage / 7) });
}
// Die Sorten der gerade gezeigten Seite, je mit ihren Gruppen.
function _slGruppen(spec) {
  const st = _slStand(spec);
  const filter = spec.filter ? spec.filter() : null;
  const m = new Map();
  for (const x of spec.alle()) {
    if (spec.imArchiv(x) !== st.archiv) continue;
    if (filter && !filter(x)) continue;
    const s = spec.sorte(x);
    if (!m.has(s.key)) m.set(s.key, { key: s.key, name: s.name, teile: new Map() });
    const g = m.get(s.key);
    const gk = spec.gruppe(x, st.archiv);
    if (!g.teile.has(gk)) g.teile.set(gk, []);
    g.teile.get(gk).push(x);
  }
  const ord = st.archiv ? spec.ordnungArchiv : spec.ordnung;
  for (const g of m.values()) for (const l of g.teile.values()) l.sort(ord);
  return [...m.values()].sort((a, b) => a.name.localeCompare(b.name, loc(), { sensitivity: 'base' }));
}
// Die Gruppen in der Reihenfolge der Beschreibung; eine, die sie nicht kennt,
// kommt hinten dazu, statt zu verschwinden.
function _slTeile(spec, g, archiv) {
  const bekannt = spec.gruppen(archiv);
  const keys = bekannt.map((x) => x.key).filter((k) => g.teile.has(k));
  for (const k of g.teile.keys()) if (!keys.includes(k)) keys.push(k);
  return keys.map((k) => ({ key: k, titel: (bekannt.find((x) => x.key === k) || {}).titel || k, liste: g.teile.get(k) }));
}
function _slEintragHtml(spec, x) {
  const z = spec.zeile(x, _slStand(spec).archiv);
  return (
    `<button type="button" class="sl-eintrag" data-sl-id="${esc(z.id)}" data-find="${esc(spec.find + ':' + z.id)}">` +
    `<span class="sl-id">${esc(z.id)}</span><span class="sl-r">${esc(z.rechts)}</span></button>`
  );
}
function _slTeilHtml(spec, g, teil) {
  const k = g.key + '|' + teil.key;
  const alle = _slStand(spec).mehr[k] || teil.liste.length <= SL_ZEIGEN + 1;
  const zeigen = alle ? teil.liste : teil.liste.slice(0, SL_ZEIGEN);
  return (
    `<div class="sl-teil"><div class="sl-teil-t">${esc(teil.titel)} <span>${teil.liste.length}</span></div>` +
    zeigen.map((x) => _slEintragHtml(spec, x)).join('') +
    (alle
      ? ''
      : `<button type="button" class="sl-mehr" data-sl-mehr="${esc(k)}">${esc(t('sl.more', { n: teil.liste.length - zeigen.length }))}</button>`) +
    '</div>'
  );
}
function _slSorteHtml(spec, g, offen) {
  const archiv = _slStand(spec).archiv;
  const chips = spec
    .chips(g, archiv)
    .map((c) => `<span class="sl-chip">${esc(c.text)} <b>${esc(c.n)}</b></span>`)
    .join('');
  const unter = !archiv && spec.unterzeile ? spec.unterzeile(g) : null;
  return (
    `<div class="sl-sorte${offen ? ' open' : ''}">` +
    `<button type="button" class="sl-kopf" data-sl-sorte="${esc(g.key)}" aria-expanded="${offen}">` +
    `<span class="sl-name">${spDot(g.name)}${esc(g.name)}` +
    (unter ? `<small class="sup sup-${esc(unter.art)}">${esc(unter.text)}</small>` : '') +
    `</span><span class="sl-chips">${chips}</span></button>` +
    (offen
      ? _slTeile(spec, g, archiv)
          .map((teil) => _slTeilHtml(spec, g, teil))
          .join('')
      : '') +
    '</div>'
  );
}
function slRender(spec) {
  const el = document.getElementById(spec.id + '-list');
  if (!el) return;
  if (spec.vorher) spec.vorher();
  const st = _slStand(spec);
  const imArchiv = spec.alle().filter(spec.imArchiv).length;
  document.getElementById(spec.id + '-count').textContent = st.archiv
    ? t('sl.inArchive', { n: imArchiv })
    : spec.zaehler();
  const ab = document.getElementById(spec.id + '-archiv');
  ab.textContent = st.archiv ? t('sl.archiveBack') : t('sl.archive', { n: imArchiv });
  ab.setAttribute('aria-pressed', String(st.archiv));
  // Mit einem Filter (vom Dashboard: "überfällig") steht alles offen: es sind
  // wenige, und gesucht war genau das.
  const gefiltert = !!(spec.filter && spec.filter());
  const gruppen = _slGruppen(spec);
  const html = gruppen.length
    ? gruppen.map((g) => _slSorteHtml(spec, g, gefiltert || st.offen === g.key)).join('')
    : '<div class="empty">' + esc(spec.leer(st.archiv, gefiltert)) + '</div>';
  // Gezeichnet wird bei jedem Sync und jedem Scan; gleiche Zeilen neu
  // hineinzuschreiben nähme einem Daumen die Zeile weg, die er gerade trifft.
  if (el.__slFp === html) return;
  el.__slFp = html;
  el.innerHTML = html;
}
function slKlick(spec, e) {
  const st = _slStand(spec);
  const kopf = e.target.closest('[data-sl-sorte]');
  if (kopf) {
    st.offen = st.offen === kopf.dataset.slSorte ? null : kopf.dataset.slSorte;
    slRender(spec);
    const neu = document.querySelector('#' + spec.id + '-list .sl-sorte.open');
    if (neu && neu.scrollIntoView) neu.scrollIntoView({ block: 'nearest' });
    return;
  }
  const mehr = e.target.closest('[data-sl-mehr]');
  if (mehr) {
    st.mehr[mehr.dataset.slMehr] = true;
    return slRender(spec);
  }
  const x = e.target.closest('[data-sl-id]');
  if (x) spec.oeffnen(x.dataset.slId);
}
function slArchiv(spec) {
  const st = _slStand(spec);
  st.archiv = !st.archiv;
  st.offen = null;
  slRender(spec);
}
// Ein Weg von außen (Suche, "Zur Charge") landet auf dem Eintrag: seine Sorte
// steht offen, auch wenn er hinter "+ N weitere" oder im Archiv läge.
function slZeige(spec, x) {
  const st = _slStand(spec);
  st.archiv = spec.imArchiv(x);
  const key = spec.sorte(x).key;
  st.offen = key;
  st.mehr[key + '|' + spec.gruppe(x, st.archiv)] = true;
  slRender(spec);
}
// Die Kamera wie der Scan-Knopf unten: ohne eine Aktion davor öffnet ein
// gescanntes Etikett sein Fenster, eine Kultur ihres, ein Beutel seins.
function slScan() {
  scan.action = null;
  scan.to = null;
  scan.from = null;
  updateSD();
  openCamScan();
}

// ── Kulturbibliothek ──
// Je Sorte, was von ihr da ist: Slants, Flüssigkultur, Petri, Spritzen, älteste
// zuerst. Ein Tipp auf eine Kultur öffnet dasselbe Fenster wie ein Scan
// (openCultureSheet), mit Verkaufen, Raus, Drucken und Löschen. Im Archiv steht,
// was verbraucht, verkauft oder kontaminiert ist, die jüngste zuerst.
const KB_ARTEN = ['MC', 'LC', 'PD', 'SY'];
const KB_TITEL = { MC: 'lab.motherCultures', LC: 'lab.liquidCultures', PD: 'lab.petriDishes', SY: 'lab.syringes' };
const KB_KURZ = { MC: 'lb.short.MC', LC: 'lb.short.LC', PD: 'lb.short.PD', SY: 'lb.short.SYall' };
const KB_STATUS = { active: 'lab.active', stored: 'lab.stored', used: 'lab.usedUp', sold: 'lab.sold', contam: 'lab.contaminated' };
const _kbDa = (c) => c.status === 'active' || c.status === 'stored';
function _kbSorte(c) {
  const ms = c.strainId ? (mushroomStrains || []).find((m) => m.id === c.strainId) : null;
  return { key: sorteKey(c), name: (ms && ms.name) || sorteName(c) || '—' };
}
const _nachAlter = (a, b) => String(a.created).localeCompare(String(b.created));
const _nachJung = (a, b) => String(b.created).localeCompare(String(a.created));
const SL_KULTUREN = {
  id: 'kb',
  find: 'culture',
  alle: () => cultures.filter((c) => KB_ARTEN.includes(c.type)),
  imArchiv: (c) => !_kbDa(c),
  sorte: _kbSorte,
  gruppe: (c) => c.type,
  gruppen: () => KB_ARTEN.map((a) => ({ key: a, titel: t(KB_TITEL[a]) })),
  ordnung: _nachAlter,
  ordnungArchiv: _nachJung,
  chips: (g) =>
    KB_ARTEN.filter((a) => g.teile.has(a)).map((a) => ({ text: t(KB_KURZ[a]), n: g.teile.get(a).length })),
  zeile: (c, archiv) => {
    const rechts = [];
    if (c.type === 'SY') rechts.push(syMl(c) + ' ml');
    if (archiv) rechts.push(t(KB_STATUS[c.status] || c.status));
    else {
      if (c.status === 'stored') rechts.push(t('lab.stored'));
      rechts.push(slAlter(c.created));
    }
    return { id: c.id, rechts: rechts.join(' · ') };
  },
  zaehler: () => t('kb.count', { n: cultures.filter(_kbDa).length }),
  leer: (archiv) => t(archiv ? 'sl.archiveEmpty' : 'lab.noCultures'),
  oeffnen: (id) => {
    const c = cultures.find((x) => x.id === id);
    if (c) openCultureSheet(c);
  }
};
function renderCultures() {
  slRender(SL_KULTUREN);
}
function kbZeige(id) {
  const c = cultures.find((x) => x.id === id);
  if (c) slZeige(SL_KULTUREN, c);
}

// ── Chargen ──
// Die Blöcke je Sorte, auf der Sortenliste wie die Kulturbibliothek: nach Phase,
// die fälligste zuerst. Neben dem Namen steht, wenn einer Sorte der Nachschub
// fehlt (sorteRollup, dieselbe Rechnung wie die Tagesliste). Im Archiv:
// fertig, kontaminiert, ohne Beutel, die jüngste zuerst.
const CH_PHASEN = [
  ['INCUBATING', 'stage.incubation'],
  ['FRUITING', 'stage.fruiting'],
  ['SPAWN RUN', 'stage.spawn']
];
const CH_ARCHIV = [
  ['DONE', 'sl.st.done'],
  ['CONTAM', 'sl.st.contam'],
  ['EMPTY', 'sl.st.empty']
];
const _chGruppen = (paare) => paare.map(([key, k]) => ({ key, titel: t(k) }));
function _chPhase(status) {
  const p = CH_PHASEN.concat(CH_ARCHIV).find(([k]) => k === status);
  return p ? t(p[1]) : status;
}
const _chStatus = (b) => getStatus(b.batchId).status;
const _chImArchiv = (b) => isArchivedStatus(_chStatus(b));
const _chSorte = (b) => ({ key: sorteKey(b), name: sorteName(b) });
// Beutel, die noch stehen: kein kontaminierter, keiner, der raus ist.
function _chLebend(b) {
  const s = _stageBagsOf(b);
  return s.spawn + s.incubation + s.fruiting;
}
function _chFaellig(b) {
  const heute = new Date();
  heute.setHours(0, 0, 0, 0);
  const due = new Date(b.due);
  due.setHours(0, 0, 0, 0);
  const n = Math.round((due - heute) / 864e5);
  if (!Number.isFinite(n)) return '';
  if (n < 0) return t('sl.overdue', { n: -n });
  if (n === 0) return t('sl.dueToday');
  return t('sl.due', { date: fmtDtShort(b.due) });
}
const _kgText = (n) => fmtKg(n, n % 1 ? 1 : 0) + ' kg';
const _anzahl = (g) => [...g.teile.values()].reduce((s, l) => s + l.length, 0);
let _chNachschub = new Map();
const SL_CHARGEN = {
  id: 'ch',
  find: 'batch',
  alle: () => batches.filter((b) => b.batchType !== 'grain'),
  imArchiv: _chImArchiv,
  sorte: _chSorte,
  gruppe: (b) => _chStatus(b),
  gruppen: (archiv) => _chGruppen(archiv ? CH_ARCHIV : CH_PHASEN),
  ordnung: (a, b) => String(a.due).localeCompare(String(b.due)),
  ordnungArchiv: _nachJung,
  vorher: () => {
    _chNachschub = new Map(sorteRollup().map((r) => [r.key, r.supply]));
  },
  chips: (g, archiv) => {
    if (archiv) return [{ text: t('sl.ch.batches'), n: _anzahl(g) }];
    let ink = 0;
    let fr = 0;
    for (const l of g.teile.values())
      for (const b of l) {
        const s = _stageBagsOf(b);
        ink += s.spawn + s.incubation;
        fr += s.fruiting;
      }
    return [ink && { text: t('sl.ch.inc'), n: ink }, fr && { text: t('sl.ch.fruit'), n: fr }].filter(Boolean);
  },
  unterzeile: (g) => {
    const s = _chNachschub.get(g.key);
    return s === 'now' || s === 'nospawn' ? { art: s, text: t('batch.supply.' + s) } : null;
  },
  zeile: (b, archiv) => {
    const rechts = [t('sl.bags', { n: archiv ? b.qty : _chLebend(b) })];
    if (archiv) rechts.push(fmtDtShort(b.created));
    else rechts.push(_chStatus(b) === 'FRUITING' ? slAlter(b.created) : _chFaellig(b));
    return { id: b.batchId, rechts: rechts.join(' · ') };
  },
  zaehler: () => t('ch.count', { n: batches.filter((b) => b.batchType !== 'grain' && !_chImArchiv(b)).length }),
  leer: (archiv, gefiltert) => t(gefiltert ? 'dash.noMatches' : archiv ? 'sl.archiveEmpty' : 'dash.noBatches'),
  filter: () => (batchAttentionFilter ? batchAttentionFilter.pred : null),
  oeffnen: (id) => {
    const b = batches.find((x) => x.batchId === id);
    if (b) openChargeSheet(b);
  }
};
function renderBatches() {
  renderBatchAttentionBanner();
  slRender(SL_CHARGEN);
}

// ── Körnerbrut ──
// Die Gläser je Sorte, auf derselben Liste: was fertig ist und was noch wächst,
// in kg, das älteste zuerst, denn das ist als nächstes dran. Ein Tipp öffnet
// dasselbe Fenster wie eine Charge.
const _grFertig = (b) => !b.due || new Date(b.due).getTime() <= Date.now();
const SL_KOERNER = {
  id: 'gr',
  find: 'batch',
  alle: () => batches.filter((b) => b.batchType === 'grain'),
  imArchiv: _chImArchiv,
  sorte: _chSorte,
  gruppe: (b, archiv) => (archiv ? _chStatus(b) : _grFertig(b) ? 'fertig' : 'waechst'),
  gruppen: (archiv) =>
    archiv
      ? _chGruppen(CH_ARCHIV)
      : [
          { key: 'fertig', titel: t('sl.gr.ready') },
          { key: 'waechst', titel: t('sl.gr.growing') }
        ],
  ordnung: _nachAlter,
  ordnungArchiv: _nachJung,
  chips: (g, archiv) => {
    if (archiv) return [{ text: t('sl.ch.batches'), n: _anzahl(g) }];
    const kg = (k) => (g.teile.get(k) || []).reduce((s, b) => s + _grainKgOf(b), 0);
    return [
      ['fertig', 'sl.gr.readyShort'],
      ['waechst', 'sl.gr.growingShort']
    ]
      .filter(([k]) => g.teile.has(k))
      .map(([k, txt]) => ({ text: t(txt), n: _kgText(kg(k)) }));
  },
  zeile: (b, archiv) => {
    const rechts = [];
    if (archiv) rechts.push(fmtDtShort(b.created));
    else {
      rechts.push(_kgText(_grainKgOf(b)));
      rechts.push(_grFertig(b) ? slAlter(b.created) : t('sl.gr.readyOn', { date: fmtDtShort(b.due) }));
    }
    return { id: b.batchId, rechts: rechts.join(' · ') };
  },
  zaehler: () =>
    t('gr.count', {
      kg: _kgText(
        batches
          .filter((b) => b.batchType === 'grain' && !_chImArchiv(b) && _grFertig(b))
          .reduce((s, b) => s + _grainKgOf(b), 0)
      )
    }),
  leer: (archiv) => t(archiv ? 'sl.archiveEmpty' : 'gr.none'),
  oeffnen: (id) => SL_CHARGEN.oeffnen(id)
};
function renderGrainBatches() {
  slRender(SL_KOERNER);
}

// Die Beutel einer Charge als Knöpfe, nach ihrem Platz: je Platz eine Zeile
// mit der Zahl, darunter die Nummern. Stand als aufklappbare Zeile unter der
// Tabellenzeile, je Beutel mit dem Platz daneben; im Fenster liefen zwanzig
// Beutel so über eine ganze Seite. Ein Knopf, kein Text: er ist der Weg ins
// Beutel-Fenster ohne Barcode, und dort liegen Umsetzen, Ernten, Melden und
// die Geschichte. Am Laptop ist er der Weg hinein.
let locColor = {};
function _bagChipsHtml(b) {
  const lastByBag = buildLastScanByBag();
  const wVals = b.bagWeights ? new Set(Object.values(b.bagWeights)) : new Set();
  const plaetze = new Map();
  for (const bag of b.bags) {
    const last = lastByBag.get(bag.toUpperCase());
    const raus = !!(last && last.action === 'REMOVE');
    let loc = '—',
      color = '#888';
    if (raus) loc = t('bagInfo.removed');
    else if (last && last.to) {
      loc = zoneDisplayName(last.to);
      color = locColor[toZone(last.to)] || '#888';
    }
    if (!plaetze.has(loc)) plaetze.set(loc, { color, raus, knoepfe: [] });
    // Das Gewicht je Beutel nur, wenn die Charge verschiedene trägt.
    const bw = b.bagWeights ? b.bagWeights[bag] : null;
    const wTag =
      bw != null && wVals.size > 1
        ? `<span class="fs-floor" style="--fs-own:8px;color:#888;margin-left:2px">${esc(String(bw).replace('.', ','))}kg</span>`
        : '';
    plaetze
      .get(loc)
      .knoepfe.push(
        `<button type="button" class="bag-open-chip fs-micro" onclick="openBagInfo('${esc(bag)}','${esc(b.batchId)}')" title="${esc(t('bagInfo.openHint'))}" style="font-family:monospace;padding:3px 8px;border-radius:5px;background:#fff;border:1px solid var(--c-border);cursor:pointer${raus ? ';text-decoration:line-through;opacity:.5' : ''}">${esc(bag.split('-').pop())}${wTag}</button>`
      );
  }
  return (
    '<div style="margin-bottom:12px">' +
    [...plaetze]
      .map(
        ([loc, p]) =>
          `<div class="fs-meta" style="margin:8px 0 4px;font-weight:600;color:${p.raus ? 'var(--c-text-muted)' : p.color}">${esc(loc)} · ${p.knoepfe.length}</div>` +
          `<div style="display:flex;flex-wrap:wrap;gap:4px">${p.knoepfe.join('')}</div>`
      )
      .join('') +
    '</div>'
  );
}

// ── Das Chargen-Fenster ──
// Ein Tipp auf eine Charge öffnet, was die Zeile der alten Tabelle trug: woraus
// sie ist, wo ihre Beutel stehen, und Umziehen, Beutel dazu, Notiz, Löschen. Im
// selben Fenster wie Beutel und Kultur (m-baginfo), mit eigenen Knöpfen
// (data-bi="ch-…").
let chBatchId = null;
function openChargeSheet(b) {
  biBagId = null;
  biBatchId = null;
  ciCultureId = null;
  chBatchId = b.batchId;
  const { status } = getStatus(b.batchId);
  const name = sorteName(b);
  const met = (k, v) =>
    `<div class="met"><div class="met-l">${esc(k)}</div><div class="fs-base" style="font-weight:600">${v}</div></div>`;
  const groessen = b.batchType === 'grain' ? grainSizeSummary(b) : null;
  const sub = groessen
    ? groessen.join(' · ')
    : b.substrate
      ? 'HW ' +
        b.substrate.hardwood +
        '% · WB ' +
        b.substrate.wheatbran +
        '%' +
        (b.substrate.rh ? ' · RH ' + b.substrate.rh + '%' : '') +
        (b.substrate.gypsum ? ' · Gypsum' : '')
      : '—';
  const quelle = [b.sourceId].concat(spawnSourceFor(b.batchId)).filter(Boolean);
  document.getElementById('bi-title').textContent = b.batchId;
  document.getElementById('bi-body').innerHTML =
    '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:12px">' +
    met(t('batch.species'), spDot(name) + esc(name)) +
    met(t('batch.strain'), (b.strainText || '').trim() ? esc(b.strainText.trim()) : '—') +
    met(t('ch.phase'), esc(_chPhase(status))) +
    met(t('ch.bagsLive'), esc(_chLebend(b) + ' / ' + b.qty)) +
    met(t('ci.created'), esc(fmtDt(b.created))) +
    met(t('th.due'), esc(fmtDt(b.due))) +
    met(groessen ? t('ch.sizes') : t('th.substrate'), esc(sub) + _batchIstRhTag(b)) +
    met(
      t('th.source'),
      quelle.length ? `<span style="font-family:monospace">${esc(quelle.join(', '))}</span>` : '—'
    ) +
    // Gemessen beim Beimpfen. Steht hier, weil eine Charge ohne Ansatz sonst
    // nirgends zeigte, was für sie eingetragen wurde. Geändert wird direkt an
    // der Zahl: ein dritter Knopf in der Reihe darunter brach dort jede
    // Beschriftung am Telefon in zwei Zeilen.
    met(
      t('sub.phAtInoc'),
      (b.ph == null ? '—' : esc(fmtKg(b.ph, 1))) +
        ` <button type="button" class="wkf-link" data-bi="ch-ph">${esc(t(b.ph == null ? 'ch.phAdd' : 'ch.phEdit'))}</button>`
    ) +
    '</div>' +
    (b.notes ? `<div class="fs-meta" style="margin-bottom:10px;white-space:pre-wrap">${esc(b.notes)}</div>` : '') +
    `<div class="fs-meta muted" style="margin-bottom:6px">${esc(t('ch.bagsTitle'))}</div>` +
    _bagChipsHtml(b);
  renderChActions(b, status);
  document.getElementById('m-baginfo').classList.add('open');
}
function renderChActions(b, status) {
  const el = document.getElementById('bi-actions');
  if (!el) return;
  // Dieselben Formen wie renderCiActions.
  const big =
    'width:100%;display:flex;align-items:center;justify-content:center;gap:8px;padding:15px;border-radius:12px;border:0;font-weight:600;margin-bottom:8px;cursor:pointer';
  const sec =
    'flex:1;display:flex;align-items:center;justify-content:center;gap:6px;padding:13px;border-radius:10px;cursor:pointer;background:var(--c-surface);border:1px solid var(--c-border)';
  let html = '';
  if (status !== 'DONE')
    html += `<button type="button" data-bi="ch-move" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-primary);color:#fff">${esc(t('batch.moveTo'))}</button>`;
  html += '<div style="display:flex;gap:8px;margin-bottom:8px">';
  html += `<button type="button" data-bi="ch-bags" class="fs-base" style="${sec};color:var(--c-text)">${esc(t('batch.addBags'))}</button>`;
  html += `<button type="button" data-bi="ch-note" class="fs-base" style="${sec};color:var(--c-text)">${esc(t(b.notes ? 'ch.editNote' : 'batch.addNote'))}</button>`;
  html += '</div>';
  html += `<button type="button" data-bi="ch-del" class="fs-base" style="${big};padding:13px;background:var(--c-red-light);color:var(--c-red-dark);border:1px solid var(--c-red-border)">${esc(t('batch.del'))}</button>`;
  el.innerHTML = html;
}
function chAction(a) {
  const id = chBatchId;
  if (!id) return;
  document.getElementById('m-baginfo').classList.remove('open');
  if (a === 'ch-move') return openMoveBatchModal(id);
  if (a === 'ch-bags') return openAddBags(id);
  if (a === 'ch-note') return openNote(id);
  if (a === 'ch-ph') return recordBatchPh(id);
  if (a === 'ch-del') return delBatch(id);
}

// pH nachtragen oder korrigieren, wie die Sterilisierzeit am Ansatz. Leer
// löscht ihn wieder.
function recordBatchPh(id) {
  const b = batches.find((x) => x.batchId === id);
  if (!b) return;
  prompt2(
    t('ch.phPrompt', { id }),
    t('ch.phHint'),
    async (v) => {
      const ph = phLesen(v);
      if (ph === undefined) {
        toast(t('batch.phNaN'), 'err');
        return;
      }
      const r = await apiPatch('/api/batches/' + encodeURIComponent(id), { ph });
      if (r && r.error) {
        toast(t('sub.failed', { err: r.error }), 'err');
        return;
      }
      b.ph = ph;
      toast(ph == null ? t('ch.phCleared') : t('ch.phSaved', { ph: fmtKg(ph, 1) }));
      // Der Mittelwert am Ansatz hängt daran.
      if (b.substrateSubId) refreshSubstrateBatches();
      openChargeSheet(b);
    },
    { inputmode: 'decimal', value: b.ph == null ? '' : fmtKg(b.ph, 1) }
  );
}

// Woraus eine Charge besteht: Größe → wie viele Beutel davon.
//
// Eine Charge Körnerbrut darf mehr als eine Größe tragen, und beides, was man
// darüber wissen will — die Aufstellung und die vorherrschende Größe — ist
// dieselbe Auszählung. Zweimal gezählt hieße zwei Regeln, die auseinanderlaufen
// können.
function grainSizeCounts(b) {
  const w = b.bagWeights || {};
  const bags = b.bags && b.bags.length ? b.bags : Object.keys(w);
  const counts = new Map();
  for (const bag of bags) {
    const kg = Number.isFinite(w[bag]) ? w[bag] : b.bagKg;
    if (!(kg > 0)) continue;
    counts.set(kg, (counts.get(kg) || 0) + 1);
  }
  return counts;
}
// "10 × 1 kg · 5 × 2 kg" — als Zeilen für die Liste.
//
// In der Spalte Substrat stand für eine Körner-Charge "HW 0% WB 0%": db.js gibt
// substrate immer als Objekt zurück, und für Körner sind alle Anteile null.
// Eine Zelle, die für diese Zeilen nichts bedeutete — und die eine Angabe, die
// sie tragen könnte, stand nirgends in der Liste.
function grainSizeSummary(b) {
  const counts = grainSizeCounts(b);
  if (!counts.size) return null;
  return [...counts.entries()]
    .sort((x, y) => x[0] - y[0])
    .map(([kg, n]) => n + ' × ' + String(kg).replace('.', ',') + ' kg');
}
// Die Größe, aus der die meisten Beutel sind. Dieselbe Regel, nach der
// createGrainBatch das Gewicht der Charge selbst bestimmt.
function _dominantBagKg(b) {
  let best = null;
  for (const [kg, n] of grainSizeCounts(b)) if (!best || n > best[1]) best = [kg, n];
  if (best) return best[0];
  return Number.isFinite(b.bagKg) && b.bagKg > 0 ? b.bagKg : null;
}
function _batchIstRhTag(b) {
  const sb = b.substrateSubId ? (_sbList || []).find((x) => x.subId === b.substrateSubId) : null;
  if (!sb || sb.actualRhPct == null) return '';
  return `<span class="sub-tag" style="background:var(--c-blue-light);color:var(--c-blue-dark)">${esc(t('bagInfo.rhActual'))} ${esc(fmtKg(sb.actualRhPct, 1))}%</span>`;
}
let addBagsBatchId = null;
let _lastNewBags = [];
function openAddBags(batchId) {
  const b = batches.find((x) => x.batchId === batchId);
  if (!b) return;
  addBagsBatchId = batchId;
  document.getElementById('ab-phase-input').style.display = '';
  document.getElementById('ab-phase-result').style.display = 'none';
  document.getElementById('m-addbags-title').textContent = t('addBags.title');
  document.getElementById('ab-info').textContent = t('addBags.info', {
    id: batchId,
    n: b.bags.length,
    last: b.bags[b.bags.length - 1]
  });
  document.getElementById('ab-qty').value = 1;
  // Bei Körnerbrut ist "wieviele" nur die halbe Frage. Vorgeschlagen wird die
  // Größe, aus der die Charge überwiegend besteht — meistens ergänzt man mehr
  // davon; wer eine andere braucht, überschreibt sie.
  const kgWrap = document.getElementById('ab-kg-wrap');
  const kgEl = document.getElementById('ab-kg');
  const isGrain = b.batchType === 'grain';
  if (kgWrap) kgWrap.style.display = isGrain ? '' : 'none';
  if (kgEl) {
    const sizes = grainSizeSummary(b);
    const main = _dominantBagKg(b);
    kgEl.value = isGrain && main ? String(main).replace('.', ',') : '';
    kgEl.title = sizes ? sizes.join(' · ') : '';
  }
  document.getElementById('ab-preview').style.display = 'none';
  document.getElementById('m-addbags').classList.add('open');
  setTimeout(() => document.getElementById('ab-qty').focus(), 80);
}
function confirmAddBags() {
  const b = batches.find((x) => x.batchId === addBagsBatchId);
  if (!b) return;
  const qty = parseInt(document.getElementById('ab-qty').value) || 0;
  if (qty < 1) {
    fieldError('ab-qty', t('addBags.enterQty'));
    return;
  }
  const kgEl = document.getElementById('ab-kg');
  const bagKg = b.batchType === 'grain' && kgEl ? parseDecimal(kgEl.value) || 0 : 0;
  if (b.batchType === 'grain' && !(bagKg > 0)) {
    fieldError('ab-kg', t('batch.enterWeight'));
    return;
  }
  const confirmBtn = document.getElementById('addbags-confirm-btn');
  if (confirmBtn) confirmBtn.disabled = true;
  const prevBags = b.bags.slice();
  const prevQty = b.qty;
  const lastNum = parseInt(b.bags[b.bags.length - 1].split('-').pop()) || b.bags.length;
  const newBags = Array.from({ length: qty }, (_, i) => b.batchId + '-' + String(lastNum + 1 + i).padStart(2, '0'));
  b.bags = [...b.bags, ...newBags];
  b.qty = b.bags.length;
  _lastNewBags = newBags;
  // Lokal mitschreiben, damit Etikett und Liste sofort das Gewicht zeigen, das
  // gleich auch in der Datenbank steht.
  if (bagKg > 0) {
    if (!b.bagWeights) b.bagWeights = {};
    for (const id of newBags) b.bagWeights[id] = bagKg;
  }
  apiPatch('/api/batches/' + encodeURIComponent(b.batchId) + '/bags', {
    add: newBags,
    newQty: b.qty,
    ...(bagKg > 0 ? { bagKg } : {})
  })
    .then((r) => {
      if (r && r.error) {
        b.bags = prevBags;
        b.qty = prevQty;
        if (b.bagWeights) for (const id of newBags) delete b.bagWeights[id];
        setFb('err', t('common.error') + ': ' + r.error);
        document.getElementById('ab-phase-input').style.display = '';
        document.getElementById('ab-phase-result').style.display = 'none';
        return;
      }
      if (r && r.bagBarcodes) {
        for (const [id, bc] of Object.entries(r.bagBarcodes)) {
          barcodeRegistry.set(bc, { type: 'bag', id });
          barcodeByEntity.set('bag:' + id, bc);
        }
      }
    })
    .finally(() => {
      if (confirmBtn) confirmBtn.disabled = false;
    });
  // Switch to result phase
  document.getElementById('ab-phase-input').style.display = 'none';
  document.getElementById('m-addbags-title').textContent = t('addBags.addedTitle');
  document.getElementById('ab-result-info').textContent = t('addBags.added', {
    qty: qty,
    id: b.batchId,
    total: b.bags.length
  });
  document.getElementById('ab-new-bags').innerHTML = newBags
    .map(
      (id) =>
        '<span class="fs-micro" style="font-family:monospace;background:var(--c-bg);padding:2px 6px;border-radius:4px;color:var(--c-text-sec)">' +
        esc(id) +
        '</span>'
    )
    .join('');
  document.getElementById('ab-phase-result').style.display = '';
  renderBatches();
}
async function printNewBags() {
  const b = batches.find((x) => x.batchId === addBagsBatchId);
  if (!b || !_lastNewBags.length) return;
  await ensureBagBarcodes(_lastNewBags);
  const zpl = makeBagZPL(_lastNewBags, b, 'full');
  const err = await sendToPrinter(zpl);
  if (err) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = b.batchId + '_new_labels.zpl';
    a.click();
  } else {
    printedFb(t('addBags.printed', { n: _lastNewBags.length, id: b.batchId }));
  }
  document.getElementById('m-addbags').classList.remove('open');
}
document.getElementById('m-addbags').addEventListener('click', (e) => {
  if (e.target.id === 'm-addbags') document.getElementById('m-addbags').classList.remove('open');
});

function delBatch(id) {
  confirm2(t('batch.deleteBatch', { id: id }), t('batch.deleteMsg'), t('batch.deleteBtn'), async () => {
    // Server-first: only apply local changes after the server confirms the delete.
    // Prevents a silent divergence where the batch reappears on next page load.
    const r = await apiDelete('/api/batches/' + encodeURIComponent(id));
    if (r && r.error) {
      setFb('err', t('common.error') + ': ' + r.error);
      return;
    }
    const b = batches.find((x) => x.batchId === id);
    // Reverse inventory deductions locally
    if (b && inventory.stock) {
      // Sum per-bag weights from bagWeights map, or fall back to qty * bagKg
      const totalBagKg =
        b.bagWeights && Object.keys(b.bagWeights).length
          ? Object.values(b.bagWeights).reduce((s, w) => s + (w || b.bagKg || 3), 0)
          : b.qty * (b.bagKg || 3);
      if (b.batchType === 'grain') {
        inventory.stock.grain = (inventory.stock.grain || 0) + totalBagKg;
      } else if (b.substrate) {
        const rh = b.substrate.rh || 0;
        const totalDryKg = mtDryKg(totalBagKg, rh);
        if (b.substrate.hardwood)
          inventory.stock.hardwood = (inventory.stock.hardwood || 0) + totalDryKg * (b.substrate.hardwood / 100);
        if (b.substrate.wheatbran)
          inventory.stock.wheatbran = (inventory.stock.wheatbran || 0) + totalDryKg * (b.substrate.wheatbran / 100);
        if (b.substrate.coir)
          inventory.stock.coir = (inventory.stock.coir || 0) + totalDryKg * (b.substrate.coir / 100);
        if (b.substrate.gypsum) inventory.stock.gypsum = (inventory.stock.gypsum || 0) + totalDryKg * 0.01;
      }
      // All-in-One raw-grain portion mixed into a block batch (credit it back too).
      if (b.batchType !== 'grain' && b.grainKg) {
        const grh = b.grainRh || 0;
        inventory.stock.grain = (inventory.stock.grain || 0) + b.qty * b.grainKg * (grh > 0 ? 1 - grh / 100 : 1);
      }
    }
    batches = batches.filter((x) => x.batchId !== id);
    scanLog = scanLog.filter((x) => x.batch !== id);
    harvests = harvests.filter((x) => x.batch !== id);
    renderBatches();
    renderStatus();
  });
}

// ─── HARVESTS ────────────────────────────────────────────────
// Kam der Beutel aus der Kamera? Dann geht es nach dem Speichern dorthin zurück,
// mit Ernten noch an — der nächste Beutel liegt schon in der Hand. Vorher
// öffnete "Speichern & weiter" die grüne Scan-Hülle für den Handscanner, und am
// Telefon hieß das: für jeden Beutel die Kamera neu aufmachen.
let _hpFromCam = false;
function showHarvestPanel(bagId, batchId) {
  _hpFromCam = document.getElementById('m-camscan').classList.contains('open');
  const b = batches.find((x) => x.batchId === batchId);
  scan.harvestBag = { bagId, batchId, species: b?.species, strain: b?.strain };
  document.getElementById('hp-lbl').textContent = t('harvest.logHarvest') + ' \u2014 ' + bagId;
  document.getElementById('hp-bag').value = bagId;
  document.getElementById('hp-grams').value = '';
  // Never carried over from the last bag. A weight gets re-typed every time, but
  // a release that looks already-filled gets confirmed by reflex — and that sets
  // the same produce aside twice.
  document.getElementById('hp-release').value = '';
  // Die Notiz gehört zu diesem Block, nie zum vorigen.
  document.getElementById('hp-note').value = '';
  renderBlockGoodButtons();
  // Hidden unless the feed actually reports releases. A field that takes a number
  // and does nothing with it is worse than no field: the crate gets packed and
  // nothing publishes it.
  document.getElementById('hp-release-wrap').style.display = harvestRelease.on ? '' : 'none';
  closeCamScan();
  closeScanModal();
  document.getElementById('harvest-panel').style.display = 'block';
  setTimeout(() => document.getElementById('hp-grams').focus(), 80);
  setFb('harvest', t('harvest.bagScanned', { bag: bagId }), { noModal: true });
}
function confirmHarvest(keepScanning) {
  const g = parseDecimal(document.getElementById('hp-grams').value),
    f = parseInt(document.getElementById('hp-flush').value) || 1;
  if (!g || g <= 0) {
    fieldError('hp-grams', t('harvest.enterWeight'));
    return;
  }
  // Only when the field is on screen. Reading it regardless would send whatever
  // a previous session left in the DOM.
  const rel = harvestRelease.on ? parseDecimal(document.getElementById('hp-release').value) || 0 : 0;
  // Caught here as well as on the server, because here it is still fixable: the
  // panel stays open with the number in it. The server rejecting it after the
  // scan modal has moved on is a message about a bag that is already back on the
  // shelf.
  if (rel > g) {
    fieldError('hp-release', t('harvest.releaseTooHigh'));
    return;
  }
  const p = scan.harvestBag;
  const tempId = 's' + ++_scanTempIdCounter;
  const hEntry = {
    time: new Date().toISOString(),
    batch: p.batchId,
    bag: p.bagId,
    species: p.species,
    strain: p.strain,
    grams: g,
    flush: f
  };
  harvests.push(hEntry);
  // Die Notiz geht als eigener Eintrag ins Blockbuch, mit der Welle, in der sie
  // geschrieben wurde. Schlägt sie fehl, sagt setFb das; die Ernte bleibt.
  const noteEl = document.getElementById('hp-note');
  const note = noteEl ? noteEl.value.trim() : '';
  if (noteEl) noteEl.value = '';
  if (note) addBlockComment(p.bagId, p.batchId, note, f);
  // `release` travels in the request but not in `hEntry`: the local array mirrors
  // the harvests table, and a field that exists on the client's copy and not in
  // the database is how the two quietly drift apart.
  apiPost('/api/harvests', rel > 0 ? { ...hEntry, release: rel } : hEntry).then((r) => {
    if (r && r.error) {
      // Roll back local state so user sees accurate harvest totals
      const i = harvests.lastIndexOf(hEntry);
      if (i >= 0) harvests.splice(i, 1);
      setFb('err', t('common.error') + ': ' + r.error);
      renderHarvests();
      updateSD();
      return;
    }
    // The harvest is stored either way — only the release failed. Saying so
    // matters because the crate is already packed: without this the produce sits
    // there and the shop never hears about it.
    //
    // `noModal: true` on both, like the five other call sites that fire from a
    // callback. Without it setFb() runs openScanModal(), and by the time this
    // resolves the worker has usually scanned the next bag — so the overlay would
    // reopen over a panel already being typed into, and on a phone it would leave
    // body.overflow pinned to hidden.
    //
    // The message names the bag and calls the figure a total, because the number
    // that comes back is the whole crate and not this bag's contribution: 500 g on
    // top of 2 kg answers "2.5 kg", and read as "just released" that looks like a
    // slipped comma.
    if (r && r.releaseError)
      setFb('err', t('harvest.releaseFailed', { bag: p.bagId }) + ': ' + r.releaseError, { noModal: true });
    else if (r && r.released)
      setFb('ok', t('harvest.releasedTotal', { bag: p.bagId, kg: (r.released.grams / 1000).toFixed(2) }), {
        noModal: true
      });
  });
  // Track in sessionEntries so session summary counts HARVEST and it appears in the log
  const sEntry = {
    time: hEntry.time,
    action: 'HARVEST',
    batch: p.batchId,
    bag: p.bagId,
    from: null,
    to: null,
    species: p.species,
    strain: p.strain,
    grams: g,
    flush: f,
    _tempId: tempId
  };
  if (!sessionStartTime) sessionStartTime = Date.now();
  sessionEntries.push(sEntry);
  scan.harvestBag = null;
  scan.count++;
  // Mitgezählt für den Ernten-Knopf, solange Ernten an ist.
  if (scan.action === 'HARVEST') modeRunTally('HARVEST', null, sEntry);
  document.getElementById('harvest-panel').style.display = 'none';
  // Zurück in die Kamera, wenn sie der Weg hierher war: das zählt für Enter wie
  // für beide Knöpfe. Synchron, noch im Tipp — iOS gibt die Kamera sonst nicht.
  const zurueck = _hpFromCam;
  _hpFromCam = false;
  if (zurueck) openCamScan();
  setFb('ok', t('harvest.logged', { bag: p.bagId, g: g, f: f }), sEntry);
  updateSD();
  // Chain: reopen the scanner so the next bag flows straight into a fresh
  // harvest panel (scan.action stays HARVEST) instead of ejecting the worker
  // and making them re-open the scanner between every bag.
  if (keepScanning && !zurueck) openScanModal();
}
function cancelHarvest() {
  scan.harvestBag = null;
  document.getElementById('harvest-panel').style.display = 'none';
  // Diesen Beutel nicht — aber Ernten bleibt an, und aus der Kamera geht es
  // dorthin zurück.
  const zurueck = _hpFromCam;
  _hpFromCam = false;
  if (zurueck) openCamScan();
  setFb('info', t('harvest.cancelled'));
}
document.getElementById('hp-grams').addEventListener('keydown', (e) => {
  if (e.key === 'Enter') confirmHarvest();
});
function renderHarvests() {
  const q = (document.getElementById('harvest-q').value || '').toLowerCase(),
    body = document.getElementById('harvest-body');
  // P-02: Chart.js is lazy-loaded. If it isn't ready yet, defer the entire
  // render until it is. The user briefly sees the previous tab render until
  // the lib finishes loading; in practice this is sub-100ms because either
  // the SW pre-cache has the lib, or the idle preload kicked off long ago.
  if (typeof Chart === 'undefined') {
    loadVendorLibs().then(() => renderHarvests());
    return;
  }
  // Newest first by default; a chosen column overrides it. The 200-row cap is
  // applied AFTER sorting, so sorting by grams shows the biggest harvests rather
  // than the biggest of the 200 most recent.
  const matching = [...harvests]
    .reverse()
    .filter((h) => !q || h.batch.toLowerCase().includes(q) || (h.species || '').toLowerCase().includes(q));
  updateSortIndicators('harvests', tableSort.harvests);
  const items = applyTableSort(matching, tableSort.harvests, (h, k) => {
    if (k === 'grams' || k === 'flush') return Number(h[k]) || 0;
    return h[k];
  }).slice(0, 200);
  body.innerHTML = items.length
    ? items
        .map(
          (h) =>
            `<tr><td data-mlabel="${esc(t('th.date'))}" class="hv-date fs-micro" style="color:var(--c-text-muted)">${fmtDtTime(h.time)}</td><td class="fs-micro" data-mlabel="${esc(t('th.batch'))}" style="font-family:monospace">${esc(h.batch) || '\u2014'}</td><td class="fs-micro" data-mlabel="${esc(t('th.bag'))}" style="font-family:monospace">${esc(h.bag) || '\u2014'}</td><td data-mlabel="${esc(t('th.species'))}">${h.species ? spDot(h.species) + esc(h.species) : '\u2014'}</td><td data-mlabel="${esc(t('th.strain'))}">${esc(h.strain) || '\u2014'}</td><td data-mlabel="${esc(t('th.flush'))}">${h.flush || 1}</td><td data-mlabel="${esc(t('th.grams'))}" class="hv-grams" style="font-weight:500;color:var(--c-amber-dark)">${h.grams}g</td></tr>`
        )
        .join('')
    : '<tr><td colspan="7" class="empty">' + t('harvest.noHarvests') + '</td></tr>';

  const byBatch = {};
  harvests.forEach((h) => {
    if (!byBatch[h.batch]) byBatch[h.batch] = { total: 0, flushes: {}, species: h.species };
    byBatch[h.batch].total += h.grams;
    byBatch[h.batch].flushes[h.flush] = (byBatch[h.batch].flushes[h.flush] || 0) + h.grams;
  });
  const ids = Object.keys(byBatch).sort((a, b) => byBatch[b].total - byBatch[a].total);
  const tot = harvests.reduce((s, h) => s + h.grams, 0);
  document.getElementById('harvest-metrics').innerHTML = ids.length
    ? [
        [t('harvest.totalHarvested'), tot >= 1000 ? (tot / 1000).toFixed(1) + 'kg' : tot + 'g'],
        [t('harvest.batchesWithYield'), ids.length],
        [t('harvest.topBatch'), ids[0] ? byBatch[ids[0]].total + 'g' : '\u2014']
      ]
        .map(
          ([l, v]) =>
            `<div class="met"><div class="met-l">${l}</div><div class="met-v fs-floor" style="--fs-own:1rem;color:var(--c-amber-dark)">${v}</div></div>`
        )
        .join('')
    : '';

  if (!ids.length) {
    document.getElementById('harvest-totals').innerHTML = '<div class="empty">' + t('harvest.noData') + '</div>';
    return;
  }

  // Bar chart: yield per batch
  const batchYieldCanvas = document.getElementById('batch-yield-chart');
  if (batchYieldCanvas) {
    if (batchYieldInst) {
      batchYieldInst.destroy();
      batchYieldInst = null;
    }
    batchYieldInst = new Chart(batchYieldCanvas, {
      type: 'bar',
      data: {
        labels: ids.slice(0, 12),
        datasets: [
          {
            label: 'Grams',
            data: ids.slice(0, 12).map((id) => byBatch[id].total),
            backgroundColor: ids.slice(0, 12).map((id) => spColor(byBatch[id].species)),
            borderRadius: 5,
            borderSkipped: false
          }
        ]
      },
      options: {
        responsive: true,
        plugins: { legend: { display: false }, tooltip: { callbacks: { label: (c) => c.parsed.y + 'g' } } },
        scales: {
          y: { ticks: { callback: (v) => v + 'g' }, grid: { color: '#f0ede8' } },
          x: { ticks: { font: { size: 9 } }, grid: { display: false } }
        }
      }
    });
  }

  // Line chart: harvest over time by week
  const byWeek = {};
  harvests.forEach((h) => {
    const d = new Date(h.time);
    const mon = new Date(d);
    // (getDay()+6)%7 puts Monday at offset 0 … Sunday at 6; the old
    // `- getDay() + 1` bucketed Sunday into the *next* week. Key by the local
    // date, not toISOString() (which shifts a local-midnight Monday to Sunday
    // in CEST and splits one local week across two buckets).
    mon.setDate(d.getDate() - ((d.getDay() + 6) % 7));
    const key = localDateStr(mon);
    byWeek[key] = (byWeek[key] || 0) + h.grams;
  });
  const weekKeys = Object.keys(byWeek).sort();
  const timelineCanvas = document.getElementById('harvest-timeline-chart');
  if (timelineCanvas) {
    if (timelineInst) {
      timelineInst.destroy();
      timelineInst = null;
    }
    timelineInst = new Chart(timelineCanvas, {
      type: 'line',
      data: {
        labels: weekKeys.map((k) => {
          const d = new Date(k);
          return fmtDtShort(d);
        }),
        datasets: [
          {
            label: 'g/week',
            data: weekKeys.map((k) => byWeek[k]),
            fill: true,
            borderColor: '#f59e0b',
            backgroundColor: 'rgba(245,158,11,.12)',
            tension: 0.4,
            pointRadius: 3,
            pointBackgroundColor: '#f59e0b'
          }
        ]
      },
      options: {
        responsive: true,
        plugins: { legend: { display: false }, tooltip: { callbacks: { label: (c) => c.parsed.y + 'g' } } },
        scales: {
          y: { ticks: { callback: (v) => v + 'g' }, grid: { color: '#f0ede8' } },
          x: { ticks: { font: { size: 9 }, maxRotation: 0 }, grid: { display: false } }
        }
      }
    });
  }

  // Per-batch totals with flush breakdown
  const max = byBatch[ids[0]].total;
  document.getElementById('harvest-totals').innerHTML = ids
    .map((id) => {
      const d = byBatch[id],
        pct = Math.round((d.total / max) * 100);
      return `<div style="margin-bottom:10px"><div style="display:flex;justify-content:space-between;align-items:baseline;margin-bottom:3px"><span class="fs-meta" style="font-weight:500">${spDot(d.species)}${esc(id)}</span><span class="fs-sm" style="font-weight:600;color:var(--c-amber-dark)">${d.total}g</span></div><div class="harvest-bar"><div class="harvest-bar-fill" style="width:${pct}%"></div></div><div class="fs-micro" style="color:var(--c-text-muted);margin-top:2px">${Object.entries(
        d.flushes
      )
        .map(([f, g]) => `Flush ${f}: ${g}g`)
        .join(' · ')}</div></div>`;
    })
    .join('');
}

// ─── TO-DO ───────────────────────────────────────────────────
function buildAutoTasks() {
  const tasks = [],
    today = new Date();
  today.setHours(0, 0, 0, 0);
  batches.forEach((b) => {
    const { status } = getStatus(b.batchId);
    // Only the two growing states produce work here. FRUITING has its own
    // Ready-to-harvest card; CONTAM is tracked via Contamination reports (resolve
    // as Discarded/Autoclaved/etc.) \u2014 once bags are in the contam zone the worker
    // has already acted, no need to nag here; DONE/EMPTY are terminal.
    if (status !== 'INCUBATING' && status !== 'SPAWN RUN') return;
    const due = new Date(b.due);
    due.setHours(0, 0, 0, 0);
    const dl = Math.round((due - today) / 864e5);
    // A missing or unparseable due date makes dl NaN, which fails every
    // comparison below \u2014 so it would fall through as "due this week" and render
    // an actionable row reading "F\u00e4llig in NaN Tag(en)". Reject it explicitly.
    if (!Number.isFinite(dl) || dl > 7) return; // only show tasks due this week
    // Two states, two different instructions \u2014 so two task kinds. A block that
    // finished incubation goes to a fruiting tent. Grain that finished its spawn
    // run is not "monitor it": it is ready to be used, and sending it to a tent
    // would skip a whole growth stage.
    const urgent = dl < 0;
    tasks.push({
      // dl === 0 gets its own string: "F\u00e4llig in 0 Tag(en)" is how a machine
      // says "today", and it reads that way on the card and the work list alike.
      detail: urgent ? t('todo.dueAgo', { n: -dl }) : dl === 0 ? t('todo.dueToday') : t('todo.dueIn', { n: dl }),
      urgent,
      // warn keeps its old meaning (due within two days) so the dashboard badge
      // and the orange dot behave exactly as before.
      warn: !urgent && dl <= 2,
      // Is it actually due? A batch 3-7 days out belongs on the card so the week
      // ahead is visible, but moving it now ends incubation early. So it is listed
      // and NOT offered a move. This is exactly the old taskAction!==null boundary,
      // kept as its own flag: taskAction says WHAT the job is, ready says whether
      // it is due yet. Every reader that meant "actionable move" tests both.
      ready: dl <= 2,
      species: b.species,
      batchId: b.batchId,
      taskAction: status === 'SPAWN RUN' ? 'inoculate' : 'move',
      // Which urgency section the row lands in \u2014 see renderDashBatchTasks.
      bucket: urgent ? 'overdue' : dl === 0 ? 'today' : 'week',
      dueIn: dl
    });
  });
  return tasks;
}
function toggleTask(id) {
  const t = manualTasks.find((x) => x.id === id);
  if (!t) return;
  t.done = !t.done;
  t.caldavSynced = null;
  apiPatch('/api/tasks/' + id, { done: t.done, caldavSynced: null });
  renderCalendar();
  updateTodoBadge();
  if (caldav.enabled && t.caldavUid) pushTaskCaldav(t);
}
function updateTodoBadge() {
  const n = manualTasks.filter((t) => !t.done).length;
  const el = document.getElementById('n-cal');
  if (el) el.classList.toggle('alert', n > 0);
  const bd = buildAutoTasks().filter((t) => t.urgent || t.warn).length + getInvAlerts().length;
  const de = document.getElementById('n-dash');
  if (de) de.classList.toggle('alert', bd > 0);
}

// ─── CalDAV SYNC ────────────────────────────────────────────
function loadCaldavSettings() {
  // Show the CalDAV URL for this server
  const url = location.protocol + '//' + location.hostname + ':' + location.port + '/caldav/calendars/';
  document.getElementById('caldav-url-display').textContent = url;
  document.getElementById('caldav-enabled').checked = !!caldav.enabled;
  loadCaldavAppPasswords();
}
function saveCaldavSettings() {
  caldav.enabled = document.getElementById('caldav-enabled').checked;
  apiPost('/api/caldav/config', caldav).then((r) => {
    if (r.error) {
      showCaldavStatus(r.error, 'var(--c-red-dark)');
    } else {
      showCaldavStatus(t('caldav.settingsSaved'), 'var(--c-green-dark)');
    }
  });
}
// ─── CalDAV app passwords (S-25) ────────────────────────────
// A calendar app keeps whatever password it is given, in a keychain that syncs
// to a cloud backup and outlives the device. Handing it the account password
// means handing it the web UI as well, and the only way to take it back is to
// change the password for everything. These open calendars and nothing else,
// and each one is revocable on its own.
async function loadCaldavAppPasswords() {
  const box = document.getElementById('caldav-apppw-list');
  if (!box) return;
  try {
    const r = await authFetch('/api/caldav/app-passwords').then((x) => x.json());
    const items = (r && r.items) || [];
    if (!items.length) {
      box.innerHTML = `<div class="fs-meta" style="color:var(--c-text-muted)">${esc(t('caldav.appPwNone'))}</div>`;
      return;
    }
    const head = `<tr style="text-align:left;color:var(--c-text-muted)"><th style="padding:4px">${esc(t('caldav.appPwDevice'))}</th><th style="padding:4px">${esc(t('caldav.appPwCreated'))}</th><th style="padding:4px">${esc(t('caldav.appPwLastUsed'))}</th><th style="padding:4px"></th></tr>`;
    const rows = items
      .map(
        (i) =>
          `<tr><td style="padding:4px">${esc(i.label)}</td><td style="padding:4px">${esc(fmtDt(i.created))}</td><td style="padding:4px">${i.lastUsedAt ? esc(fmtDt(i.lastUsedAt)) : '—'}</td><td style="padding:4px;text-align:right"><button class="btn btn-r fs-xs" style="padding:2px 8px" data-action="caldav-apppw-revoke" data-id="${esc(i.id)}">${esc(t('caldav.appPwRevoke'))}</button></td></tr>`
      )
      .join('');
    box.innerHTML = `<table class="fs-meta" style="width:100%;border-collapse:collapse">${head}${rows}</table>`;
  } catch (e) {
    box.textContent = t('common.error');
  }
}

async function createCaldavAppPassword() {
  const input = document.getElementById('caldav-apppw-label');
  const label = (input.value || '').trim();
  if (!label) {
    showCaldavStatus(t('caldav.appPwNeedLabel'), 'var(--c-amber-dark)');
    return;
  }
  const r = await apiPost('/api/caldav/app-passwords', { label });
  if (!r || r.error) {
    showCaldavStatus((r && r.error) || t('common.error'), 'var(--c-red-dark)');
    return;
  }
  input.value = '';
  // The only place this value is ever displayed. The server keeps a hash, so
  // there is no "show it again" to build later.
  document.getElementById('caldav-apppw-value').textContent = r.password;
  document.getElementById('caldav-apppw-new').style.display = 'block';
  loadCaldavAppPasswords();
}

function revokeCaldavAppPassword(id) {
  confirm2(t('caldav.appPwRevoke'), t('caldav.appPwRevokeConfirm'), t('caldav.appPwRevoke'), async () => {
    const r = await apiDelete('/api/caldav/app-passwords/' + id);
    if (r && r.error) {
      showCaldavStatus(r.error, 'var(--c-red-dark)');
      return;
    }
    loadCaldavAppPasswords();
  });
}

// Delegated, not an onclick attribute: the rows are rebuilt on every load, and
// inline handlers are the reason the CSP still needs 'unsafe-inline'.
function onCaldavAppPwClick(e) {
  const btn = e.target.closest('button[data-action="caldav-apppw-revoke"]');
  if (!btn) return;
  const id = parseInt(btn.dataset.id, 10);
  if (Number.isFinite(id)) revokeCaldavAppPassword(id);
}

function showCaldavStatus(msg, color) {
  const el = document.getElementById('caldav-status');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
  setTimeout(() => {
    el.style.display = 'none';
  }, 8000);
}
async function syncCaldavNow() {
  if (!caldav.enabled) {
    showCaldavStatus('Enable sync first, then save settings.', '#92400e');
    return;
  }
  const btn = document.getElementById('caldav-sync-btn');
  btn.disabled = true;
  btn.textContent = t('caldav.syncing');
  showCaldavStatus('Writing tasks to calendar files...', '#888');
  try {
    const r = await authFetch('/api/caldav/sync', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ caldav, teamMembers, manualTasks })
    }).then((r) => r.json());
    if (r.error) {
      showCaldavStatus('Sync failed: ' + r.error, 'var(--c-red-dark)');
    } else {
      showCaldavStatus(
        `Done! ${r.pushed} tasks written to calendar.${r.errors ? ' (' + r.errors + ' errors)' : ''}  Calendar clients can now see them via CalDAV.`,
        r.errors ? 'var(--c-amber-dark)' : 'var(--c-green-dark)'
      );
      // Selective refresh: only reload tasks to get updated caldavUid/caldavSynced
      // instead of loadData() which would overwrite ALL local state
      try {
        const td = await authFetch('/api/data').then((r) => r.json());
        if (td.manualTasks) manualTasks = td.manualTasks;
        if (td.calendarEvents) calendarEvents = td.calendarEvents;
      } catch {}
      renderCalendar();
    }
  } catch (e) {
    showCaldavStatus('Sync error: ' + e.message, 'var(--c-red-dark)');
  } finally {
    btn.disabled = false;
    btn.textContent = t('caldav.syncNow');
  }
}
async function pushTaskCaldav(task) {
  if (!caldav.enabled) return;
  try {
    const r = await authFetch('/api/caldav/push-one', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ task })
    }).then((r) => r.json());
    if (r.ok && r.uid) {
      task.caldavUid = r.uid;
      task.caldavSynced = new Date().toISOString();
      apiPatch('/api/tasks/' + task.id, { caldavUid: task.caldavUid, caldavSynced: task.caldavSynced });
      renderCalendar();
    }
  } catch (e) {
    console.error('CalDAV push error:', e);
  }
}

// ─── DUCKDNS ────────────────────────────────────────────────
// ── Versand (Sendcloud) config (Admin → Settings → Versand) ──
async function loadShipSettings() {
  try {
    const r = await authFetch('/api/ship/config');
    const cfg = await r.json();
    const set = (id, v) => {
      const el = document.getElementById(id);
      if (el) el.value = v;
    };
    const en = document.getElementById('versand-enabled');
    if (en) en.checked = !!cfg.enabled;
    set('versand-public', cfg.publicKey || '');
    set('versand-secret', '');
    const sec = document.getElementById('versand-secret');
    if (sec) sec.placeholder = cfg.hasSecret ? t('versand.secretSet') : 'Secret Key';
    set('versand-mode', cfg.mode || 'test');
    set('versand-weight', cfg.defaultWeightG != null ? cfg.defaultWeightG : 1000);
  } catch (e) {
    /* not configured yet */
  }
}
async function saveShipSettings() {
  const cfg = {
    enabled: document.getElementById('versand-enabled').checked,
    publicKey: (document.getElementById('versand-public').value || '').trim(),
    secretKey: (document.getElementById('versand-secret').value || '').trim(),
    mode: document.getElementById('versand-mode').value || 'test',
    defaultWeightG: parseInt(document.getElementById('versand-weight').value, 10) || 1000
  };
  try {
    const r = await apiPatch('/api/ship/config', cfg);
    if (r && r.error) {
      setFb('err', r.error);
      return;
    }
    setFb('ok', t('versand.saved'));
    loadShipSettings();
  } catch (e) {
    setFb('err', t('common.error'));
  }
}
async function testShipConnection() {
  const el = document.getElementById('versand-test-result');
  if (el) {
    el.style.display = 'block';
    el.textContent = t('common.loading');
  }
  try {
    const r = await authFetch('/api/ship/test');
    const d = await r.json();
    if (!r.ok || d.error) {
      if (el) el.textContent = '⚠ ' + (d.error || 'HTTP ' + r.status);
      return;
    }
    let carriers = '';
    try {
      const mr = await authFetch('/api/ship/methods');
      const md = await mr.json();
      if (mr.ok && md.methods) carriers = [...new Set(md.methods.map((m) => m.carrier))].join(', ');
    } catch (e2) {
      /* methods are a bonus */
    }
    if (el) el.textContent = '✓ ' + t('versand.connected', { account: d.account || 'ok' }) + (carriers ? ' — ' + carriers : '');
  } catch (e) {
    if (el) el.textContent = '⚠ ' + t('common.error');
  }
}

// ── Sales channels (Admin → Settings → Kanäle) ──
async function loadChannelsSettings() {
  try {
    const r = await authFetch('/api/channels');
    const d = await r.json();
    const wix = (d.channels || []).find((c) => c.channel === 'wix') || {};
    const en = document.getElementById('wix-enabled');
    if (en) en.checked = !!wix.enabled;
    const sid = document.getElementById('wix-siteid');
    if (sid) sid.value = wix.siteId || '';
    const aid = document.getElementById('wix-accountid');
    if (aid) aid.value = wix.clientId || '';
    const ak = document.getElementById('wix-apikey');
    if (ak) {
      ak.value = '';
      ak.placeholder = wix.hasApiKey ? t('channels.keySet') : 'API-Key';
    }
    const st = document.getElementById('wix-status');
    // Also shown when it has never synced but Billbee is standing in for it:
    // "why is nothing arriving from Wix" is asked at this line, and a blank one
    // answers nothing.
    if (st && (wix.lastSync || wix.supersededBy)) {
      st.style.display = 'block';
      st.textContent = wix.supersededBy
        ? t('channels.supersededByBillbee')
        : wix.lastError
          ? '⚠ ' + wix.lastError
          : '✓ ' + t('channels.lastSync', { time: fmtDt(wix.lastSync) });
    }
    // eBay + Etsy (OAuth): client_id / secret / RuName + connection status.
    const fillOauth = (prefix, ch) => {
      const en = document.getElementById(prefix + '-enabled');
      if (en) en.checked = !!ch.enabled;
      const cid = document.getElementById(prefix + '-clientid');
      if (cid) cid.value = ch.clientId || '';
      const sid = document.getElementById(prefix + '-siteid');
      if (sid) sid.value = ch.siteId || '';
      const sec = document.getElementById(prefix + '-secret');
      if (sec) {
        sec.value = '';
        sec.placeholder = ch.hasClientSecret ? t('channels.keySet') : 'Cert-ID';
      }
      const st2 = document.getElementById(prefix + '-status');
      if (st2) {
        const bits = [ch.connected ? '✓ ' + t('channels.linked') : t('channels.notLinked')];
        // Standing down outranks the last error: while Billbee carries this
        // channel the error is whatever it was before, and reading it as the
        // current state sends somebody debugging a connection nobody is using.
        if (ch.supersededBy) bits.push(t('channels.supersededByBillbee'));
        else if (ch.lastError) bits.push('⚠ ' + ch.lastError);
        else if (ch.lastSync) bits.push(t('channels.lastSync', { time: fmtDt(ch.lastSync) }));
        st2.style.display = 'block';
        st2.textContent = bits.join(' · ');
      }
    };
    // Billbee is neither: an app key plus the account it acts for, no OAuth.
    const bb = (d.channels || []).find((c) => c.channel === 'billbee') || {};
    const bbEnabled = document.getElementById('billbee-enabled');
    if (bbEnabled) bbEnabled.checked = !!bb.enabled;
    const bbUser = document.getElementById('billbee-user');
    if (bbUser) bbUser.value = bb.clientId || '';
    const bbKey = document.getElementById('billbee-apikey');
    if (bbKey) {
      bbKey.value = '';
      bbKey.placeholder = bb.hasApiKey ? t('channels.keySet') : t('channels.apiKey');
    }
    const bbPw = document.getElementById('billbee-apipw');
    if (bbPw) {
      bbPw.value = '';
      bbPw.placeholder = bb.hasClientSecret ? t('channels.keySet') : t('channels.billbeeApiPassword');
    }
    const bbStatus = document.getElementById('billbee-status');
    if (bbStatus) {
      const bits = [bb.connected ? '✓ ' + t('channels.linked') : t('channels.notLinked')];
      if (bb.lastError) bits.push('⚠ ' + bb.lastError);
      else if (bb.lastSync) bits.push(t('channels.lastSync', { time: fmtDt(bb.lastSync) }));
      // The trap this whole card warns about, caught in the act — except the
      // server now holds them back rather than letting the same sale in twice,
      // so this says what happened, not what might. Same flag the sync obeys:
      // the page cannot promise something the server does not do.
      const stood = (d.channels || []).filter((c) => c.supersededBy === 'billbee').map((c) => c.channel);
      if (stood.length) bits.push(t('channels.billbeeStandsIn', { list: stood.join(', ') }));
      bbStatus.style.display = 'block';
      bbStatus.textContent = bits.join(' · ');
    }
    fillOauth('ebay', (d.channels || []).find((c) => c.channel === 'ebay') || {});
    fillOauth('etsy', (d.channels || []).find((c) => c.channel === 'etsy') || {});
    // eBay account-deletion setup: never echo the stored token back, and show the
    // endpoint URL the server actually hashes so it can be copied into the portal.
    const ebay = (d.channels || []).find((c) => c.channel === 'ebay') || {};
    const vt = document.getElementById('ebay-verifytoken');
    if (vt) {
      vt.value = '';
      vt.placeholder = ebay.hasWebhookSecret ? t('channels.keySet') : t('channels.ebayVerifyToken');
    }
    const du = document.getElementById('ebay-deletion-url');
    if (du) du.textContent = (d.urls && d.urls.ebayDeletion) || '';
  } catch (e) {
    /* not configured yet */
  }
  loadSyringeStock();
}

// ── Spritzen-, Petrischalen- und Körnerbrutbestand → Billbee (Karte unter Billbee) ──
// Je Art ein Block, darin eine Zeile je Spritzengröße, eine für die
// Petrischale und eine je Beutelgröße Körnerbrut: Zahl im Labor, SKU-Feld,
// und was Billbee zuletzt gesagt hat. Die SKU speichert beim Verlassen des
// Feldes, ohne Knopf.
async function loadSyringeStock() {
  try {
    renderSyringeStock(await apiGet('/api/syringe-stock'));
  } catch (e) {
    /* not admin, or the server predates the card */
  }
}
function _syrStatusLine(r) {
  if (!r.sku) return '';
  if (r.lastError) return '⚠ ' + r.lastError;
  if (r.pushedAt) {
    // Billbee's figure is after it took the open orders off, so it can be lower
    // than the lab's count; showing both is what makes that readable.
    const frei = r.billbeeStock != null ? r.billbeeStock : r.pushedCount;
    return '✓ ' + t('syr.reported', { n: frei, time: fmtDt(r.pushedAt) });
  }
  return t('syr.notYet');
}
function renderSyringeStock(d) {
  if (!d || !Array.isArray(d.rows)) return;
  const en = document.getElementById('syr-enabled');
  if (en) en.checked = !!d.enabled;
  const box = document.getElementById('syr-rows');
  if (!box) return;
  if (!d.rows.length) {
    box.innerHTML = '<div class="fs-meta" style="color: var(--c-text-muted)">' + esc(t('syr.noSpecies')) + '</div>';
  } else {
    // Eine Art, darunter ihre Größen und die Petrischale: jede ist im Shop ein
    // eigener Artikel und hat ihre eigene SKU. Die Zeilen kommen je Art
    // zusammenhängend.
    const arten = [];
    for (const r of d.rows) {
      const letzte = arten[arten.length - 1];
      if (letzte && letzte.strainId === r.strainId) letzte.rows.push(r);
      else arten.push({ strainId: r.strainId, name: r.name, rows: [r] });
    }
    const zeile = (r) =>
      '<div style="display: flex; flex-wrap: wrap; align-items: center; gap: 6px 10px">' +
      '<div style="flex: 1 1 120px; min-width: 0"><b>' +
      esc(r.type === 'PD' ? t('syr.petri') : r.type === 'GS' ? t('syr.grain', { kg: r.kg }) : (r.ml || 10) + ' ml') +
      '</b> <span class="fs-meta" style="color: var(--c-text-muted)">' +
      esc(t('syr.inLab', { n: r.count })) +
      '</span></div>' +
      '<input type="text" class="syr-sku" data-strain="' +
      r.strainId +
      '" data-ml="' +
      esc(String(r.slot || r.ml || 10)) +
      '" value="' +
      esc(r.sku) +
      '" placeholder="' +
      esc(t('syr.skuPlaceholder')) +
      '" autocapitalize="characters" spellcheck="false" style="flex: 0 1 180px; min-width: 0" />' +
      (r.sku
        ? '<div class="fs-meta" style="flex-basis: 100%; color: var(--c-text-muted)">' + esc(_syrStatusLine(r)) + '</div>'
        : '') +
      '</div>';
    box.innerHTML = arten
      .map(
        (a) =>
          '<div style="display: flex; flex-direction: column; gap: 6px; padding: 8px 0; border-bottom: 1px solid var(--c-border-light)">' +
          '<div style="font-weight: 600">' +
          esc(a.name) +
          '</div>' +
          a.rows.map(zeile).join('') +
          '</div>'
      )
      .join('');
    box.querySelectorAll('.syr-sku').forEach((inp) => {
      inp.dataset.was = inp.value;
      inp.addEventListener('change', () => saveSyringeSku(inp));
    });
  }
  const st = document.getElementById('syr-status');
  if (st) {
    const hint = d.worktree ? t('syr.worktree') : !d.billbeeReady ? t('syr.needBillbee') : '';
    st.style.display = hint ? 'block' : 'none';
    st.textContent = hint;
  }
}
async function saveSyringeSku(inp) {
  const sku = (inp.value || '').trim();
  if (sku === inp.dataset.was) return;
  const r = await apiPut('/api/syringe-stock/' + inp.dataset.strain + '/' + (inp.dataset.ml || 10), { sku });
  if (r && r.error) {
    setFb('err', r.error);
    inp.value = inp.dataset.was;
    return;
  }
  setFb('ok', sku ? t('syr.saved') : t('syr.removed'));
  renderSyringeStock(r);
}
async function setSyringeSyncEnabled(on) {
  const r = await apiPatch('/api/syringe-stock', { enabled: on });
  if (r && r.error) {
    setFb('err', r.error);
    loadSyringeStock();
    return;
  }
  renderSyringeStock(r);
  // The first report goes out a few seconds after switching on; look again then.
  if (on) setTimeout(loadSyringeStock, 8000);
}
async function pushSyringeStockNow() {
  const st = document.getElementById('syr-status');
  if (st) {
    st.style.display = 'block';
    st.textContent = t('common.loading');
  }
  const r = await apiPost('/api/syringe-stock/push', {});
  if (r && r.error) {
    if (st) st.textContent = '⚠ ' + r.error;
    return;
  }
  renderSyringeStock(r);
  const msg = r.errors && r.errors.length ? '⚠ ' + r.errors[0] : t('syr.pushed', { n: r.pushed || 0 });
  if (st) {
    st.style.display = 'block';
    st.textContent = msg;
  }
}
async function saveChannel(channel) {
  let body;
  if (channel === 'wix') {
    body = {
      enabled: document.getElementById('wix-enabled').checked,
      apiKey: (document.getElementById('wix-apikey').value || '').trim(),
      siteId: (document.getElementById('wix-siteid').value || '').trim(),
      clientId: (document.getElementById('wix-accountid').value || '').trim()
    };
  } else if (channel === 'ebay') {
    body = {
      enabled: document.getElementById('ebay-enabled').checked,
      clientId: (document.getElementById('ebay-clientid').value || '').trim(), // App-ID
      clientSecret: (document.getElementById('ebay-secret').value || '').trim(), // Cert-ID (blank = keep)
      siteId: (document.getElementById('ebay-siteid').value || '').trim(), // RuName
      // Account-deletion verification token (blank = keep the stored one). Read
      // defensively so a cached older index.html can still save the other fields.
      webhookSecret: ((document.getElementById('ebay-verifytoken') || {}).value || '').trim()
    };
  } else if (channel === 'etsy') {
    body = {
      enabled: document.getElementById('etsy-enabled').checked,
      clientId: (document.getElementById('etsy-clientid').value || '').trim() // Keystring
    };
  } else if (channel === 'billbee') {
    body = {
      enabled: document.getElementById('billbee-enabled').checked,
      apiKey: (document.getElementById('billbee-apikey').value || '').trim(), // X-Billbee-Api-Key (blank = keep)
      clientId: (document.getElementById('billbee-user').value || '').trim(), // Billbee login
      clientSecret: (document.getElementById('billbee-apipw').value || '').trim() // API password (blank = keep)
    };
  } else {
    return false;
  }
  try {
    const r = await apiPatch('/api/channels/' + channel, body);
    if (r && r.error) {
      setFb('err', r.error);
      return false;
    }
    setFb('ok', t('channels.saved'));
    loadChannelsSettings();
    return true;
  } catch (e) {
    setFb('err', t('common.error'));
    return false;
  }
}
// Start the OAuth login: persist creds first (so the server has client_id / RuName),
// then redirect the browser to the provider's authorize page. The provider sends the
// user back to the public callback, which stores the tokens.
async function connectChannel(channel) {
  const ok = await saveChannel(channel);
  if (ok === false) return;
  try {
    const r = await authFetch('/api/channels/' + channel + '/oauth/start');
    const d = await r.json();
    if (d && d.url) {
      window.location.href = d.url;
      return;
    }
    setFb('err', (d && d.error) || t('common.error'));
  } catch (e) {
    if (e.message !== 'unauthorized') setFb('err', t('common.error'));
  }
}
async function testChannel(channel) {
  const st = document.getElementById(channel + '-status');
  if (st) {
    st.style.display = 'block';
    st.textContent = t('common.loading');
  }
  try {
    const r = await apiPost('/api/channels/' + channel + '/test', {});
    // Billbee answers with the shops it collects from. Naming them turns the
    // card's advice ("switch those off here") into something checkable.
    const shops = r && Array.isArray(r.shops) && r.shops.length ? ' — ' + r.shops.join(', ') : '';
    if (st) st.textContent = r && r.error ? '⚠ ' + r.error : '✓ ' + t('channels.connected') + shops;
  } catch (e) {
    if (st) st.textContent = '⚠ ' + t('common.error');
  }
}
async function syncChannel(channel) {
  const st = document.getElementById(channel + '-status');
  if (st) {
    st.style.display = 'block';
    st.textContent = t('channels.syncing');
  }
  try {
    const r = await apiPost('/api/channels/' + channel + '/sync', {});
    if (r && r.error) {
      if (st) st.textContent = '⚠ ' + r.error;
      return;
    }
    if (st) st.textContent = '✓ ' + t('channels.synced', { n: r.imported || 0 });
    setFb('ok', t('channels.synced', { n: r.imported || 0 }));
  } catch (e) {
    if (st) st.textContent = '⚠ ' + t('common.error');
  }
}

async function loadDuckdnsSettings() {
  try {
    const r = await authFetch('/api/duckdns/config');
    if (!r.ok) return;
    const cfg = await r.json();
    document.getElementById('duckdns-enabled').checked = !!cfg.enabled;
    document.getElementById('duckdns-domain').value = cfg.domain || '';
    const tokenEl = document.getElementById('duckdns-token');
    tokenEl.value = '';
    tokenEl.placeholder = cfg.hasToken ? '••••••••••' : '';
    document.getElementById('duckdns-le-enabled').checked = !!cfg.leEnabled;
  } catch (e) {
    /* non-admin */
  }
  await refreshDuckdnsStatus();
}
// The banner used to be green whenever an address had ever been recorded, with
// no notion of when. That is the state a broken updater sits in: the last good
// address from days ago, painted as health, while the name it belongs to points
// somewhere the server no longer is. Nobody finds that by looking — they find it
// when the site stops answering.
//
// So the address alone no longer decides the colour. Red means the record is or
// may be wrong right now and somebody has to act; amber means we cannot confirm
// it; green means the authoritative nameservers were asked and agreed. The
// reason is always spelled out, because "DuckDNS is broken" is not something
// anyone can act on and "token refused" is.
function paintDuckdnsBanner(banner, s) {
  const h = s.health || {};
  const tone = (bg, border, fg) => {
    banner.style.background = 'var(' + bg + ')';
    banner.style.border = '1px solid var(' + border + ')';
    banner.style.color = 'var(' + fg + ')';
  };
  const red = () => tone('--c-red-light', '--c-red-border', '--c-red-dark');
  const amber = () => tone('--c-amber-light', '--c-amber-border', '--c-amber-dark');
  const green = () => tone('--c-primary-light', '--c-green-border', '--c-green-dark');

  const head = '<strong>' + esc(s.domain) + '</strong>' + (s.lastIp ? ' &rarr; ' + esc(s.lastIp) : '');
  const note = (msg) => '<div class="fs-sm" style="margin-top:4px">' + msg + '</div>';
  const since = s.lastIpUpdate
    ? ' <span style="color:var(--c-text-muted)">(' + esc(fmtDtTime(s.lastIpUpdate)) + ')</span>'
    : '';
  const why = h.lastError ? note(esc(t('duckdns.lastError', { error: h.lastError }))) : '';
  const minutes = h.ageMs == null ? null : Math.round(h.ageMs / 60000);
  // The out-of-process fallback keeps the record alive while this server's own
  // updater is down, and that is worth saying next to the red rather than
  // instead of it: the record being fine does not make a dead updater fine.
  const fbMin = s.fallbackLast ? Math.round((Date.now() - Date.parse(s.fallbackLast)) / 60000) : null;
  const covering =
    fbMin != null && fbMin < 30 ? note(esc(t('duckdns.fallbackCovering', { min: fbMin }))) : '';

  if (!h.running) {
    red();
    banner.innerHTML = head + since + note(esc(t('duckdns.updaterStopped'))) + why + covering;
    return;
  }
  if (h.conflict) {
    red();
    banner.innerHTML = head + since + note(esc(t('duckdns.conflict'))) + why;
    return;
  }
  if (h.stale) {
    red();
    const msg = minutes == null ? t('duckdns.noUpdateYet') : t('duckdns.stale', { min: minutes });
    banner.innerHTML = head + since + note(esc(msg)) + why + covering;
    return;
  }
  if (!s.lastIp) {
    amber();
    banner.textContent = t('duckdns.noUpdateYet');
    return;
  }
  if (h.verifyOk === false) {
    amber();
    const msg = h.observedIp
      ? t('duckdns.mismatch', { served: h.observedIp, expected: s.lastIp })
      : t('duckdns.recordMissing');
    banner.innerHTML = head + since + note(esc(msg)) + why;
    return;
  }
  green();
  banner.innerHTML = head + since + (h.verifyOk === true ? note(esc(t('duckdns.verified'))) : why);
}

async function refreshDuckdnsStatus() {
  try {
    const r = await authFetch('/api/duckdns/status');
    if (!r.ok) return;
    const s = await r.json();
    const banner = document.getElementById('duckdns-status-banner');
    if (s.enabled && s.domain) {
      banner.style.display = 'block';
      paintDuckdnsBanner(banner, s);
    } else {
      banner.style.display = 'none';
    }
    const certEl = document.getElementById('le-cert-status');
    if (s.cert && s.cert.exists) {
      certEl.style.display = 'block';
      if (s.cert.type === 'letsencrypt' && s.leExpiry) {
        const daysLeft = Math.round((new Date(s.leExpiry) - Date.now()) / 86400000);
        const ok = daysLeft > 30,
          warn = daysLeft > 7;
        certEl.style.background = ok ? 'var(--c-primary-light)' : warn ? 'var(--c-amber-light)' : 'var(--c-red-light)';
        certEl.style.border =
          '1px solid ' + (ok ? 'var(--c-green-border)' : warn ? 'var(--c-amber-border)' : 'var(--c-red-border)');
        certEl.style.color = ok ? 'var(--c-green-dark)' : warn ? 'var(--c-amber-dark)' : 'var(--c-red-dark)';
        certEl.innerHTML =
          t('le.certActive') + '. ' + t('le.certIssued', { domain: s.domain || '', date: fmtDt(s.leExpiry) });
      } else {
        certEl.style.background = 'var(--c-blue-light)';
        certEl.style.border = '1px solid var(--c-blue-border)';
        certEl.style.color = 'var(--c-blue-dark)';
        certEl.textContent = t('duckdns.currentCert') + s.cert.type;
      }
    } else {
      certEl.style.display = 'none';
    }
  } catch (e) {
    /* non-admin */
  }
}
// ── Harvest feed ─────────────────────────────────────────────────────────────
async function loadHarvestFeedSettings() {
  try {
    const r = await authFetch('/api/harvest-feed/config');
    if (!r.ok) return;
    const cfg = await r.json();
    document.getElementById('harvestfeed-enabled').checked = !!cfg.enabled;
    document.getElementById('harvestfeed-url').value = cfg.url || '';
    document.getElementById('harvestfeed-interval').value = cfg.intervalMin ?? 15;
    document.getElementById('harvestfeed-fresh').value = cfg.freshDays ?? 3;
    document.getElementById('harvestfeed-planned').value = cfg.plannedDays ?? 28;
    document.getElementById('harvestfeed-lead').value = cfg.leadDays ?? 0;
    document.getElementById('harvestfeed-strain').checked = cfg.strain !== false;
    document.getElementById('harvestfeed-site').value = cfg.site || '';
    renderHarvestPackSizes(Array.isArray(cfg.packSizes) ? cfg.packSizes : []);
    const sec = document.getElementById('harvestfeed-secret');
    sec.value = '';
    // A stored secret is never sent back to the page. The placeholder says one
    // exists; leaving the field empty on save keeps it.
    sec.placeholder = cfg.hasSecret ? '••••••••••' : '';
    renderHarvestFeedBanner(cfg);
  } catch (e) {
    /* non-admin */
  }
}

// ── Amounts handed out ───────────────────────────────────────────────────────
//
// Which portions a release is handed over in — 250 g, 500 g, a kilo — for every
// species at once. A shop reads this list and offers exactly these amounts,
// leaving out whatever a release no longer covers.
//
// The ladder below is only what the ready-made boxes offer. It is not a rule
// about what may be stored: anything from 25 g to 25 kg is allowed, arrives
// through the field beside them, and comes back as a box of its own next time
// this loads. Otherwise a farm packing 400 g trays would be stuck ticking
// somebody else's sizes.
const HARVEST_PACK_LADDER = [100, 250, 500, 750, 1000, 2000];

/** "250 g", "1 kg" — the way it is said, not the way it is stored. */
function packSizeLabel(g) {
  return g >= 1000 && g % 1000 === 0 ? g / 1000 + ' kg' : g + ' g';
}

// A size somebody typed in, rather than one of the ready-made boxes. It is the
// only kind that can be got rid of entirely — untick a ladder size and the box
// stays, because it is an offer; untick a size of your own and there is nothing
// left to offer.
function isOwnPackSize(g) {
  return !HARVEST_PACK_LADDER.includes(g);
}

function renderHarvestPackSizes(chosen) {
  const box = document.getElementById('harvestfeed-packs');
  if (!box) return;
  const ticked = new Set((chosen || []).filter((n) => Number.isInteger(n) && n > 0));
  const all = [...new Set([...HARVEST_PACK_LADDER, ...ticked])].sort((a, b) => a - b);
  box.innerHTML = all
    .map((g) => {
      const feld =
        '<label class="fs-meta" style="display:flex;align-items:center;gap:4px;cursor:pointer;margin:0">' +
        '<input type="checkbox" class="hf-pack" value="' +
        g +
        '" style="width:auto"' +
        (ticked.has(g) ? ' checked' : '') +
        '><span>' +
        esc(packSizeLabel(g)) +
        '</span></label>';
      // ⚠️ The × sits beside the label and not inside it. Inside, every click on
      // it would also toggle the checkbox it is meant to remove — a button that
      // does its job and one other thing on the way out.
      if (!isOwnPackSize(g)) return feld;
      const weg = t('harvestFeed.packRemove') + ' — ' + packSizeLabel(g);
      return (
        '<span style="display:flex;align-items:center;gap:2px">' +
        feld +
        '<button type="button" class="hf-pack-del fs-base" data-size="' +
        g +
        '" title="' +
        esc(weg) +
        '" aria-label="' +
        esc(weg) +
        '" style="background:none;border:0;padding:0 2px;cursor:pointer;line-height:1;color:var(--c-text-muted)">×</button>' +
        '</span>'
      );
    })
    .join('');
}

/**
 * Take a self-added size out of the list.
 *
 * Unticking would do it too — an unticked size is not saved — but only the next
 * load would clear the box, so a mistyped 4000 sits there looking permanent
 * until then. Adding something you cannot see yourself remove is half a
 * feature.
 *
 * A ladder size has no × for the same reason: unticking it is the whole of what
 * "remove" could mean, and the box stays because it is still on offer.
 */
function removeHarvestPackSize(g) {
  renderHarvestPackSizes(harvestPackSizes().filter((n) => n !== g));
}

/** What is ticked, ascending — the order a shop will show them in. */
function harvestPackSizes() {
  return [...document.querySelectorAll('#harvestfeed-packs .hf-pack')]
    .filter((el) => el.checked)
    .map((el) => parseInt(el.value, 10))
    .filter((n) => Number.isInteger(n) && n > 0)
    .sort((a, b) => a - b);
}

// A size the ladder does not offer. It is ticked straight away: somebody who
// types 400 and presses Add has said what they pack in, and leaving it unticked
// would make the button look broken.
//
// ⚠️ The same bounds as harvest-feed.js. They are repeated rather than fetched
// because the message has to appear next to the field as it is typed; the
// server checks again and drops anything that gets past this.
function addHarvestPackSize() {
  const field = document.getElementById('harvestfeed-pack-new');
  const msg = document.getElementById('harvestfeed-pack-msg');
  const n = parseInt(field.value, 10);
  if (!Number.isInteger(n) || n < 25 || n > 25000) {
    msg.textContent = t('harvestFeed.packBad');
    return;
  }
  msg.textContent = '';
  field.value = '';
  renderHarvestPackSizes([...harvestPackSizes(), n]);
}

// ── Released for sale ────────────────────────────────────────────────────────
//
// One row per species: how much of it the feed may offer. The rows are not only
// the ones already released — species harvested inside the fresh window are
// listed too, at zero, because "what did we harvest that nobody has released
// yet" is the question this screen exists to answer, and it cannot be answered
// by a list that only shows what has already been decided.
//
// ── Why this table saves on a button and not on every keystroke ──────────────
//
// A number here is the amount a shop may publicly offer, and the feed carries it
// out within one interval. Saving as it is typed would publish 50 on the way to
// 5, and a wrong figure in a shop window cannot be taken back by fixing the
// field afterwards — somebody has already read it.
//
// What a Save button costs is the edit nobody saved, and this screen pays that
// in three places instead of pretending it does not exist: a touched row is
// marked, the count of pending changes sits next to the button, and every way
// out — another page, the tab, a background refresh — has to get past it. The
// last one is not hypothetical: renderPickups() runs on every `data-changed`
// event, which is every scan by every client in the building.

/**
 * The table's rows, as data.
 *
 * It used to be the other way round: the state lived in the inputs and was read
 * back out of the DOM. That cannot survive the redraw adding a row performs, and
 * it has nowhere to put the two things a row now has to remember — whether it
 * was touched, and whether it is marked for removal. Neither has an input.
 */
let harvestReleaseRows = [];
// Grams already booked, keyed by species; grams the feed could not attribute to
// one; and what the feed last managed to send. All three are read-only — see
// loadHarvestReleases() for why they do not live on the rows.
let harvestReleasePromised = {};
let harvestReleaseUnattributed = 0;
let harvestReleaseFeed = null;

async function loadHarvestReleases() {
  const body = document.getElementById('harvestrelease-body');
  if (!body) return;
  // Unsaved work outranks a fresher `harvested` column. Without this line a
  // colleague scanning a bag two rooms away redraws this table from the server
  // and takes a half-typed release with it — no click, no keystroke, no warning.
  if (harvestReleaseDirty()) return;
  const karte = document.getElementById('harvestrelease-card');
  try {
    const r = await authFetch('/api/harvest-feed/release');
    if (!r.ok) return;
    const data = await r.json();
    if (karte) karte.style.display = '';
    const rows = new Map();
    // `stored` is the difference between a decision and an observation. A row
    // that only exists because something was harvested has nothing to delete.
    for (const rec of data.recent || [])
      rows.set(rec.species, { species: rec.species, harvested: rec.grams, grams: 0, validUntil: null, stored: false });
    for (const rel of data.releases || []) {
      const row = rows.get(rel.species) || { species: rel.species, harvested: null };
      rows.set(rel.species, { ...row, ...rel, stored: true });
    }
    // How much of each release is already booked, and how much the feed could
    // not attribute. Held next to the rows rather than merged into them: it is
    // an observation about the bookings, not part of the release someone typed,
    // and merging the two is how a display value ends up being saved.
    harvestReleasePromised = data.promised || {};
    harvestReleaseUnattributed = Number(data.promisedUnattributed) || 0;
    harvestReleaseFeed = data.feed || null;
    harvestReleaseRows = [...rows.values()].sort((a, b) => a.species.localeCompare(b.species)).map(freshReleaseRow);
    renderHarvestReleases();
    renderHarvestReleaseFeed();
    knownSpecies = data.known || [];
    fillHarvestReleasePicker();
  } catch (e) {
    /* non-admin */
  }
}

/**
 * The editable half of a row, seeded from what the server sent.
 *
 * `wasKg` / `wasUntil` are what "unchanged" means for the whole screen: the save
 * filter, the marks on the rows, the count next to the button and the question
 * asked on the way out all compare against them, so they are set in one place.
 */
function freshReleaseRow(row) {
  // Kilograms in the form, grams on the wire. The scale reads grams and the
  // feed carries grams; a shop lists kilos. Converting in one place beats a
  // unit that changes meaning halfway through the stack.
  const kg = row.grams ? (row.grams / 1000).toFixed(2) : '';
  const until = row.validUntil || '';
  return { ...row, kg, until, wasKg: kg, wasUntil: until, removing: false };
}

/** Rows that would be written if Save were pressed right now. */
function harvestReleaseChanges() {
  return harvestReleaseRows.filter((r) => r.removing || r.kg !== r.wasKg || r.until !== r.wasUntil);
}

function harvestReleaseDirty() {
  return harvestReleaseChanges().length > 0;
}

// The species this database knows, verbatim. Held so the picker can be refilled
// after every render without another round trip — adding a row changes what is
// left to offer, and that has to be visible immediately or the same species can
// be added twice.
let knownSpecies = [];

function fillHarvestReleasePicker() {
  const wahl = document.getElementById('harvestrelease-new');
  if (!wahl) return;
  // Including the rows marked for removal: they are still on screen, and
  // offering one back in the picker would let the same species be added twice.
  const drin = new Set(harvestReleaseRows.map((r) => r.species));
  const offen = knownSpecies.filter((s) => !drin.has(s));
  // Disabled with a reason beats an empty list that looks broken. "Nothing left
  // to add" and "this database has no species yet" are different situations and
  // the person in front of it can only act on one of them.
  wahl.disabled = offen.length === 0;
  wahl.innerHTML =
    '<option value="">' +
    esc(t(offen.length ? 'harvestFeed.addSpecies' : knownSpecies.length ? 'harvestFeed.allListed' : 'harvestFeed.noSpecies')) +
    '</option>' +
    offen.map((s) => '<option value="' + esc(s) + '">' + esc(s) + '</option>').join('');
}

/**
 * The button at the end of a row, which depends on what removing it would mean.
 *
 * A species harvested inside the fresh window is listed because it was
 * harvested, not because anybody decided anything — it comes straight back on
 * the next load, so a button promising to remove it would be a lie. That is the
 * one case with no button at all.
 */
function harvestReleaseRemoveBtn(row) {
  if (row.removing) return '<button class="btn btn-sm hr-undo">' + esc(t('harvestFeed.undoRemove')) + '</button>';
  if (!row.stored && row.harvested != null) return '';
  return '<button class="btn btn-sm hr-remove">' + esc(t('harvestFeed.remove')) + '</button>';
}

function renderHarvestReleases() {
  const body = document.getElementById('harvestrelease-body');
  if (!harvestReleaseRows.length) {
    body.innerHTML =
      '<tr><td class="empty" colspan="7" style="color:var(--c-text-muted)">' + esc(t('harvestFeed.noRelease')) + '</td></tr>';
    updateHarvestReleasePending();
    // Also here: bookings that match no release row are exactly what an empty
    // table needs to mention, not what it may leave out.
    renderHarvestReleaseUnattributed();
    return;
  }
  body.innerHTML = harvestReleaseRows
    .map((row, i) => {
      const harvested = row.harvested == null ? '—' : (row.harvested / 1000).toFixed(2) + ' kg';
      const touched = row.removing || row.kg !== row.wasKg || row.until !== row.wasUntil;
      // A marked row keeps its numbers on screen, struck through and labelled.
      // Blanking the two fields is what the old button did, and it is why
      // "clear" got read as "remove": afterwards the row looks like a species
      // nobody released, and nothing says what Save is about to do with it.
      const durch = row.removing ? ' style="text-decoration:line-through;color:var(--c-text-muted)"' : '';
      return (
        '<tr data-species="' +
        esc(row.species) +
        '" data-i="' +
        i +
        '"' +
        (touched ? ' style="background:var(--c-amber-light)"' : '') +
        '><td data-mlabel="' +
        esc(t('harvestFeed.colSpecies')) +
        '"' +
        durch +
        '>' +
        esc(row.species) +
        '</td><td data-mlabel="' +
        esc(t('harvestFeed.colHarvested')) +
        '" style="color:var(--c-text-muted)">' +
        harvested +
        (row.removing
          ? ' <span style="color:var(--c-amber-dark)">(' + esc(t('harvestFeed.markedRemoved')) + ')</span>'
          : row.expired
            ? ' <span style="color:var(--c-red-dark)">(' + esc(t('harvestFeed.expired')) + ')</span>'
            : '') +
        '</td><td data-mlabel="' +
        esc(t('harvestFeed.colRelease')) +
        '"><input type="number" class="hr-kg" step="0.01" min="0" style="width:90px" value="' +
        esc(row.kg) +
        '"' +
        (row.removing ? ' disabled' : '') +
        '></td>' +
        promisedCells(row) +
        '<td data-mlabel="' +
        esc(t('harvestFeed.colUntil')) +
        '"><input type="date" class="hr-until" style="width:150px" value="' +
        esc(row.until) +
        '"' +
        (row.removing ? ' disabled' : '') +
        '></td><td class="hr-actions">' +
        harvestReleaseRemoveBtn(row) +
        '</td></tr>'
      );
    })
    .join('');
  renderHarvestReleaseUnattributed();
  body.querySelectorAll('tr[data-i]').forEach((tr) => {
    const row = harvestReleaseRows[Number(tr.dataset.i)];
    const kg = tr.querySelector('.hr-kg');
    const until = tr.querySelector('.hr-until');
    // `input` and not `change`: the mark and the count have to follow the typing.
    // On `change` they arrive when the field is left, which is exactly the moment
    // somebody who is done here walks away from an unsaved table.
    kg.addEventListener('input', () => {
      row.kg = kg.value.trim();
      markHarvestReleaseRow(tr, row);
    });
    until.addEventListener('input', () => {
      row.until = until.value;
      markHarvestReleaseRow(tr, row);
    });
    const weg = tr.querySelector('.hr-remove');
    if (weg) weg.addEventListener('click', () => removeHarvestReleaseRow(row));
    const zurueck = tr.querySelector('.hr-undo');
    if (zurueck)
      zurueck.addEventListener('click', () => {
        row.removing = false;
        renderHarvestReleases();
      });
  });
  updateHarvestReleasePending();
}

/**
 * The two read-only cells: how much of this release is booked, and what is left.
 *
 * ⚠️ **Against the saved figure, not the one being typed.** `row.wasKg` is what
 * the shop is working from; `row.kg` is a half-finished edit. Subtracting
 * bookings from an unsaved number would show a free amount that exists only in
 * this browser, and the whole point of the column is that somebody can trust it
 * at the stall.
 *
 * A row nobody has released yet has nothing to be free of, so both cells stay
 * empty rather than reading 0,00 kg — "none released" and "all gone" are
 * different situations and only one of them means stop selling.
 */
function promisedCells(row) {
  const still = Number(harvestReleasePromised[row.species]) || 0;
  const released = Number(row.wasKg) * 1000;
  const muted = 'color:var(--c-text-muted)';
  const lbl = (k) => ' data-mlabel="' + esc(t(k)) + '"';
  if (!(released > 0) && !still)
    return (
      '<td' + lbl('harvestFeed.colPromised') + ' style="' + muted + '">—</td>' +
      '<td' + lbl('harvestFeed.colFree') + ' style="' + muted + '">—</td>'
    );
  const frei = released - still;
  // Negative is real and not an arithmetic slip: more is promised than was set
  // aside. It reads as a warning rather than a quantity, because there is
  // nothing left to hand out and somebody has to decide what happens.
  const freiFarbe = frei > 0 ? '' : 'color:var(--c-red-dark);font-weight:600';
  return (
    '<td' + lbl('harvestFeed.colPromised') + ' style="' + muted + '">' + (still ? (still / 1000).toFixed(2) + ' kg' : '—') + '</td>' +
    '<td' + lbl('harvestFeed.colFree') + ' style="' + freiFarbe + '">' + (frei / 1000).toFixed(2) + ' kg</td>'
  );
}

/**
 * Bookings that could not be tied to a release row.
 *
 * They come from a receiver that predates the `species` field, so the line
 * disappears by itself as those pickups age out. Named rather than dropped:
 * leaving them out would make "promised" too small, and too small is the number
 * that costs produce.
 */
function renderHarvestReleaseUnattributed() {
  const zeile = document.getElementById('harvestrelease-unattributed');
  if (!zeile) return;
  if (!harvestReleaseUnattributed) {
    zeile.style.display = 'none';
    return;
  }
  zeile.style.display = '';
  // The cell, not the row: writing textContent onto the <tr> would replace the
  // <td> with a text node and the browser would drop it back out of the table.
  zeile.querySelector('td').textContent = t('harvestFeed.promisedUnattributed', {
    kg: (harvestReleaseUnattributed / 1000).toFixed(2)
  });
}

/**
 * Whether the shop has actually heard the numbers in this table.
 *
 * ⚠️ **The same facts exist in Settings, two pages away.** That is where they
 * were, and it made the outage case read backwards: the service stops
 * publishing amounts once a push is late, while this table went on showing
 * releases exactly as before. The person looking at the figures is here.
 *
 * No threshold is hard-coded. How long the receiver waits before it goes quiet
 * is its setting, not ours; "last sent at 11:42" is true without knowing it.
 */
function renderHarvestReleaseFeed() {
  const el = document.getElementById('harvestrelease-feed');
  if (!el) return;
  const f = harvestReleaseFeed;
  if (!f || !f.enabled) {
    el.style.display = 'none';
    return;
  }
  el.style.display = '';
  const gut = f.lastOk === true;
  el.style.background = gut ? 'var(--c-primary-light)' : 'var(--c-amber-light)';
  el.style.border = '1px solid ' + (gut ? 'var(--c-green-border)' : 'var(--c-amber-border)');
  el.style.color = gut ? 'var(--c-green-dark)' : 'var(--c-amber-dark)';
  el.textContent = !f.lastAt
    ? t('harvestFeed.neverSent')
    : gut
      ? t('harvestFeed.shopHeard', { time: fmtDtTime(f.lastAt) })
      : t('harvestFeed.shopSilent', { time: fmtDtTime(f.lastAt) });
}

// Repaints one row instead of the table: a redraw while somebody is typing takes
// the caret with it.
function markHarvestReleaseRow(tr, row) {
  const touched = row.removing || row.kg !== row.wasKg || row.until !== row.wasUntil;
  tr.style.background = touched ? 'var(--c-amber-light)' : '';
  updateHarvestReleasePending();
}

/**
 * Take a species out of the list.
 *
 * A stored release is marked, not deleted on the spot. Everything else on this
 * screen waits for Save, and a delete that did not would be the one action here
 * that cannot be taken back by walking away from it — which is the wrong shape
 * for the mis-click this button is closest to.
 *
 * A row that was never stored has nothing to delete and nothing to undo; it only
 * ever existed in this table, so it leaves at once and the picker offers it again.
 */
function removeHarvestReleaseRow(row) {
  if (row.stored) row.removing = true;
  else harvestReleaseRows = harvestReleaseRows.filter((r) => r !== row);
  renderHarvestReleases();
  fillHarvestReleasePicker();
}

// How much is typed but not stored, next to the button that would store it.
function updateHarvestReleasePending() {
  const el = document.getElementById('harvestrelease-pending');
  if (!el) return;
  const n = harvestReleaseChanges().length;
  el.textContent = n ? tp('harvestFeed.pending', n) : '';
  el.style.display = n ? '' : 'none';
}

function showHarvestReleaseResult(msg, color) {
  const el = document.getElementById('harvestrelease-result');
  el.style.display = 'block';
  el.style.color = color || 'var(--c-text-muted)';
  el.textContent = msg;
}

async function saveHarvestReleases() {
  const bad = harvestReleaseRows.find((r) => !r.removing && r.kg !== '' && !(Number(r.kg) >= 0));
  if (bad) {
    showHarvestReleaseResult(t('harvestFeed.badAmount'), 'var(--c-red-dark)');
    return;
  }
  // Only the rows somebody actually touched. Posting all of them would stamp
  // `updated` on decisions nobody revisited — and it would create a zero row for
  // every species ever harvested, turning the table into a list of everything
  // that was never released.
  const changed = harvestReleaseChanges();
  if (!changed.length) {
    showHarvestReleaseResult(t('harvestFeed.nothingChanged'), 'var(--c-text-muted)');
    return;
  }
  showHarvestReleaseResult(t('harvestFeed.saving'), 'var(--c-text-muted)');
  try {
    for (const row of changed) {
      if (row.removing) {
        // Not `grams: 0`. A zeroed row publishes nothing either, but it stays in
        // this table for good — which is how the list filled up with species
        // somebody had already decided against.
        await apiPost('/api/harvest-feed/release', { species: row.species, remove: true });
        continue;
      }
      await apiPost('/api/harvest-feed/release', {
        species: row.species,
        grams: row.kg === '' ? 0 : Math.round(Number(row.kg) * 1000),
        validUntil: row.until || null
      });
    }
    // Removing a species harvested inside the fresh window leaves the row on
    // screen — at zero, as a suggestion, which is what this table is for. Saying
    // so beats a reload that reads as a delete which did not take.
    const bleibt = changed.some((r) => r.removing && r.harvested != null);
    showHarvestReleaseResult(
      t('harvestFeed.saved') + (bleibt ? ' ' + t('harvestFeed.removedStillListed') : ''),
      'var(--c-green-dark)'
    );
    // Clean first, then reload: loadHarvestReleases() refuses to redraw while
    // anything is pending, and that refusal is what keeps a background refresh
    // off a half-typed row. Skipping this would leave the table frozen on the
    // values it just saved.
    for (const r of harvestReleaseRows) {
      r.wasKg = r.kg;
      r.wasUntil = r.until;
      r.removing = false;
    }
    updateHarvestReleasePending();
    loadHarvestReleases();
  } catch (e) {
    showHarvestReleaseResult(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  }
}

function addHarvestReleaseRow() {
  const input = document.getElementById('harvestrelease-new');
  const species = input.value;
  if (!species) return;
  if (harvestReleaseRows.some((r) => r.species === species)) {
    showHarvestReleaseResult(t('harvestFeed.alreadyListed'), 'var(--c-amber-dark)');
    return;
  }
  // Straight into the table rather than straight to the server: an empty row
  // that is never saved costs nothing, and until the amount is filled in there
  // is nothing to save.
  harvestReleaseRows.push(freshReleaseRow({ species, harvested: null, grams: 0, validUntil: null, stored: false }));
  harvestReleaseRows.sort((a, b) => a.species.localeCompare(b.species));
  renderHarvestReleases();
  fillHarvestReleasePicker();
}

function renderHarvestFeedBanner(cfg) {
  const banner = document.getElementById('harvestfeed-status-banner');
  // Configured through the environment: the form below is not what is running,
  // and saying so beats an empty form on a server that is busily posting.
  if (cfg.envActive) {
    banner.style.display = 'block';
    banner.style.background = 'var(--c-amber-light)';
    banner.style.border = '1px solid var(--c-amber-border)';
    banner.style.color = 'var(--c-amber-dark)';
    banner.textContent = t('harvestFeed.envActive');
    return;
  }
  if (!cfg.enabled) {
    banner.style.display = 'none';
    return;
  }
  banner.style.display = 'block';
  if (cfg.lastOk === true) {
    banner.style.background = 'var(--c-primary-light)';
    banner.style.border = '1px solid var(--c-green-border)';
    banner.style.color = 'var(--c-green-dark)';
    banner.textContent = t('harvestFeed.lastOk') + ' ' + (cfg.lastAt ? fmtDtTime(cfg.lastAt) : '');
  } else if (cfg.lastOk === false) {
    banner.style.background = 'var(--c-red-light)';
    banner.style.border = '1px solid var(--c-red-border)';
    banner.style.color = 'var(--c-red-dark)';
    banner.textContent =
      t('harvestFeed.lastFailed') +
      ' ' +
      (cfg.lastAt ? fmtDtTime(cfg.lastAt) : '') +
      (cfg.lastError ? ' — ' + cfg.lastError : '');
  } else {
    banner.style.background = 'var(--c-amber-light)';
    banner.style.border = '1px solid var(--c-amber-border)';
    banner.style.color = 'var(--c-amber-dark)';
    banner.textContent = t('harvestFeed.neverSent');
  }
}

function showHarvestFeedResult(msg, color) {
  const el = document.getElementById('harvestfeed-result');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
}

function generateHarvestFeedSecret() {
  // 32 random bytes as hex. Generated here rather than asked for, because a
  // secret someone thinks up is a secret someone can guess — and this one is
  // copied into another system once and then never typed again.
  const raw = new Uint8Array(32);
  crypto.getRandomValues(raw);
  const hex = Array.from(raw)
    .map((b) => b.toString(16).padStart(2, '0'))
    .join('');
  const el = document.getElementById('harvestfeed-secret');
  el.type = 'text';
  el.value = hex;
  showHarvestFeedResult(t('harvestFeed.generated'), 'var(--c-amber-dark)');
}

async function saveHarvestFeedSettings() {
  const secret = document.getElementById('harvestfeed-secret').value.trim();
  const cfg = {
    enabled: document.getElementById('harvestfeed-enabled').checked,
    url: document.getElementById('harvestfeed-url').value.trim(),
    intervalMin: parseInt(document.getElementById('harvestfeed-interval').value, 10),
    freshDays: parseInt(document.getElementById('harvestfeed-fresh').value, 10),
    plannedDays: parseInt(document.getElementById('harvestfeed-planned').value, 10),
    leadDays: parseInt(document.getElementById('harvestfeed-lead').value, 10),
    strain: document.getElementById('harvestfeed-strain').checked,
    site: document.getElementById('harvestfeed-site').value.trim(),
    packSizes: harvestPackSizes()
  };
  if (secret) cfg.secret = secret;
  try {
    const r = await apiPost('/api/harvest-feed/config', cfg);
    if (r.error) {
      showHarvestFeedResult(t('common.error') + ': ' + r.error, 'var(--c-red-dark)');
      return;
    }
    showHarvestFeedResult(t('harvestFeed.saved'), 'var(--c-green-dark)');
    document.getElementById('harvestfeed-secret').type = 'password';
    loadHarvestFeedSettings();
  } catch (e) {
    showHarvestFeedResult(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  }
}

/**
 * `previewOnly` goes to a different endpoint, not a different flag on the same
 * one. "Show what would be sent" that sends is a button whose label is a lie,
 * and this is the button people press when they are not yet sure they want the
 * feed on at all.
 */
async function testHarvestFeed(previewOnly) {
  const pre = document.getElementById('harvestfeed-payload');
  showHarvestFeedResult(t(previewOnly ? 'harvestFeed.building' : 'harvestFeed.sending'), 'var(--c-text-muted)');
  try {
    const r = await apiPost(previewOnly ? '/api/harvest-feed/preview' : '/api/harvest-feed/test', {});
    if (r.error) {
      showHarvestFeedResult(t('common.error') + ': ' + r.error, 'var(--c-red-dark)');
      pre.style.display = 'none';
      return;
    }
    if (r.payload) {
      pre.style.display = 'block';
      pre.textContent = JSON.stringify(r.payload, null, 2);
    }
    if (previewOnly) {
      showHarvestFeedResult(t('harvestFeed.previewOk') + ' ' + r.harvested + ' / ' + r.planned, 'var(--c-text-muted)');
      return;
    }
    if (r.ok) {
      showHarvestFeedResult(t('harvestFeed.testOk') + ' ' + r.harvested + ' / ' + r.planned, 'var(--c-green-dark)');
    } else {
      showHarvestFeedResult(t('harvestFeed.testFailed') + ': ' + (r.error || ''), 'var(--c-red-dark)');
    }
    loadHarvestFeedSettings();
  } catch (e) {
    showHarvestFeedResult(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  }
}

function showDuckdnsStatus(msg, color) {
  const el = document.getElementById('duckdns-ip-status');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
  setTimeout(() => {
    el.style.display = 'none';
  }, 8000);
}
function showLeStatus(msg, color) {
  const el = document.getElementById('le-status');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
  setTimeout(() => {
    el.style.display = 'none';
  }, 15000);
}
async function saveDuckdnsSettings() {
  const tokenVal = document.getElementById('duckdns-token').value.trim();
  const cfg = {
    enabled: document.getElementById('duckdns-enabled').checked,
    domain: document.getElementById('duckdns-domain').value.trim().toLowerCase(),
    leEnabled: document.getElementById('duckdns-le-enabled').checked
  };
  if (tokenVal) cfg.token = tokenVal;
  if (cfg.enabled && !cfg.domain) {
    showDuckdnsStatus(t('duckdns.subdomainRequired'), 'var(--c-red-dark)');
    return;
  }
  if (cfg.enabled && !tokenVal && !document.getElementById('duckdns-token').placeholder) {
    showDuckdnsStatus(t('duckdns.tokenRequired'), 'var(--c-red-dark)');
    return;
  }
  try {
    const r = await apiPost('/api/duckdns/config', cfg);
    if (r.error) {
      showDuckdnsStatus(t('common.error') + ': ' + r.error, 'var(--c-red-dark)');
    } else {
      showDuckdnsStatus(t('duckdns.saved'), 'var(--c-green-dark)');
      refreshDuckdnsStatus();
    }
  } catch (e) {
    showDuckdnsStatus('Fehler: ' + e.message, 'var(--c-red-dark)');
  }
}
// The auto-renewal box sits in the Let's Encrypt card, but the only button that
// ever persisted it is Save in the DuckDNS card above — tick it, reload, and the
// tick was gone. Save on change instead, and send the stored domain rather than
// the field above it so a half-typed DuckDNS edit can't ride along unasked.
async function saveLeEnabled() {
  const box = document.getElementById('duckdns-le-enabled');
  const want = box.checked;
  try {
    const r = await authFetch('/api/duckdns/config');
    if (!r.ok) throw new Error('HTTP ' + r.status);
    const cur = await r.json();
    const res = await apiPost('/api/duckdns/config', {
      enabled: !!cur.enabled,
      domain: cur.domain || '',
      leEnabled: want
    });
    if (res.error) throw new Error(res.error);
    showLeStatus(t('duckdns.saved'), 'var(--c-green-dark)');
  } catch (e) {
    box.checked = !want;
    showLeStatus(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  }
}
async function triggerDuckdnsUpdate() {
  const btn = document.getElementById('duckdns-update-btn');
  btn.disabled = true;
  btn.textContent = t('duckdns.updating');
  showDuckdnsStatus(t('duckdns.sendingIp'), '#888');
  try {
    const r = await authFetch('/api/duckdns/update-ip', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: '{}'
    });
    const data = await r.json();
    if (data.error) {
      showDuckdnsStatus(t('common.error') + ': ' + data.error, 'var(--c-red-dark)');
    } else {
      showDuckdnsStatus(t('duckdns.ipUpdated'), 'var(--c-green-dark)');
      refreshDuckdnsStatus();
    }
  } catch (e) {
    showDuckdnsStatus(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  } finally {
    btn.disabled = false;
    btn.textContent = t('duckdns.updateNow');
  }
}
async function requestLeCert() {
  const btn = document.getElementById('le-request-btn');
  btn.disabled = true;
  btn.textContent = t('le.requesting');
  showLeStatus(t('le.certRequesting'), '#888');
  try {
    const r = await authFetch('/api/duckdns/request-cert', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: '{}'
    });
    const data = await r.json();
    if (data.error) {
      showLeStatus(t('common.error') + ': ' + data.error, 'var(--c-red-dark)');
    } else {
      showLeStatus(t('le.certIssued', { domain: data.domain, date: fmtDt(data.expiry) }), 'var(--c-green-dark)');
      refreshDuckdnsStatus();
    }
  } catch (e) {
    showLeStatus(t('common.error') + ': ' + e.message, 'var(--c-red-dark)');
  } finally {
    btn.disabled = false;
    btn.textContent = t('le.requestNow');
  }
}

// ─── MCP TAB (admin-only) ───────────────────────────────────
function showMcpTab() {
  showAdminSubTab('mcp');
}

// ─── CAMERA TAB (admin-only WIP) ─────────────────────────────
// Surfaces what an external camera module writes into camera_* tables
// and lets admins edit calibration values + manage the cameras list. The
// detection/measurement loop is external; this dashboard does not run it.
const _cam = {
  calibration: null,
  cameras: [],
  editingId: null,
  pxDistance: null
};

const CAM_CALIB_FIELDS = [
  ['pxPerMm', 'cam.pxPerMm', 'real'],
  ['incubationBagRadiusPx', 'cam.incubationBagRadiusPx', 'int'],
  ['qrAssignRadiusPx', 'cam.qrAssignRadiusPx', 'int'],
  ['yoloConfThreshold', 'cam.yoloConfThreshold', 'real'],
  ['pinMaxAreaRatio', 'cam.pinMaxAreaRatio', 'real'],
  ['harvestGrowthThresholdPct', 'cam.harvestGrowthThresholdPct', 'real'],
  ['harvestStallReadings', 'cam.harvestStallReadings', 'int'],
  ['colonisationScoreThreshold', 'cam.colonisationScoreThreshold', 'real'],
  ['colonisationMinFraction', 'cam.colonisationMinFraction', 'real'],
  ['unseenBagAlertHours', 'cam.unseenBagAlertHours', 'int'],
  ['contamConfThreshold', 'cam.contamConfThreshold', 'real']
];

function showCameraTab() {
  showAdminSubTab('camera');
}

async function loadCameraTab() {
  if (!currentUser || currentUser.role !== 'admin') return;
  let data;
  try {
    const r = await authFetch('/api/camera/dashboard');
    data = await r.json();
  } catch (e) {
    document.getElementById('cam-stats').textContent = t('common.error') + ': ' + (e.message || '');
    return;
  }
  _cam.calibration = data.calibration;
  _cam.cameras = data.cameras || [];
  renderCameraStats(data.stats);
  renderCameraList(_cam.cameras);
  renderCameraCalibForm(_cam.calibration);
  renderCameraFlags(data.flags);
  renderCameraRecent(data.recentMeasurements || []);
}

function renderCameraStats(s) {
  const el = document.getElementById('cam-stats');
  if (!el) return;
  if (!s) {
    el.textContent = t('common.error');
    return;
  }
  const cell = (label, value) =>
    `<div class="card" style="padding:10px;margin:0">
      <div class="fs-xs" style="color:var(--c-text-muted)">${esc(label)}</div>
      <div class="fs-floor" style="--fs-own:1.125rem;font-weight:600;color:var(--c-text)">${esc(String(value))}</div>
    </div>`;
  el.innerHTML =
    cell(t('cam.statCameras'), s.enabledCameras + ' / ' + s.cameras) +
    cell(t('cam.statMeasurements7d'), s.measurementsLast7) +
    cell(t('cam.statSnapshots7d'), s.snapshotsLast7) +
    cell(t('cam.statOpenHarvest'), s.openHarvestFlags) +
    cell(t('cam.statOpenFruiting'), s.openFruitingFlags) +
    cell(t('cam.statLabelled'), s.labelledSamples);
}

function renderCameraList(list) {
  const el = document.getElementById('cam-list');
  if (!el) return;
  if (!list.length) {
    el.innerHTML =
      '<div class="fs-sm" style="color:var(--c-text-muted);padding:8px 0">' + esc(t('cam.noCameras')) + '</div>';
    return;
  }
  const rows = list
    .map((c) => {
      const zone = c.zoneId ? esc(zoneDisplayName(c.zoneId)) : '<span style="color:var(--c-text-muted)">—</span>';
      const masked = maskRtspUrl(c.rtspUrl);
      const stateBadge = c.enabled
        ? `<span class="badge" style="background:#dcfce7;color:#166534">${esc(t('cam.enabled'))}</span>`
        : `<span class="badge" style="background:#fef3c7;color:#92400e">${esc(t('cam.disabled'))}</span>`;
      return `<div class="card" style="padding:10px;margin-bottom:8px;display:flex;gap:10px;align-items:center;flex-wrap:wrap">
          <div style="flex:1;min-width:200px">
            <div style="font-weight:600">${esc(c.name)} ${stateBadge}</div>
            <div class="fs-xs" style="color:var(--c-text-muted);font-family:monospace;word-break:break-all">${esc(masked)}</div>
            <div class="fs-xs" style="color:var(--c-text-muted)">${esc(t('cam.fieldZone'))}: ${zone}</div>
          </div>
          <div style="display:flex;gap:6px">
            <button class="btn btn-sm" data-cam-edit="${c.id}" data-i18n="cam.edit">Edit</button>
            <button class="btn btn-sm btn-r" data-cam-delete="${c.id}" data-i18n="cam.delete">Delete</button>
          </div>
        </div>`;
    })
    .join('');
  el.innerHTML = rows;
  el.querySelectorAll('[data-cam-edit]').forEach((b) =>
    b.addEventListener('click', () => openCameraEdit(parseInt(b.dataset.camEdit, 10)))
  );
  el.querySelectorAll('[data-cam-delete]').forEach((b) =>
    b.addEventListener('click', () => deleteCamera(parseInt(b.dataset.camDelete, 10)))
  );
}

function maskRtspUrl(url) {
  // Hide credentials (rtsp://user:pass@host -> rtsp://***@host) so admins
  // sharing screenshots don't leak passwords.
  if (!url) return '';
  return url.replace(/^(rtsp?:\/\/)([^:]+):([^@]+)@/i, '$1***:***@');
}

function renderCameraCalibForm(c) {
  const wrap = document.getElementById('cam-calib-form');
  if (!wrap) return;
  if (!c) {
    wrap.textContent = t('common.error');
    return;
  }
  wrap.innerHTML = CAM_CALIB_FIELDS.map(([key, label, kind]) => {
    const step = kind === 'int' ? '1' : '0.01';
    const val = c[key] != null ? c[key] : '';
    return `<div>
        <label class="fs-meta" style="font-weight:600;display:block" data-i18n="${label}">${esc(key)}</label>
        <input type="number" step="${step}" min="0" data-cam-calib="${key}" value="${esc(String(val))}" style="width:100%" />
      </div>`;
  }).join('');
  translatePage();
  const ts = c.updatedAt ? new Date(c.updatedAt).toLocaleString(loc()) : '—';
  document.getElementById('cam-calib-status').textContent = t('cam.lastUpdated') + ': ' + ts;
}

async function saveCameraCalibration() {
  const inputs = document.querySelectorAll('[data-cam-calib]');
  const patch = {};
  for (const el of inputs) {
    const v = el.value.trim();
    if (v === '') continue;
    const num = Number(v);
    if (!Number.isFinite(num) || num < 0) {
      document.getElementById('cam-calib-status').textContent = t('cam.invalidValue') + ': ' + el.dataset.camCalib;
      return;
    }
    patch[el.dataset.camCalib] = num;
  }
  try {
    const r = await authFetch('/api/camera/calibration', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(patch)
    });
    if (!r.ok) {
      const err = await r.json().catch(() => ({}));
      document.getElementById('cam-calib-status').textContent = t('common.error') + ': ' + (err.error || r.status);
      return;
    }
    const updated = await r.json();
    _cam.calibration = updated;
    renderCameraCalibForm(updated);
    document.getElementById('cam-calib-status').textContent = t('cam.saved');
  } catch (e) {
    document.getElementById('cam-calib-status').textContent = t('common.error') + ': ' + (e.message || '');
  }
}

function renderCameraFlags(flags) {
  const el = document.getElementById('cam-flags');
  if (!el) return;
  if (!flags || ((!flags.harvest || !flags.harvest.length) && (!flags.fruiting || !flags.fruiting.length))) {
    el.innerHTML = '<div class="fs-sm" style="color:var(--c-text-muted)">' + esc(t('cam.noOpenFlags')) + '</div>';
    return;
  }
  const row = (kind, f) => {
    const ago = f.flaggedAt ? new Date(f.flaggedAt).toLocaleString(loc()) : '—';
    const extra =
      kind === 'harvest'
        ? f.predictedHarvestAt
          ? esc(t('cam.predicted')) + ': ' + new Date(f.predictedHarvestAt).toLocaleString(loc())
          : ''
        : f.peakScore != null
          ? esc(t('cam.peakScore')) + ': ' + Number(f.peakScore).toFixed(2)
          : '';
    return `<div style="display:flex;gap:8px;align-items:center;padding:6px 0;border-bottom:1px solid var(--c-border)">
        <div style="flex:1;min-width:180px">
          <div><b>${esc(f.bagId)}</b> <span style="color:var(--c-text-muted)">${esc(f.batchId || '')}</span></div>
          <div class="fs-xs" style="color:var(--c-text-muted)">${esc(ago)}${extra ? ' · ' + extra : ''}</div>
        </div>
        <button class="btn btn-sm" data-cam-resolve="${kind}:${f.id}" data-i18n="cam.resolve">Resolve</button>
      </div>`;
  };
  let html = '';
  if (flags.harvest && flags.harvest.length) {
    html +=
      '<div style="font-weight:600;margin-bottom:4px">' +
      esc(t('cam.harvestFlags')) +
      '</div>' +
      flags.harvest.map((f) => row('harvest', f)).join('');
  }
  if (flags.fruiting && flags.fruiting.length) {
    html +=
      '<div style="font-weight:600;margin:10px 0 4px">' +
      esc(t('cam.fruitingFlags')) +
      '</div>' +
      flags.fruiting.map((f) => row('fruiting', f)).join('');
  }
  el.innerHTML = html;
  translatePage();
  el.querySelectorAll('[data-cam-resolve]').forEach((b) =>
    b.addEventListener('click', async () => {
      const [kind, id] = b.dataset.camResolve.split(':');
      try {
        const r = await authFetch('/api/camera/flags/' + kind + '/' + id + '/resolve', { method: 'POST' });
        if (!r.ok) throw new Error((await r.json().catch(() => ({}))).error || r.status);
        loadCameraTab();
      } catch (e) {
        toast(t('common.error') + ': ' + (e.message || ''), 'err');
      }
    })
  );
}

function renderCameraRecent(rows) {
  const el = document.getElementById('cam-recent');
  if (!el) return;
  if (!rows.length) {
    el.innerHTML = '<div style="color:var(--c-text-muted)">' + esc(t('cam.noRecent')) + '</div>';
    return;
  }
  const head = `<thead><tr>
      <th>${esc(t('cam.colTime'))}</th>
      <th>${esc(t('cam.colBag'))}</th>
      <th>${esc(t('cam.colDiameter'))}</th>
      <th>${esc(t('cam.colCount'))}</th>
      <th>${esc(t('cam.colConf'))}</th>
    </tr></thead>`;
  const body = rows
    .map((m) => {
      const dt = m.capturedAt ? new Date(m.capturedAt).toLocaleString(loc()) : '—';
      const dia = m.capDiameterMm != null ? Number(m.capDiameterMm).toFixed(1) + ' mm' : '—';
      const conf = m.detectionConf != null ? (Number(m.detectionConf) * 100).toFixed(0) + '%' : '—';
      return `<tr>
          <td>${esc(dt)}</td>
          <td>${esc(m.bagId)}</td>
          <td>${esc(dia)}</td>
          <td>${esc(String(m.mushroomCount || 0))}</td>
          <td>${esc(conf)}</td>
        </tr>`;
    })
    .join('');
  el.innerHTML = '<div style="overflow-x:auto"><table>' + head + '<tbody>' + body + '</tbody></table></div>';
}

function openCameraEdit(id) {
  _cam.editingId = id || null;
  const cam = id ? _cam.cameras.find((c) => c.id === id) : null;
  document.getElementById('cam-edit-title').textContent = id ? t('cam.editCamera') : t('cam.addCamera');
  document.getElementById('cam-edit-name').value = cam ? cam.name : '';
  document.getElementById('cam-edit-rtsp').value = cam ? cam.rtspUrl : '';
  document.getElementById('cam-edit-enabled').checked = cam ? !!cam.enabled : true;
  document.getElementById('cam-edit-status').textContent = '';
  // Populate zone dropdown from existing zones
  const sel = document.getElementById('cam-edit-zone');
  sel.innerHTML =
    `<option value="">${esc(t('cam.zoneNone'))}</option>` +
    zones.map((z) => `<option value="${esc(z.id)}">${esc(z.name || z.id)}</option>`).join('');
  sel.value = cam && cam.zoneId ? cam.zoneId : '';
  document.getElementById('m-cam-edit').classList.add('open');
  setTimeout(() => document.getElementById('cam-edit-name').focus(), 0);
}

function closeCameraEdit() {
  document.getElementById('m-cam-edit').classList.remove('open');
  _cam.editingId = null;
}

async function saveCameraEdit() {
  const payload = {
    name: document.getElementById('cam-edit-name').value.trim(),
    rtspUrl: document.getElementById('cam-edit-rtsp').value.trim(),
    zoneId: document.getElementById('cam-edit-zone').value || null,
    enabled: document.getElementById('cam-edit-enabled').checked
  };
  if (!payload.name) {
    document.getElementById('cam-edit-status').textContent = t('cam.fieldName') + ': ' + t('common.required');
    return;
  }
  if (!payload.rtspUrl) {
    document.getElementById('cam-edit-status').textContent = t('cam.fieldRtsp') + ': ' + t('common.required');
    return;
  }
  try {
    const url = _cam.editingId ? '/api/camera/cameras/' + _cam.editingId : '/api/camera/cameras';
    const method = _cam.editingId ? 'PUT' : 'POST';
    const r = await authFetch(url, {
      method,
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(payload)
    });
    if (!r.ok) {
      const err = await r.json().catch(() => ({}));
      document.getElementById('cam-edit-status').textContent = err.error || 'HTTP ' + r.status;
      return;
    }
    closeCameraEdit();
    loadCameraTab();
  } catch (e) {
    document.getElementById('cam-edit-status').textContent = e.message || t('common.error');
  }
}

async function deleteCamera(id) {
  const cam = _cam.cameras.find((c) => c.id === id);
  if (!cam) return;
  if (!(await askConfirm(t('cam.delete'), t('cam.confirmDelete', { name: cam.name }), t('cam.delete')))) return;
  try {
    const r = await authFetch('/api/camera/cameras/' + id, { method: 'DELETE' });
    if (!r.ok) throw new Error((await r.json().catch(() => ({}))).error || r.status);
    loadCameraTab();
  } catch (e) {
    toast(t('common.error') + ': ' + (e.message || ''), 'err');
  }
}

// Pixel calibration helper: load image into canvas, click two endpoints,
// compute pixel distance, divide by user-entered mm to get px/mm.
function initCameraPxCalib() {
  const fileInput = document.getElementById('cam-calib-image');
  const canvas = document.getElementById('cam-calib-canvas');
  const pxLabel = document.getElementById('cam-calib-px');
  const mmInput = document.getElementById('cam-calib-mm');
  const applyBtn = document.getElementById('cam-calib-apply');
  if (!fileInput || !canvas || !pxLabel || !mmInput || !applyBtn) return;
  const ctx = canvas.getContext('2d');
  let img = null;
  let p1 = null;
  let p2 = null;

  function redraw() {
    if (!img) return;
    ctx.drawImage(img, 0, 0, canvas.width, canvas.height);
    function dot(p, color) {
      ctx.beginPath();
      ctx.arc(p.x, p.y, 6, 0, 2 * Math.PI);
      ctx.fillStyle = color;
      ctx.fill();
      ctx.strokeStyle = '#fff';
      ctx.lineWidth = 2;
      ctx.stroke();
    }
    if (p1) dot(p1, '#ea580c');
    if (p2) dot(p2, '#0284c7');
    if (p1 && p2) {
      ctx.strokeStyle = '#ea580c';
      ctx.lineWidth = 3;
      ctx.beginPath();
      ctx.moveTo(p1.x, p1.y);
      ctx.lineTo(p2.x, p2.y);
      ctx.stroke();
    }
  }

  function updatePx() {
    if (p1 && p2) {
      const dx = p2.x - p1.x;
      const dy = p2.y - p1.y;
      const px = Math.sqrt(dx * dx + dy * dy);
      _cam.pxDistance = px;
      pxLabel.style.display = '';
      pxLabel.textContent = t('cam.pxMeasured', { px: px.toFixed(1) });
      applyBtn.disabled = false;
    } else {
      _cam.pxDistance = null;
      pxLabel.style.display = 'none';
      applyBtn.disabled = true;
    }
  }

  fileInput.addEventListener('change', () => {
    const f = fileInput.files && fileInput.files[0];
    if (!f) return;
    const reader = new FileReader();
    reader.onload = (e) => {
      const im = new Image();
      im.onload = () => {
        // Cap canvas at 800px wide so it fits on small screens
        const maxW = 800;
        const scale = im.width > maxW ? maxW / im.width : 1;
        canvas.width = Math.round(im.width * scale);
        canvas.height = Math.round(im.height * scale);
        canvas.style.display = '';
        img = im;
        p1 = null;
        p2 = null;
        updatePx();
        redraw();
      };
      im.src = e.target.result;
    };
    reader.readAsDataURL(f);
  });

  canvas.addEventListener('click', (e) => {
    if (!img) return;
    const rect = canvas.getBoundingClientRect();
    const x = ((e.clientX - rect.left) / rect.width) * canvas.width;
    const y = ((e.clientY - rect.top) / rect.height) * canvas.height;
    if (!p1 || (p1 && p2)) {
      p1 = { x, y };
      p2 = null;
    } else {
      p2 = { x, y };
    }
    updatePx();
    redraw();
  });

  applyBtn.addEventListener('click', () => {
    if (!_cam.pxDistance) return;
    const mm = parseDecimal(mmInput.value);
    if (!Number.isFinite(mm) || mm <= 0) {
      toast(t('cam.invalidMm'), 'err');
      return;
    }
    const ratio = _cam.pxDistance / mm;
    const inp = document.querySelector('[data-cam-calib="pxPerMm"]');
    if (inp) {
      inp.value = ratio.toFixed(3);
      inp.scrollIntoView({ block: 'nearest', behavior: 'smooth' });
      document.getElementById('cam-calib-status').textContent = t('cam.calibratedFromImage', {
        ratio: ratio.toFixed(3)
      });
    }
  });
}

// ─── SERVER TAB ─────────────────────────────────────────────
function showServerTab() {
  showAdminSubTab('server');
}
async function loadServerTab() {
  const el = document.getElementById('server-info');
  if (!el) return;
  if (!currentUser || currentUser.role !== 'admin') {
    el.textContent = t('server.adminRequired');
    return;
  }
  try {
    const r = await authFetch('/api/health');
    const h = await r.json();
    const uptimeH = Math.floor(h.uptime / 3600);
    const uptimeM = Math.floor((h.uptime % 3600) / 60);
    const platLabel = h.platform === 'win32' ? 'Windows' : h.platform === 'darwin' ? 'macOS' : 'Linux';
    el.innerHTML =
      '<div><b>' +
      t('server.statusLabel') +
      ':</b> ' +
      esc(h.status) +
      '</div>' +
      '<div><b>' +
      t('server.versionLabel') +
      ':</b> ' +
      esc(h.version) +
      '</div>' +
      // The commit tells whether an update arrived; the version above never
      // changes. Missing without git on the server.
      '<div><b>' +
      t('server.codeLabel') +
      ':</b> ' +
      (h.code ? esc(h.code.commit) + (h.code.date ? ' · ' + esc(fmtDtTime(h.code.date)) : '') : '–') +
      '</div>' +
      (h.labChain ? serverKette(h.labChain) : '') +
      '<div><b>' +
      t('server.platformLabel') +
      ':</b> ' +
      platLabel +
      '</div>' +
      '<div><b>' +
      t('server.nodeLabel') +
      ':</b> ' +
      esc(h.nodeVersion || '–') +
      '</div>' +
      '<div><b>' +
      t('server.uptimeLabel') +
      ':</b> ' +
      uptimeH +
      'h ' +
      uptimeM +
      'm</div>' +
      '<div><b>' +
      t('server.sseLabel') +
      ':</b> ' +
      h.sseClients +
      '</div>' +
      (h.memory ? '<div><b>' + t('server.ramLabel') + ':</b> ' + h.memory.rss + ' MB</div>' : '');
    const stempeln = document.getElementById('btn-lab-stamp');
    if (stempeln) stempeln.addEventListener('click', labStempeln);
  } catch (e) {
    el.textContent = t('server.loadError');
  }
}
// Die Pruefkette des Laborbuchs in einer Zeile: ob der Verlauf noch so ist, wie
// er geschrieben wurde, der juengste Zeitstempel, ob die Signaturen der Stelle
// halten, und ob der letzte Versuch, einen zu holen, scheiterte. Darunter der
// Knopf, der gleich einen holt.
function serverKette(k) {
  const teile = [
    k.ok
      ? t('server.chainOk', { n: k.entries })
      : t('server.chainBroken', { id: k.broken && k.broken[0] ? k.broken[0].id : '?' })
  ];
  // Nachgetragene Eintraege sind kein Bruch, aber sie bleiben genannt.
  for (const a of k.adopted || []) {
    teile.push(t('server.chainAdopted', { n: a.count ?? '?', d: fmtDtTime(a.at), from: a.from ?? '?', to: a.to ?? '?' }));
  }
  const s = k.lastStamp;
  teile.push(s ? t('server.chainStamp', { d: fmtDtTime(s.genTime), id: s.historyId }) : t('server.chainNoStamp'));
  // Die Signaturen fuer sich, ueber alle Stempel: welche nicht halten, welche
  // sich nicht pruefen lassen, und sonst, dass alle geprueft sind. Ein Server
  // von vor der Pruefung schickt sie nicht mit.
  const sig = k.signatures;
  if (sig && k.stamps) {
    if (sig.bad) {
      // firstBad auch dann, wenn vor ihm zehn stehen, die sich nur nicht
      // pruefen lassen.
      const erster = sig.firstBad || (sig.problems || []).find((p) => p.signature === 'bad');
      teile.push(t('server.chainSigBad', { n: sig.bad, total: k.stamps, id: erster ? erster.historyId : '?' }));
    }
    if (sig.unchecked) teile.push(t('server.chainSigUnchecked', { n: sig.unchecked, total: k.stamps }));
    if (!sig.bad && !sig.unchecked) teile.push(t('server.chainSigOk'));
  }
  const an = !!(k.stamping && k.stamping.tsa);
  if (!an) teile.push(t('server.chainStampOff'));
  else if (k.stamping.lastError) {
    teile.push(
      t('server.chainStampErr', { d: fmtDtTime(k.stamping.lastError.at), err: k.stamping.lastError.message })
    );
  }
  // Die juengste zurueckgespielte Sicherung in einer Zeile: wann, wie viel sie
  // verworfen hat, und wo der Stand davor liegt. Alle stehen im Laborbuch.
  const zurueck = k.restores || [];
  const r = zurueck[zurueck.length - 1];
  const sicherung = r
    ? [
        t('server.restoreWhen', { d: fmtDtTime(r.at), user: r.user || '—', n: r.discarded ?? '?' }),
        r.kept ? t('server.restoreKept', { file: r.kept }) : '',
        zurueck.length > 1 ? t('server.restoreEarlier', { n: zurueck.length - 1 }) : ''
      ].filter(Boolean)
    : null;
  return (
    '<div><b>' +
    esc(t('server.chainLabel')) +
    ':</b> ' +
    esc(teile.join(' · ')) +
    '</div>' +
    (an
      ? '<div><button type="button" class="btn btn-sm fs-xs" id="btn-lab-stamp">' +
        esc(t('server.chainStampBtn')) +
        '</button> <span id="lab-stamp-status" class="fs-xs"></span></div>'
      : '') +
    (sicherung ? '<div><b>' + esc(t('server.restoreLabel')) + ':</b> ' + esc(sicherung.join(' · ')) + '</div>' : '')
  );
}
// Was die Antwort auf "Zeitstempel jetzt holen" heisst.
function labStempelText(r) {
  if (!r || r.error) return t('server.chainStampErr', { d: fmtDtTime(new Date().toISOString()), err: (r && r.error) || '' });
  if (r.status === 'stamped') return t('server.chainStampDone', { d: fmtDtTime(r.stamp.genTime) });
  if (r.status === 'current') return t('server.chainStampCurrent');
  if (r.status === 'empty') return t('server.chainStampEmpty');
  if (r.status === 'off') return t('server.chainStampOff');
  return t('server.chainStampWait');
}
async function labStempeln() {
  const btn = document.getElementById('btn-lab-stamp');
  const status = document.getElementById('lab-stamp-status');
  if (btn) btn.disabled = true;
  const r = await apiPost('/api/lab-history/timestamp', {});
  if (status) status.textContent = labStempelText(r);
  if (btn) btn.disabled = false;
  // Ein neuer Stempel steht dann auch in der Zeile darueber.
  if (r && r.status === 'stamped') setTimeout(loadServerTab, 1500);
}
function restartServer() {
  confirm2(t('server.restartTitle'), t('server.restartMsg'), t('server.restartConfirm'), async () => {
    const btn = document.getElementById('btn-server-restart');
    const status = document.getElementById('server-restart-status');
    btn.disabled = true;
    btn.textContent = t('server.restarting');
    status.style.display = 'block';
    status.style.color = 'var(--c-text-muted)';
    status.textContent = t('server.updateStatus');
    try {
      await authFetch('/api/server/restart', {
        method: 'POST',
        headers: { 'Content-Type': 'application/json' },
        body: '{}'
      });
      status.textContent = t('server.waitReconnect');
      let attempts = 0;
      const poll = setInterval(async () => {
        attempts++;
        try {
          const r = await fetch('/api/health');
          if (r.ok) {
            clearInterval(poll);
            window.location.reload();
          }
        } catch (e) {
          /* still down */
        }
        if (attempts > 60) {
          clearInterval(poll);
          status.textContent = t('server.noResponse');
          status.style.color = 'var(--c-red-dark)';
          btn.disabled = false;
          btn.textContent = t('server.updateBtn');
        }
      }, 3000);
    } catch (e) {
      status.textContent = t('common.error') + ': ' + e.message;
      status.style.color = 'var(--c-red-dark)';
      btn.disabled = false;
      btn.textContent = t('server.updateBtn');
    }
  });
}

// ─── MCP SETTINGS ───────────────────────────────────────────
let _mcpToken = '';
async function loadMcpSettings() {
  try {
    const r = await authFetch('/api/mcp/config');
    if (!r.ok) return;
    const cfg = await r.json();
    document.getElementById('mcp-enabled').checked = cfg.enabled;
    document.getElementById('mcp-url').value = cfg.connectorUrl || '';
    toggleMcpSections(cfg.enabled);
    const banner = document.getElementById('mcp-status-banner');
    if (cfg.enabled) {
      banner.style.display = 'block';
      banner.style.background = 'var(--c-primary-light)';
      banner.style.border = '1px solid var(--c-green-border)';
      banner.style.color = 'var(--c-green-dark)';
      banner.textContent = t('mcp.active');
    } else {
      banner.style.display = 'none';
    }
    const statusR = await authFetch('/api/mcp/status');
    if (statusR.ok) {
      const st = await statusR.json();
      if (st.activeSessions > 0) {
        banner.style.display = 'block';
        banner.style.background = 'var(--c-primary-light)';
        banner.style.border = '1px solid var(--c-green-border)';
        banner.style.color = 'var(--c-green-dark)';
        banner.textContent = t('mcp.sessions').replace('{n}', st.activeSessions);
      }
    }
    if (cfg.enabled) loadOAuthClients();
  } catch (e) {
    /* non-admin */
  }
}
function toggleMcpSections(enabled) {
  document.getElementById('mcp-url-section').style.display = enabled ? 'block' : 'none';
  document.getElementById('mcp-token-section').style.display = enabled ? 'block' : 'none';
  document.getElementById('mcp-guide-card').style.display = enabled ? 'block' : 'none';
  document.getElementById('mcp-diag-card').style.display = enabled ? 'block' : 'none';
  document.getElementById('mcp-oauth-card').style.display = enabled ? 'block' : 'none';
}
function showMcpStatus(msg, color) {
  const el = document.getElementById('mcp-status');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
  setTimeout(() => {
    el.style.display = 'none';
  }, 8000);
}
async function saveMcpSettings() {
  try {
    const r = await apiPost('/api/mcp/config', { enabled: document.getElementById('mcp-enabled').checked });
    if (r.error) {
      showMcpStatus(t('mcp.error').replace('{msg}', r.error), 'var(--c-red-dark)');
    } else {
      showMcpStatus(t('mcp.saved'), 'var(--c-green-dark)');
      loadMcpSettings();
    }
  } catch (e) {
    showMcpStatus(t('mcp.error').replace('{msg}', e.message), 'var(--c-red-dark)');
  }
}
async function generateMcpToken() {
  try {
    const r = await authFetch('/api/mcp/generate-token', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: '{}'
    });
    const data = await r.json();
    if (data.error) {
      showMcpStatus(t('mcp.error').replace('{msg}', data.error), 'var(--c-red-dark)');
      return;
    }
    _mcpToken = data.token;
    document.getElementById('mcp-token-display').textContent = data.token;
    document.getElementById('mcp-token-display').style.display = 'block';
    document.getElementById('mcp-copy-token-btn').style.display = 'inline-flex';
    showMcpStatus(t('mcp.keyGenerated'), 'var(--c-green-dark)');
  } catch (e) {
    showMcpStatus(t('mcp.error').replace('{msg}', e.message), 'var(--c-red-dark)');
  }
}
async function revokeMcpToken() {
  if (!(await askConfirm(t('mcp.revokeKey'), t('mcp.revokeKeyConfirm'), t('mcp.revokeKey')))) return;
  try {
    const r = await authFetch('/api/mcp/token', { method: 'DELETE' });
    const data = await r.json();
    if (data.error) {
      showMcpStatus(t('mcp.error').replace('{msg}', data.error), 'var(--c-red-dark)');
      return;
    }
    _mcpToken = null;
    document.getElementById('mcp-token-display').textContent = '';
    document.getElementById('mcp-token-display').style.display = 'none';
    document.getElementById('mcp-copy-token-btn').style.display = 'none';
    showMcpStatus(t('mcp.keyRevoked'), 'var(--c-green-dark)');
  } catch (e) {
    showMcpStatus(t('mcp.error').replace('{msg}', e.message), 'var(--c-red-dark)');
  }
}

async function runMcpDiagnostics() {
  const el = document.getElementById('mcp-diag-result');
  el.innerHTML = '<p style="color:var(--c-text-muted)">' + t('mcp.diagRunning') + '</p>';
  try {
    const r = await authFetch('/api/mcp/diagnostics');
    if (!r.ok) {
      el.innerHTML = '<p style="color:var(--c-red-dark)">' + t('mcp.diagFailed') + '</p>';
      return;
    }
    const d = await r.json();
    let html = '<table class="fs-meta" style="width:100%;border-collapse:collapse">';
    const row = (label, val, color) =>
      '<tr><td style="padding:4px 8px;font-weight:600;white-space:nowrap;vertical-align:top">' +
      label +
      '</td><td style="padding:4px 8px;color:' +
      (color || '#333') +
      '">' +
      val +
      '</td></tr>';
    const checks = d.checks || {};
    for (const [k, v] of Object.entries(checks)) {
      const pass = v.startsWith('PASS');
      html += row(k, esc(v), pass ? 'var(--c-green-dark)' : 'var(--c-red-dark)');
    }
    html += row('Protocol', esc(d.protocol));
    html += row(
      'Base URL',
      '<code class="fs-xs" style="background:#f1f5f9;padding:1px 4px;border-radius:3px">' +
        esc(d.connectorUrl) +
        '</code>'
    );
    html += row(t('mcp.diagAutoClients'), String(d.oauthClients?.auto || 0));
    html += row(t('mcp.diagManualClients'), String(d.oauthClients?.manual || 0));
    html += row(t('mcp.diagSessions'), String(d.activeSessions || 0));
    html += '</table>';
    if (d.hint)
      html +=
        '<div class="fs-xs" style="margin-top:8px;padding:8px 10px;border-radius:6px;background:var(--c-primary-light);border:1px solid var(--c-green-border);color:var(--c-green-dark)">' +
        esc(d.hint) +
        '</div>';
    el.innerHTML = html;
  } catch (e) {
    el.innerHTML = '<p style="color:var(--c-red-dark)">Error: ' + esc(e.message) + '</p>';
  }
}

// ─── OAUTH CLIENT MANAGEMENT ────────────────────────────────
function showOAuthStatus(msg, color) {
  const el = document.getElementById('oauth-client-status');
  el.style.display = 'block';
  el.style.color = color || '#888';
  el.textContent = msg;
  setTimeout(() => {
    el.style.display = 'none';
  }, 8000);
}
async function loadOAuthClients() {
  try {
    const r = await authFetch('/api/mcp/oauth-clients');
    if (!r.ok) return;
    const data = await r.json();
    const list = document.getElementById('oauth-client-list');
    if (!list) return;
    if (!data.clients || data.clients.length === 0) {
      list.innerHTML = '<p class="fs-meta" style="color:var(--c-text-muted)">' + t('mcp.noClients') + '</p>';
      return;
    }
    list.innerHTML =
      '<table class="fs-meta" style="width:100%;border-collapse:collapse"><thead><tr>' +
      '<th style="text-align:left;padding:6px;border-bottom:1px solid var(--c-border)">' +
      t('mcp.clientName') +
      '</th>' +
      '<th style="text-align:left;padding:6px;border-bottom:1px solid var(--c-border)">Client ID</th>' +
      '<th style="text-align:left;padding:6px;border-bottom:1px solid var(--c-border)">' +
      t('mcp.created') +
      '</th>' +
      '<th style="text-align:left;padding:6px;border-bottom:1px solid var(--c-border)">' +
      t('mcp.activeSessions') +
      '</th>' +
      '<th style="padding:6px;border-bottom:1px solid var(--c-border)"></th></tr></thead><tbody>' +
      data.clients
        .map((c) => {
          const name = c.clientName || t('mcp.unnamed');
          return (
            '<tr>' +
            '<td style="padding:6px">' +
            esc(name) +
            '</td>' +
            '<td style="padding:6px;font-family:monospace">' +
            esc(c.clientId.slice(0, 8)) +
            '…</td>' +
            '<td style="padding:6px">' +
            esc(c.created ? c.created.slice(0, 10) : '') +
            '</td>' +
            '<td style="padding:6px;text-align:center">' +
            c.activeSessions +
            '</td>' +
            '<td style="padding:6px"><button class="btn btn-sm fs-xs" style="padding:2px 8px;color:var(--c-red-dark)" data-oauth-action="delete" data-client-id="' +
            esc(c.clientId) +
            '" data-auto="' +
            (c.autoRegistered ? 1 : 0) +
            '">' +
            t('mcp.deleteClient') +
            '</button></td></tr>'
          );
        })
        .join('') +
      '</tbody></table>';
    list.onclick = function (e) {
      const btn = e.target.closest('[data-oauth-action="delete"]');
      if (!btn) return;
      deleteOAuthClient(btn.dataset.clientId, btn.dataset.auto === '1');
    };
  } catch (e) {
    console.error('loadOAuthClients:', e);
  }
}
async function deleteOAuthClient(clientId, isAuto) {
  const frage = isAuto ? t('mcp.confirmDeleteAuto') : t('mcp.confirmDelete');
  if (!(await askConfirm(t('mcp.deleteClient'), frage, t('mcp.deleteClient')))) return;
  try {
    const r = await authFetch('/api/mcp/oauth-clients/' + encodeURIComponent(clientId), { method: 'DELETE' });
    const data = await r.json();
    if (data.error) {
      showOAuthStatus(t('mcp.error').replace('{msg}', data.error), 'var(--c-red-dark)');
      return;
    }
    showOAuthStatus(t('mcp.clientDeleted'), 'var(--c-green-dark)');
    loadOAuthClients();
  } catch (e) {
    showOAuthStatus(t('mcp.error').replace('{msg}', e.message), 'var(--c-red-dark)');
  }
}

// ─── SCAN LOG ────────────────────────────────────────────────
let logSortCol = 'time',
  logSortDir = 'desc',
  logDisplayLimit = 200;
function toggleLogSort(col) {
  if (logSortCol === col) logSortDir = logSortDir === 'desc' ? 'asc' : 'desc';
  else {
    logSortCol = col;
    logSortDir = 'desc';
  }
  renderLog();
}
function renderLog() {
  const q = (document.getElementById('log-q').value || '').toLowerCase();
  const actionF = document.getElementById('log-action-filter').value;
  const dateFrom = document.getElementById('log-date-from').value;
  const dateTo = document.getElementById('log-date-to').value;
  const body = document.getElementById('log-body');
  // The ✕ used to be an inline onclick with the row's values pasted into it.
  // esc() is right for markup but not for that: inside an attribute the parser
  // turns &#39; back into ' before the JavaScript is compiled, so a value that
  // merely *looked* escaped ran as code. Reading the values back out of
  // data-* attributes keeps them data — a string the browser hands over, never
  // something it compiles. Wired once, because renderLog() replaces the rows
  // but not the container they sit in.
  if (body && !body._lgDelWired) {
    body._lgDelWired = true;
    body.addEventListener('click', (ev) => {
      const btn = ev.target.closest && ev.target.closest('.lg-del');
      if (!btn || !body.contains(btn)) return;
      deleteLogEntry(btn, btn.dataset.time, btn.dataset.batch, btn.dataset.action, btn.dataset.bag);
    });
  }
  let items = [...scanLog];
  // Filters
  if (q) items = items.filter((e) => JSON.stringify(e).toLowerCase().includes(q));
  if (actionF) items = items.filter((e) => e.action === actionF);
  if (dateFrom) items = items.filter((e) => e.time >= dateFrom);
  if (dateTo) items = items.filter((e) => e.time < dateTo + 'T23:59:59');
  // Sort
  const dir = logSortDir === 'desc' ? -1 : 1;
  items.sort((a, b) => {
    const av = a[logSortCol] || '',
      bv = b[logSortCol] || '';
    return av < bv ? -dir : av > bv ? dir : 0;
  });
  // Sort indicators
  document.querySelectorAll('[id^="log-sort-"]').forEach((el) => (el.textContent = ''));
  const si = document.getElementById('log-sort-' + logSortCol);
  if (si) si.textContent = logSortDir === 'desc' ? '▼' : '▲';
  // Count display
  const total = scanLog.length,
    filtered = items.length;
  const countEl = document.getElementById('log-count');
  if (countEl)
    countEl.textContent =
      filtered === total ? t('log.entries', { n: total }) : t('log.entriesFiltered', { n: filtered, total: total });
  // Paginate
  const hasMore = items.length > logDisplayLimit;
  items = items.slice(0, logDisplayLimit);
  const now = Date.now(),
    h24 = 24 * 60 * 60 * 1000;
  body.innerHTML = items.length
    ? items
        .map((e) => {
          const isRecent = now - new Date(e.time).getTime() < h24;
          return `<tr><td data-mlabel="${esc(t('settings.time'))}" class="lg-time fs-micro" style="color:var(--c-text-muted)">${fmtDtTime(e.time)}</td><td class="fs-xs" data-mlabel="${esc(t('settings.user'))}">${esc(e.user) || '\u2014'}</td><td data-mlabel="${esc(t('settings.action'))}"><span class="badge ${e.action === 'ADD' ? 'b-add' : e.action === 'REMOVE' ? 'b-remove' : e.action === 'HARVEST' ? 'b-harvest' : 'b-move'}">${esc(e.action)}</span></td><td class="fs-micro" data-mlabel="${esc(t('batch.batchId'))}" style="font-family:monospace">${esc(e.batch) || '\u2014'}</td><td class="fs-micro" data-mlabel="${esc(t('settings.bag'))}" style="font-family:monospace">${esc(e.bag) || '\u2014'}</td><td data-mlabel="${esc(t('settings.from'))}">${esc(e.from) || '\u2014'}</td><td data-mlabel="${esc(t('settings.to'))}">${esc(e.to) || '\u2014'}</td><td data-mlabel="${esc(t('batch.species'))}">${e.species ? spDot(e.species) + esc(e.species) : '\u2014'}</td><td class="lg-actions">${isRecent ? '<button class="btn-xs lg-del fs-micro" style="padding:2px 6px" data-time="' + esc(e.time) + '" data-batch="' + esc(e.batch || '') + '" data-action="' + esc(e.action) + '" data-bag="' + esc(e.bag || '') + '" title="' + esc(t('common.delete')) + '">✕</button>' : ''}</td></tr>`;
        })
        .join('')
    : '<tr><td colspan="9" class="empty">' + t('settings.noScans') + '</td></tr>';
  const loadMore = document.getElementById('log-load-more');
  if (loadMore) loadMore.style.display = hasMore ? 'block' : 'none';
}
function deleteLogEntry(btn, time, batch, action, bag) {
  confirm2(
    t('log.deleteEntry'),
    t('log.deleteEntryMsg', { action: action, batch: batch, time: fmtDtTime(time) }),
    t('common.delete'),
    () => {
      // Match on bag too: a bulk ADD/MOVE writes the same time+batch+action to
      // every bag, so without the bag the ✕ on one row deleted the first
      // matching row (and its server id) instead of the clicked one.
      const match = (e) => e.time === time && e.batch === batch && e.action === action && (e.bag || '') === bag;
      const idx = scanLog.findIndex(match);
      if (idx === -1) return;
      const entry = scanLog[idx];
      scanLog.splice(idx, 1);
      const mi = movements.findIndex(match);
      if (mi !== -1) movements.splice(mi, 1);
      const serverId = entry._serverId || entry.id;
      if (serverId) apiDelete('/api/scan-log/' + serverId);
      renderLog();
      renderStatus();
    }
  );
}
function clearLog() {
  confirm2(
    t('settings.clearLog'),
    t('settings.clearLogMsg', { n: scanLog.length }),
    t('settings.clearLogBtn'),
    async () => {
      await apiDelete('/api/scan-log');
      scanLog = [];
      renderLog();
    }
  );
}

// ─── INVENTORY ───────────────────────────────────────────────
const MAT_LABELS = { hardwood: 'Hardwood pellets', wheatbran: 'Wheat bran', gypsum: 'Gypsum', grain: 'Grain', corn: 'Corn meal', calcium: 'Calcium carbonate' };
const MAT_COLORS = { hardwood: '#92400e', wheatbran: '#166534', gypsum: '#1e40af', grain: '#6b21a8', corn: '#a16207', calcium: '#475569' };
const MAT_BG = { hardwood: '#fff7ed', wheatbran: '#f0fdf4', gypsum: '#eff6ff', grain: '#faf5ff', corn: '#fefce8', calcium: '#f8fafc' };
const MAT_BORDER = { hardwood: '#fed7aa', wheatbran: '#bbf7d0', gypsum: '#bfdbfe', grain: '#e9d5ff', corn: '#fef08a', calcium: '#cbd5e1' };

// Wie weit zurück gezählt wird, um zu gewichten. Kurz genug, dass eine
// Umstellung im Sortiment durchschlägt, lang genug, dass eine ruhige Woche
// den Durchschnitt nicht kippt.
const AVG_FENSTER_TAGE = 90;

// Beutel je Sorte im Fenster — das Gewicht, mit dem ihr Rezept zählt.
function _avgGewichte() {
  const grenze = Date.now() - AVG_FENSTER_TAGE * 86400000;
  const w = {};
  for (const b of batches) {
    if (!b.strainId) continue;
    const t = Date.parse(b.created);
    if (!Number.isFinite(t) || t < grenze) continue;
    w[b.strainId] = (w[b.strainId] || 0) + (Number(b.qty) || 0);
  }
  return w;
}

// Gewichtetes Mittel eines Rezeptfeldes. Null, wenn keine Sorte einen
// brauchbaren Wert beisteuert — dann greift die nächste Stufe.
function _avgMittel(sorten, feld, gewicht) {
  let summe = 0;
  let gesamt = 0;
  for (const s of sorten) {
    const v = Number(s[feld]);
    if (!Number.isFinite(v) || v <= 0) continue;
    const g = gewicht(s);
    if (!(g > 0)) continue;
    summe += v * g;
    gesamt += g;
  }
  return gesamt > 0 ? summe / gesamt : null;
}

// Der Durchschnitt für die Lagerschätzung — gerechnet, nicht getippt.
//
// Vier Stufen, absteigend: nach der Produktion der letzten 90 Tage gewichtet;
// sonst jedes Rezept gleich; sonst der zuletzt gespeicherte Wert; sonst die
// eingebaute Vorgabe. `quelle` sagt der Oberfläche, welche Stufe gegriffen hat,
// damit dort nicht einfach eine Zahl ohne Herkunft steht.
function getAvgComp() {
  const gespeichert = inventory.avgComposition || {};
  const gew = _avgGewichte();
  const nachProduktion = Object.keys(gew).length > 0;
  const g = (s) => (nachProduktion ? gew[s.id] || 0 : 1);
  const alle = (mushroomStrains || []).filter((s) => s.recBatchType);
  // Holz und Kleie nur aus Block-Rezepten: eine CVG-Sorte hat ihre Masse im
  // Kokos und würde den Schnitt nach unten ziehen, obwohl sie kein Holz nimmt.
  const bloecke = alle.filter((s) => s.recBatchType !== 'grain' && (s.recSubstrate || 'holzkleie') !== 'cvg');
  let quelle = nachProduktion ? 'produktion' : 'rezepte';
  const stufe = (sorten, feld) => {
    const w = _avgMittel(sorten, feld, g);
    if (w != null) return w;
    const m = _avgMittel(sorten, feld, () => 1);
    if (m != null && quelle === 'produktion') quelle = 'rezepte';
    return m;
  };
  const _gyp = _avgMittel(bloecke, 'recGypsumPct', g) ?? _avgMittel(bloecke, 'recGypsumPct', () => 1);
  const nimm = (wert, schluessel, vorgabe) => {
    if (wert != null) return Math.round(wert * 10) / 10;
    quelle = 'gespeichert';
    return gespeichert[schluessel] ?? vorgabe;
  };
  return {
    hwPct: nimm(stufe(bloecke, 'recHardwoodPct'), 'hwPct', 75),
    wbPct: nimm(stufe(bloecke, 'recWheatbranPct'), 'wbPct', 25),
    rhPct: nimm(stufe(bloecke, 'recRhPct'), 'rhPct', 63),
    bagKg: nimm(stufe(bloecke, 'recBagKg'), 'bagKg', NB_BAG_KG_DEFAULT),
    // Kein Rezeptfeld trägt die Größe einer Körnerbrut-Tüte. Die bleibt als
    // Einstellung stehen, und nur die.
    grainBagKg: gespeichert.grainBagKg ?? 1,
    // Gips stand als einziger Anteil dieser Schätzung fest eingebaut auf 1 %,
    // obwohl rec_gypsum_pct daneben liegt und der Mischlauf ihn längst liest.
    // Gemittelt wird wie oben, aber an `quelle` vorbei: die meisten Rezepte
    // führen Gips als Flag ohne Zahl, und ein fehlender Gipsanteil sagt nichts
    // darüber, woher Holz, Kleie und Blockgewicht kommen. Trägt kein Rezept
    // einen Anteil, bleibt es bei 1 % — dann rechnet die Schätzung wie bisher.
    gypPct: _gyp != null ? Math.round(_gyp * 10) / 10 : (gespeichert.gypPct ?? 1),
    grainRhPct: nimm(stufe(alle, 'recGrainRhPct'), 'grainRhPct', 52),
    quelle,
    rezepte: bloecke.length,
    beutel: Object.values(gew).reduce((s, n) => s + n, 0)
  };
}

function estBagsFromMat(mat, stockKg) {
  // Estimate how many fruiting blocks (or grain bags) can be made from this material
  // For HW/WB: dry matter per bag = bagKg × (1 − rh/100), split by avg %
  // For grain: dry grain per bag = grainBagKg × (1 − grainRhPct/100); stock is dry.
  // Gypsum rides on the same dry matter, at the share the recipes carry.
  const c = getAvgComp();
  if (mat === 'grain') {
    const dryPerGrainBag = c.grainBagKg * (c.grainRhPct > 0 ? 1 - c.grainRhPct / 100 : 1);
    return {
      bags: dryPerGrainBag > 0 ? Math.floor(stockKg / dryPerGrainBag) : 0,
      bagKg: c.grainBagKg,
      isGrain: true
    };
  }
  const dryPerBag = mtDryKg(c.bagKg, c.rhPct); // dry matter per bag
  let matPerBag = 0;
  if (mat === 'hardwood') matPerBag = dryPerBag * (c.hwPct / 100);
  if (mat === 'wheatbran') matPerBag = dryPerBag * (c.wbPct / 100);
  if (mat === 'gypsum') matPerBag = dryPerBag * (c.gypPct / 100);
  // Maismehl und Calciumcarbonat haben keinen Durchschnittsanteil, aus dem sich
  // schätzen ließe. null heißt "keine Schätzung" — "reicht für ~0 Blöcke" las
  // sich bei 10 kg im Regal wie ein leerer Bestand.
  if (!['hardwood', 'wheatbran', 'gypsum'].includes(mat)) {
    return { bags: null, matPerBag: 0, bagKg: c.bagKg, isGrain: false };
  }
  const bags = matPerBag > 0 ? Math.floor(stockKg / matPerBag) : 0;
  return { bags, matPerBag, bagKg: c.bagKg, isGrain: false };
}

function renderInvStock() {
  if (!inventory.stock) inventory.stock = { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0 };
  if (!inventory.thresholds)
    inventory.thresholds = {
      hardwood: { minKg: 50 },
      wheatbran: { minKg: 20 },
      gypsum: { minKg: 5 },
      grain: { minKg: 10 }
    };
  if (!inventory.avgComposition)
    inventory.avgComposition = { hwPct: 75, wbPct: 25, rhPct: 63, bagKg: 3, grainBagKg: 1, grainRhPct: 52 };

  const cards = document.getElementById('inv-cards');
  cards.innerHTML = Object.keys(MAT_LABELS)
    .map((mat) => {
      const stock = inventory.stock[mat] || 0;
      const thresh = inventory.thresholds[mat] || { minKg: 0 };
      const low = thresh.minKg > 0 && stock < thresh.minKg;
      const { bags, bagKg, matPerBag, isGrain } = estBagsFromMat(mat, stock);
      const pct =
        thresh.minKg > 0
          ? Math.min(100, Math.round((stock / Math.max(stock, thresh.minKg * 3)) * 100))
          : Math.min(100, Math.round((stock / Math.max(stock, 100)) * 100));
      const estNote = isGrain
        ? t('inv.grainBagsEst', { n: bags, kg: bagKg })
        : bags == null
          ? ''
          : t('inv.blocksEst', { n: '<strong>' + bags + '</strong>', kg: bagKg }) +
          ' <span class="fs-micro" style="color:var(--c-text-muted)">' +
          t('inv.avgEstimate') +
          '</span>';
      return `<div style="background:${MAT_BG[mat]};border:1px solid ${low ? 'var(--c-red)' : MAT_BORDER[mat]};border-radius:10px;padding:14px 16px">
      <div style="display:flex;align-items:center;justify-content:space-between;margin-bottom:6px">
        <div class="fs-meta" style="font-weight:600;color:${MAT_COLORS[mat]}">${MAT_LABELS[mat]}</div>
        ${low ? `<span class="fs-micro" style="background:var(--c-red-light);color:var(--c-red-dark);padding:2px 7px;border-radius:99px;font-weight:600">${t('inv.lowStock')}</span>` : ''}
      </div>
      <div class="fs-floor" style="--fs-own:1.625rem;font-weight:700;color:var(--c-text);margin-bottom:2px">${stock.toFixed(1)} <span class="fs-floor" style="--fs-own:0.875rem;font-weight:400;color:var(--c-text-muted)">kg</span></div>
      <div style="height:5px;border-radius:3px;background:rgba(0,0,0,.08);overflow:hidden;margin-bottom:8px">
        <div style="height:100%;border-radius:3px;background:${low ? 'var(--c-red)' : MAT_COLORS[mat]};width:${pct}%;transition:width .3s"></div>
      </div>
      <div class="fs-meta" style="color:var(--c-text-sec);line-height:1.6">${estNote}</div>
      ${thresh.minKg > 0 ? `<div class="fs-xs" style="color:${low ? 'var(--c-red-dark)' : 'var(--c-text-muted)'};margin-top:2px">${t('inv.alertBelow', { n: thresh.minKg })}</div>` : ''}
      <button class="btn btn-sm fs-xs" onclick="openStab('inv','delivery')" style="margin-top:8px">${t('inv.logDelivery')}</button>
      ${(() => {
        const sups = getSuppliersForMat(mat);
        if (!sups.length) return '';
        return `<div class="fs-xs" style="margin-top:8px;padding-top:6px;border-top:1px solid rgba(0,0,0,.06);color:var(--c-text-sec)">
          <span style="font-weight:600;color:${low ? 'var(--c-red-dark)' : 'var(--c-text-muted)'}">${low ? t('inv.reorderFrom') : t('inv.suppliers')}:</span>
          ${sups.map((s) => (safeHref(s.url) ? `<a href="${safeHref(s.url)}" target="_blank" rel="noopener" style="color:var(--c-blue);margin-left:4px">${esc(s.name)}</a>` : `<span style="margin-left:4px">${esc(s.name)}</span>`)).join(',')}
        </div>`;
      })()}
    </div>`;
    })
    .join('');
  renderThresholds();
}

function renderThresholds() {
  const el = document.getElementById('inv-thresholds');
  if (!el) return;
  const c = getAvgComp();

  // Per-material alert thresholds
  const threshHtml = `<div style="overflow-x:auto;margin-bottom:16px"><table>
    <thead><tr><th>${t('inv.thMaterial')}</th><th>${t('inv.thInStock')}</th><th>${t('inv.thAlertBelow')}</th><th>${t('inv.thEstBags')}</th></tr></thead>
    <tbody>
    ${Object.keys(MAT_LABELS)
      .map((mat) => {
        const stock = inventory.stock[mat] || 0;
        const t = inventory.thresholds[mat] || { minKg: 0 };
        const { bags } = estBagsFromMat(mat, stock);
        return `<tr>
        <td style="font-weight:500;color:${MAT_COLORS[mat]}">${MAT_LABELS[mat]}</td>
        <td style="font-weight:600">${stock.toFixed(2)} kg</td>
        <td><input class="fs-meta" type="text" inputmode="decimal" value="${esc(t.minKg)}" style="width:80px;padding:3px 6px" onchange="updateThreshold('${mat}','minKg',this.value)" /></td>
        <td class="fs-meta" style="color:var(--c-text-sec)">${bags == null ? '–' : `~${bags} bags <span class="fs-micro" style="color:var(--c-text-muted)">(avg)</span>`}</td>
      </tr>`;
      })
      .join('')}
    </tbody>
  </table></div>`;

  // Average composition settings
  const compHtml = `<div style="background:var(--c-bg);border-radius:8px;padding:12px">
    <div class="fs-xs" style="font-weight:600;color:var(--c-text-muted);text-transform:uppercase;letter-spacing:.07em;margin-bottom:10px">
      ${t('inv.avgCompTitle')}
    </div>
    <p class="fs-meta" style="color:var(--c-text-muted);margin-bottom:10px;line-height:1.6">
      ${t('inv.avgCompDesc')}
    </p>
    <div class="g6" style="gap:8px">
      ${[
        ['inv.hwPct', c.hwPct, '%'],
        ['inv.wbPct', c.wbPct, '%'],
        ['inv.gypsumPct', c.gypPct, '%'],
        ['inv.waterPct', c.rhPct, '%'],
        ['inv.blockWeight', c.bagKg, 'kg'],
        ['inv.grainWaterPct', c.grainRhPct, '%']
      ]
        .map(
          ([k, v, e]) =>
            `<div><label class="fs-xs">${t(k)}</label>
               <div class="avg-wert">${esc(String(v))}<span class="avg-einheit">${e}</span></div></div>`
        )
        .join('')}
      <div><label class="fs-xs">${t('inv.grainBagWeight')}</label>
        <input type="text" inputmode="decimal" value="${esc(c.grainBagKg)}" class="fs-sm" style="padding:5px 8px" onchange="updateAvgComp('grainBagKg',this.value)" /></div>
    </div>
    <div class="fs-xs" style="margin-top:8px;color:var(--c-text-muted);line-height:1.7">
      <div>${esc(
        c.quelle === 'produktion'
          ? t('inv.avgFromProduction', { n: c.rezepte, bags: c.beutel, days: AVG_FENSTER_TAGE })
          : c.quelle === 'rezepte'
            ? t('inv.avgFromRecipes', { n: c.rezepte })
            : t('inv.avgFromStored')
      )}</div>
      <div>${esc(
        t('inv.avgCompNote', {
          bag: c.bagKg,
          hw: (mtDryKg(c.bagKg, c.rhPct) * (c.hwPct / 100)).toFixed(3),
          wb: (mtDryKg(c.bagKg, c.rhPct) * (c.wbPct / 100)).toFixed(3),
          rh: c.rhPct,
          gbag: c.grainBagKg,
          grain: mtDryKg(c.grainBagKg, c.grainRhPct).toFixed(3),
          grh: c.grainRhPct
        })
      )}</div>
    </div>
  </div>`;
  el.innerHTML = threshHtml + compHtml;
}

// Nur noch die Körnerbrut-Tüte: alles andere kommt aus den Rezepten und ließe
// sich hier nur scheinbar ändern.
function updateAvgComp(key, val) {
  if (key !== 'grainBagKg') return;
  if (!inventory.avgComposition) inventory.avgComposition = {};
  inventory.avgComposition[key] = parseDecimal(val) || 0;
  saveInvConfig();
  renderInvStock();
}

function updateThreshold(mat, key, val) {
  if (!inventory.thresholds) inventory.thresholds = {};
  if (!inventory.thresholds[mat]) inventory.thresholds[mat] = { minKg: 0 };
  inventory.thresholds[mat][key] = parseDecimal(val) || 0;
  saveInvConfig();
  renderInvStock();
}

function delMatChange() {
  const mat = document.getElementById('del-mat').value;
  const stock = inventory.stock?.[mat] || 0;
  document.getElementById('del-current').textContent = t('inv.currentStock', { n: stock.toFixed(2) });
  document.getElementById('del-kg').value = '';
  document.getElementById('del-preview').style.display = 'none';
}
function delPreview() {
  const mat = document.getElementById('del-mat').value;
  const kg = parseDecimal(document.getElementById('del-kg').value) || 0;
  const el = document.getElementById('del-preview');
  if (!kg) {
    el.style.display = 'none';
    return;
  }
  const cur = inventory.stock?.[mat] || 0;
  el.innerHTML =
    t('inv.afterDeliveryLabel') +
    '<strong>' +
    (cur + kg).toFixed(2) +
    ' kg</strong> (' +
    cur.toFixed(2) +
    ' + ' +
    kg +
    ' kg)';
  el.style.display = 'block';
}
function adjMatChange() {
  const mat = document.getElementById('adj-mat').value;
  const stock = inventory.stock?.[mat] || 0;
  document.getElementById('adj-current').textContent = t('inv.currentStock', { n: stock.toFixed(2) });
  document.getElementById('adj-absolute').value = '';
  document.getElementById('adj-delta').value = '';
  document.getElementById('adj-preview').style.display = 'none';
}
function adjPreview(mode) {
  const mat = document.getElementById('adj-mat').value;
  const cur = inventory.stock?.[mat] || 0;
  const el = document.getElementById('adj-preview');
  let newVal, diff;
  if (mode === 'absolute') {
    const abs = parseDecimal(document.getElementById('adj-absolute').value);
    if (isNaN(abs)) {
      el.style.display = 'none';
      return;
    }
    document.getElementById('adj-delta').value = '';
    newVal = Math.max(0, abs);
    diff = newVal - cur;
    el.innerHTML =
      t('inv.setToLabel') +
      '<strong>' +
      newVal.toFixed(2) +
      ' kg</strong> ' +
      (diff >= 0 ? '+' : '') +
      diff.toFixed(2) +
      t('inv.kgFromCurrent');
  } else {
    const delta = parseDecimal(document.getElementById('adj-delta').value);
    if (isNaN(delta)) {
      el.style.display = 'none';
      return;
    }
    document.getElementById('adj-absolute').value = '';
    newVal = Math.max(0, cur + delta);
    diff = delta;
    el.innerHTML =
      t('inv.newTotalLabel') +
      '<strong>' +
      newVal.toFixed(2) +
      ' kg</strong> (' +
      (diff >= 0 ? '+' : '') +
      diff.toFixed(2) +
      ' kg)';
  }
  el.style.display = 'block';
}
function logDelivery() {
  const mat = document.getElementById('del-mat').value;
  const kg = parseDecimal(document.getElementById('del-kg').value) || 0;
  const note = document.getElementById('del-note').value.trim();
  if (kg <= 0) {
    fieldError('del-kg', t('inv.enterQty'));
    return;
  }
  if (!inventory.stock) inventory.stock = { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0 };
  const prev = inventory.stock[mat] || 0;
  inventory.stock[mat] = prev + kg;
  document.getElementById('del-kg').value = '';
  document.getElementById('del-note').value = '';
  document.getElementById('del-preview').style.display = 'none';
  openStab('inv', 'stock');
  renderInvStock();
  // Confirm only once the server has it. /api/inventory/delta is NOT in the
  // service worker's offline queue (that covers scan-log and contamination
  // reports only), so an offline booking is simply lost — and the optimistic
  // local number is overwritten by the next poll. Reporting success for a
  // delivery that never landed is how stock silently drifts from the floor.
  invDelta(mat, kg, 'delivery', note || 'delivery').then((r) => {
    if (r && r.error) {
      inventory.stock[mat] = prev;
      renderInvStock();
      setFb('err', t('inv.deliveryFailed', { err: r.error }));
      return;
    }
    setFb(
      'ok',
      'Delivery logged: +' + kg + 'kg ' + MAT_LABELS[mat] + ' now ' + inventory.stock[mat].toFixed(2) + 'kg total'
    );
  });
}
function logAdjustment() {
  const mat = document.getElementById('adj-mat').value;
  const absVal = document.getElementById('adj-absolute').value;
  const deltaVal = document.getElementById('adj-delta').value;
  const reason = document.getElementById('adj-reason').value.trim() || 'Manual adjustment';
  if (!inventory.stock) inventory.stock = { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0 };
  const cur = inventory.stock[mat] || 0;
  let newStock, delta;
  if (absVal !== '') {
    newStock = Math.max(0, parseDecimal(absVal) || 0);
    delta = newStock - cur;
  } else if (deltaVal !== '') {
    delta = parseDecimal(deltaVal) || 0;
    newStock = Math.max(0, cur + delta);
  } else {
    // Neither box filled in, so point at the absolute one — it is the first of
    // the pair and the one that needs no arithmetic to use.
    fieldError('adj-absolute', t('inv.enterAmount'));
    return;
  }
  const prevStock = inventory.stock[mat] || 0;
  inventory.stock[mat] = newStock;
  document.getElementById('adj-absolute').value = '';
  document.getElementById('adj-delta').value = '';
  document.getElementById('adj-reason').value = '';
  document.getElementById('adj-preview').style.display = 'none';
  openStab('inv', 'stock');
  renderInvStock();
  // Same as logDelivery: /api/inventory/set has no offline queue, so confirm
  // only after the server accepts it. A stocktake correction reported as saved
  // and then silently reverted by the next poll is worse than an error.
  invSetAbsolute(mat, newStock, 'adjustment', reason).then((r) => {
    if (r && r.error) {
      inventory.stock[mat] = prevStock;
      renderInvStock();
      setFb('err', t('inv.adjustFailed', { err: r.error }));
      return;
    }
    setFb(
      'ok',
      'Adjusted ' +
        MAT_LABELS[mat] +
        ': ' +
        (delta >= 0 ? '+' : '') +
        delta.toFixed(2) +
        'kg now ' +
        newStock.toFixed(2) +
        'kg'
    );
  });
}

function renderInvLog() {
  const filter = document.getElementById('inv-log-filter').value;
  const body = document.getElementById('inv-log-body');
  if (!inventory.log || !inventory.log.length) {
    body.innerHTML = '<tr><td colspan="6" class="empty">' + t('inv.noUsageHistory') + '</td></tr>';
    return;
  }
  const rows = [...inventory.log]
    .reverse()
    .filter((e) => filter === 'all' || e.mat === filter)
    .slice(0, 200);
  // Build running totals per material going forwards for display
  body.innerHTML = rows
    .map(
      (e) => `<tr>
    <td class="fs-micro" style="color:var(--c-text-muted)">${fmtDtTime(e.time)}</td>
    <td style="color:${MAT_COLORS[e.mat]};font-weight:500">${MAT_LABELS[e.mat]}</td>
    <td style="font-weight:600;color:${e.deltaKg < 0 ? 'var(--c-red-dark)' : 'var(--c-green-dark)'}">${e.deltaKg > 0 ? '+' : ''}${e.deltaKg.toFixed(2)} kg</td>
    <td class="fs-xs">${(e.running || 0).toFixed(1)} kg</td>
    <td><span class="badge ${e.type === 'delivery' ? 'b-add' : e.type === 'adjustment' ? 'b-move' : 'b-harvest'}">${esc(e.type)}</span></td>
    <td class="fs-xs" style="color:var(--c-text-sec)">${esc(e.ref) || '—'}</td>
  </tr>`
    )
    .join('');
}

// Show low-stock alerts in dashboard
function getInvAlerts() {
  if (!inventory.stock || !inventory.thresholds) return [];
  return Object.keys(MAT_LABELS)
    .filter((mat) => {
      const stock = inventory.stock[mat] || 0;
      const thresh = (inventory.thresholds[mat] || {}).minKg || 0;
      return thresh > 0 && stock < thresh;
    })
    .map((mat) => {
      const stock = inventory.stock[mat] || 0;
      const thresh = inventory.thresholds[mat].minKg;
      const { bags } = estBagsFromMat(mat, stock);
      const sups = getSuppliersForMat(mat);
      const supNote = sups.length ? ` — ${t('inv.reorderFrom')}: ${sups.map((s) => s.name).join(', ')}` : '';
      return {
        text: `Low stock: ${MAT_LABELS[mat]}`,
        detail: `${stock.toFixed(1)} kg remaining${bags == null ? '' : ` (≈${bags} bags)`} — below ${thresh}kg threshold${supNote}`,
        urgent: stock < thresh * 0.5,
        warn: true,
        species: null
      };
    });
}

// Show low lab stock alerts in dashboard
function getLabAlerts() {
  if (!inventory.labThresholds) return [];
  const counts = getLabStockCounts();
  const breakdown = getLabStrainBreakdown();
  const alerts = [];
  // Two floors, and they measure different things. labThresholds is about the
  // shelf as a whole, so it is compared against the total — for every type, as
  // it always was. The per-Sorte minimums v79 added are about one mushroom, and
  // were not read here at all: a Sorte sitting at zero slants with min_mc = 5
  // turned its tile red, raised a task, and still said nothing on the dashboard.
  // Applying the farm-wide number per Sorte instead would be the other error —
  // ten slants in total is not ten slants each.
  LAB_TYPES.forEach((type) => {
    const farmMin = inventory.labThresholds[type] || 0;
    const count = counts[type] || 0;
    if (farmMin > 0 && count < farmMin) {
      alerts.push({
        text: t('lab.lowLabAlert', { type: getLabLabel(type) }),
        detail: t('lab.belowMin', { n: count, min: farmMin }),
        urgent: count === 0,
        warn: true
      });
    }
    // Die Untergrenzen je Sorte liest buildLabMinTasks(), und nur die. Hier
    // standen sie ein zweites Mal: dieselbe Aufschlüsselung, dieselbe
    // Bedingung, und beide Ergebnisse landeten in derselben Tagesliste — eine
    // gerissene Untergrenze als zwei Zeilen. Schlimmer noch, diese Kopie
    // überging die Programm-Kennzeichnung, die die andere achtet, also blieb
    // eine geparkte Sorte hier stehen und rief jeden Tag weiter. Genau die
    // Dauerwarnung, gegen die v78 geschrieben wurde.
  });
  return alerts;
}

// ─── SUPPLIERS ───────────────────────────────────────────────
function renderSuppliers() {
  const el = document.getElementById('suppliers-list');
  if (!el) return;
  if (!suppliers.length) {
    el.innerHTML = `<p class="fs-sm" style="color:var(--c-text-muted)">${t('inv.noSuppliers')}</p>`;
    return;
  }
  const grouped = {};
  Object.keys(MAT_LABELS).forEach((m) => (grouped[m] = []));
  suppliers.forEach((s) => {
    if (grouped[s.mat]) grouped[s.mat].push(s);
  });
  el.innerHTML = Object.keys(MAT_LABELS)
    .map((mat) => {
      const list = grouped[mat];
      if (!list.length) return '';
      return `<div style="margin-bottom:16px">
      <div class="fs-meta" style="font-weight:600;color:${MAT_COLORS[mat]};margin-bottom:6px">${MAT_LABELS[mat]}</div>
      <div style="overflow-x:auto"><table>
        <thead><tr><th>${t('inv.supplierName')}</th><th>${t('inv.supplierUrl')}</th><th>${t('inv.supplierPhone')}</th><th>${t('inv.supplierNotes')}</th><th></th></tr></thead>
        <tbody>${list
          .map(
            (s) => `<tr>
          <td style="font-weight:500">${esc(s.name)}</td>
          <td>${safeHref(s.url) ? `<a class="fs-meta" href="${safeHref(s.url)}" target="_blank" rel="noopener" style="color:var(--c-blue)">${esc(s.url)}</a>` : esc(s.url) || '-'}</td>
          <td class="fs-meta">${s.phone ? esc(s.phone) : '-'}</td>
          <td class="fs-meta" style="color:var(--c-text-sec)">${s.notes ? esc(s.notes) : '-'}</td>
          <td style="white-space:nowrap">
            <button class="btn btn-sm fs-xs" onclick="editSupplier(${s.id})">${t('inv.editSupplier')}</button>
            <button class="btn btn-sm fs-xs" onclick="removeSupplier(${s.id})" style="color:var(--c-red-dark)">${t('inv.deleteSupplier')}</button>
          </td>
        </tr>`
          )
          .join('')}</tbody>
      </table></div>
    </div>`;
    })
    .join('');
}

function editSupplier(id) {
  const existing = id ? suppliers.find((s) => s.id === id) : null;
  const matOpts = Object.keys(MAT_LABELS)
    .map((m) => `<option value="${m}"${existing && existing.mat === m ? ' selected' : ''}>${MAT_LABELS[m]}</option>`)
    .join('');
  const html = `<div style="display:flex;flex-direction:column;gap:10px">
    <div><label>${t('inv.material')}</label><select id="sup-mat">${matOpts}</select></div>
    <div><label>${t('inv.supplierName')}</label><input type="text" id="sup-name" value="${existing ? esc(existing.name) : ''}" placeholder="e.g. Beispiel Pellets GmbH" /></div>
    <div><label>${t('inv.supplierUrl')}</label><input type="text" id="sup-url" value="${existing && existing.url ? esc(existing.url) : ''}" placeholder="https://..." /></div>
    <div><label>${t('inv.supplierPhone')}</label><input type="text" id="sup-phone" value="${existing && existing.phone ? esc(existing.phone) : ''}" placeholder="+49..." /></div>
    <div><label>${t('inv.supplierNotes')}</label><input type="text" id="sup-notes" value="${existing && existing.notes ? esc(existing.notes) : ''}" placeholder="e.g. order number, contact person" /></div>
  </div>`;
  document.getElementById('m-title').textContent = existing ? t('inv.editSupplier') : t('inv.addSupplier');
  document.getElementById('m-body').innerHTML = html;
  document.getElementById('m-ok').textContent = existing ? t('inv.editSupplier') : t('inv.addSupplier');
  confirmCb = async () => {
    const s = {
      mat: document.getElementById('sup-mat').value,
      name: document.getElementById('sup-name').value.trim(),
      url: document.getElementById('sup-url').value.trim(),
      phone: document.getElementById('sup-phone').value.trim(),
      notes: document.getElementById('sup-notes').value.trim()
    };
    if (!s.name) {
      fieldError('sup-name', t('zones.nameRequired'));
      return;
    }
    if (existing) s.id = existing.id;
    const r = await apiPost('/api/suppliers', s);
    if (r && r.id && !existing) {
      s.id = r.id;
      suppliers.push(s);
    } else if (existing) {
      Object.assign(existing, s);
    }
    renderSuppliers();
    renderInvStock();
    setFb('ok', t('inv.supplierSaved'));
  };
  document.getElementById('m-confirm').classList.add('open');
}

// ── Pickup locations ────────────────────────────────────────
// Retired ones stay in the table, greyed out. A calendar event may still point
// at one, and a list that hides it turns "the market we stopped doing" into a
// blank field nobody can explain.
//
// The buttons are wired by delegation rather than the `onclick="fn(id)"` this
// file otherwise uses. Not a style preference: a handler only ever named inside
// an HTML string is invisible to ESLint, so each one costs a permanent
// "defined but never used" warning, and the lint budget is a deliberate ratchet
// (see eslint.config.js — 14 of the existing warnings are exactly this).
function renderPickupLocations() {
  const el = document.getElementById('pickuploc-list');
  if (!el) return;
  if (!el.dataset.wired) {
    el.dataset.wired = '1';
    el.addEventListener('click', (e) => {
      const btn = e.target.closest('button[data-act]');
      if (!btn) return;
      const id = Number(btn.dataset.id);
      if (btn.dataset.act === 'edit') editPickupLocation(id);
      else if (btn.dataset.act === 'retire') retirePickupLocation(id);
      else if (btn.dataset.act === 'reactivate') setPickupLocationActive(id, true);
    });
  }
  if (!pickupLocations.length) {
    el.innerHTML = `<p class="fs-sm" style="color:var(--c-text-muted)">${t('pickupLoc.none')}</p>`;
    return;
  }
  el.innerHTML = `<div style="overflow-x:auto"><table>
    <thead><tr><th>${t('pickupLoc.name')}</th><th>${t('pickupLoc.address')}</th><th>${t('pickupLoc.order')}</th><th></th></tr></thead>
    <tbody>${pickupLocations
      .map(
        (l) => `<tr${l.active ? '' : ' style="opacity:.55"'}>
      <td style="font-weight:500">${esc(l.name)}${l.active ? '' : ` <span class="fs-xs" style="font-weight:400;color:var(--c-text-muted)">(${t('pickupLoc.retired')})</span>`}</td>
      <td class="fs-meta" style="color:var(--c-text-sec)">${l.address ? esc(l.address) : '-'}</td>
      <td class="fs-meta">${l.sortOrder}</td>
      <td style="white-space:nowrap">
        <button class="btn btn-sm fs-xs" data-act="edit" data-id="${l.id}">${t('pickupLoc.edit')}</button>
        ${
          l.active
            ? `<button class="btn btn-sm fs-xs" data-act="retire" data-id="${l.id}" style="color:var(--c-red-dark)">${t('pickupLoc.retire')}</button>`
            : `<button class="btn btn-sm fs-xs" data-act="reactivate" data-id="${l.id}">${t('pickupLoc.reactivate')}</button>`
        }
      </td>
    </tr>`
      )
      .join('')}</tbody>
  </table></div>`;
}

// Every field says what it does, under itself. One paragraph at the foot used
// to cover the name and the address, and it sat directly beneath Reihenfolge —
// the field it did not mention — so the sentence read as an explanation of the
// number above it and left the number unexplained. Three fields, three hints,
// each where the hand already is.
function editPickupLocation(id) {
  const existing = id ? pickupLocations.find((l) => l.id === id) : null;
  const hint = (key) =>
    `<div class="fs-xs" style="color:var(--c-text-muted);margin-top:2px;line-height:1.5">${esc(t(key))}</div>`;
  const html = `<div style="display:flex;flex-direction:column;gap:10px">
    <div><label>${t('pickupLoc.name')}</label><input type="text" id="ploc-name" maxlength="120" value="${existing ? esc(existing.name) : ''}" placeholder="${esc(t('pickupLoc.namePh'))}" />${hint('pickupLoc.nameHint')}</div>
    <div><label>${t('pickupLoc.address')}</label><input type="text" id="ploc-address" maxlength="200" value="${existing && existing.address ? esc(existing.address) : ''}" placeholder="${esc(t('pickupLoc.addressPh'))}" />${hint('pickupLoc.addressHint')}</div>
    <div><label>${t('pickupLoc.order')}</label><input type="number" id="ploc-sort" step="1" value="${existing ? Number(existing.sortOrder) || 0 : 0}" />${hint('pickupLoc.orderHint')}</div>
  </div>`;
  document.getElementById('m-title').textContent = existing ? t('pickupLoc.edit') : t('pickupLoc.add');
  document.getElementById('m-body').innerHTML = html;
  document.getElementById('m-ok').textContent = t('common.save');
  confirmCb = async () => {
    const l = {
      name: document.getElementById('ploc-name').value.trim(),
      address: document.getElementById('ploc-address').value.trim(),
      sortOrder: parseInt(document.getElementById('ploc-sort').value, 10) || 0,
      active: existing ? existing.active !== false : true
    };
    if (!l.name) {
      toast(t('zones.nameRequired'), 'err');
      return;
    }
    if (existing) l.id = existing.id;
    const r = await apiPost('/api/pickup-locations', l);
    if (!r) return;
    if (existing) Object.assign(existing, l);
    else pickupLocations.push({ ...l, id: r.id });
    pickupLocations.sort((a, b) => a.sortOrder - b.sortOrder || a.name.localeCompare(b.name));
    renderPickupLocations();
    setFb('ok', t('pickupLoc.saved'));
  };
  document.getElementById('m-confirm').classList.add('open');
}

async function retirePickupLocation(id) {
  const l = pickupLocations.find((x) => x.id === id);
  if (!l) return;
  if (!(await askConfirm(t('pickupLoc.retire'), t('pickupLoc.confirmRetire', { name: l.name }), t('pickupLoc.retire'))))
    return;
  const r = await apiDelete('/api/pickup-locations/' + id);
  if (!r) return;
  l.active = false;
  renderPickupLocations();
  setFb('ok', t('pickupLoc.saved'));
}

async function setPickupLocationActive(id, active) {
  const l = pickupLocations.find((x) => x.id === id);
  if (!l) return;
  const r = await apiPost('/api/pickup-locations', { ...l, active });
  if (!r) return;
  l.active = active;
  renderPickupLocations();
  setFb('ok', t('pickupLoc.saved'));
}

async function removeSupplier(id) {
  const s = suppliers.find((x) => x.id === id);
  if (!s) return;
  confirm2(
    t('inv.deleteSupplier'),
    'Remove ' + s.name + ' (' + MAT_LABELS[s.mat] + ')?',
    t('inv.deleteSupplier'),
    async () => {
      const r = await apiDelete('/api/suppliers/' + id);
      if (r && r.error) {
        setFb('err', t('common.error') + ': ' + r.error);
        return;
      }
      suppliers = suppliers.filter((x) => x.id !== id);
      renderSuppliers();
      renderInvStock();
      setFb('ok', t('inv.supplierDeleted'));
    }
  );
}

function getSuppliersForMat(mat) {
  return suppliers.filter((s) => s.mat === mat);
}

// ─── USB STICK BACKUP ────────────────────────────────────────
// The start screen reminds admins once a day; Settings → Backup sets sticks up
// and shows what happened. The server notices a plugged-in stick on its own
// (scripts/usb-backup.js) and announces every change as the SSE event
// "usb-backup", so this side asks when told — plus once a minute, which is how
// "done for today" turns into "due" after midnight, and every two seconds
// while a backup runs, in case the event stream is down.
let _usb = null;
let _usbDrives = null;
let _usbKey = null;
let _usbSetupOpen = false;
let _usbTimer = null;

function _usbAdmin() {
  return !!(currentUser && currentUser.role === 'admin');
}

async function loadUsbBackup() {
  clearTimeout(_usbTimer);
  if (!_usbAdmin()) {
    _usb = null;
    renderUsbReminder();
    return;
  }
  try {
    _usb = await apiGet('/api/usb-backup');
  } catch (e) {
    // The last answer stays on screen; the next event or tick asks again.
  }
  renderUsbReminder();
  renderUsbCard();
  const running = !!(_usb && _usb.run && _usb.run.state === 'running');
  _usbTimer = setTimeout(loadUsbBackup, running ? 2000 : 60000);
}

function _usbPct(run) {
  if (!run || !run.bytesTotal) return 0;
  return Math.min(100, Math.floor((run.bytesDone / run.bytesTotal) * 100));
}

// "today 09:12", "yesterday 17:40", or the date: when the last backup was
// is what the reminder is about, and a timestamp makes the reader do the sum.
function _usbWhen(iso) {
  const d = new Date(iso);
  const hm = String(d.getHours()).padStart(2, '0') + ':' + String(d.getMinutes()).padStart(2, '0');
  const today = new Date();
  const yesterday = new Date(today.getFullYear(), today.getMonth(), today.getDate() - 1);
  if (localDateStr(d) === localDateStr(today)) return t('usb.today', { time: hm });
  if (localDateStr(d) === localDateStr(yesterday)) return t('usb.yesterday', { time: hm });
  return fmtDtTime(d);
}

function _usbSize(n) {
  if (n === null || n === undefined) return '–';
  if (n >= 1e9) return (n / 1e9).toLocaleString(loc(), { maximumFractionDigits: 1 }) + ' GB';
  return Math.max(1, Math.round(n / 1e6)).toLocaleString(loc()) + ' MB';
}

// The server answers with a code; every code has a sentence in each language.
const USB_ERR_CODES = [
  'NOT_A_DRIVE',
  'SAME_DISK',
  'NEEDS_KEY',
  'HAS_KEY',
  'EXISTS',
  'WRONG_KEY',
  'BAD_KEY',
  'FORMAT',
  'NO_STICK',
  'NOT_PRESENT',
  'BUSY',
  'FULL',
  'READ_ONLY',
  'GONE',
  'NOT_EMPTY',
  'SHRUNK',
  'HELD',
  'DAMAGED',
  'STATE',
  'FAILED'
];
function _usbErrText(code) {
  return t('usb.err.' + (USB_ERR_CODES.includes(code) ? code : 'FAILED'));
}

function _usbReminderText(s) {
  if (s.reminder === 'running') return t('usb.remRunning', { pct: _usbPct(s.run) });
  if (s.reminder === 'state') return '⚠ ' + t('usb.err.STATE');
  if (s.reminder === 'setup') return t('usb.remSetup');
  if (s.reminder === 'first') return t('usb.remFirst');
  if (s.reminder === 'error') return '⚠ ' + t('usb.remError', { why: _usbErrText(s.run && s.run.error && s.run.error.code) });
  if (s.reminder === 'gaps') return '⚠ ' + t('usb.remGaps');
  if (s.reminder === 'remove') return '✓ ' + t('usb.remRemove');
  return s.lastSuccess ? t('usb.remDue', { when: _usbWhen(s.lastSuccess.time) }) : t('usb.remDueNever');
}

function _usbBindReminder(el) {
  if (el.dataset.bound) return;
  el.dataset.bound = '1';
  el.addEventListener('click', () => {
    go('settings', 'n-settings');
    const tab = document.getElementById('st-settings-backup');
    if (tab) tab.click();
  });
}

// Two lines: the backup (due, running, done, failed), and beside it, never
// instead of it, a recovery key nobody has confirmed as put away yet.
function renderUsbReminder() {
  const el = document.getElementById('wk-usb');
  const keyEl = document.getElementById('wk-usb-key');
  if (keyEl) {
    _usbBindReminder(keyEl);
    keyEl.hidden = !(_usb && _usb.enabled !== false && _usb.configured && !_usb.keyConfirmed);
    keyEl.textContent = '⚠ ' + t('usb.remKey');
  }
  if (!el) return;
  _usbBindReminder(el);
  const r = _usb && _usb.reminder;
  el.hidden = !r;
  if (!r) return;
  el.className = 'wk-usb wk-usb-' + r;
  el.textContent = _usbReminderText(_usb);
}

// The key field for the stick in `root`: an id per drive.
function _usbConnectId(root) {
  return 'usb-connect-key-' + encodeURIComponent(root).replace(/[^A-Za-z0-9]/g, '_');
}

// A plugged-in stick a backup may be written to (as the server decides it).
function _usbUsable(p) {
  return !!(p && p.registered && !p.otherKey && p.supported && !p.sameDisk);
}

function _usbStatusLine(s) {
  if (!s.configured) return t('usb.notSetUp');
  if (!s.lastSuccess) return t('usb.noBackupYet');
  return (
    t('usb.lastBackup', { when: _usbWhen(s.lastSuccess.time), label: s.lastSuccess.label }) +
    ' · ' +
    tp('usb.newPhotos', s.lastSuccess.photosNew)
  );
}

function _usbProgressHtml(run) {
  const text =
    run.phase === 'photos' && run.total
      ? t('usb.progressPhotos', { label: run.label, done: run.done, total: run.total })
      : t('usb.progressDb', { label: run.label });
  return (
    '<div class="usb-progress"><progress class="usb-bar" max="100" value="' +
    _usbPct(run) +
    '"></progress><div class="fs-meta">' +
    esc(text) +
    '</div></div>'
  );
}

function renderUsbCard() {
  const body = document.getElementById('usb-body');
  if (!body) return;
  // Someone typing a recovery key into the card: the card is drawn on every
  // data change of anyone, every usb-backup event and once a minute, and
  // each redraw took the field away under their fingers (on a phone, the
  // keyboard with it). It waits until they have left the field.
  const fokus = document.activeElement;
  if (fokus && body.contains && body.contains(fokus) && /^usb-connect-key-/.test(fokus.id || '')) return;
  const s = _usb;
  if (!s) {
    body.innerHTML = '<div class="fs-meta">' + esc(t('usb.loading')) + '</div>';
    return;
  }
  const running = !!(s.run && s.run.state === 'running');
  // Switched off on this server: nothing to set up or plug in here.
  if (s.enabled === false) {
    body.innerHTML = '<div class="usb-msg">' + esc(t('usb.disabled')) + '</div>';
    return;
  }
  let h = '<div class="usb-status">' + esc(_usbStatusLine(s)) + '</div>';
  if (s.stateError) h += '<div class="usb-msg usb-msg-err">⚠ ' + esc(t('usb.err.STATE')) + '</div>';
  // Until somebody confirms the key is put away, the card says so first.
  if (s.configured && !s.keyConfirmed) h += '<div class="usb-msg usb-msg-err">⚠ ' + esc(t('usb.keyUnconfirmed')) + '</div>';
  if (running) h += _usbProgressHtml(s.run);
  else if (s.firstRunPending) h += '<div class="usb-msg usb-msg-err">' + esc(t('usb.firstPending')) + '</div>';
  else if (s.reminder === 'error') {
    const code = s.run && s.run.error && s.run.error.code;
    h += '<div class="usb-msg usb-msg-err">⚠ ' + esc(_usbErrText(code)) + '</div>';
    // Far less than last time is either a mistake or meant; only a person
    // can tell which, so the backup waits for one.
    // For the stick that stopped, by its id: with a second stick plugged in,
    // the server would otherwise take the first it finds.
    const failedStick = s.run && s.run.stickId;
    if (code === 'SHRUNK' && s.present.some((p) => p.id === failedStick && _usbUsable(p))) {
      h +=
        '<div class="usb-row"><button type="button" class="btn btn-r" data-usb="run-force" data-id="' +
        esc(failedStick) +
        '">' +
        esc(t('usb.forceGo')) +
        '</button></div>';
    }
  } else if (s.reminder === 'remove') h += '<div class="usb-msg usb-msg-ok">✓ ' + esc(t('usb.remRemove')) + '</div>';
  // What the last backup could not read on the PC is not on the stick.
  const ls = s.lastSuccess;
  if (!running && ls && (ls.skipped || ls.unreadable)) {
    const parts = [];
    if (ls.skipped) parts.push(tp('usb.gapsFiles', ls.skipped));
    if (ls.unreadable) parts.push(tp('usb.gapsFolders', ls.unreadable));
    h +=
      '<div class="usb-msg usb-msg-err">⚠ ' +
      esc(parts.join(' ')) +
      (ls.missing && ls.missing.length
        ? '<div class="fs-meta">' + esc(t('usb.gapsExamples', { list: ls.missing.join(', ') })) + '</div>'
        : '') +
      '</div>';
  }

  // The sticks a backup can go to right now. With more than one plugged in,
  // each gets its own button, so the backup goes where it was asked for.
  const usable = running ? [] : s.present.filter(_usbUsable);
  if (s.sticks.length) {
    h += '<ul class="usb-sticks">';
    for (const k of s.sticks) {
      const last = k.lastSuccess ? t('usb.stickLast', { when: _usbWhen(k.lastSuccess.time) }) : t('usb.stickNever');
      h +=
        '<li class="usb-stick"><div class="usb-stick-main"><span class="usb-stick-name">' +
        esc(k.label) +
        '</span>' +
        (k.present ? ' <span class="usb-badge">' + esc(t('usb.present')) + '</span>' : '') +
        '<div class="fs-meta">' +
        esc(last) +
        (k.lastError ? ' · ⚠ ' + esc(_usbErrText(k.lastError.code)) : '') +
        '</div></div>' +
        (usable.length > 1 && usable.some((p) => p.id === k.id)
          ? '<button type="button" class="btn btn-sm btn-p" data-usb="run" data-id="' +
            esc(k.id) +
            '">' +
            esc(t('usb.runNow')) +
            '</button>'
          : '') +
        '<button type="button" class="btn btn-sm" data-usb="forget" data-id="' +
        esc(k.id) +
        '" data-label="' +
        esc(k.label) +
        '"' +
        (running ? ' disabled' : '') +
        '>' +
        esc(t('usb.forget')) +
        '</button></li>';
    }
    h += '</ul>';
  }

  // A stick folder of ours on the app's own disk: a copy, never written to.
  for (const p of s.present.filter((x) => x.registered && x.sameDisk)) {
    h += '<div class="usb-msg">' + esc(t('usb.copyOnPc', { name: p.root })) + '</div>';
  }
  // A stick that is plugged in but not one of ours.
  for (const p of s.present.filter((x) => !x.registered)) {
    const name = p.label ? p.root + ' (' + p.label + ')' : p.root;
    if (!p.supported) h += '<div class="usb-msg">' + esc(t('usb.foreignNewer', { name })) + '</div>';
    else if (!s.configured) {
      // One field per stick, each with its own id: with one id for all of
      // them, Connect read the first field whichever row it was in. A key
      // being typed survives the redraw, in its own field.
      const fieldId = _usbConnectId(p.root);
      const typed = document.getElementById(fieldId);
      h +=
        '<div class="usb-connect"><div class="usb-msg">' +
        esc(t('usb.foreignConnect', { name })) +
        '</div><div class="usb-row"><input type="text" id="' +
        esc(fieldId) +
        '" autocomplete="off" spellcheck="false" placeholder="' +
        esc(t('usb.keyPh')) +
        '" value="' +
        esc(typed ? typed.value : '') +
        '"><button type="button" class="btn btn-p" data-usb="connect" data-root="' +
        esc(p.root) +
        '" data-input="' +
        esc(fieldId) +
        '">' +
        esc(t('usb.connect')) +
        '</button></div></div>';
    } else if (p.otherKey) h += '<div class="usb-msg">' + esc(t('usb.foreignOtherKey', { name })) + '</div>';
    else h += '<div class="usb-msg">' + esc(t('usb.foreignForgotten', { name })) + '</div>';
  }

  h += '<div class="usb-row">';
  if (usable.length === 1) {
    h +=
      '<button type="button" class="btn btn-p" data-usb="run" data-id="' +
      esc(usable[0].id) +
      '">' +
      esc(t('usb.runNow')) +
      '</button>';
  }
  if (!running) {
    h +=
      '<button type="button" class="btn" data-usb="setup-open">' +
      esc(t(s.configured ? 'usb.setupAnother' : 'usb.setupFirst')) +
      '</button>';
  }
  if (s.configured) h += '<button type="button" class="btn" data-usb="key">' + esc(t('usb.keyShow')) + '</button>';
  h += '</div>';
  body.innerHTML = h;
}

function renderUsbSetup() {
  const box = document.getElementById('usb-setup');
  if (!box) return;
  box.hidden = !_usbSetupOpen;
  if (!_usbSetupOpen) {
    box.innerHTML = '';
    return;
  }
  const configured = !!(_usb && _usb.configured);
  let h = '<div class="usb-sub">' + esc(t('usb.setupTitle')) + '</div>';
  h += '<p class="fs-meta">' + esc(t('usb.setupHint')) + '</p>';
  if (!_usbDrives) h += '<div class="fs-meta">' + esc(t('usb.searching')) + '</div>';
  else if (!_usbDrives.length) h += '<div class="fs-meta">' + esc(t('usb.noDrives')) + '</div>';
  else {
    h += '<div class="usb-drives">';
    for (const d of _usbDrives) {
      let why = '';
      let off = false;
      if (d.sameDisk) {
        why = t('usb.driveSameDisk');
        off = true;
      } else if (d.stick && !d.stick.supported) {
        why = t('usb.driveNewer');
        off = true;
      } else if (d.stick && d.stick.registered) {
        why = t('usb.driveRegistered');
        off = true;
      } else if (d.stick && !configured) {
        why = t('usb.driveNeedsKey');
        off = true;
      } else if (d.stick && d.stick.otherKey) {
        why = t('usb.driveOtherKey');
        off = true;
      } else if (d.stick) why = t('usb.driveKnown');
      const size = d.total ? t('usb.driveSize', { free: _usbSize(d.free), total: _usbSize(d.total) }) : '';
      h +=
        '<label class="usb-drive' +
        (off ? ' is-off' : '') +
        '"><input type="radio" name="usb-drive" value="' +
        esc(d.root) +
        '"' +
        (off ? ' disabled' : '') +
        '><span class="usb-drive-root">' +
        esc(d.root) +
        '</span><span class="fs-meta">' +
        esc([size, why].filter(Boolean).join(' · ')) +
        '</span></label>';
    }
    h += '</div>';
  }
  h +=
    '<div class="usb-row"><input type="text" id="usb-label" maxlength="40" autocomplete="off" placeholder="' +
    esc(t('usb.labelPh')) +
    '"></div><div class="usb-row"><button type="button" class="btn btn-p" data-usb="setup-go"' +
    (_usbDrives && _usbDrives.length ? '' : ' disabled') +
    '>' +
    esc(t('usb.setupGo')) +
    '</button><button type="button" class="btn" data-usb="setup-rescan">' +
    esc(t('usb.rescan')) +
    '</button><button type="button" class="btn" data-usb="setup-close">' +
    esc(t('common.cancel')) +
    '</button></div>';
  box.innerHTML = h;
}

// The recovery key, right after the first stick was set up or when an admin
// asked for it. The first time, "Done" waits for the box saying it has been
// put away: without the key, a stick is unreadable once this PC is gone.
function renderUsbKey() {
  const box = document.getElementById('usb-key');
  if (!box) return;
  box.hidden = !_usbKey;
  if (!_usbKey) {
    box.innerHTML = '';
    return;
  }
  box.innerHTML =
    '<div class="usb-key"><div class="usb-sub">' +
    esc(t('usb.keyTitle')) +
    '</div><p class="fs-meta">' +
    esc(t('usb.keyWhy')) +
    '</p><code class="usb-key-code">' +
    esc(_usbKey.key) +
    '</code><div class="usb-row"><button type="button" class="btn btn-sm" data-usb="key-copy">' +
    esc(t('usb.keyCopy')) +
    '</button></div>' +
    (_usbKey.fresh
      ? '<label class="usb-key-saved"><input type="checkbox" id="usb-key-saved"><span>' +
        esc(t('usb.keySaved')) +
        '</span></label>'
      : '') +
    '<div class="usb-row"><button type="button" class="btn btn-p" id="usb-key-done" data-usb="key-done"' +
    (_usbKey.fresh ? ' disabled' : '') +
    '>' +
    esc(t('usb.keyDone')) +
    '</button></div></div>';
}

async function _usbLoadDrives() {
  try {
    _usbDrives = (await apiGet('/api/usb-backup/drives')).drives || [];
  } catch (e) {
    _usbDrives = [];
    toast(t('common.error') + ': ' + (e.message || ''), 'err');
  }
  renderUsbSetup();
}

async function _usbSetupGo(btn) {
  const picked = document.querySelector('input[name="usb-drive"]:checked');
  if (!picked) {
    toast(t('usb.pickDrive'), 'err');
    return;
  }
  const labelEl = document.getElementById('usb-label');
  btn.disabled = true;
  const r = await apiPost('/api/usb-backup/setup', { root: picked.value, label: labelEl ? labelEl.value.trim() : '' });
  btn.disabled = false;
  if (!r || r.error) {
    toast(_usbErrText(r && r.code), 'err');
    return;
  }
  _usbSetupOpen = false;
  renderUsbSetup();
  // The key comes back with every setup until it is confirmed as put away.
  if (r.recoveryKey) {
    _usbKey = { key: r.recoveryKey, fresh: true };
    renderUsbKey();
  }
  toast(t('usb.setupDone', { label: (r.stick && r.stick.label) || '' }), 'ok');
  loadUsbBackup();
}

async function _usbConnect(btn) {
  const input = document.getElementById(btn.dataset.input);
  const key = input ? input.value.trim() : '';
  if (!key) {
    toast(t('usb.err.BAD_KEY'), 'err');
    return;
  }
  btn.disabled = true;
  const r = await apiPost('/api/usb-backup/connect', { root: btn.dataset.root, recoveryKey: key });
  btn.disabled = false;
  if (!r || r.error) {
    toast(_usbErrText(r && r.code), 'err');
    return;
  }
  if (input) input.value = '';
  toast(t('usb.connected'), 'ok');
  loadUsbBackup();
}

async function _usbShowKey() {
  if (!(await askConfirm(t('usb.keyShowTitle'), t('usb.keyShowBody'), t('usb.keyShow')))) return;
  const r = await apiPost('/api/usb-backup/key', {});
  if (!r || r.error || !r.recoveryKey) {
    toast(t('common.error'), 'err');
    return;
  }
  // Shown on request before it was ever confirmed, it asks for the
  // confirmation just as the first time does.
  _usbKey = { key: r.recoveryKey, fresh: !(_usb && _usb.keyConfirmed) };
  renderUsbKey();
}

async function _usbKeyDone() {
  if (_usbKey && _usbKey.fresh) {
    const r = await apiPost('/api/usb-backup/key/confirm', {});
    if (!r || r.error) {
      toast(t('common.error'), 'err');
      return;
    }
  }
  _usbKey = null;
  renderUsbKey();
  loadUsbBackup();
}

async function _usbCopyKey() {
  if (!_usbKey) return;
  try {
    await navigator.clipboard.writeText(_usbKey.key);
    toast(t('usb.keyCopied'), 'ok');
  } catch (e) {
    // No clipboard (an old browser, a page not served over HTTPS): select the
    // key so it can be copied by hand.
    const code = document.querySelector('#usb-key .usb-key-code');
    if (code) window.getSelection().selectAllChildren(code);
  }
}

async function _usbForget(id, label) {
  if (!(await askConfirm(t('usb.forgetTitle'), t('usb.forgetBody', { label }), t('usb.forget')))) return;
  const r = await apiDelete('/api/usb-backup/sticks/' + encodeURIComponent(id));
  if (!r || r.error) {
    toast(_usbErrText(r && r.code), 'err');
    return;
  }
  loadUsbBackup();
}

async function _usbRunNow(btn, force) {
  if (force && !(await askConfirm(t('usb.forceTitle'), t('usb.forceBody'), t('usb.forceGo')))) return;
  btn.disabled = true;
  const body = {};
  if (btn.dataset.id) body.id = btn.dataset.id;
  if (force) body.force = true;
  const r = await apiPost('/api/usb-backup/run', body);
  if (!r || r.error) {
    btn.disabled = false;
    toast(_usbErrText(r && r.code), 'err');
    return;
  }
  loadUsbBackup();
}

function initUsbCard() {
  const card = document.getElementById('usb-card');
  if (!card) return;
  card.addEventListener('click', (e) => {
    const b = e.target.closest('[data-usb]');
    if (!b || b.disabled) return;
    const a = b.dataset.usb;
    if (a === 'setup-open') {
      _usbSetupOpen = true;
      _usbDrives = null;
      renderUsbSetup();
      _usbLoadDrives();
    } else if (a === 'setup-close') {
      _usbSetupOpen = false;
      renderUsbSetup();
    } else if (a === 'setup-rescan') {
      _usbDrives = null;
      renderUsbSetup();
      _usbLoadDrives();
    } else if (a === 'setup-go') _usbSetupGo(b);
    else if (a === 'run') _usbRunNow(b, false);
    else if (a === 'run-force') _usbRunNow(b, true);
    else if (a === 'key') _usbShowKey();
    else if (a === 'key-copy') _usbCopyKey();
    else if (a === 'key-done') _usbKeyDone();
    else if (a === 'forget') _usbForget(b.dataset.id, b.dataset.label);
    else if (a === 'connect') _usbConnect(b);
  });
  card.addEventListener('change', (e) => {
    if (e.target.id !== 'usb-key-saved') return;
    const done = document.getElementById('usb-key-done');
    if (done) done.disabled = !e.target.checked;
  });
}

// ─── BACKUP ──────────────────────────────────────────────────
function setStatus(el, msg, ok) {
  el.style.color = ok ? 'var(--c-green-dark)' : 'var(--c-red-dark)';
  el.textContent = msg;
}
async function downloadBackup() {
  const pw = document.getElementById('backup-dl-pw').value;
  const st = document.getElementById('backup-dl-status');
  if (!pw || pw.length < 8) {
    setStatus(st, t('users.minPw'), false);
    return;
  }
  setStatus(st, 'Preparing backup…', true);
  try {
    const r = await authFetch('/api/backup/download', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ password: pw })
    });
    if (!r.ok) {
      const e = await r.json().catch(() => ({}));
      setStatus(st, e.error || 'Download failed', false);
      return;
    }
    const blob = await r.blob();
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    const cd = r.headers.get('content-disposition') || '';
    const m = cd.match(/filename="(.+?)"/);
    a.download = m ? m[1] : 'meistertracker_backup.enc';
    a.click();
    URL.revokeObjectURL(a.href);
    setStatus(st, 'Backup downloaded.', true);
    document.getElementById('backup-dl-pw').value = '';
  } catch (err) {
    setStatus(st, 'Download failed', false);
  }
}
// Clean-slate reset. Deliberately awkward to fire: you pick the categories, type
// the confirmation phrase, and still get a summary dialog naming what goes. The
// server writes a verified backup before deleting anything.
const RESET_CONFIRM_PHRASE = 'ALLES LOESCHEN';
async function runCleanReset() {
  const st = document.getElementById('reset-status');
  const scopes = {
    growing: document.getElementById('reset-growing').checked,
    orders: document.getElementById('reset-orders').checked,
    planning: document.getElementById('reset-planning').checked,
    stock: document.getElementById('reset-stock').checked
  };
  if (!scopes.growing && !scopes.orders && !scopes.planning && !scopes.stock) {
    setStatus(st, t('reset.errNoScope'), false);
    return;
  }
  const typed = (document.getElementById('reset-confirm').value || '').trim().toUpperCase();
  if (typed !== RESET_CONFIRM_PHRASE) {
    setStatus(st, t('reset.errPhrase', { phrase: RESET_CONFIRM_PHRASE }), false);
    return;
  }
  const parts = [];
  if (scopes.growing) parts.push(t('reset.scopeGrowing'));
  if (scopes.orders) parts.push(t('reset.scopeOrders'));
  if (scopes.planning) parts.push(t('reset.scopePlanning'));
  if (scopes.stock) parts.push(t('reset.scopeStock'));
  confirm2(t('reset.confirmTitle'), t('reset.confirmMsg', { what: parts.join(' · ') }), t('reset.btn'), async () => {
    setStatus(st, t('reset.running'), true);
    const r = await apiPost('/api/admin/reset', { ...scopes, confirm: RESET_CONFIRM_PHRASE });
    if (!r || r.error) {
      setStatus(st, t('reset.failed', { err: (r && r.error) || '?' }), false);
      return;
    }
    const rows = Object.values(r.counts || {}).reduce((s, n) => s + n, 0);
    setStatus(st, t('reset.done', { rows: rows, backup: r.backup }), true);
    document.getElementById('reset-confirm').value = '';
    await loadData(); // re-renders via refresh()
  });
}
function restoreBackup() {
  const file = document.getElementById('restore-file').files[0];
  const pw = document.getElementById('backup-restore-pw').value;
  const st = document.getElementById('backup-restore-status');
  if (!file) {
    setStatus(st, 'Select a .enc backup file.', false);
    return;
  }
  if (!pw) {
    setStatus(st, 'Enter the decryption password.', false);
    return;
  }
  confirm2(
    t('settings.restoreBackup') || 'Restore this backup?',
    t('settings.restoreMsg') || 'Replaces ALL data on the server for all users. Cannot be undone.',
    t('settings.restoreConfirm') || 'Yes, restore',
    async () => {
      setStatus(st, 'Restoring…', true);
      try {
        const buf = await file.arrayBuffer();
        const r = await authFetch('/api/backup/restore', {
          method: 'POST',
          headers: { 'Content-Type': 'application/octet-stream', 'x-backup-password': pw },
          body: buf
        });
        if (!r.ok) {
          const e = await r.json().catch(() => ({}));
          setStatus(st, e.error || 'Restore failed', false);
          return;
        }
        setStatus(st, 'Restored successfully. Reloading…', true);
        document.getElementById('backup-restore-pw').value = '';
        setTimeout(() => window.location.reload(), 1500);
      } catch (err) {
        setStatus(st, 'Restore failed', false);
      }
    }
  );
}

// ─── ZONES (Location Management) ────────────────────────────
const ROLE_LABELS = {
  spawn: 'zones.roleSpawn',
  incubation: 'zones.roleIncubation',
  fruiting: 'zones.roleFruiting',
  contaminated: 'zones.roleContaminated'
};
const ROLE_ORDER = ['spawn', 'incubation', 'fruiting', 'contaminated'];
function renderZones() {
  const el = document.getElementById('zones-list');
  if (!el) return;
  if (!zones.length) {
    // Vor der ersten Antwort von /api/data ist zones die leere Vorbelegung.
    // "Noch keine Zonen angelegt" wäre dann eine Behauptung über die Daten,
    // die niemand geprüft hat — und schickt jemanden Zonen anlegen, die es
    // längst gibt. Ob der Abgleich hängt, sagt der Punkt in der Kopfzeile.
    el.innerHTML = '<div class="empty">' + esc(t(datenGeladen ? 'zones.empty' : 'common.loading')) + '</div>';
    return;
  }
  // Group zones by role in canonical order; unknown roles go last.
  const groups = {};
  ROLE_ORDER.forEach((r) => {
    groups[r] = [];
  });
  const extraRoles = [];
  zones.forEach((z) => {
    if (groups[z.role]) groups[z.role].push(z);
    else {
      if (!groups[z.role]) {
        groups[z.role] = [];
        extraRoles.push(z.role);
      }
      groups[z.role].push(z);
    }
  });
  // Within each group: sort by sortOrder (fallback to name for stability).
  Object.keys(groups).forEach((role) => {
    groups[role].sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0) || a.name.localeCompare(b.name));
  });
  const renderZone = (z) => {
    const zoneBags = getZoneBags(z.id);
    const bagCount = Object.keys(zoneBags).length;
    const rackIds = new Set(z.racks.map((r) => r.id));
    const directCount = Object.values(zoneBags).filter((b) => !rackIds.has(b.loc)).length;
    const rackHtml = z.racks.length
      ? z.racks
          .map((r) => {
            const rBags = Object.keys(getRackBags(r.id)).length;
            return `<span class="zone-rack-chip">${esc(r.id)} <span style="color:var(--c-text-muted)">(${rBags})</span>${rBags === 0 ? `<button class="btn btn-sm btn-r zone-rack-del" data-action="del-rack" data-rack="${esc(r.id)}" title="${esc(t('zones.delete'))}">&times;</button>` : ''}</span>`;
          })
          .join('')
      : '<span class="fs-xs" style="color:var(--c-text-muted)">' + t('zones.noRacks') + '</span>';
    return `<div class="zone-row" data-find="zone:${esc(z.id)}" data-zone-id="${esc(z.id)}" data-zone-role="${esc(z.role)}" style="border-left:4px solid ${safeColor(z.color)}">
      <div class="zone-row-header">
        <span class="zone-drag-handle" draggable="true" title="${esc(t('zones.dragToReorder'))}" aria-label="${esc(t('zones.dragToReorder'))}">\u22ee\u22ee</span>
        <span class="zone-row-name">${esc(z.name)}</span>
        <span class="badge">${esc(t(ROLE_LABELS[z.role]) || z.role)}</span>
        <span class="fs-xs" style="color:var(--c-text-muted)">${z.maxCapacity ? bagCount + ' / ' + z.maxCapacity + ' Bags' : tp('dash.bags', bagCount)}</span>
        ${directCount > 0 ? `<span class="badge zone-direct-badge" title="${esc(t('zones.directBagsHint'))}">\u26a0 ${esc(t('zones.directBags', { count: directCount }))}</span>` : ''}
        ${directCount > 0 && z.racks.length ? `<button class="btn btn-sm fs-micro" data-action="bulk-move" data-zone="${esc(z.id)}" style="color:var(--c-red-dark);font-weight:600">${esc(t('zones.moveToRack'))}</button>` : ''}
        <span style="flex:1"></span>
        <button class="btn btn-sm fs-xs" data-action="rename-zone" data-zone="${esc(z.id)}">${esc(t('batch.zones.rename'))}</button>
        <button class="btn btn-sm fs-xs" data-action="zone-capacity" data-zone="${esc(z.id)}" title="${esc(z.maxCapacity ? z.name + ': ' + bagCount + ' / ' + z.maxCapacity : t('zones.capacityNone'))}">${esc(t('zones.capacity'))}</button>
        <button class="btn btn-sm fs-xs" data-action="add-rack" data-zone="${esc(z.id)}">${esc(t('zones.addRack'))}</button>
        <button class="btn btn-sm fs-xs" data-action="toggle-qr" data-zone="${esc(z.id)}">${esc(t('zones.showQr'))}</button>
        <button class="btn btn-sm fs-xs" data-action="print-zone-qr" data-zone="${esc(z.id)}">${esc(t('zones.printQr'))}</button>
        ${
          bagCount === 0
            ? `<button class="btn btn-sm btn-r fs-xs" data-action="del-zone" data-zone="${esc(z.id)}">${t('zones.delete')}</button>`
            : `<button class="btn btn-sm btn-r fs-xs" disabled title="${esc(t('zones.hasBags', { count: bagCount }))}" style="opacity:.45;cursor:not-allowed">${t('zones.delete')}</button>`
        }
      </div>
      <div class="zone-row-racks">${rackHtml}</div>
      <div class="zone-qr-panel" id="zone-qr-${esc(z.id)}" style="display:none"></div>
    </div>`;
  };
  const orderedRoles = [...ROLE_ORDER, ...extraRoles];
  el.innerHTML = orderedRoles
    .map((role) => {
      const zs = groups[role];
      if (!zs || !zs.length) return '';
      const label = esc(t(ROLE_LABELS[role]) || role);
      const header = `<div class="zone-group-header">${label}</div>`;
      return header + zs.map(renderZone).join('');
    })
    .join('');
}
// Drag-and-drop state for zone reordering.
let draggedZoneId = null;
let draggedZoneRole = null;
function clearZoneDropHints() {
  document.querySelectorAll('.zone-row.zone-drop-before,.zone-row.zone-drop-after').forEach((r) => {
    r.classList.remove('zone-drop-before', 'zone-drop-after');
  });
}
function onZoneDragStart(e) {
  const handle = e.target.closest('.zone-drag-handle');
  if (!handle) {
    return;
  }
  const row = handle.closest('.zone-row');
  if (!row) {
    return;
  }
  draggedZoneId = row.dataset.zoneId;
  draggedZoneRole = row.dataset.zoneRole;
  if (e.dataTransfer) {
    e.dataTransfer.effectAllowed = 'move';
    try {
      e.dataTransfer.setData('text/plain', draggedZoneId);
    } catch (_) {}
    try {
      const rect = row.getBoundingClientRect();
      e.dataTransfer.setDragImage(row, e.clientX - rect.left, e.clientY - rect.top);
    } catch (_) {}
  }
  // Delay the dragging class so the browser snapshots the row before we dim it.
  setTimeout(() => {
    row.classList.add('zone-dragging');
  }, 0);
}
function onZoneDragOver(e) {
  if (!draggedZoneId) return;
  const row = e.target.closest('.zone-row');
  if (!row || row.dataset.zoneRole !== draggedZoneRole || row.dataset.zoneId === draggedZoneId) {
    clearZoneDropHints();
    return;
  }
  e.preventDefault();
  if (e.dataTransfer) e.dataTransfer.dropEffect = 'move';
  const rect = row.getBoundingClientRect();
  const before = e.clientY - rect.top < rect.height / 2;
  clearZoneDropHints();
  row.classList.add(before ? 'zone-drop-before' : 'zone-drop-after');
}
function onZoneDrop(e) {
  if (!draggedZoneId) return;
  const row = e.target.closest('.zone-row');
  if (!row || row.dataset.zoneRole !== draggedZoneRole || row.dataset.zoneId === draggedZoneId) {
    clearZoneDropHints();
    return;
  }
  e.preventDefault();
  const rect = row.getBoundingClientRect();
  const before = e.clientY - rect.top < rect.height / 2;
  const targetId = row.dataset.zoneId;
  const sourceId = draggedZoneId;
  const role = draggedZoneRole;
  clearZoneDropHints();
  reorderZoneWithinRole(sourceId, targetId, before, role);
}
function onZoneDragEnd() {
  document.querySelectorAll('.zone-row.zone-dragging').forEach((r) => r.classList.remove('zone-dragging'));
  clearZoneDropHints();
  draggedZoneId = null;
  draggedZoneRole = null;
}
async function reorderZoneWithinRole(sourceId, targetId, before, role) {
  const sameRole = zones
    .filter((x) => x.role === role)
    .sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0) || a.name.localeCompare(b.name));
  const srcIdx = sameRole.findIndex((x) => x.id === sourceId);
  if (srcIdx < 0) return;
  const [src] = sameRole.splice(srcIdx, 1);
  const tgtIdx = sameRole.findIndex((x) => x.id === targetId);
  if (tgtIdx < 0) sameRole.push(src);
  else sameRole.splice(before ? tgtIdx : tgtIdx + 1, 0, src);
  // Build full order: roles in canonical order + any extras, each group in its new local order.
  const groups = {};
  ROLE_ORDER.forEach((r) => {
    groups[r] = [];
  });
  const extra = [];
  zones.forEach((x) => {
    if (x.role === role) return;
    if (!groups[x.role]) {
      groups[x.role] = [];
      extra.push(x.role);
    }
    groups[x.role].push(x);
  });
  groups[role] = sameRole;
  Object.keys(groups).forEach((r) => {
    if (r !== role) groups[r].sort((a, b) => (a.sortOrder || 0) - (b.sortOrder || 0) || a.name.localeCompare(b.name));
  });
  const fullOrder = [...ROLE_ORDER, ...extra].flatMap((r) => groups[r] || []).map((x) => x.id);
  // Optimistic local update so the UI moves immediately.
  fullOrder.forEach((id, idx) => {
    const zz = zones.find((x) => x.id === id);
    if (zz) zz.sortOrder = idx + 1;
  });
  renderZones();
  try {
    const res = await apiPost('/api/zones/reorder', { order: fullOrder });
    if (res && res.error) {
      toast(res.error, 'err');
      await loadData();
    }
  } catch (err) {
    console.error('reorder zones error:', err);
    toast(t('zones.errorReorder', { err: err.message || 'unknown error' }), 'err');
    await loadData();
  }
}
async function addZone() {
  const nameRaw = document.getElementById('zone-name').value.trim();
  // ID is derived from uppercase version for stability; display name keeps user casing
  const id = nameRaw
    .toUpperCase()
    .replace(/[^A-Z0-9]/g, '_')
    .replace(/^_+|_+$/g, '');
  if (!id || id.length < 2) {
    fieldError('zone-name', t('zones.errShort'));
    return;
  }
  if (nameRaw.length > 50) {
    toast(t('zones.errLong'), 'err');
    return;
  }
  if (!/^[A-Z]/.test(id)) {
    toast(t('zones.errIdStart'), 'err');
    return;
  }
  const dup = zones.find((z) => z.id === id);
  if (dup) {
    toast(t('zones.errExists') + ' (' + dup.name + ')', 'err');
    return;
  }
  const role = document.getElementById('zone-role').value;
  const color = document.getElementById('zone-color').value;
  const racksRaw = document.getElementById('zone-racks').value.trim();
  const racks = racksRaw
    ? [
        ...new Set(
          racksRaw
            .split(',')
            .map(
              (r) =>
                id +
                '_' +
                r
                  .trim()
                  .toUpperCase()
                  .replace(/[^A-Z0-9]/g, '')
            )
            .filter((r) => r !== id + '_')
        )
      ]
    : [];
  if (racks.some((r) => r === id + '_' || r.length <= id.length + 1)) {
    toast(t('zones.errRackEmpty'), 'err');
    return;
  }
  if (racks.length > 50) {
    toast(t('zones.errTooManyRacks'), 'err');
    return;
  }
  const capVal = document.getElementById('zone-capacity').value.trim();
  const maxCapacity = capVal ? parseInt(capVal, 10) : null;
  if (maxCapacity !== null && (!Number.isFinite(maxCapacity) || maxCapacity < 1)) {
    fieldError('zone-capacity', t('zones.errCapacity'));
    return;
  }
  try {
    const now = new Date().toISOString();
    const res = await apiPost('/api/zones', {
      id,
      name: nameRaw,
      role,
      color,
      sortOrder: zones.length + 1,
      racks,
      maxCapacity,
      created: now
    });
    if (res.error) {
      toast(res.error, 'err');
      return;
    }
    zones.push({
      id,
      name: nameRaw,
      role,
      color,
      sortOrder: zones.length + 1,
      maxCapacity,
      racks: racks.map((r, i) => ({ id: r, sortOrder: i + 1 }))
    });
    rebuildZoneConstants();
    renderZones();
    renderStatus();
    document.getElementById('zone-name').value = '';
    document.getElementById('zone-racks').value = '';
    document.getElementById('zone-color').value = ZONE_ROLE_COLOR.fruiting;
    document.getElementById('zone-role').value = 'fruiting';
    document.getElementById('zone-capacity').value = '';
  } catch (e) {
    console.error('addZone error:', e);
    toast(t('zones.errorCreate', { err: e.message || 'unknown error' }), 'err');
  }
}
function renameZone(id) {
  const z = zones.find((x) => x.id === id);
  if (!z) return;
  prompt2(t('batch.zones.renamePrompt', { old: z.name }), z.name, function (newName) {
    if (!newName || !newName.trim()) return;
    newName = newName.trim();
    if (newName === z.name) return;
    apiPatch('/api/zones/' + encodeURIComponent(id) + '/name', { name: newName }).then((res) => {
      if (res && res.error) {
        toast(res.error, 'err');
        return;
      }
      z.name = newName;
      renderZones();
      renderStatus();
      renderBatches();
    });
  });
}
// Capacity could be set when a zone was created and never again, so a tent whose
// real limit only became clear in use was stuck at whatever was guessed on day
// one — or at nothing. Empty clears the limit rather than meaning zero.
function editZoneCapacity(id) {
  const z = zones.find((x) => x.id === id);
  if (!z) return;
  prompt2(t('zones.capacityPrompt', { zone: z.name }), z.maxCapacity ? String(z.maxCapacity) : '', function (raw) {
    if (raw === null || raw === undefined) return;
    const s = String(raw).trim();
    // '' clears; anything else must be a whole, non-negative number. Number('')
    // is 0, so the empty case is taken first and never reads as a limit of zero.
    let cap;
    if (s === '') cap = null;
    else {
      const n = Number(s);
      if (!Number.isInteger(n) || n < 0) {
        setFb('err', t('zones.capacityBad'));
        return;
      }
      cap = n === 0 ? null : n;
    }
    if ((z.maxCapacity || null) === cap) return;
    apiPatch('/api/zones/' + encodeURIComponent(id) + '/capacity', { maxCapacity: cap }).then((res) => {
      if (res && res.error) {
        toast(res.error, 'err');
        return;
      }
      z.maxCapacity = cap;
      setFb('ok', t('zones.capacitySaved'));
      renderZones();
      renderStatus();
      renderDashBatchTasks();
    });
  });
}
function removeZone(id) {
  const z = zones.find((x) => x.id === id);
  if (!z) return;
  confirm2(t('zones.deleteTitle'), t('zones.deleteMsg', { name: z.name }), t('zones.delete'), async () => {
    const res = await apiDelete('/api/zones/' + encodeURIComponent(id));
    if (res.error) {
      toast(res.error, 'err');
      return;
    }
    zones = zones.filter((x) => x.id !== id);
    rebuildZoneConstants();
    renderZones();
    renderStatus();
  });
}
function addRackToZone(zoneId) {
  prompt2(t('zones.rackPrompt'), 'R3', function (name) {
    if (!name) return;
    const rackId =
      zoneId +
      '_' +
      name
        .trim()
        .toUpperCase()
        .replace(/[^A-Z0-9]/g, '');
    if (ALL_RACKS.includes(rackId)) {
      toast(t('zones.errRackExists'), 'err');
      return;
    }
    apiPost('/api/zones/' + encodeURIComponent(zoneId) + '/racks', { id: rackId }).then((res) => {
      if (res.error) {
        toast(res.error, 'err');
        return;
      }
      const zone = zones.find((z) => z.id === zoneId);
      if (zone) zone.racks.push({ id: rackId, sortOrder: zone.racks.length + 1 });
      rebuildZoneConstants();
      renderZones();
      renderStatus();
    });
  });
}
function removeRack(rackId) {
  confirm2(t('zones.rackDeleteTitle'), t('zones.rackDeleteMsg', { name: rackId }), t('zones.delete'), () => {
    apiDelete('/api/racks/' + encodeURIComponent(rackId)).then((res) => {
      if (res.error) {
        toast(res.error, 'err');
        return;
      }
      zones.forEach((z) => {
        z.racks = z.racks.filter((r) => r.id !== rackId);
      });
      rebuildZoneConstants();
      renderZones();
      renderStatus();
    });
  });
}
function bulkMoveToRack(zoneId) {
  const z = zones.find((x) => x.id === zoneId);
  if (!z || !z.racks.length) return;
  const zoneBags = getZoneBags(zoneId);
  const rackIds = new Set(z.racks.map((r) => r.id));
  const directBags = Object.entries(zoneBags).filter(([, b]) => !rackIds.has(b.loc));
  if (!directBags.length) return;
  const m = document.getElementById('m-locmove');
  document.getElementById('lm-title').textContent = t('zones.moveToRackTitle', { count: directBags.length });
  document.getElementById('lm-info').textContent = zoneDisplayName(zoneId);
  document.getElementById('lm-confirm').style.display = 'none';
  const grid = document.getElementById('lm-grid');
  grid.style.display = 'flex';
  grid.innerHTML = z.racks
    .map((r) => {
      const rBags = Object.keys(getRackBags(r.id)).length;
      return `<button class="btn btn-sm fs-meta" data-action="bulk-rack-target" data-zone="${esc(zoneId)}" data-rack="${esc(r.id)}" style="padding:8px 12px">${esc(r.id)} (${rBags})</button>`;
    })
    .join('');
  m.classList.add('open');
}
async function executeBulkMoveToRack(zoneId, rackId) {
  const z = zones.find((x) => x.id === zoneId);
  if (!z) return;
  const zoneBags = getZoneBags(zoneId);
  const rackIds = new Set(z.racks.map((r) => r.id));
  const directBags = Object.entries(zoneBags).filter(([, b]) => !rackIds.has(b.loc));
  if (!directBags.length) return;
  const entries = directBags.map(([bagId, b]) => ({
    action: 'MOVE',
    batch: b.batchId,
    bag: bagId,
    from: b.loc,
    to: rackId,
    species: b.species,
    strain: b.strain,
    time: new Date().toISOString(),
    client_uuid: newScanUuid(),
    // I-12: optimistic concurrency snapshot for offline-queue replays.
    expected_current_zone: b.loc ? toZone(b.loc) : null
  }));
  const res = await apiPost('/api/scan-log', { entries });
  if (handleZoneMismatch(res, entries)) return; // I-12
  if (res.error) {
    toast(res.error, 'err');
    return;
  }
  entries.forEach((e) => scanLog.push(e));
  document.getElementById('m-locmove').classList.remove('open');
  renderZones();
  renderStatus();
  setFb('ok', t('zones.movedToRack', { count: directBags.length, rack: rackId }));
}

// ─── ZONE QR CODES ──────────────────────────────────────────
async function renderZoneQrPanel(zoneId) {
  const panel = document.getElementById('zone-qr-' + zoneId);
  if (!panel) return;
  // Toggle if already loaded
  if (panel.dataset.loaded) {
    const show = panel.style.display === 'none';
    panel.style.display = show ? '' : 'none';
    const btn = panel.closest('.zone-row').querySelector('[data-action="toggle-qr"]');
    if (btn) btn.textContent = show ? t('zones.hideQr') : t('zones.showQr');
    return;
  }
  panel.style.display = '';
  panel.dataset.loaded = '1';
  const btn = panel.closest('.zone-row').querySelector('[data-action="toggle-qr"]');
  if (btn) btn.textContent = t('zones.hideQr');
  const z = zones.find((x) => x.id === zoneId);
  if (!z) return;
  const items = [zoneId, ...z.racks.map((r) => r.id)];
  const grid = document.createElement('div');
  grid.className = 'zone-qr-grid';
  for (const val of items) {
    const cell = document.createElement('div');
    cell.className = 'zone-qr-cell';
    const img = await makeQR(val);
    if (img) {
      img.style.cssText = 'width:80px;height:80px';
      cell.appendChild(img);
    }
    const lbl = document.createElement('div');
    lbl.className = 'zone-qr-label';
    lbl.textContent = val;
    cell.appendChild(lbl);
    grid.appendChild(cell);
  }
  panel.innerHTML = '';
  panel.appendChild(grid);
}

async function printZoneQrBrowser(zoneId) {
  const z = zones.find((x) => x.id === zoneId);
  if (!z) return;
  const items = [zoneId, ...z.racks.map((r) => r.id)];
  await printQrSheet(items, z.name);
}

async function printAllZoneQrBrowser() {
  const items = [...ZONES, ...ALL_RACKS];
  await printQrSheet(items, 'All Zones');
}

async function printQrSheet(items, title) {
  const sheet = document.getElementById('ref-print-sheet');
  sheet.innerHTML = '';
  const hdr = document.createElement('div');
  // px-auf-papier: this is a printed sheet, and 15px there is a sixth of an
  // inch of paper. A rem would follow the reader's browser setting and change
  // how much fits on the page, which is not what a browser setting is for.
  hdr.style.cssText = 'font-family:Arial,sans-serif;font-size:15px;font-weight:bold;margin-bottom:12px;padding:8px';
  hdr.textContent = 'QR Codes: ' + title;
  sheet.appendChild(hdr);
  const row = document.createElement('div');
  row.style.cssText = 'display:flex;flex-wrap:wrap;gap:6px;padding:0 8px';
  for (const val of items) {
    const cell = document.createElement('div');
    cell.style.cssText =
      'border:1px solid var(--c-border);border-radius:5px;padding:5px 7px;text-align:center;background:var(--c-surface);page-break-inside:avoid';
    const img = await makeQR(val);
    if (img) {
      img.style.width = '80px';
      img.style.height = '80px';
      cell.appendChild(img);
    }
    const lbl = document.createElement('div');
    lbl.className = 'fs-micro';
    lbl.style.cssText = 'font-weight:bold;font-family:Arial,sans-serif';
    lbl.textContent = val;
    cell.appendChild(lbl);
    row.appendChild(cell);
  }
  sheet.appendChild(row);
  setTimeout(() => window.print(), 600);
}

// ─── VORHABEN (Forschung · Produkte · Bau) ───────────────────
//
// Drei Unterlagen, die an der Werkbank gebraucht werden und nicht am
// Schreibtisch. Ihr Wortlaut steht nicht hier, sondern in der Datenbank
// (/api/project-docs): diesen Code liest jeder, der das Repository sieht, die
// Unterlagen gehören dem Betrieb. Hier steht nur, wie sie gezeichnet werden.
// Gepflegt werden sie außerhalb des Trackers und kommen per Import herein.
//
// Der Text ist Inhalt, keine Oberfläche, und geht deshalb nicht durch t().
// Übersetzt werden die Reiter und die Knöpfe. Das ist dieselbe Grenze, die eine
// Zone oder ein Substratrezept schon hat: wie die Dinge heißen, steht in der
// Datenbank und bleibt wie es ist; was man mit ihnen tun kann, steht im
// Wörterbuch. Drei Rechercheberichte in drei Sprachen zu halten hieße, sie
// dreimal zu pflegen, und gepflegt würde dann einer.
//
// Bausteine je Abschnitt: p, ul, ol, note, table, cards, steps, tasks, plan,
// copy. Welche Form ein Dokument haben muss, prüft der Server beim Import
// (checkProjectDoc in db.js), damit hier nie eine Datei ankommt, die der
// Zeichner nicht lesen kann.
//
// Geladen wird erst, wenn jemand einen der drei Reiter öffnet: die Texte sind
// lang, und /api/data läuft bei jedem Sync. /api/data trägt nur eine Marke;
// ändert sie sich, holt der nächste Reiterwechsel den neuen Stand.
let pjDocsAbruf = null; // laufender Abruf, damit zwei Reiter nicht zweimal holen
function pjDocsLaden() {
  if (!pjDocsAbruf) {
    pjDocsAbruf = apiGet('/api/project-docs')
      .then((r) => {
        projectDocs = (r && r.docs) || {};
      })
      .catch(() => {
        /* projectDocs bleibt null; der Reiter zeigt dann den Knopf zum Nachladen */
      })
      .finally(() => {
        pjDocsAbruf = null;
      });
  }
  return pjDocsAbruf;
}

// **fett** ist die einzige Auszeichnung, die diese drei Dokumente brauchen, und
// sie wird nach dem Escapen eingesetzt: der Inhalt geht durch esc(), erst danach
// entsteht Markup. Andersherum wäre jedes Sternchen im Text ein offenes Tor.
function pjText(s) {
  return esc(s).replace(/\*\*([^*]+)\*\*/g, '<b>$1</b>');
}
function pjTable(tb) {
  // .t-cards ist der Kartenmodus, den zwölf Tabellen dieser Anwendung unter
  // 769px schon benutzen: thead aus, jede Zeile eine Karte, und die
  // Beschriftung kommt aus data-mlabel. Deshalb sind die Spaltenköpfe hier
  // kurz — sie stehen am Telefon in einer 84px breiten Spalte.
  const head = tb.head.map((h) => `<th>${pjText(h)}</th>`).join('');
  const rows = tb.rows
    .map(
      (r) =>
        '<tr>' + r.map((c, i) => `<td data-mlabel="${esc(tb.head[i] || '')}">${pjText(c)}</td>`).join('') + '</tr>'
    )
    .join('');
  return `<table class="t-cards pj-t"><thead><tr>${head}</tr></thead><tbody>${rows}</tbody></table>`;
}
function pjCards(cards) {
  return (
    '<div class="pj-cards">' +
    cards
      .map((c) => {
        const rows = (c.rows || [])
          .map((r) => `<li><span class="pj-k">${pjText(r[0])}</span><span class="pj-v">${pjText(r[1])}</span></li>`)
          .join('');
        return (
          '<div class="pj-rx">' +
          `<div class="pj-rx-t">${pjText(c.t)}</div>` +
          (c.sub ? `<div class="pj-rx-sub">${pjText(c.sub)}</div>` : '') +
          `<ul class="pj-ing">${rows}</ul>` +
          (c.foot ? `<div class="pj-rx-foot">${pjText(c.foot)}</div>` : '') +
          '</div>'
        );
      })
      .join('') +
    '</div>'
  );
}
function pjSteps(steps) {
  return (
    '<div class="pj-steps">' +
    steps.map((s) => `<div class="pj-step"><div class="pj-step-k">${pjText(s.k)}</div><div>${pjText(s.v)}</div></div>`).join('') +
    '</div>'
  );
}
// Ein Schritt, den man anfassen kann. Die Liste allein ist eine Liste; was
// daraus wird, entscheidet sich erst, wenn sie im Kalender steht — deshalb
// trägt jede Zeile ihren eigenen Knopf. Angelegt wird eine ganz normale
// manuelle Aufgabe, mit heutigem Datum, weil eine Aufgabe ohne Datum im
// Kalender nicht gezeichnet wird (renderCalendar überspringt sie).
function pjTasks(tasks) {
  return (
    '<ul class="pj-tasks">' +
    tasks
      .map(
        (x) =>
          `<li><span>${pjText(x)}</span>` +
          `<button class="btn btn-sm fs-xs pj-add" data-pj-task="${esc(x)}">${esc(t('proj.asTask'))}</button></li>`
      )
      .join('') +
    '</ul>'
  );
}
// Der Tagesplan. Eine Zeile ist ein Handgriff, die Marke links sagt wo
// (Einkauf, Bank, Autoklav, Flow), und abgehakt heisst weg — am Tisch zeigt
// die Liste, was noch zu tun ist, nicht was schon war. Ausgeblendet, nicht
// geloescht: ein Knopf holt die erledigten zum Korrigieren zurueck. Dieselbe
// Mechanik und dieselben Worte wie die Laborliste, die es vorher schon gab,
// damit nicht zwei Werkzeuge zwei Sprachen sprechen.
//
// Der Haken liegt im Browser, nicht auf dem Server: er gilt fuer einen Ansatz
// an einem Tag an einem Geraet, und dafuer waere eine Tabelle mit Sync die
// falsche Groesse. Ist der Versuch durch, setzt der Knopf alles zurueck.
// ── Experimente ─────────────────────────────────────────────
//
// Ein Experiment ist ein Ansatz: "Ansatz A", "Ansatz B". Die Gefaesse darin
// sind seine Wiederholungen und seine Kontrolle — A-01, A-02, A-K. Das ist die
// Ebene, auf der eine Frage beantwortet wird, und deshalb die Ebene, die ein
// Ergebnis, ein Rezept und Fotos traegt.
//
// Vorher hing alles an einem Versuchstag, mit allen Gefaessen in einer flachen
// Liste. Das war die falsche Ebene: Zeilen, die nicht sagen, welche
// zusammengehoeren, und ein Fazit fuer alles zusammen, wo es doch mehrere
// verschiedene Fragen waren.
//
// Zwei Ansichten: die Liste und ein Experiment. Ein Tipp auf die Zeile geht
// hinein, der Pfeil wieder heraus.
const PJ_AUSGANG = ['open', 'good', 'contam', 'discarded'];
let pjOffen = null; // id des geoeffneten Experiments, null = Liste
function pjLaufend() {
  return experiments.filter((v) => v.status === 'running' && !v.archived);
}
function pjExp(id) {
  return experiments.find((v) => v.id === id) || null;
}
function pjAusgangSelect(r) {
  return (
    `<select class="pj-out" data-pj-run="${r.id}" data-pj-feld="outcome" aria-label="${esc(t('exp.outcome'))}">` +
    PJ_AUSGANG.map(
      (o) => `<option value="${o}"${r.outcome === o ? ' selected' : ''}>${esc(t('exp.out.' + o))}</option>`
    ).join('') +
    '</select>'
  );
}
// Eine Zeile in der Liste sagt in einem Blick, was der Ansatz ist, woraus er
// besteht und wie weit er ist. Alles andere steht drinnen.
function pjListenzeile(v) {
  // Das Arbeitspaket steht vor den Gefaessen: ein Blick sagt, wofuer der Ansatz
  // laeuft.
  const paket = v.workPackageId != null ? workPackages.find((w) => w.id === v.workPackageId) : null;
  const gefaesse = [paket ? paket.code : '', v.runs.map((r) => r.code).join(', ')].filter(Boolean).join(' · ');
  const offen = v.runs.filter((r) => r.outcome === 'open').length;
  const zustand = v.runs.length
    ? offen
      ? t('exp.openOf', { n: offen, sum: v.runs.length })
      : t('exp.allIn')
    : t('exp.noVessels');
  return (
    `<button type="button" class="pj-liste-zeile" data-pj-open="${v.id}">` +
    `<span class="pj-liste-code">${esc(v.code)}</span>` +
    `<span class="pj-liste-mitte"><span class="pj-liste-titel">${esc(v.title)}</span>` +
    `<span class="pj-liste-meta">${esc(gefaesse || '—')}</span></span>` +
    `<span class="pj-liste-rechts"><span class="pj-liste-meta">${esc(zustand)}</span>` +
    (v.photos.length ? `<span class="pj-liste-meta">${esc(t('exp.photos', { n: v.photos.length }))}</span>` : '') +
    '</span><span class="pj-liste-pfeil" aria-hidden="true">›</span></button>'
  );
}
function pjListe() {
  const laufend = pjLaufend();
  return (
    '<div class="card pj-sec">' +
    `<div class="sec">${esc(t('exp.running', { n: laufend.length }))}</div>` +
    (laufend.length
      ? '<div class="pj-liste">' + laufend.map(pjListenzeile).join('') + '</div>'
      : `<p class="pj-empty">${esc(t('exp.none'))}</p>`) +
    '<div class="pj-run pj-run-new">' +
    `<input id="pj-new-vcode" placeholder="${esc(t('exp.newCodePh'))}" maxlength="20">` +
    `<input id="pj-new-vtitle" placeholder="${esc(t('exp.newTitlePh'))}" maxlength="200">` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-newexp="1">${esc(t('exp.new'))}</button>` +
    '</div></div>' +
    pjArchiv() +
    pjArbeitspakete() +
    pjLbZeitraum()
  );
}
// ── Arbeitspakete ───────────────────────────────────────────
//
// Die Gliederung eines Vorhabens in Arbeitspakete: AP1, AP2
// und so weiter. Anlegen, umbenennen und ausblenden darf ein Admin, hier unter
// der Liste; einen Versuch zuordnen darf jeder, in seiner Ansicht. Was die
// Pakete heissen, steht in der Datenbank und nicht hier.
//
// Ein Paket als "AP2 · Titel", und eines, das es nicht mehr gibt, als seine
// Kennung: der Verlauf zeigt auch dann, dass da eines war.
function pjApName(pakete, id) {
  const w = (pakete || []).find((x) => x.id === Number(id));
  return w ? w.code + ' · ' + w.title : '#' + id;
}
// Die Auswahl im Versuch. Angeboten werden die sichtbaren Pakete; ein
// ausgeblendetes bleibt stehen, wo es schon steht. Ohne Pakete keine Auswahl.
function pjApAuswahl(v) {
  const angeboten = workPackages.filter((w) => !w.archived || w.id === v.workPackageId);
  if (!angeboten.length) return '';
  return (
    `<label class="pj-ap">${esc(t('exp.wp'))}` +
    `<select data-pj-exp="${v.id}" data-pj-feld="workPackageId">` +
    `<option value=""${v.workPackageId == null ? ' selected' : ''}>${esc(t('exp.wpNone'))}</option>` +
    angeboten
      .map(
        (w) =>
          `<option value="${w.id}"${w.id === v.workPackageId ? ' selected' : ''}>${esc(w.code + ' · ' + w.title)}</option>`
      )
      .join('') +
    '</select></label>'
  );
}
let pjApOffen = false;
function pjArbeitspakete() {
  if (!(currentUser && currentUser.role === 'admin')) return '';
  const zeilen = workPackages
    .map(
      (w) =>
        `<div class="pj-run pj-ap-zeile${w.archived ? ' pj-ap-weg' : ''}">` +
        `<input class="pj-ap-code" data-pj-ap="${w.id}" data-pj-apfeld="code" value="${esc(w.code)}" ` +
        `maxlength="20" aria-label="${esc(t('exp.wpCode'))}">` +
        `<input class="pj-ap-titel" data-pj-ap="${w.id}" data-pj-apfeld="title" value="${esc(w.title)}" ` +
        `maxlength="200" aria-label="${esc(t('exp.wpTitle'))}">` +
        `<button type="button" class="btn btn-sm fs-xs" data-pj-aparch="${w.id}">` +
        `${esc(w.archived ? t('exp.wpShow') : t('exp.wpHide'))}</button></div>`
    )
    .join('');
  return (
    `<details class="card pj-sec pj-fold" data-pj-apfold="1"${pjApOffen ? ' open' : ''}>` +
    `<summary class="sec">${esc(t('exp.wps', { n: workPackages.length }))}</summary>` +
    `<p class="pj-count">${esc(t('exp.wpHint'))}</p>` +
    zeilen +
    '<div class="pj-run pj-run-new">' +
    `<input id="pj-ap-new-code" class="pj-ap-code" placeholder="${esc(t('exp.wpCodePh'))}" maxlength="20" ` +
    `aria-label="${esc(t('exp.wpCode'))}">` +
    `<input id="pj-ap-new-title" class="pj-ap-titel" placeholder="${esc(t('exp.newTitlePh'))}" maxlength="200" ` +
    `aria-label="${esc(t('exp.wpTitle'))}">` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-apadd="1">${esc(t('exp.wpAdd'))}</button>` +
    '</div></details>'
  );
}
// Zwei Zeilen je Gefaess, auf jedem Geraet gleich: oben der Code und wofuer es
// steht, unten das Ergebnis, der Ausgang und das Etikett. Alles in eine Zeile zu
// zwingen hiess am Telefon drei Zeilen, weil der Etikettenknopf allein umbrach —
// und drei Gefaesse waren dann neun Zeilen fuer drei Kolben.
function pjGefaessZeile(r) {
  return (
    `<div class="pj-run" data-pj-runrow="${r.id}">` +
    '<div class="pj-run-kopf">' +
    `<span class="pj-run-code">${esc(r.code)}</span>` +
    (r.what ? `<span class="pj-run-what">${esc(r.what)}</span>` : '') +
    `<button type="button" class="btn btn-sm fs-xs pj-run-etikett" data-pj-label="${r.id}">${esc(t('exp.label'))}</button>` +
    `<button type="button" class="pj-run-weg" data-pj-rundel="${r.id}" aria-label="${esc(t('exp.removeRunNamed', { code: r.code }))}" ` +
    `title="${esc(t('exp.removeRunNamed', { code: r.code }))}">&times;</button>` +
    '</div><div class="pj-run-tools">' +
    `<input class="pj-run-res" data-pj-run="${r.id}" data-pj-feld="result" value="${esc(r.result)}" ` +
    `placeholder="${esc(t('exp.resultPh'))}" maxlength="1000">` +
    pjAusgangSelect(r) +
    '</div></div>'
  );
}
// ── Entfernte Gefaesse und Fotos ────────────────────────────
//
// Entfernt ist nicht geloescht: was jemand herausgenommen hat, steht zugeklappt
// unter der Liste, nur zum Lesen, mit einem Knopf, der es zurueckholt. Wer es
// wann entfernt hat, steht im Verlauf.
function pjEntferntesGefaess(r) {
  return (
    '<div class="pj-run pj-run-ro">' +
    '<div class="pj-run-kopf">' +
    `<span class="pj-run-code">${esc(r.code)}</span>` +
    (r.what ? `<span class="pj-run-what">${esc(r.what)}</span>` : '') +
    `<button type="button" class="btn btn-sm fs-xs pj-run-zurueck" data-pj-runback="${r.id}" ` +
    `aria-label="${esc(t('exp.restoreRunNamed', { code: r.code }))}">${esc(t('exp.restore'))}</button>` +
    '</div><div class="pj-run-tools">' +
    `<span class="pj-run-res">${esc(r.result || '—')}</span>` +
    `<span class="pj-out-${esc(r.outcome)}">${esc(t('exp.out.' + r.outcome))}</span>` +
    `<span class="pj-count">${esc(t('exp.removedAt', { d: fmtDt(r.removedAt) }))}</span>` +
    '</div></div>'
  );
}
// Welche Klappen "Entfernte ..." offen sind, je Versuch und Art. Jede Aktion
// zeichnet die Ansicht neu; ohne das klappte die Liste nach jedem Zurueckholen
// wieder zu, und wer drei Fotos zurueckholte, oeffnete sie dreimal.
const pjWegOffen = {};
function pjEntfernte(titel, n, inhalt, schluessel) {
  if (!n) return '';
  return (
    `<details class="pj-fold pj-weg" data-pj-weg="${esc(schluessel)}"${pjWegOffen[schluessel] ? ' open' : ''}>` +
    `<summary class="sec">${esc(t(titel, { n }))}</summary>` +
    inhalt +
    '</details>'
  );
}
function pjFotoKachel(v, f, nr) {
  // Endgueltig geloescht: kein Bild mehr, nur der Platz, an dem es war. Dass es
  // da war, steht mit Pruefsumme im Verlauf.
  if (f.purged) {
    return (
      '<figure class="pj-foto pj-foto-entfernt">' +
      `<div class="pj-foto-leer">${esc(t('exp.purged'))}</div>` +
      `<figcaption>${esc(fmtDt(f.uploadedAt))}</figcaption></figure>`
    );
  }
  const url = '/api/experiments/' + v.id + '/photos/' + encodeURIComponent(f.uuid);
  // Ein entferntes Foto kann ein Admin endgueltig loeschen, fuer das Bild, das
  // nicht gespeichert bleiben darf.
  const admin = !!(currentUser && currentUser.role === 'admin');
  // Ein Bildschirmleser liest die Knoepfe einzeln vor: "Zurueckholen" dreimal
  // sagt nicht, welches Foto. Deshalb traegt jeder Knopf, wovon er spricht.
  // Fotos aus einem Zug tragen dieselbe Minute; die Nummer in der Liste macht
  // ihre Namen verschieden.
  const wann = fmtDtTime(f.uploadedAt);
  const name = { n: nr || 1, d: wann };
  return (
    `<figure class="pj-foto${f.removedAt ? ' pj-foto-entfernt' : ''}"><a href="${esc(url)}" target="_blank" rel="noopener">` +
    `<img src="${esc(url)}?thumb=1" alt="${esc(t('exp.photoAlt', name))}" loading="lazy"></a>` +
    `<figcaption>${esc(fmtDt(f.uploadedAt))}` +
    // Das Original in voller Aufloesung, wo es eins gibt: zum Heranzoomen, zum
    // Ausmessen, zum Beilegen.
    (f.original
      ? ` · <a class="pj-foto-original" href="${esc(url)}?original=1" target="_blank" rel="noopener" ` +
        `aria-label="${esc(t('exp.originalNamed', name))}">${esc(t('exp.original'))}</a>`
      : '') +
    // Ohne Original, weil die App geschlossen wurde, das Netz zu lange weg war
    // oder das Foto von vor den Originalen ist: wer es hochgeladen hat, oder
    // ein Admin, reicht es nach. Der Server prueft dasselbe.
    (!f.original &&
    !f.removedAt &&
    !pjOriginaleUnterwegs.has(f.id) &&
    (admin || (f.uploadedBy && currentUser && f.uploadedBy === currentUser.userId))
      ? ` · <button type="button" class="pj-foto-original-neu" data-pj-original="${f.id}" ` +
        `aria-label="${esc(t('exp.originalAddNamed', name))}">${esc(t('exp.originalAdd'))}</button>`
      : '') +
    '</figcaption>' +
    (f.removedAt
      ? `<button type="button" class="btn btn-sm fs-xs pj-foto-zurueck" data-pj-photoback="${f.id}" ` +
        `aria-label="${esc(t('exp.restorePhotoNamed', name))}">${esc(t('exp.restore'))}</button>` +
        (admin
          ? `<button type="button" class="btn btn-sm fs-xs pj-foto-zurueck" data-pj-photopurge="${f.id}" ` +
            `aria-label="${esc(t('exp.purgePhotoNamed', name))}">${esc(t('exp.purge'))}</button>`
          : '')
      : `<button type="button" class="pj-foto-weg" data-pj-photodel="${f.id}" ` +
        `aria-label="${esc(t('exp.removePhotoNamed', name))}">&times;</button>`) +
    '</figure>'
  );
}
// Ein Experiment, von oben nach unten so, wie der Tag laeuft: was drinsteht,
// wie es aussieht, womit es angesetzt wurde, was dabei herauskam.
function pjDetail(v) {
  const wegG = v.removedRuns;
  const wegF = v.removedPhotos;
  const kopf =
    '<div class="card pj-sec">' +
    '<div class="pj-v-head">' +
    `<div><button type="button" class="pj-zurueck" data-pj-back="1">← ${esc(t('exp.back'))}</button>` +
    `<div><span class="pj-v-code">${esc(v.code)}</span> <span class="pj-v-title">${esc(v.title)}</span></div>` +
    `<div class="pj-v-meta">${esc(t('exp.since', { d: v.started }))}${v.ended ? ' – ' + esc(v.ended) : ''}</div></div>` +
    '<div class="pj-v-knoepfe">' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-lbexp="${v.id}" ` +
    `aria-label="${esc(t('exp.lbPrintNamed', { code: v.code }))}">${esc(t('exp.lbPrint'))}</button>` +
    (v.status === 'running'
      ? `<button type="button" class="btn btn-sm fs-xs" data-pj-finish="${v.id}">${esc(t('exp.finish'))}</button>`
      : '') +
    '</div></div>' +
    pjApAuswahl(v) +
    (v.runs.length ? v.runs.map(pjGefaessZeile).join('') : `<p class="pj-empty">${esc(t('exp.noVessels'))}</p>`) +
    '<div class="pj-run pj-run-new">' +
    `<input id="pj-new-code" placeholder="${esc(t('exp.codePh'))}" maxlength="40">` +
    `<input id="pj-new-what" placeholder="${esc(t('exp.whatPh'))}" maxlength="200">` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-addrun="${v.id}">${esc(t('exp.addRun'))}</button>` +
    '</div>' +
    pjEntfernte('exp.removedRuns', wegG.length, wegG.map(pjEntferntesGefaess).join(''), v.id + ':runs') +
    '</div>';
  const fotos =
    '<div class="card pj-sec">' +
    `<div class="sec">${esc(t('exp.photos', { n: v.photos.length }))}</div>` +
    '<div class="pj-fotos">' +
    v.photos.map((f, i) => pjFotoKachel(v, f, i + 1)).join('') +
    '</div>' +
    '<input type="file" id="pj-cam" accept="image/*" capture="environment" multiple hidden>' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-cam="${v.id}">${esc(t('exp.takePhoto'))}</button>` +
    `<span class="pj-count" id="pj-cam-status">${esc(pjKameraZeile.id === v.id ? pjKameraZeile.text : '')}</span>` +
    '<input type="file" id="pj-orig" accept="image/jpeg" hidden>' +
    pjEntfernte(
      'exp.removedPhotos',
      wegF.length,
      '<div class="pj-fotos">' + wegF.map((f, i) => pjFotoKachel(v, f, i + 1)).join('') + '</div>',
      v.id + ':photos'
    ) +
    '</div>';
  const text =
    '<div class="card pj-sec">' +
    `<label for="pj-v-recipe">${esc(t('exp.recipe'))}</label>` +
    `<textarea id="pj-v-recipe" data-pj-exp="${v.id}" data-pj-feld="recipe" rows="3" ` +
    `placeholder="${esc(t('exp.recipePh'))}">${esc(v.recipe)}</textarea>` +
    `<label for="pj-v-outcome">${esc(t('exp.conclusion'))}</label>` +
    `<textarea id="pj-v-outcome" data-pj-exp="${v.id}" data-pj-feld="outcome" rows="3" ` +
    `placeholder="${esc(t('exp.conclusionPh'))}">${esc(v.outcome)}</textarea>` +
    '</div>';
  return kopf + fotos + text + pjVerlauf(v);
}
function pjArchiv() {
  const alte = experiments.filter((v) => v.status !== 'running' || v.archived);
  if (!alte.length) return '';
  return (
    '<details class="card pj-sec pj-fold"><summary class="sec">' +
    esc(t('exp.archive', { n: alte.length })) +
    '</summary><div class="pj-liste">' +
    alte.map(pjListenzeile).join('') +
    '</div></details>'
  );
}
// ── Verlauf ─────────────────────────────────────────────────
//
// Wer wann was geaendert hat: am Experiment, an seinen Gefaessen, an seinen
// Fotos. Die Felder darueber zeigen den Stand von jetzt; hier steht, wie er
// zustande kam. Das Neueste oben, der Anfang unten.
//
// Zugeklappt, weil man darin nachschlaegt und nicht arbeitet. Geholt wird er
// erst beim Aufklappen und nicht mit /api/data: er waechst mit jeder Aenderung,
// und /api/data laeuft bei jedem Sync. Geholt wird seitenweise: beim Aufklappen
// die juengsten Eintraege, nach einer Aenderung nur, was seitdem dazukam, und
// Aelteres auf Wunsch. Einmal aufgeklappt bleibt er offen, auch wenn die
// Ansicht darunter neu gezeichnet wird.
let pjVerlaufOffen = null; // id des Experiments, dessen Verlauf offen ist
let pjVerlaufStand = null; // { id, eintraege, mehr } oder { id, fehler: true }
let pjVerlaufNr = 0; // ein neuer Anfang verwirft Antworten auf fruehere Abrufe
function pjVerlauf(v) {
  const offen = pjVerlaufOffen === v.id;
  // Die Liste steht nur im offenen Verlauf; zugeklappt waere sie Arbeit fuer
  // nichts, bei jedem Neuzeichnen.
  return (
    `<details class="card pj-sec pj-fold pj-verlauf" data-pj-verlauf="${v.id}"${offen ? ' open' : ''}>` +
    `<summary class="sec">${esc(t('exp.hist'))}</summary>` +
    `<div id="pj-verlauf-liste">${offen ? pjVerlaufListe(v) : ''}</div>` +
    '</details>'
  );
}
// Ein Gefaess heisst im Verlauf so, wie es zuletzt hiess: wer es umbenennt,
// steht als eigener Eintrag da. Der Verlauf kann neuer sein als die geladenen
// Daten; ein Gefaess, das ein anderes Geraet eben angelegt hat, kennt dann nur
// er. Tragen zwei Gefaesse denselben Code (ein entferntes und das, das danach
// unter seinem Code angelegt wurde), kommt die Beschreibung dazu, und reicht die
// nicht, die Kennung.
function pjVerlaufCodes(v, eintraege) {
  const gefaesse = {};
  for (const e of eintraege) {
    if (e.entity !== 'run') continue;
    const g = gefaesse[e.entityId] || { code: '', what: '' };
    if (e.record && e.record.code) {
      g.code = e.record.code;
      g.what = e.record.what || '';
    }
    if (e.field === 'code' && e.to) g.code = e.to;
    if (e.field === 'what') g.what = e.to || '';
    if (g.code) gefaesse[e.entityId] = g;
  }
  for (const r of v.runs.concat(v.removedRuns)) gefaesse[r.id] = { code: r.code, what: r.what || '' };
  const anzahl = (schluessel) => {
    const n = {};
    for (const g of Object.values(gefaesse)) n[schluessel(g)] = (n[schluessel(g)] || 0) + 1;
    return n;
  };
  const jeCode = anzahl((g) => g.code.toLowerCase());
  const jeCodeUndWas = anzahl((g) => g.code.toLowerCase() + '\u0000' + g.what);
  const codes = {};
  for (const [id, g] of Object.entries(gefaesse)) {
    let name = g.code;
    if (jeCode[g.code.toLowerCase()] > 1) {
      if (g.what) name += ' (' + g.what + ')';
      if (jeCodeUndWas[g.code.toLowerCase() + '\u0000' + g.what] > 1) name += ' #' + id;
    }
    codes[id] = name;
  }
  return codes;
}
function pjVerlaufWert(e, x) {
  if (x == null || x === '') return '—';
  if (e.entity === 'run' && e.field === 'outcome') return t('exp.out.' + x);
  if (e.field === 'status') return t('exp.hist.status.' + x);
  if (e.field === 'archived') return x === 'true' ? t('exp.hist.yes') : t('exp.hist.no');
  if (e.field === 'workPackageId') return pjApName(workPackages, x);
  return x;
}
function pjVerlaufZeile(e, codes, fotoBild) {
  const gefaess = e.entity === 'run' ? codes[e.entityId] || '#' + e.entityId : '';
  let was;
  let wert = '';
  if (e.action === 'update') {
    const feld = t('exp.hist.f.' + e.entity + '.' + e.field);
    was = gefaess ? gefaess + ' · ' + feld : feld;
    wert =
      '<div class="pj-hist-wert">' +
      `<del>${esc(pjVerlaufWert(e, e.from))}</del> → <ins>${esc(pjVerlaufWert(e, e.to))}</ins></div>`;
  } else if (e.action === 'backup') {
    // Eine zurueckgespielte Sicherung: was danach stand, ist nicht mehr da, aber
    // in der Kopie von vorher, wenn der Server sie aufgehoben hat.
    was = t(e.entity === 'work_package' ? 'exp.hist.backupWp' : 'exp.hist.backup', {
      n: (e.record && e.record.discarded) || 0
    });
    if (e.record && e.record.kept) was += ' ' + t('exp.hist.backupKept', { file: e.record.kept });
  } else {
    was = t('exp.hist.' + e.action + '.' + e.entity, { code: gefaess });
    // Ein Foto sagt, zu welchem Gefaess es gehoert, wenn es eins hat.
    const runId = e.entity === 'photo' && e.record ? e.record.runId : null;
    if (runId && codes[runId]) was += ' · ' + codes[runId];
  }
  // Ein Foto zeigt sich selbst: drei "Foto hinzugefuegt" aus einem Zug waren
  // sonst nicht auseinanderzuhalten. Die Kachel ist zwischengespeichert.
  const bild = e.entity === 'photo' && e.record && e.record.uuid && fotoBild ? fotoBild(e.record.uuid) : '';
  // Ein Name, dessen Konto es nicht mehr gibt, sagt das: ein neues Konto mit
  // demselben Namen ist ein anderer Mensch.
  const wer = e.user ? ' · ' + esc(e.user) + (e.userGone ? ' ' + esc(t('exp.hist.userGone')) : '') : '';
  return (
    '<li class="pj-hist">' +
    `<div class="pj-hist-kopf">${esc(fmtDtTime(e.at))}${wer}</div>` +
    '<div class="pj-hist-was">' +
    (bild ? `<img class="pj-hist-foto" src="${esc(bild)}" alt="" loading="lazy">` : '') +
    `${esc(was)}</div>` +
    wert +
    '</li>'
  );
}
// Der Ausgangsstand ist ein Eintrag je Datensatz, der beim Einfuehren des
// Verlaufs da war. Einzeln gezeigt waeren das zwanzig gleiche Zeilen am Ende;
// gemeint ist eine: ab hier wird mitgeschrieben.
function pjVerlaufListe(v) {
  const s = pjVerlaufStand;
  if (!s || s.id !== v.id) return `<p class="pj-empty">${esc(t('common.loading'))}</p>`;
  if (s.fehler) return `<p class="pj-empty">${esc(t('exp.histErr'))}</p>`;
  const codes = pjVerlaufCodes(v, s.eintraege);
  const fotos = {};
  for (const f of v.photos.concat(v.removedPhotos)) fotos[f.uuid] = f;
  const fotoBild = (uuid) =>
    fotos[uuid] && !fotos[uuid].purged
      ? '/api/experiments/' + v.id + '/photos/' + encodeURIComponent(uuid) + '?thumb=1'
      : '';
  const zeilen = s.eintraege
    .filter((e) => e.action !== 'baseline')
    .reverse()
    .map((e) => pjVerlaufZeile(e, codes, fotoBild));
  const anfang = s.eintraege.find((e) => e.action === 'baseline');
  if (anfang) {
    zeilen.push(
      '<li class="pj-hist">' +
        `<div class="pj-hist-kopf">${esc(fmtDtTime(anfang.at))}</div>` +
        `<div class="pj-hist-was">${esc(t('exp.hist.baseline'))}</div></li>`
    );
  }
  if (s.mehr) {
    zeilen.push(
      `<li class="pj-hist pj-hist-mehr"><button type="button" class="btn btn-sm fs-xs" data-pj-hist-mehr="${v.id}">` +
        `${esc(t('exp.histMore'))}</button></li>`
    );
  }
  return zeilen.length
    ? '<ul class="pj-hist-liste">' + zeilen.join('') + '</ul>'
    : `<p class="pj-empty">${esc(t('exp.histNone'))}</p>`;
}
// Wie viel Neues ein Nachladen hoechstens holt (der Server nimmt bis 500).
const PJ_VERLAUF_NEU = 500;
// Zwei Seiten zu einer: nach Kennung, jeder Eintrag einmal.
function pjVerlaufMischen(alt, neu) {
  const nachId = new Map();
  for (const e of alt) nachId.set(e.id, e);
  for (const e of neu) nachId.set(e.id, e);
  return [...nachId.values()].sort((a, b) => a.id - b.id);
}
// art: 'erste' die juengsten Eintraege (ersetzt, was da war), 'neu' was seit
// dem letzten bekannten dazukam, 'aelter' die Seite vor dem aeltesten. Ohne
// Stand fuer diesen Versuch ist jeder Abruf ein erster.
function pjVerlaufLaden(id, art) {
  const da = pjVerlaufStand && pjVerlaufStand.id === id && !pjVerlaufStand.fehler ? pjVerlaufStand : null;
  if (!da || !da.eintraege.length) art = 'erste';
  if (art === 'erste') pjVerlaufNr++;
  const nr = pjVerlaufNr;
  let pfad = '/api/experiments/' + id + '/history';
  if (art === 'neu') pfad += '?after=' + da.eintraege[da.eintraege.length - 1].id + '&limit=' + PJ_VERLAUF_NEU;
  if (art === 'aelter') pfad += '?before=' + da.eintraege[0].id;
  return apiGet(pfad)
    .then((r) => ({
      eintraege: (r && r.entries) || [],
      mehr: !!(r && r.more),
      neuester: r && typeof r.newest === 'number' ? r.newest : null
    }))
    .catch(() => null)
    .then((seite) => {
      if (nr !== pjVerlaufNr) return;
      const jetzt = pjVerlaufStand && pjVerlaufStand.id === id && !pjVerlaufStand.fehler ? pjVerlaufStand : null;
      // Juenger als alles, was der Server hat? Dann wurde eine Sicherung
      // zurueckgespielt, und die Kennungen fangen wieder frueher an: von vorn.
      const bekannt = jetzt && jetzt.eintraege.length ? jetzt.eintraege[jetzt.eintraege.length - 1].id : 0;
      if (seite && art !== 'erste' && seite.neuester !== null && seite.neuester < bekannt) {
        pjVerlaufLaden(id, 'erste');
        return;
      }
      if (!seite) {
        // Ein Nachladen, das scheitert, laesst stehen, was schon da ist.
        if (art === 'erste' || !jetzt) pjVerlaufStand = { id, fehler: true };
      } else if (art === 'erste' || !jetzt) {
        pjVerlaufStand = { id, eintraege: seite.eintraege, mehr: seite.mehr };
      } else {
        pjVerlaufStand = {
          id,
          eintraege: pjVerlaufMischen(jetzt.eintraege, seite.eintraege),
          mehr: art === 'aelter' ? seite.mehr : jetzt.mehr
        };
      }
      const el = document.getElementById('pj-verlauf-liste');
      const v = pjExp(pjOffen);
      if (el && v && v.id === id && pjVerlaufOffen === id) el.innerHTML = pjVerlaufListe(v);
      // Eine volle Seite Neues heisst: es kam mehr dazu, als eine Seite fasst.
      if (seite && art === 'neu' && seite.eintraege.length >= PJ_VERLAUF_NEU) pjVerlaufLaden(id, 'neu');
    });
}
// Nach einem Feld, das gespeichert wird, ohne dass die Ansicht neu gezeichnet
// wird: Ergebnis, Mengen, Fazit. Nur die Liste, damit ein halb getippter Satz
// im naechsten Feld stehen bleibt, und nur das Neue.
function pjVerlaufNeu() {
  if (pjOffen && pjVerlaufOffen === pjOffen) pjVerlaufLaden(pjOffen, 'neu');
}
// <details> meldet das Auf- und Zuklappen mit "toggle", und das steigt nicht
// auf; der Zuhoerer haengt deshalb in der Capture-Phase an der Seite. Ein
// Verlauf, der schon als offen gilt, wurde nicht von Hand geoeffnet, sondern
// mit der Ansicht neu gezeichnet; das Holen uebernimmt dann renderVersuch().
function pjToggle(e) {
  const det = e.target;
  if (det && det.dataset && det.dataset.pjWeg) {
    pjWegOffen[det.dataset.pjWeg] = det.open;
    return;
  }
  if (det && det.dataset && det.dataset.pjLb) {
    pjLbOffen = det.open;
    return;
  }
  if (det && det.dataset && det.dataset.pjApfold) {
    pjApOffen = det.open;
    return;
  }
  if (!det || !det.dataset || !det.dataset.pjVerlauf) return;
  const id = Number(det.dataset.pjVerlauf);
  if (det.open) {
    if (pjVerlaufOffen === id) return;
    pjVerlaufOffen = id;
    const el = document.getElementById('pj-verlauf-liste');
    const v = pjExp(id);
    if (el && v) el.innerHTML = pjVerlaufListe(v);
    pjVerlaufLaden(id, 'erste');
  } else if (pjVerlaufOffen === id) {
    // Zu ist zu: der Stand faellt weg, und Antworten, die noch unterwegs sind,
    // zaehlen nicht mehr. Beim naechsten Aufklappen kommt der Verlauf frisch.
    pjVerlaufOffen = null;
    pjVerlaufStand = null;
    pjVerlaufNr++;
  }
}
// Was die Versuchsseite zuletzt gezeichnet hat: die Versuche und welcher offen
// war. Aendert sich das unter ihr, ist sie veraltet.
let pjVersuchGezeigt = null;
function pjVersuchStand() {
  // Die Arbeitspakete mit: ein Paket, das ein anderes Geraet anlegt oder
  // umbenennt, steht sonst erst beim naechsten Neuzeichnen in der Auswahl.
  return JSON.stringify([pjOffen, experiments, workPackages]);
}
// Wann die offene Vorhaben-Seite bei einem neuen Datenstand neu gezeichnet wird.
//
// Die Unterlagen haengen nicht an jedem Datenstand, sie kommen ueber ihren
// eigenen Abruf (pjDocsLaden). Sie werden gezeichnet, wenn noch nichts dasteht,
// und nach einem Sprachwechsel, sonst nicht: niemand soll alle 30 Sekunden ein
// Dokument unter den Augen neu gebaut bekommen.
//
// Der Versuch dagegen zeigt Daten, die sich unter ihm aendern. Ein Gefaess, das
// ein anderes Geraet entfernt hat, stand sonst weiter mit Eingabefeldern da, und
// was man hineintippte, landete im entfernten. Er wird deshalb neu gezeichnet,
// sobald sich an den Versuchen etwas geaendert hat, ausser jemand gibt darin
// gerade etwas ein: dann wartet er, bis das Feld verlassen ist.
function pjRefresh() {
  const offen = document.querySelector('#p-proj .sp.active > div');
  if (!offen) return;
  const versuch = offen.id === 'pj-versuch';
  const leer = !offen.innerHTML;
  const andereSprache = offen.dataset.lang !== currentLang;
  // Beschaeftigt ist, wer in ein Feld tippt. Ein Knopf mit dem Fokus zaehlt
  // nicht: in Safari bekommt ein angetippter Knopf keinen, und nach Entfernen
  // oder Zurueckholen steht der Fokus auf einem, ohne dass jemand etwas tut.
  const fokus = document.activeElement;
  const tippt = !!fokus && offen.contains(fokus) && /^(INPUT|TEXTAREA|SELECT)$/.test(fokus.tagName || '');
  const veraltet = versuch && pjVersuchGezeigt !== pjVersuchStand() && !tippt;
  if (!leer && !andereSprache && !veraltet) return;
  if (versuch) renderVersuch();
  else renderProjekte(offen.id.replace('pj-', ''));
}
// Die Felder zum Anlegen und der Zeitraum fuers Laborbuch: was darin steht und
// noch nicht abgeschickt ist, uebersteht das Neuzeichnen derselben Ansicht.
const PJ_ANLEGEN_FELDER = [
  'pj-new-code',
  'pj-new-what',
  'pj-new-vcode',
  'pj-new-vtitle',
  'pj-ap-new-code',
  'pj-ap-new-title',
  'pj-lb-von',
  'pj-lb-bis',
  'pj-lb-ap'
];
let pjGezeichnetFuer; // pjOffen beim letzten Zeichnen
function renderVersuch() {
  const el = document.getElementById('pj-versuch');
  if (!el) return;
  const v = pjOffen ? pjExp(pjOffen) : null;
  const angefangen = {};
  if (pjGezeichnetFuer === pjOffen) {
    for (const id of PJ_ANLEGEN_FELDER) {
      const feld = document.getElementById(id);
      if (feld && feld.value) angefangen[id] = feld.value;
    }
  }
  el.innerHTML = v ? pjDetail(v) : pjListe();
  pjGezeichnetFuer = pjOffen;
  for (const [id, wert] of Object.entries(angefangen)) {
    const feld = document.getElementById(id);
    if (feld) feld.value = wert;
  }
  el.dataset.lang = currentLang;
  pjVersuchGezeigt = pjVersuchStand();
  if (v && pjVerlaufOffen === v.id) pjVerlaufLaden(v.id, 'neu');
}
// Ein Etikett je Gefaess — dieselbe Vorlage, die die Kulturen drucken. Ein
// Kolben und ein Glas bekommen dasselbe Etikett, und das ist der Punkt: am
// Regal unterscheidet sie nur der Code.
async function pjPrintRun(id) {
  const v = pjExp(pjOffen);
  const r = v && v.runs.find((x) => x.id === id);
  if (!r) return;
  const zpl = itemsToZPL(
    labLabelItems(
      r.code,
      {
        species: v.code + (r.what ? ' · ' + r.what : ''),
        strainText: '',
        notes: '',
        created: v.started,
        parentId: null
      },
      'full',
      false
    )
  );
  const fehler = await sendToPrinter(zpl);
  if (fehler) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = r.code + '_label.zpl';
    a.click();
  } else {
    printedFb(t('exp.printed', { code: r.code }));
  }
}
// ── Laborbuch drucken ───────────────────────────────────────
//
// Fuer einen Bericht, fuer eine Pruefung und fuers Archiv: ein Versuch oder
// alle eines Zeitraums auf Papier, mit ihren Gefaessen, den Fotos samt
// Pruefsumme und dem ganzen Verlauf. Gedruckt wird ueber den Druckdialog des
// Browsers, und dort ist "Als PDF sichern" das, was man ablegt. Ein eigenes PDF
// waere eine Bibliothek mehr fuer etwas, das jeder Browser schon kann.
//
// Ein eigenes Fenster wie bei der Arbeitsliste: das Blatt hat Papiermasse und
// keine Seitenleiste, und die Anwendung dahinter bleibt, wie sie war. Die
// Groessen stehen in pt und mm, weil Papier keine Schrifteinstellung liest.
// Der Verlauf ist derselbe wie in der Anwendung (pjVerlaufZeile), nur ohne
// Vorschaubilder: die Fotos stehen gross darueber.
const PJ_LB_STIL =
  '@page{size:A4;margin:14mm 14mm 16mm;@bottom-right{content:counter(page) " / " counter(pages);font:8pt Arial,sans-serif}}' +
  'body{font:10pt/1.35 Arial,Helvetica,sans-serif;color:#000;margin:0}' +
  '@media screen{body{max-width:182mm;margin:10mm auto;padding:0 4mm}}' +
  'h1{font-size:16pt;margin:0 0 2pt}h2{font-size:13pt;margin:0 0 3pt;padding-bottom:2pt;border-bottom:1.5pt solid #000}' +
  'h3{font-size:10.5pt;margin:10pt 0 3pt}.kopf{color:#444;font-size:9pt;margin-bottom:3pt}' +
  'section{break-before:page}section:first-of-type{break-before:auto;margin-top:10pt}' +
  '.meta{color:#333;font-size:9pt}.code{font-weight:bold}.leer{color:#666;font-style:italic;margin:0}' +
  'table{width:100%;border-collapse:collapse;font-size:9pt}' +
  'th,td{text-align:left;vertical-align:top;padding:2pt 4pt;border-bottom:0.5pt solid #bbb}' +
  'th{border-bottom:1pt solid #000;font-size:8pt}tr,li,figure{break-inside:avoid}' +
  '.text{white-space:pre-wrap;border-left:2pt solid #ccc;padding-left:6pt}.weg{color:#666}' +
  '.fotos{display:flex;flex-wrap:wrap;gap:6pt}figure{margin:0;width:calc(50% - 3pt)}' +
  'figure img{display:block;width:100%;height:auto;border:0.5pt solid #999}' +
  'figure .leer{border:0.5pt dashed #999;padding:18pt 6pt;text-align:center}' +
  'figcaption{font-size:8pt;margin-top:2pt}.hash{font-family:monospace;font-size:7pt;overflow-wrap:anywhere}' +
  '.hist{list-style:none;margin:0;padding:0;font-size:9pt}.pj-hist{padding:2pt 0;border-bottom:0.5pt solid #ddd}' +
  '.pj-hist-kopf{color:#444;font-size:8pt}.pj-hist-wert{white-space:pre-wrap}' +
  'del{color:#555}ins{text-decoration:none;font-weight:bold}' +
  '.kette{margin-top:14pt;border-top:1pt solid #000;padding-top:4pt;font-size:8.5pt;break-inside:avoid}' +
  '.kette p{margin:2pt 0}';
// Gedruckt wird, wenn alle Bilder da sind; sonst kaemen leere Rahmen aufs Papier.
const PJ_LB_DRUCK =
  'function drucken(){var b=[].slice.call(document.images);' +
  'Promise.all(b.map(function(i){return i.complete?0:new Promise(function(r){i.onload=i.onerror=r})}))' +
  '.then(function(){setTimeout(function(){window.print()},200)})}' +
  "if(document.readyState==='complete')drucken();else window.addEventListener('load',drucken)";
// Ein Tag aus dem Datumsfeld so, wie er in der Anwendung steht.
function pjLbTag(tag) {
  return tag ? fmtDt(parseDateStr(tag)) : '—';
}
// Wer etwas entfernt hat und wann. Auf dem Papier gibt es keine Klappe, hinter
// der das Entfernte liegt; es steht mit in der Liste und sagt, dass es weg ist.
function pjLbEntfernt(x) {
  if (!x.removedAt) return '';
  return x.removedBy
    ? t('exp.lbRemovedBy', { d: fmtDtTime(x.removedAt), user: x.removedBy })
    : t('exp.removedAt', { d: fmtDtTime(x.removedAt) });
}
function pjLbGefaess(r) {
  const verknuepft = [r.cultureId, r.batchId].filter(Boolean).join(' · ');
  return (
    `<tr${r.removedAt ? ' class="weg"' : ''}>` +
    `<td class="code">${esc(r.code)}</td><td>${esc(r.what)}</td><td>${esc(r.result)}</td>` +
    `<td>${esc(t('exp.out.' + r.outcome))}</td><td>${esc(verknuepft)}</td>` +
    `<td>${esc(pjLbEntfernt(r) || t('exp.lbActive'))}</td></tr>`
  );
}
// Ein Foto mit allem, was es belegt: wann, von wem, an welchem Gefaess, und
// seine Pruefsumme. Mit ihr laesst sich spaeter zeigen, dass eine Datei im
// Archiv genau die ist, die an dem Tag hochgeladen wurde. Ein endgueltig
// geloeschtes Foto hat kein Bild mehr, seine Pruefsumme steht trotzdem da.
function pjMb(bytes) {
  return (Number(bytes || 0) / (1024 * 1024)).toLocaleString(loc(), { maximumFractionDigits: 1 });
}
function pjLbFoto(v, f, nr, codes) {
  const wann = fmtDtTime(f.uploadedAt);
  const bild = f.purged
    ? `<div class="leer">${esc(t('exp.purged'))}</div>`
    : `<img src="${esc('/api/experiments/' + v.id + '/photos/' + encodeURIComponent(f.uuid))}" ` +
      `alt="${esc(t('exp.photoAlt', { n: nr, d: wann }))}">`;
  const zeile = [t('exp.lbPhoto', { n: nr }), wann, f.uploadedBy, f.runId ? codes[f.runId] : '']
    .filter(Boolean)
    .join(' · ');
  const weg = pjLbEntfernt(f);
  // Das Original belegt, was die Kamera aufgenommen hat; das gedruckte Bild ist
  // die verkleinerte Fassung. Beide Pruefsummen, damit sich jede Datei im
  // Archiv zuordnen laesst.
  const o = f.original;
  const original = o
    ? `<div class="hash">${esc(t('exp.lbOriginal', { w: o.width || '?', h: o.height || '?', mb: pjMb(o.bytes) }))}` +
      `<br>SHA-256 ${esc(o.sha256)}</div>`
    : '';
  return (
    `<figure${f.removedAt ? ' class="weg"' : ''}>${bild}<figcaption>${esc(zeile)}` +
    (weg ? '<br>' + esc(weg) : '') +
    `<div class="hash">SHA-256 ${esc(f.sha256)}</div>${original}</figcaption></figure>`
  );
}
function pjLbVersuch(v, pakete) {
  // Das Laborbuch kennt jedes Gefaess, auch die entfernten, in einer Liste.
  const codes = pjVerlaufCodes({ runs: v.runs, removedRuns: [] }, v.history);
  const meta = [
    v.workPackageId != null ? t('exp.wp') + ' ' + pjApName(pakete, v.workPackageId) : '',
    t('exp.hist.f.experiment.started') + ' ' + pjLbTag(v.started),
    t('exp.hist.f.experiment.ended') + ' ' + pjLbTag(v.ended),
    t('exp.hist.status.' + v.status),
    v.archived ? t('exp.lbArchived') : ''
  ]
    .filter(Boolean)
    .join(' · ');
  const text = (titel, inhalt) =>
    `<h3>${esc(titel)}</h3>` + (inhalt ? `<div class="text">${esc(inhalt)}</div>` : '<p class="leer">—</p>');
  const spalten = [
    t('exp.hist.f.run.code'),
    t('exp.hist.f.run.what'),
    t('exp.hist.f.run.result'),
    t('exp.hist.f.run.outcome'),
    t('exp.lbLink'),
    t('exp.lbState')
  ];
  const gefaesse = v.runs.length
    ? '<table><thead><tr>' +
      spalten.map((s) => `<th>${esc(s)}</th>`).join('') +
      '</tr></thead><tbody>' +
      v.runs.map(pjLbGefaess).join('') +
      '</tbody></table>'
    : `<p class="leer">${esc(t('exp.noVessels'))}</p>`;
  const fotos = v.photos.length
    ? '<div class="fotos">' + v.photos.map((f, i) => pjLbFoto(v, f, i + 1, codes)).join('') + '</div>'
    : `<p class="leer">${esc(t('exp.lbNoPhotos'))}</p>`;
  // Von oben nach unten, wie ein Laborbuch sich liest: das Aelteste zuerst. Der
  // Ausgangsstand ist eine Zeile, wie in der Anwendung.
  const zeilen = v.history.filter((e) => e.action !== 'baseline').map((e) => pjVerlaufZeile(e, codes, null));
  const anfang = v.history.find((e) => e.action === 'baseline');
  if (anfang) {
    zeilen.unshift(
      `<li class="pj-hist"><div class="pj-hist-kopf">${esc(fmtDtTime(anfang.at))}</div>` +
        `<div class="pj-hist-was">${esc(t('exp.hist.baseline'))}</div></li>`
    );
  }
  const verlauf = zeilen.length
    ? '<ul class="hist">' + zeilen.join('') + '</ul>'
    : `<p class="leer">${esc(t('exp.lbHistNone'))}</p>`;
  return (
    `<section><h2><span class="code">${esc(v.code)}</span> ${esc(v.title)}</h2>` +
    `<div class="meta">${esc(meta)}</div>` +
    `<h3>${esc(t('exp.lbRuns'))}</h3>` +
    gefaesse +
    text(t('exp.hist.f.experiment.recipe'), v.recipe) +
    text(t('exp.conclusion'), v.outcome) +
    `<h3>${esc(t('exp.photos', { n: v.photos.length }))}</h3>` +
    fotos +
    `<h3>${esc(t('exp.hist'))}</h3>` +
    verlauf +
    '</section>'
  );
}
// Wer die Arbeitspakete angelegt, umbenannt oder ausgeblendet hat: je Paket
// sein heutiger Name, darunter sein Verlauf, das Aelteste zuerst. Ein Paket
// ohne Eintrag im Zeitraum kommt nicht vor, und ohne Eintraege gibt es den
// Abschnitt nicht.
function pjLbArbeitspakete(buch, pakete) {
  const jePaket = new Map();
  for (const e of buch.workPackageHistory || []) {
    if (!jePaket.has(e.entityId)) jePaket.set(e.entityId, []);
    jePaket.get(e.entityId).push(e);
  }
  if (!jePaket.size) return '';
  const teile = [...jePaket.entries()].map(([id, eintraege]) => {
    const zeilen = eintraege.filter((e) => e.action !== 'baseline').map((e) => pjVerlaufZeile(e, {}, null));
    const anfang = eintraege.find((e) => e.action === 'baseline');
    if (anfang) {
      zeilen.unshift(
        `<li class="pj-hist"><div class="pj-hist-kopf">${esc(fmtDtTime(anfang.at))}</div>` +
          `<div class="pj-hist-was">${esc(t('exp.hist.baseline'))}</div></li>`
      );
    }
    const paket = pakete.find((w) => w.id === id);
    const name = pjApName(pakete, id) + (paket && paket.archived ? ' (' + t('exp.lbWpHidden') + ')' : '');
    return `<h3>${esc(name)}</h3><ul class="hist">${zeilen.join('')}</ul>`;
  });
  return `<section><h2>${esc(t('exp.lbWpHist'))}</h2>${teile.join('')}</section>`;
}
// Die Pruefkette unter dem Blatt: ob der Verlauf noch so ist, wie er geschrieben
// wurde, das juengste Glied und der juengste Zeitstempel darauf. Wer das Blatt
// spaeter neben die Datei legt, sieht an dem Glied, ob seitdem etwas geaendert
// wurde; der Zeitstempel belegt, dass es das Glied an dem Tag schon gab, und
// seine Signatur, ob er von der Stelle kommt.
function pjLbKette(buch) {
  const k = buch.chain;
  if (!k) return '';
  const hash = (h) => `<div class="hash">SHA-256 ${esc(h)}</div>`;
  const zeilen = [
    esc(k.ok ? t('exp.lbChainOk', { n: k.entries }) : t('exp.lbChainBroken', { id: k.broken[0] ? k.broken[0].id : '?' }))
  ];
  for (const a of k.adopted || []) {
    zeilen.push(esc(t('exp.lbChainAdopted', { d: fmtDtTime(a.at), n: a.count ?? '?', from: a.from ?? '?', to: a.to ?? '?' })));
  }
  // Jede zurueckgespielte Sicherung: bis wohin ihr Verlauf reicht, was dabei
  // verworfen wurde, je Versuch und Paket, auch was es seitdem nicht mehr gibt,
  // und wo der Stand davor liegt. Ein Blatt von vorher, das ein spaeteres Glied
  // nennt, passt danach nicht mehr zur Datei; hier steht, warum.
  const je = (liste) =>
    liste
      .map((x) => (x.code || '#' + x.id) + ': ' + x.discarded + (x.inBackup === false ? ' (' + t('exp.lbChainRestoreGone') + ')' : ''))
      .join(', ');
  for (const r of k.restores || []) {
    // Eine Sicherung ohne Verlauf (von bevor es ihn gab) verwirft alles, und
    // nach Kennung gezaehlt ist das dann genau.
    const teile = [
      r.upTo
        ? t('exp.lbChainRestore', { d: fmtDtTime(r.at), user: r.user || '—', last: r.upTo, n: r.discarded ?? '?' })
        : t('exp.lbChainRestoreNone', { d: fmtDtTime(r.at), user: r.user || '—', n: r.discarded ?? '?' })
    ];
    if (r.experiments && r.experiments.length) teile.push(t('exp.lbChainRestoreExp', { list: je(r.experiments) }));
    if (r.workPackages && r.workPackages.length) teile.push(t('exp.lbChainRestoreWp', { list: je(r.workPackages) }));
    if (r.counted === 'id' && r.upTo) teile.push(t('exp.lbChainRestoreById'));
    if (r.counted === 'migrated') teile.push(t('exp.lbChainRestoreMigrated'));
    if (r.kept) teile.push(t('exp.lbChainRestoreKept', { file: r.kept }));
    zeilen.push(esc(teile.join(' ')));
  }
  if (k.head) zeilen.push(esc(t('exp.lbChainHead', { id: k.head.historyId })) + hash(k.head.hash));
  const s = k.lastStamp;
  if (s) {
    zeilen.push(esc(t('exp.lbChainStamp', { d: fmtDtTime(s.genTime), id: s.historyId, tsa: s.tsa })) + hash(s.hash));
    if (s.signature === 'ok') zeilen.push(esc(t('exp.lbChainSigOk', { signer: s.signer || '?' })));
    else if (s.signature === 'bad') zeilen.push(esc(t('exp.lbChainSigBad')));
    else if (s.signature === 'unchecked') zeilen.push(esc(t('exp.lbChainSigUnchecked')));
    if (k.head && k.head.historyId > s.historyId) zeilen.push(esc(t('exp.lbChainAfter', { id: s.historyId })));
  } else {
    zeilen.push(esc(t('exp.lbChainNoStamp')));
  }
  // Halten aeltere Stempel nicht, oder lassen sie sich nicht pruefen, steht
  // das auch auf dem Blatt, nicht nur der juengste.
  const sig = k.signatures;
  if (sig && k.stamps > 1 && (sig.bad || sig.unchecked)) {
    zeilen.push(esc(t('exp.lbChainSigAll', { total: k.stamps, bad: sig.bad, unchecked: sig.unchecked })));
  }
  return `<div class="kette"><h3>${esc(t('exp.lbChain'))}</h3>${zeilen.map((z) => '<p>' + z + '</p>').join('')}</div>`;
}
// Das ganze Blatt. buch ist die Antwort von /api/lab-book, wer der Name dessen,
// der druckt.
function pjLbHtml(buch, titel, wer) {
  const zeitraum = buch.from || buch.to;
  const pakete = buch.workPackages || [];
  const kopf = [
    buch.workPackageId != null ? t('exp.lbWpFilter', { name: pjApName(pakete, buch.workPackageId) }) : '',
    zeitraum ? t('exp.lbRange', { from: pjLbTag(buch.from), to: pjLbTag(buch.to) }) : '',
    t('exp.lbCreated', { d: fmtDtTime(buch.createdAt), user: wer || '—' })
  ]
    .filter(Boolean)
    .join(' · ');
  const inhalt = buch.experiments.length
    ? buch.experiments.map((v) => pjLbVersuch(v, pakete)).join('')
    : `<p class="leer">${esc(t('exp.lbNone'))}</p>`;
  // Der Titel des Fensters ist der Dateiname, den der Druckdialog fuer das PDF
  // vorschlaegt. Mit Paket und Zeitraum heissen zwei Berichte nicht gleich, und
  // mit den Tagen als JJJJ-MM-TT stehen sie im Ordner in ihrer Reihenfolge.
  const paket = buch.workPackageId != null ? pakete.find((w) => w.id === buch.workPackageId) : null;
  const dateiname = [
    titel,
    paket ? paket.code : '',
    zeitraum ? t('exp.lbRange', { from: buch.from || '…', to: buch.to || '…' }) : ''
  ]
    .filter(Boolean)
    .join(' ');
  return (
    `<!doctype html><html lang="${esc(currentLang)}"><head><meta charset="utf-8">` +
    `<title>${esc(dateiname)}</title><style>${PJ_LB_STIL}</style></head><body>` +
    `<h1>${esc(titel)}</h1><div class="kopf">${esc(kopf)}</div>` +
    (zeitraum ? `<div class="kopf">${esc(t('exp.lbNote'))}</div>` : '') +
    pjLbArbeitspakete(buch, pakete) +
    inhalt +
    pjLbKette(buch) +
    '<scr' +
    'ipt>' +
    PJ_LB_DRUCK +
    '<\/scr' +
    'ipt></body></html>'
  );
}
// Das Fenster geht im Tippen selbst auf und nicht erst, wenn die Daten da sind:
// eines, das eine Anfrage spaeter kommt, haelt der Browser fuer Werbung und
// blockiert es. Bis die Daten da sind, sagt es, dass es arbeitet.
function pjLbDrucken(pfad, titel) {
  const win = window.open('', '_blank');
  if (!win) {
    toast(t('worklist.popupBlocked'), 'err');
    return Promise.resolve(false);
  }
  win.document.write(
    `<!doctype html><html><head><meta charset="utf-8"><title>${esc(titel)}</title></head>` +
      `<body><p>${esc(t('exp.lbPreparing'))}</p></body></html>`
  );
  win.document.close();
  const wer = (currentUser && currentUser.username) || '';
  return apiGet(pfad).then(
    (buch) => {
      // Wer das Fenster schon zugemacht hat, will nichts mehr drucken.
      if (win.closed) return false;
      win.document.open();
      win.document.write(pjLbHtml(buch, titel, wer));
      win.document.close();
      return true;
    },
    (e) => {
      if (!win.closed) win.close();
      toast(t('exp.lbErr', { err: (e && e.message) || '' }), 'err');
      return false;
    }
  );
}
// Der Zeitraum fuer das Laborbuch, unter der Liste. Vorgeschlagen ist das
// laufende Jahr bis heute: so fragen Berichte meist.
let pjLbOffen = false;
function pjLbZeitraum() {
  if (!experiments.length) return '';
  const heute = new Date();
  return (
    `<details class="card pj-sec pj-fold" data-pj-lb="1"${pjLbOffen ? ' open' : ''}>` +
    `<summary class="sec">${esc(t('exp.lb'))}</summary>` +
    `<p class="pj-count">${esc(t('exp.lbHint'))}</p>` +
    '<div class="pj-bar pj-lb-bar">' +
    `<label class="pj-lb-feld">${esc(t('exp.lbFrom'))}` +
    `<input type="date" id="pj-lb-von" value="${localDateStr(new Date(heute.getFullYear(), 0, 1))}"></label>` +
    `<label class="pj-lb-feld">${esc(t('exp.lbTo'))}` +
    `<input type="date" id="pj-lb-bis" value="${localDateStr(heute)}"></label>` +
    // Fuer den Bericht je Arbeitspaket; ohne Pakete gibt es nichts zu waehlen.
    (workPackages.length
      ? `<label class="pj-lb-feld">${esc(t('exp.wp'))}<select id="pj-lb-ap">` +
        `<option value="">${esc(t('exp.lbWpAll'))}</option>` +
        workPackages.map((w) => `<option value="${w.id}">${esc(w.code + ' · ' + w.title)}</option>`).join('') +
        '</select></label>'
      : '') +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-lbdruck="1">${esc(t('exp.lbPrint'))}</button>` +
    // Das Archiv: dasselbe als ZIP, mit Fotos, Originalen, Pruefkette und
    // Zeitstempeln, pruefbar ohne den Tracker. Es kann gross werden; nur fuer
    // Admins, und der Server baut eins zur Zeit.
    (currentUser && currentUser.role === 'admin'
      ? `<button type="button" class="btn btn-sm fs-xs" data-pj-lbarchiv="1" title="${esc(t('exp.lbArchiveHint'))}">` +
        `${esc(t('exp.lbArchive'))}</button>`
      : '') +
    '</div></details>'
  );
}
// Die Auswahl unter der Liste als Abfrage fuer /api/lab-book und das Archiv,
// oder null, wenn das Ende vor dem Anfang liegt.
function pjLbFrage() {
  const von = (document.getElementById('pj-lb-von') || {}).value || '';
  const bis = (document.getElementById('pj-lb-bis') || {}).value || '';
  const paket = (document.getElementById('pj-lb-ap') || {}).value || '';
  if (von && bis && von > bis) return null;
  return [
    von ? 'from=' + encodeURIComponent(von) : '',
    bis ? 'to=' + encodeURIComponent(bis) : '',
    paket ? 'workPackage=' + encodeURIComponent(paket) : ''
  ]
    .filter(Boolean)
    .join('&');
}
// Der Griff zur Kamera. `capture="environment"` oeffnet am Telefon direkt die
// Ruecklinse statt der Galerie. Zusammengedrueckt wird im Browser mit derselben
// Funktion, die die Kontaminationsfotos benutzt: 1280 px fuers Bild, 200 px
// fuer die Kachel — ein Telefonfoto sind sonst 4 MB.
// Die gewaehlten Bilder an pjKamera. Erst abschreiben, dann leeren: files ist
// die Liste des Feldes selbst, und value = '' leert genau diese Liste. Mit der
// Liste statt einer Abschrift kam bei pjKamera nie ein Bild an. Geleert wird,
// damit dasselbe Bild ein zweites Mal gewaehlt werden kann.
function pjKameraAuswahl(eingabe, id) {
  const dateien = Array.from(eingabe.files || []);
  eingabe.value = '';
  if (id) pjKamera(id, dateien);
}
// Mehr nimmt der Server in einem Zug nicht an (EXP_MAX_PHOTOS_PER_CALL).
const PJ_MAX_FOTOS = 8;
// Die Zeile unter "Foto aufnehmen": was die Kamera eines Versuchs gerade tut.
// Sie steht im Zustand, nicht nur im Element: der Sync nach dem eigenen
// Speichern zeichnet die Seite neu, und eine gemerkte Zeile schrieb danach in
// ein Element, das nicht mehr auf der Seite hing. pjDetail zeichnet sie mit.
let pjKameraZeile = { id: null, text: '' };
function pjKameraStatus(versuchId, text) {
  pjKameraZeile = { id: versuchId, text: text || '' };
  const el = document.getElementById('pj-cam-status');
  if (el && pjOffen === versuchId) el.textContent = pjKameraZeile.text;
}
async function pjKamera(versuchId, dateien) {
  const bilder = Array.from(dateien || []).filter((f) => f && f.type && f.type.startsWith('image/'));
  if (!bilder.length) return;
  // Was ueber die Grenze geht, bleibt liegen, aber nicht stillschweigend: wer
  // zwoelf Bilder waehlt und acht wiederfindet, sucht sonst nach den vier.
  if (bilder.length > PJ_MAX_FOTOS) {
    toast(t('exp.photoLimit', { n: PJ_MAX_FOTOS, rest: bilder.length - PJ_MAX_FOTOS }), 'err');
  }
  const fertig = [];
  for (const datei of bilder.slice(0, PJ_MAX_FOTOS)) {
    pjKameraStatus(versuchId, t('contam.compressing', { name: datei.name }));
    try {
      fertig.push(await _crCompressFile(datei));
    } catch (e) {
      pjKameraStatus(versuchId, t('contam.compressErr'));
      return;
    }
  }
  pjKameraStatus(versuchId, t('exp.uploading', { n: fertig.length }));
  const r = await apiPost('/api/experiment-photos', { experimentId: versuchId, photos: fertig });
  // apiPost wirft nicht, es meldet {error}. Ohne diese Pruefung sah ein
  // gescheiterter Upload aus wie ein gelungener: die Statuszeile wurde leer,
  // das Nachladen setzte den Sync wieder auf gruen, und die Bilder waren weg.
  if (!r || r.error) {
    const warum = t('exp.uploadErr', { err: (r && r.error) || '' });
    pjKameraStatus(versuchId, warum);
    toast(warum, 'err');
    return;
  }
  // Kein vorlaeufiges Einhaengen: die Kennung des Bildes vergibt der Server,
  // und eine Kachel ohne sie zeigt ein kaputtes Bild. Einmal nachladen ist
  // schneller geschrieben und immer richtig. Die Fotos sind gespeichert und
  // erscheinen sofort; die Originale kommen danach.
  await loadData();
  renderVersuch();
  await pjOriginaleHochladen(versuchId, bilder.slice(0, PJ_MAX_FOTOS), r.ids || []);
  pjKameraStatus(versuchId, '');
  await loadData();
  renderVersuch();
}
// Die Originale zu den Fotos, die eben gespeichert wurden: dieselbe Reihenfolge
// wie die Kennungen, die der Server zurueckgab. Das Foto selbst ist schon da, in
// 1280 px; scheitert ein Original, bleibt es dabei, und das wird gesagt.
// Nur JPEG: ein anderes Format haette der Server nicht von seinem Standort
// befreien koennen. Eins nach dem anderen, roh, ohne Base64.
function pjIstJpeg(datei) {
  return datei.type === 'image/jpeg' || (!datei.type && /\.jpe?g$/i.test(datei.name || ''));
}
// Mehr nimmt der Server fuer ein Original nicht an (ORIGINAL_MAX_BYTES).
const PJ_ORIGINAL_MAX = 40 * 1024 * 1024;
// Wie lange ein Original vor jedem neuen Versuch wartet: knapp eine Minute in
// allem. Ohne Netz antwortet der Service Worker sofort mit 503, und zwei
// Versuche ohne Pause waren in Millisekunden verbraucht.
const PJ_ORIGINAL_PAUSEN = [2000, 5000, 15000, 30000];
function pjWarten(ms) {
  return new Promise((r) => setTimeout(r, ms));
}
// Ein Original zu seinem Foto. Wiederholt wird, was sich durch Warten aendern
// kann: kein Netz, ein Fehler am Server. Nicht eine Absage (4xx), die beim
// naechsten Mal dieselbe waere, und nicht 507: ein voller Speicher wird nicht
// leerer, waehrend das Handy 40 MB noch einmal schickt. Gibt den Status der
// letzten Antwort zurueck, 0 ohne Netz. beimWarten(): vor jeder Pause.
async function pjOriginalSenden(fotoId, datei, beimWarten) {
  for (let i = 0; ; i++) {
    let status = 0;
    try {
      const antwort = await authFetch('/api/experiment-photos/' + fotoId + '/original', {
        method: 'PUT',
        headers: { 'Content-Type': 'image/jpeg' },
        body: datei
      });
      status = antwort.status;
    } catch (e) {
      // authFetch wirft nach einem 401, auf dem Weg zur Anmeldung.
      if (e && e.message === 'unauthorized') return 401;
    }
    if (status && (status < 500 || status === 507)) return status;
    if (i >= PJ_ORIGINAL_PAUSEN.length) return status;
    if (beimWarten) beimWarten();
    await pjWarten(PJ_ORIGINAL_PAUSEN[i]);
  }
}
async function pjOriginaleHochladen(versuchId, dateien, ids) {
  const paare = dateien.map((d, i) => [d, ids[i]]).filter(([d, id]) => id && pjIstJpeg(d));
  const senden = paare.filter(([d]) => !(d.size > PJ_ORIGINAL_MAX));
  const zuGross = paare.length - senden.length;
  const ohne = dateien.filter((d) => !pjIstJpeg(d)).length;
  let fehl = 0;
  let voll = 0;
  for (const [, id] of senden) pjOriginaleUnterwegs.add(id);
  try {
    for (let i = 0; i < senden.length; i++) {
      // Ist der Speicher voll, bleiben auch die uebrigen draussen, ohne dass
      // jedes noch einmal ganz hochgeht, um dasselbe zu hoeren.
      if (voll) {
        voll++;
        continue;
      }
      const [datei, id] = senden[i];
      const zeile = t('exp.originalsUploading', { done: i + 1, total: senden.length });
      pjKameraStatus(versuchId, zeile);
      const status = await pjOriginalSenden(id, datei, () =>
        pjKameraStatus(versuchId, zeile + ' ' + t('exp.originalsRetry'))
      );
      if (status === 507) voll++;
      else if (status === 401) {
        fehl += senden.length - i;
        break;
      } else if (status !== 200) fehl++;
    }
  } finally {
    for (const [, id] of senden) pjOriginaleUnterwegs.delete(id);
  }
  // Eine Meldung fuer alles: zwei nacheinander teilen sich einen Platz, und die
  // zweite ueberschrieb die erste, den Fehler eingeschlossen.
  const teile = [];
  if (voll) teile.push(t('exp.originalsFull', { n: voll }));
  if (fehl) teile.push(t('exp.originalsFailed', { n: fehl }));
  if (zuGross) teile.push(tp('exp.originalsTooBig', zuGross));
  if (ohne) teile.push(tp('exp.originalsNotJpeg', ohne));
  if (teile.length) toast(teile.join(' '), voll || fehl || zuGross ? 'err' : undefined);
}
// Ein Original nachreichen, fuer ein Foto, das noch keins hat. Gewaehlt wird
// die Datei, die die Kamera geschrieben hat; der Server prueft, dass sie zu
// diesem Foto passt.
async function pjOriginalNachreichen(versuchId, fotoId, datei) {
  if (!datei) return;
  if (!pjIstJpeg(datei)) {
    toast(tp('exp.originalsNotJpeg', 1), 'err');
    return;
  }
  if (datei.size > PJ_ORIGINAL_MAX) {
    toast(tp('exp.originalsTooBig', 1), 'err');
    return;
  }
  const zeile = t('exp.originalsUploading', { done: 1, total: 1 });
  pjKameraStatus(versuchId, zeile);
  pjOriginaleUnterwegs.add(fotoId);
  let status;
  try {
    status = await pjOriginalSenden(fotoId, datei, () =>
      pjKameraStatus(versuchId, zeile + ' ' + t('exp.originalsRetry'))
    );
  } finally {
    pjOriginaleUnterwegs.delete(fotoId);
  }
  pjKameraStatus(versuchId, '');
  if (status === 200) toast(t('exp.originalAdded'));
  else if (status === 422) toast(t('exp.originalMismatch'), 'err');
  else if (status === 507) toast(t('exp.originalsFull', { n: 1 }), 'err');
  else toast(t('exp.originalsFailed', { n: 1 }), 'err');
  await loadData();
  renderVersuch();
}
// apiPost, apiPatch und apiDelete werfen nicht, sie melden {error}. Wer das
// nicht prueft, zeigt einen gescheiterten Schreibvorgang wie einen gelungenen:
// der Sync-Punkt wird kurz rot, und das naechste Nachladen setzt ihn wieder auf
// gruen. pjFehlgeschlagen sagt es laut und gibt zurueck, ob etwas schiefging.
function pjFehlgeschlagen(r) {
  if (r && !r.error) return false;
  toast(t('proj.saveErr', { err: (r && r.error) || '' }), 'err');
  return true;
}
// Den Fokus auf ein Element nach dem Neuzeichnen; gibt es es nicht (mehr),
// bleibt alles, wie es ist.
function pjFokus(sel) {
  const el = document.querySelector(sel);
  if (el && typeof el.focus === 'function') el.focus();
}
// Tippen speichert beim Verlassen des Feldes, nicht bei jedem Zeichen: ein
// Ergebnis wird in einem Stueck eingetragen, und ein PATCH je Tastendruck waere
// eine Zeile Nutzen und hundert Anfragen.
function pjChange(e) {
  if (e.target.dataset && e.target.dataset.pjDocFor) {
    const datei = e.target.files && e.target.files[0];
    e.target.value = '';
    if (datei) pjDocImportieren(e.target.dataset.pjDocFor, datei);
    return;
  }
  // Code oder Titel eines Arbeitspakets. Leer gibt es nicht: das Feld zeigt
  // dann wieder, was gespeichert ist.
  if (e.target.dataset && e.target.dataset.pjAp) {
    const w = workPackages.find((x) => x.id === Number(e.target.dataset.pjAp));
    const feldName = e.target.dataset.pjApfeld;
    if (!w || !feldName) return;
    const neuerWert = String(e.target.value || '').trim();
    if (!neuerWert || neuerWert === w[feldName]) {
      e.target.value = w[feldName];
      return;
    }
    const alt = w[feldName];
    w[feldName] = neuerWert;
    apiPatch('/api/work-packages/' + w.id, { [feldName]: neuerWert }).then((antwort) => {
      if (pjFehlgeschlagen(antwort)) {
        w[feldName] = alt;
        renderVersuch();
      }
    });
    return;
  }
  const feld = e.target.closest('[data-pj-feld]');
  if (!feld) return;
  const name = feld.dataset.pjFeld;
  // Das Arbeitspaket kommt aus einer Auswahl als Text; gespeichert wird die
  // Kennung, und keins heisst null.
  const wert = name === 'workPackageId' ? (feld.value ? Number(feld.value) : null) : feld.value;
  if (feld.dataset.pjRun) {
    const id = Number(feld.dataset.pjRun);
    const v = pjExp(pjOffen);
    const r = v && v.runs.find((x) => x.id === id);
    // Eine veraltete Zeile: das Gefaess ist inzwischen entfernt, etwa auf einem
    // anderen Geraet. Nichts schicken, neu zeichnen und sagen, warum.
    if (!r) {
      toast(t('exp.runGone'), 'err');
      renderVersuch();
      return;
    }
    const vorher = r[name];
    r[name] = wert;
    apiPatch('/api/experiment-runs/' + id, { [name]: wert }).then((antwort) => {
      // Nicht gespeichert: der alte Wert gilt wieder. Ein Ausgang steht in
      // einer Auswahl, die dann den gespeicherten zeigen muss; ein Ergebnis
      // bleibt im Feld stehen, damit das Getippte nicht verloren ist.
      if (pjFehlgeschlagen(antwort)) {
        r[name] = vorher;
        if (name === 'outcome') renderVersuch();
        return;
      }
      pjVerlaufNeu();
    });
    if (name === 'outcome') renderVersuch();
    return;
  }
  if (feld.dataset.pjExp) {
    const id = Number(feld.dataset.pjExp);
    const v = pjExp(id);
    const vorher = v ? v[name] : undefined;
    if (v) v[name] = wert;
    apiPatch('/api/experiments/' + id, { [name]: wert }).then((antwort) => {
      // Der Text bleibt im Feld, nur der Stand dahinter gilt wieder als alt.
      if (pjFehlgeschlagen(antwort)) {
        if (v) v[name] = vorher;
        return;
      }
      pjVerlaufNeu();
    });
  }
}
// Ein Anlegen, dessen Antwort noch aussteht; ein zweiter Tipp wartet.
let pjGefaessUnterwegs = false;
let pjVersuchUnterwegs = false;
let pjPaketUnterwegs = false;
function pjVersuchClick(e) {
  const aelter = e.target.closest('[data-pj-hist-mehr]');
  if (aelter) {
    pjVerlaufLaden(Number(aelter.dataset.pjHistMehr), 'aelter');
    return true;
  }
  const rein = e.target.closest('[data-pj-open]');
  if (rein) {
    pjOffen = Number(rein.dataset.pjOpen);
    renderVersuch();
    return true;
  }
  if (e.target.closest('[data-pj-back]')) {
    pjOffen = null;
    renderVersuch();
    return true;
  }
  const nachreichen = e.target.closest('[data-pj-original]');
  if (nachreichen) {
    const eingabe = document.getElementById('pj-orig');
    if (eingabe) {
      const versuchId = pjOffen;
      const fotoId = Number(nachreichen.dataset.pjOriginal);
      // Wie bei der Kamera: der Zuhoerer haengt am Feld, das Feld wird nach
      // der Auswahl geleert, damit dieselbe Datei noch einmal gewaehlt werden kann.
      eingabe.onchange = () => {
        const datei = (eingabe.files || [])[0];
        eingabe.value = '';
        pjOriginalNachreichen(versuchId, fotoId, datei);
      };
      eingabe.click();
    }
    return true;
  }
  const kamera = e.target.closest('[data-pj-cam]');
  if (kamera) {
    const eingabe = document.getElementById('pj-cam');
    if (eingabe) {
      const id = Number(kamera.dataset.pjCam);
      // Der Zuhoerer haengt am Feld selbst, nicht an der Seite: wird die Ansicht
      // neu gezeichnet, waehrend die Auswahl offen ist, haengt das Feld nicht
      // mehr in der Seite, und ein Zuhoerer dort hoerte die Auswahl nie.
      eingabe.onchange = () => pjKameraAuswahl(eingabe, id);
      eingabe.click();
    }
    return true;
  }
  // Entfernen und Zurueckholen: danach einmal neu laden, statt die Listen hier
  // von Hand umzuhaengen. Was entfernt ist, bestimmt der Server. Der Knopf, der
  // den Fokus hatte, ist nach dem Neuzeichnen weg; der Fokus geht dorthin, wo
  // das Ding jetzt steht, statt auf die ganze Seite zu fallen.
  const neuZeichnen = (fokus) => async (r) => {
    pjFehlgeschlagen(r);
    await loadData();
    renderVersuch();
    if (fokus) pjFokus(fokus);
  };
  const versuchId = pjOffen;
  const fotoWeg = e.target.closest('[data-pj-photodel]');
  if (fotoWeg) {
    const id = Number(fotoWeg.dataset.pjPhotodel);
    confirm2(t('exp.photoDelTitle'), t('exp.photoDelMsg'), t('exp.remove'), () => {
      apiDelete('/api/experiment-photos/' + id).then(neuZeichnen('[data-pj-weg="' + versuchId + ':photos"] > summary'));
    });
    return true;
  }
  const fotoZurueck = e.target.closest('[data-pj-photoback]');
  if (fotoZurueck) {
    const id = Number(fotoZurueck.dataset.pjPhotoback);
    apiPost('/api/experiment-photos/' + id + '/restore').then(neuZeichnen('[data-pj-photodel="' + id + '"]'));
    return true;
  }
  const fotoEndgueltig = e.target.closest('[data-pj-photopurge]');
  if (fotoEndgueltig) {
    const id = Number(fotoEndgueltig.dataset.pjPhotopurge);
    confirm2(t('exp.purgeTitle'), t('exp.purgeMsg'), t('exp.purge'), () => {
      apiPost('/api/experiment-photos/' + id + '/purge').then((r) => {
        // Die Zeile ist geloescht, eine Datei aber nicht: sonst stuende hier
        // "geloescht", waehrend das Bild noch auf der Platte liegt.
        if (r && r.leftoverFiles) toast(t('exp.purgeLeftover'), 'err');
        return neuZeichnen('[data-pj-weg="' + versuchId + ':photos"] > summary')(r);
      });
    });
    return true;
  }
  const gefaessWeg = e.target.closest('[data-pj-rundel]');
  if (gefaessWeg) {
    const v = pjExp(pjOffen);
    const r = v && v.runs.find((x) => x.id === Number(gefaessWeg.dataset.pjRundel));
    if (!r) {
      toast(t('exp.runGone'), 'err');
      renderVersuch();
      return true;
    }
    confirm2(t('exp.removeRunTitle'), t('exp.removeRunMsg', { code: r.code }), t('exp.remove'), () => {
      apiDelete('/api/experiment-runs/' + r.id).then(neuZeichnen('[data-pj-weg="' + versuchId + ':runs"] > summary'));
    });
    return true;
  }
  const gefaessZurueck = e.target.closest('[data-pj-runback]');
  if (gefaessZurueck) {
    const id = Number(gefaessZurueck.dataset.pjRunback);
    apiPost('/api/experiment-runs/' + id + '/restore').then(neuZeichnen('[data-pj-rundel="' + id + '"]'));
    return true;
  }
  const drucken = e.target.closest('[data-pj-label]');
  if (drucken) {
    pjPrintRun(Number(drucken.dataset.pjLabel));
    return true;
  }
  // Das Laborbuch: ein Versuch aus seiner Ansicht, die eines Zeitraums aus der
  // Liste. Ohne Datum bleibt die Seite offen: ohne Anfang ab dem ersten Versuch,
  // ohne Ende bis heute.
  const buchVersuch = e.target.closest('[data-pj-lbexp]');
  if (buchVersuch) {
    const v = pjExp(Number(buchVersuch.dataset.pjLbexp));
    if (v) pjLbDrucken('/api/lab-book?experiment=' + v.id, t('exp.lbTitle') + ' · ' + v.code);
    return true;
  }
  if (e.target.closest('[data-pj-lbdruck]')) {
    const frage = pjLbFrage();
    if (frage === null) {
      toast(t('exp.lbBadRange'), 'err');
      return true;
    }
    pjLbDrucken('/api/lab-book' + (frage ? '?' + frage : ''), t('exp.lbTitle'));
    return true;
  }
  // Das Archiv laedt der Browser selbst herunter: ein Link mit download, den
  // der Server mit Content-Disposition beantwortet. Die Seite bleibt, wo sie ist.
  if (e.target.closest('[data-pj-lbarchiv]')) {
    const frage = pjLbFrage();
    if (frage === null) {
      toast(t('exp.lbBadRange'), 'err');
      return true;
    }
    const a = document.createElement('a');
    a.href = '/api/lab-book/archive' + (frage ? '?' + frage : '');
    a.download = '';
    document.body.appendChild(a);
    a.click();
    a.remove();
    toast(t('exp.lbArchiveStarted'));
    return true;
  }
  // Ein Arbeitspaket anlegen: Code und Titel, und der Code ist frei, gross
  // oder klein geschrieben. Danach steht es in der Liste und in jeder Auswahl.
  const paketNeu = e.target.closest('[data-pj-apadd]');
  if (paketNeu) {
    if (pjPaketUnterwegs) return true;
    const code = ((document.getElementById('pj-ap-new-code') || {}).value || '').trim();
    const title = ((document.getElementById('pj-ap-new-title') || {}).value || '').trim();
    if (!code || !title) {
      toast(t('exp.needCodeTitle'), 'err');
      return true;
    }
    if (workPackages.some((w) => w.code.toLowerCase() === code.toLowerCase())) {
      toast(t('exp.wpCodeTaken', { code }), 'err');
      return true;
    }
    pjPaketUnterwegs = true;
    paketNeu.disabled = true;
    apiPost('/api/work-packages', { code, title }).then((r) => {
      pjPaketUnterwegs = false;
      if (!r || !r.id) {
        paketNeu.disabled = false;
        pjFehlgeschlagen(r || null);
        return;
      }
      workPackages.push({ id: r.id, code, title, archived: false });
      for (const id of ['pj-ap-new-code', 'pj-ap-new-title']) {
        const feld = document.getElementById(id);
        if (feld) feld.value = '';
      }
      renderVersuch();
    });
    return true;
  }
  // Ausblenden und wieder anbieten. Ein ausgeblendetes Paket bleibt an den
  // Versuchen, die es schon tragen.
  const paketWeg = e.target.closest('[data-pj-aparch]');
  if (paketWeg) {
    const w = workPackages.find((x) => x.id === Number(paketWeg.dataset.pjAparch));
    if (!w) return true;
    const archived = !w.archived;
    apiPatch('/api/work-packages/' + w.id, { archived }).then((r) => {
      if (pjFehlgeschlagen(r)) return;
      w.archived = archived;
      renderVersuch();
    });
    return true;
  }
  const gefaess = e.target.closest('[data-pj-addrun]');
  if (gefaess) {
    if (pjGefaessUnterwegs) return true;
    const code = (document.getElementById('pj-new-code').value || '').trim();
    if (!code) {
      toast(t('exp.needCode'), 'err');
      return true;
    }
    const daten = {
      experimentId: Number(gefaess.dataset.pjAddrun),
      code,
      what: (document.getElementById('pj-new-what').value || '').trim()
    };
    // Dieselbe Pruefung wie auf dem Server, nur vor dem Abschicken: ein Code
    // bezeichnet in einem Versuch ein Gefaess, gross oder klein geschrieben.
    const hier = pjExp(daten.experimentId);
    if (hier && hier.runs.some((x) => String(x.code).toLowerCase() === code.toLowerCase())) {
      toast(t('exp.runCodeTaken', { code }), 'err');
      return true;
    }
    // Bis die Antwort da ist, nimmt der Knopf keinen zweiten Tipp an: ein
    // Doppeltipp auf langsamer Verbindung legte sonst zwei gleiche Gefaesse an.
    // Die Sperre haengt nicht am Knopf: wird die Ansicht zwischendurch neu
    // gezeichnet, ist der Knopf ein neuer und waere wieder frei.
    pjGefaessUnterwegs = true;
    gefaess.disabled = true;
    apiPost('/api/experiment-runs', daten).then((r) => {
      pjGefaessUnterwegs = false;
      if (!r || !r.id) {
        // Die Eingaben bleiben stehen; gezeichnet wird nichts neu.
        gefaess.disabled = false;
        pjFehlgeschlagen(r || null);
        return;
      }
      const v = pjExp(daten.experimentId);
      if (v) v.runs.push({ ...daten, id: r.id, result: '', outcome: 'open', removedAt: null });
      for (const id of ['pj-new-code', 'pj-new-what']) {
        const feld = document.getElementById(id);
        if (feld) feld.value = '';
      }
      renderVersuch();
    });
    return true;
  }
  const neu = e.target.closest('[data-pj-newexp]');
  if (neu) {
    if (pjVersuchUnterwegs) return true;
    const code = (document.getElementById('pj-new-vcode').value || '').trim();
    const title = (document.getElementById('pj-new-vtitle').value || '').trim();
    if (!code || !title) {
      toast(t('exp.needCodeTitle'), 'err');
      return true;
    }
    // Ein Code gehoert einem Versuch, auch einem archivierten. Das zu sagen,
    // bevor etwas abgeschickt ist, erspart die Suche nach dem Grund.
    if (experiments.some((x) => String(x.code).toLowerCase() === code.toLowerCase())) {
      toast(t('exp.codeTaken', { code }), 'err');
      return true;
    }
    const daten = { code, title, started: localDateStr(new Date()) };
    pjVersuchUnterwegs = true;
    neu.disabled = true;
    apiPost('/api/experiments', daten).then((r) => {
      pjVersuchUnterwegs = false;
      if (!r || !r.id) {
        // Code und Titel bleiben in den Feldern stehen.
        neu.disabled = false;
        pjFehlgeschlagen(r || null);
        return;
      }
      for (const id of ['pj-new-vcode', 'pj-new-vtitle']) {
        const feld = document.getElementById(id);
        if (feld) feld.value = '';
      }
      experiments.push({
        ...daten,
        id: r.id,
        ended: null,
        status: 'running',
        archived: false,
        recipe: '',
        outcome: '',
        // Dieselbe Form wie aus /api/data, damit nichts, was sie liest, einen
        // eben angelegten Versuch als Sonderfall kennen muss.
        runs: [],
        removedRuns: [],
        photos: [],
        removedPhotos: []
      });
      // Direkt hinein: wer gerade einen Ansatz angelegt hat, will jetzt die
      // Gefaesse dazuschreiben und nicht erst eine Liste ansehen.
      pjOffen = r.id;
      renderVersuch();
    });
    return true;
  }
  // Abgeschlossen heisst: Enddatum setzen und aus der laufenden Liste nehmen.
  // Die Gefaesse bleiben, das Fazit bleibt, alles steht im Archiv darunter.
  const fertig = e.target.closest('[data-pj-finish]');
  if (fertig) {
    const id = Number(fertig.dataset.pjFinish);
    const v = pjExp(id);
    if (!v) return true;
    confirm2(t('exp.finishTitle'), t('exp.finishMsg', { code: v.code }), t('exp.finish'), () => {
      const vorher = { status: v.status, ended: v.ended };
      v.status = 'done';
      v.ended = localDateStr(new Date());
      apiPatch('/api/experiments/' + id, { status: 'done', ended: v.ended }).then((antwort) => {
        // Nicht abgeschlossen: der Versuch laeuft weiter und steht wieder da.
        if (pjFehlgeschlagen(antwort)) {
          v.status = vorher.status;
          v.ended = vorher.ended;
          renderVersuch();
        }
      });
      pjOffen = null;
      renderVersuch();
    });
    return true;
  }
  return false;
}

const PJ_CHK = 'mp_vorhaben_chk';
function pjChkLoad() {
  try {
    return JSON.parse(localStorage.getItem(PJ_CHK) || '{}');
  } catch (e) {
    return {};
  }
}
function pjChkSave(d) {
  try {
    localStorage.setItem(PJ_CHK, JSON.stringify(d));
  } catch (e) {
    /* privater Modus, voller Speicher: die Liste funktioniert, sie merkt es sich nur nicht */
  }
}
// Ein Haken gehoert zu einem Schritt, nicht zu einer Zeilennummer. Mit der
// Nummer wanderte er nach einem Neuimport, der oben eine Zeile einfuegt, auf den
// naechsten Schritt, und weil erledigte Zeilen ausgeblendet werden, verschwand
// damit ein Schritt, der noch offen war. Der Schluessel ist deshalb der Plan
// und der Wortlaut der Zeile (Marke und Handgriff); steht derselbe Wortlaut
// zweimal im Plan, zaehlt ein Zusatz mit. Plan und Rest trennt ein |, das ein
// Planschluessel nicht enthalten kann (siehe _docBaustein in db.js).
function pjChkSchluessel(plan, it, gesehen) {
  const text = String(it[0] || '') + '\u0000' + String(it[1] || '');
  let h = 2166136261;
  for (let i = 0; i < text.length; i++) {
    h ^= text.charCodeAt(i);
    h = Math.imul(h, 16777619);
  }
  const basis = (h >>> 0).toString(36);
  const n = (gesehen[basis] = (gesehen[basis] || 0) + 1);
  return plan + '|' + basis + (n > 1 ? '~' + n : '');
}
// Ein Haken im alten Format dieses Plans: Plan, Bindestrich, Zeilennummer.
function pjChkAlt(k, plan) {
  return k.length > plan.length + 1 && k.startsWith(plan + '-') && /^\d+$/.test(k.slice(plan.length + 1));
}
function pjPlan(pl) {
  const st = pjChkLoad();
  const gesehen = {};
  let umgezogen = false;
  const rows = pl.items
    .map((it, i) => {
      const k = pjChkSchluessel(pl.key, it, gesehen);
      // Haken aus der Zeit, als die Zeilennummer der Schluessel war, ziehen
      // einmal um. Das nimmt an, dass sich die Unterlage seit dem Haken nicht
      // geaendert hat; mehr weiss heute niemand mehr darueber.
      const alt = pl.key + '-' + i;
      if (alt in st) {
        if (st[alt] && !st[k]) st[k] = 1;
        delete st[alt];
        umgezogen = true;
      }
      const id = 'pjc-' + k;
      const an = !!st[k];
      // Die Zeile ist kurz. Was daran noch zu wissen ist — Mengen, Temperaturen,
      // die Begruendung — steht dahinter und kommt erst auf Antippen. Eine
      // Liste, die man lesen muss, ist keine Liste mehr.
      const det = it[2]
        ? `<button type="button" class="pj-more" data-pj-more="${esc(k)}" aria-expanded="false" aria-label="${esc(t('proj.moreOn'))}">…</button>` +
          `<div class="pj-det" id="pjd-${esc(k)}" hidden>${pjText(it[2])}</div>`
        : '';
      return (
        `<div class="pj-chk${an ? ' is-done' : ''}">` +
        `<input type="checkbox" id="${esc(id)}" data-pj-chk="${esc(k)}"${an ? ' checked' : ''}>` +
        `<div class="pj-body"><span class="pj-tag">${pjText(it[0])}</span>` +
        `<label for="${esc(id)}">${pjText(it[1])}</label>${det}</div></div>`
      );
    })
    .join('');
  // Was nach alter Zeilennummer uebrig ist (eine Zeile, die es nicht mehr
  // gibt), geht ebenfalls: sonst hakte es spaeter eine neue Zeile ab, die an
  // dieselbe Stelle rueckt, und die verschwaende als erledigt.
  for (const k of Object.keys(st)) {
    if (pjChkAlt(k, pl.key)) {
      delete st[k];
      umgezogen = true;
    }
  }
  if (umgezogen) pjChkSave(st);
  return (
    `<div class="pj-plan" data-pj-plan="${esc(pl.key)}">` +
    rows +
    `<p class="pj-empty" hidden>${esc(t('proj.allDone'))}</p>` +
    '<div class="pj-bar">' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-show="${esc(pl.key)}" hidden></button>` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-reset="${esc(pl.key)}" hidden>${esc(t('proj.resetChecks'))}</button>` +
    '<span class="pj-count"></span></div></div>'
  );
}
/** Zaehlt, blendet aus und beschriftet die beiden Knoepfe — eine Stelle für alles. */
function pjPlanRefresh(box) {
  if (!box) return;
  const st = pjChkLoad();
  const zeilen = box.querySelectorAll('.pj-chk');
  let fertig = 0;
  // Den Schluessel jeder Zeile traegt ihr Kasten, pjPlan hat ihn vergeben.
  zeilen.forEach((row) => {
    const cb = row.querySelector('input');
    const an = !!(cb && st[cb.dataset.pjChk]);
    if (an) fertig++;
    row.classList.toggle('is-done', an);
    if (cb) cb.checked = an;
  });
  const zeigt = box.classList.contains('pj-show-done');
  const zahl = box.querySelector('.pj-count');
  if (zahl) zahl.textContent = t('proj.doneOf', { n: fertig, sum: zeilen.length });
  const leer = box.querySelector('.pj-empty');
  if (leer) leer.hidden = !(fertig === zeilen.length && !zeigt);
  const zeigen = box.querySelector('[data-pj-show]');
  if (zeigen) {
    zeigen.hidden = !fertig;
    zeigen.textContent = t(zeigt ? 'proj.hideDone' : 'proj.showDone', { n: fertig });
  }
  const zurueck = box.querySelector('[data-pj-reset]');
  if (zurueck) zurueck.hidden = !fertig;
}
function pjPlansRefresh(wurzel) {
  (wurzel || document).querySelectorAll('.pj-plan').forEach(pjPlanRefresh);
}
function pjItem(it) {
  const head = it.t ? `<div class="pj-h">${pjText(it.t)}</div>` : '';
  let body = '';
  if (it.p) body = `<p class="pj-p">${pjText(it.p)}</p>`;
  else if (it.ul) body = '<ul class="pj-ul">' + it.ul.map((x) => `<li>${pjText(x)}</li>`).join('') + '</ul>';
  else if (it.ol) body = '<ol class="pj-ul">' + it.ol.map((x) => `<li>${pjText(x)}</li>`).join('') + '</ol>';
  else if (it.note) body = `<div class="pj-note${it.tone === 'warn' ? ' pj-note-warn' : ''}">${pjText(it.note)}</div>`;
  else if (it.table) body = pjTable(it.table);
  else if (it.cards) body = pjCards(it.cards);
  else if (it.steps) body = pjSteps(it.steps);
  else if (it.tasks) body = pjTasks(it.tasks);
  else if (it.plan) body = pjPlan(it.plan);
  else if (it.copy)
    body =
      `<pre class="pj-pre">${esc(it.copy.text)}</pre>` +
      `<button class="btn btn-sm fs-xs" data-pj-copy="1">${esc(t('common.copy'))}</button>`;
  return head + body;
}
// ── Notizen ─────────────────────────────────────────────────
//
// Der Reiter trug zwei Sorten Text nebeneinander: die Handgriffe eines Tages
// und die Recherche dahinter. Beide standen als gleich grosse Karten
// untereinander, und die Recherche war die laengere — ein Dutzend zugeklappter
// Karten unter den offenen. Am Telefon heisst das scrollen an etwas vorbei,
// das heute niemand braucht.
//
// Jetzt gibt es dafuer eine Tuer, und hinter derselben Tuer steht, was hier
// selbst entsteht. Das ist derselbe Gedanke wie beim Ansatz, dessen Ergebnis
// eine Zeile ist: was laenger ist als die Zeile, gehoert nach hinten. Der
// Versuch bleibt eine Tabelle, die man ueberfliegt.
function pjNotizDatum(iso) {
  const d = new Date(iso);
  if (isNaN(d.getTime())) return '';
  return d.toLocaleDateString(loc(), { day: 'numeric', month: 'long', year: 'numeric' });
}
function pjNotizZeile(n) {
  return (
    `<li class="pj-note" data-pj-note-id="${n.id}">` +
    '<div class="pj-note-top">' +
    `<span class="pj-note-date">${esc(pjNotizDatum(n.created))}${n.updated ? ' · ' + esc(t('proj.noteEdited')) : ''}</span>` +
    '<span class="pj-note-btns">' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-note-edit="${n.id}">${esc(t('proj.noteEdit'))}</button>` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-note-del="${n.id}">${esc(t('common.delete'))}</button>` +
    '</span></div>' +
    // Der Text steht doppelt da: einmal gelesen, einmal zum Aendern. Umgeschaltet
    // wird mit einer Klasse, nicht mit neuem HTML — sonst waere der halb
    // getippte Satz beim naechsten Datenstand weg.
    `<div class="pj-note-body">${pjText(n.body)}</div>` +
    `<textarea class="pj-note-edit" rows="6" maxlength="20000" aria-label="${esc(t('proj.notes'))}">${esc(n.body)}</textarea>` +
    '<div class="pj-note-bar">' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-note-save="${n.id}">${esc(t('common.save'))}</button>` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-note-cancel="${n.id}">${esc(t('common.cancel'))}</button>` +
    '</div></li>'
  );
}
function pjNotizen(key, zu) {
  const meine = projectNotes.filter((n) => n.tab === key);
  const liste = meine.length
    ? '<ul class="pj-notes">' + meine.map(pjNotizZeile).join('') + '</ul>'
    : `<p class="pj-empty">${esc(t('proj.noteNone'))}</p>`;
  const recherche = zu.length
    ? '<details class="pj-fold pj-refs">' +
      `<summary class="sec">${esc(t('proj.research', { n: zu.length }))}</summary>` +
      zu
        .map(
          (s) =>
            '<details class="pj-fold pj-ref">' +
            `<summary class="sec">${pjText(s.t)}</summary>` +
            s.items.map(pjItem).join('') +
            '</details>'
        )
        .join('') +
      '</details>'
    : '';
  return (
    '<div class="card pj-sec pj-notebox">' +
    `<div class="sec">${esc(t('proj.notes'))}</div>` +
    `<p class="pj-p">${esc(t('proj.noteLead'))}</p>` +
    `<textarea id="pj-note-new" rows="3" maxlength="20000" placeholder="${esc(t('proj.notePh'))}" aria-label="${esc(t('proj.notes'))}"></textarea>` +
    '<div class="pj-note-bar">' +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-note-add="${esc(key)}">${esc(t('proj.noteAdd'))}</button>` +
    '</div>' +
    liste +
    recherche +
    '</div>'
  );
}
// Anlegen, aendern, wegwerfen. Aendern schaltet nur eine Klasse um und schreibt
// nichts neu, damit ein halb getippter Satz einen Datenstand ueberlebt.
function pjNotizClick(e) {
  const anlegen = e.target.closest('[data-pj-note-add]');
  if (anlegen) {
    const feld = document.getElementById('pj-note-new');
    const body = ((feld && feld.value) || '').trim();
    if (!body) {
      toast(t('proj.noteEmpty'), 'err');
      return true;
    }
    if (anlegen.disabled) return true;
    const tab = anlegen.dataset.pjNoteAdd;
    const daten = { tab, body };
    anlegen.disabled = true;
    apiPost('/api/project-notes', daten).then((r) => {
      if (!r || !r.id) {
        // Der Text bleibt im Feld; gezeichnet wird nichts neu.
        anlegen.disabled = false;
        pjFehlgeschlagen(r || null);
        return;
      }
      projectNotes.unshift({ ...daten, id: r.id, created: new Date().toISOString(), updated: '' });
      renderProjekte(tab);
    });
    return true;
  }
  const aendern = e.target.closest('[data-pj-note-edit]');
  if (aendern) {
    const zeile = aendern.closest('.pj-note');
    if (zeile) {
      zeile.classList.add('is-edit');
      const feld = zeile.querySelector('.pj-note-edit');
      if (feld) feld.focus();
    }
    return true;
  }
  const abbrechen = e.target.closest('[data-pj-note-cancel]');
  if (abbrechen) {
    const zeile = abbrechen.closest('.pj-note');
    const n = projectNotes.find((x) => x.id === Number(abbrechen.dataset.pjNoteCancel));
    if (zeile) {
      zeile.classList.remove('is-edit');
      const feld = zeile.querySelector('.pj-note-edit');
      if (feld && n) feld.value = n.body;
    }
    return true;
  }
  const sichern = e.target.closest('[data-pj-note-save]');
  if (sichern) {
    const id = Number(sichern.dataset.pjNoteSave);
    const zeile = sichern.closest('.pj-note');
    const feld = zeile && zeile.querySelector('.pj-note-edit');
    const body = ((feld && feld.value) || '').trim();
    if (!body) {
      toast(t('proj.noteEmpty'), 'err');
      return true;
    }
    const n = projectNotes.find((x) => x.id === id);
    if (n) {
      // Derselbe Text ist keine Aenderung; der Server schreibt dann nichts, und
      // "geaendert" stuende hier nur bis zum naechsten Datenstand.
      if (n.body !== body) {
        const vorher = { body: n.body, updated: n.updated };
        n.body = body;
        n.updated = new Date().toISOString();
        apiPatch('/api/project-notes/' + id, { body }).then((r) => {
          if (!pjFehlgeschlagen(r)) return;
          // Nicht gespeichert: der alte Stand gilt wieder, damit ein zweites
          // Speichern mit demselben Text auch wirklich geschickt wird, und die
          // Notiz geht mit dem Getippten wieder zum Bearbeiten auf.
          n.body = vorher.body;
          n.updated = vorher.updated;
          renderProjekte(n.tab);
          const knopf = document.querySelector('[data-pj-note-save="' + id + '"]');
          const offen = knopf && knopf.closest('.pj-note');
          if (offen) {
            offen.classList.add('is-edit');
            const eingabe = offen.querySelector('.pj-note-edit');
            if (eingabe) eingabe.value = body;
          }
        });
      }
      renderProjekte(n.tab);
    }
    return true;
  }
  const weg = e.target.closest('[data-pj-note-del]');
  if (weg) {
    const id = Number(weg.dataset.pjNoteDel);
    const n = projectNotes.find((x) => x.id === id);
    if (!n) return true;
    confirm2(t('proj.noteDelTitle'), t('proj.noteDelMsg'), t('common.delete'), () => {
      const stelle = projectNotes.indexOf(n);
      projectNotes = projectNotes.filter((x) => x.id !== id);
      apiDelete('/api/project-notes/' + id).then((r) => {
        // Nicht geloescht: die Notiz steht wieder an ihrem Platz.
        if (!pjFehlgeschlagen(r)) return;
        if (!projectNotes.some((x) => x.id === id)) projectNotes.splice(Math.max(0, stelle), 0, n);
        renderProjekte(n.tab);
      });
      renderProjekte(n.tab);
    });
    return true;
  }
  return false;
}
// Solange nichts geladen ist, steht ein Platzhalter da. Schlägt der Abruf fehl,
// bleibt ein Knopf zum Nachladen stehen, statt dass es endlos weiterlädt.
function pjDocsWarten(el, key) {
  el.innerHTML = `<div class="card pj-sec"><p class="pj-empty">${esc(t('proj.docLoading'))}</p></div>`;
  pjDocsLaden().then(() => {
    if (projectDocs) {
      renderProjekte(key);
      return;
    }
    el.innerHTML =
      '<div class="card pj-sec">' +
      `<p class="pj-empty">${esc(t('proj.docLoadErr'))}</p>` +
      '<div class="pj-note-bar">' +
      `<button type="button" class="btn btn-sm fs-xs" data-pj-doc-retry="${esc(key)}">${esc(t('proj.docRetry'))}</button>` +
      '</div></div>';
  });
}
// Der Import nimmt die Datei, die außerhalb des Trackers gepflegt wird: ein
// Objekt mit research, products und build, oder ein einzelnes Dokument für den
// offenen Reiter. Den Knopf sieht nur ein Admin; der Server prüft das ohnehin.
// Dasselbe Muster wie die Kamera: ein verstecktes Dateifeld, ein Knopf davor.
function pjDocImport(key, ersetzen) {
  if (!currentUser || currentUser.role !== 'admin') return '';
  return (
    '<div class="pj-note-bar">' +
    `<input type="file" id="pj-doc-datei-${esc(key)}" accept=".json,application/json" data-pj-doc-for="${esc(key)}" hidden>` +
    `<button type="button" class="btn btn-sm fs-xs" data-pj-doc-import="${esc(key)}">` +
    `${esc(t(ersetzen ? 'proj.docReplace' : 'proj.docImport'))}</button>` +
    '</div>'
  );
}
async function pjDocImportieren(key, datei) {
  let daten;
  try {
    daten = JSON.parse(await datei.text());
  } catch (e) {
    toast(t('proj.docBadFile'), 'err');
    return;
  }
  // Ein einzelnes Dokument gehört zum offenen Reiter; die gepflegte Datei trägt
  // alle drei und geht, wie sie ist.
  const body = daten && Array.isArray(daten.sections) ? { [key]: daten } : daten;
  const r = await apiPut('/api/project-docs', body);
  if (!r || r.error) {
    toast(t('proj.docBadFile') + (r && r.error ? ': ' + r.error : ''), 'err');
    return;
  }
  projectDocs = null;
  toast(t('proj.docImported', { n: (r.tabs || []).length }));
  renderProjekte(key);
}
function renderProjekte(key) {
  const el = document.getElementById('pj-' + key);
  if (!el) return;
  el.dataset.lang = currentLang;
  if (!projectDocs) {
    pjDocsWarten(el, key);
    return;
  }
  const doc = projectDocs[key];
  if (!doc) {
    // Noch nichts importiert. Die Notizen hängen nicht an der Unterlage und
    // bleiben auch ohne sie benutzbar.
    el.innerHTML =
      '<div class="card pj-sec">' +
      `<p class="pj-empty">${esc(t('proj.docNone'))}</p>` +
      pjDocImport(key, false) +
      '</div>' +
      (key === 'research' ? pjNotizen(key, []) : '');
    return;
  }
  const offen = doc.sections.filter((s) => !s.fold);
  const zu = doc.sections.filter((s) => s.fold);
  // Nur die Forschung hat die Notizen-Tuer. Produkte und Bau behalten ihre
  // zugeklappten Karten, bis jemand dort dieselbe Ordnung will — dann ist es
  // diese eine Bedingung.
  const hinten =
    key === 'research'
      ? pjNotizen(key, zu)
      : zu
          .map(
            (s) =>
              '<details class="card pj-sec pj-fold">' +
              `<summary class="sec">${pjText(s.t)}</summary>` +
              s.items.map(pjItem).join('') +
              '</details>'
          )
          .join('');
  el.innerHTML =
    '<div class="card pj-head">' +
    `<div class="pj-title">${pjText(doc.title)}</div>` +
    `<div class="pj-meta">${pjText(doc.meta)}</div>` +
    `<p class="pj-lead">${pjText(doc.lead)}</p>` +
    '</div>' +
    offen
      .map(
        (s) =>
          '<div class="card pj-sec">' +
          `<div class="sec">${pjText(s.t)}</div>` +
          s.items.map(pjItem).join('') +
          '</div>'
      )
      .join('') +
    hinten +
    pjDocImport(key, true);
  pjPlansRefresh(el);
}
// Beide Knöpfe dieser Seite hängen an einem Zuhörer an der Seite selbst: der
// Inhalt wird bei jedem Reiterwechsel neu geschrieben, und Zuhörer, die an den
// Knöpfen selbst hängen, gingen dabei jedes Mal mit verloren.
function pjClick(e) {
  // Ein Tipp auf die Beschriftung schaltet den Kasten, und der Klick des
  // Kastens landet hier — ein Zuhoerer je Seite statt einer je Zeile, weil
  // der Inhalt bei jedem Reiterwechsel neu geschrieben wird.
  const kasten = e.target.closest('[data-pj-chk]');
  if (kasten) {
    const stand = pjChkLoad();
    if (kasten.checked) stand[kasten.dataset.pjChk] = 1;
    else delete stand[kasten.dataset.pjChk];
    pjChkSave(stand);
    pjPlanRefresh(kasten.closest('.pj-plan'));
    return;
  }
  if (pjVersuchClick(e)) return;
  if (pjNotizClick(e)) return;
  const importieren = e.target.closest('[data-pj-doc-import]');
  if (importieren) {
    const feld = document.getElementById('pj-doc-datei-' + importieren.dataset.pjDocImport);
    if (feld) feld.click();
    return;
  }
  const nachladen = e.target.closest('[data-pj-doc-retry]');
  if (nachladen) {
    renderProjekte(nachladen.dataset.pjDocRetry);
    return;
  }
  const mehr = e.target.closest('[data-pj-more]');
  if (mehr) {
    const det = document.getElementById('pjd-' + mehr.dataset.pjMore);
    if (det) {
      det.hidden = !det.hidden;
      mehr.setAttribute('aria-expanded', det.hidden ? 'false' : 'true');
      mehr.textContent = det.hidden ? '…' : '×';
    }
    return;
  }
  const zeigen = e.target.closest('[data-pj-show]');
  if (zeigen) {
    const feld = zeigen.closest('.pj-plan');
    if (feld) {
      feld.classList.toggle('pj-show-done');
      pjPlanRefresh(feld);
    }
    return;
  }
  const zuruecksetzen = e.target.closest('[data-pj-reset]');
  if (zuruecksetzen) {
    const feld = zuruecksetzen.closest('.pj-plan');
    const schluessel = feld && feld.dataset.pjPlan;
    if (!schluessel) return;
    const stand = pjChkLoad();
    // Genau dieser Plan: der Schluessel bis zum letzten |. Mit dem Anfang
    // allein nahm das Zuruecksetzen von "tag" die Haken von "tag-2" mit.
    Object.keys(stand).forEach((k) => {
      const trenner = k.lastIndexOf('|');
      if ((trenner > 0 && k.slice(0, trenner) === schluessel) || pjChkAlt(k, schluessel)) delete stand[k];
    });
    pjChkSave(stand);
    feld.classList.remove('pj-show-done');
    pjPlanRefresh(feld);
    return;
  }
  const kopieren = e.target.closest('[data-pj-copy]');
  if (kopieren) {
    const pre = kopieren.previousElementSibling;
    if (pre) copyToClipboardWithFeedback(pre.textContent, kopieren);
    return;
  }
  const btn = e.target.closest('[data-pj-task]');
  if (!btn) return;
  const text = btn.dataset.pjTask;
  // Zweimal tippen darf nicht zweimal anlegen. Der Vergleich geht über den
  // Text, weil das die einzige Kennung ist, die diese Seite und eine schon
  // bestehende Aufgabe teilen.
  if (manualTasks.some((x) => x.text === text && !x.done)) {
    toast(t('proj.taskExists'));
    return;
  }
  const task = {
    text,
    priority: 'med',
    done: false,
    created: new Date().toISOString(),
    assignee: (currentUser && currentUser.username) || null,
    dueDate: localDateStr(new Date()),
    dueTime: null,
    dueEndTime: null,
    description: '',
    caldavUid: null,
    caldavSynced: null,
    private: false,
    recurrence: null,
    recurrenceUntil: null
  };
  manualTasks.push(task);
  apiPost('/api/tasks', task).then((r) => {
    if (r && r.id) {
      task.id = r.id;
      if (caldav.enabled) pushTaskCaldav(task);
    }
    renderCalendar();
    updateTodoBadge();
  });
  toast(t('proj.taskAdded'));
}

// ─── MUSHROOM STRAINS ────────────────────────────────────────
function fillStrainSelects() {
  const opts =
    '<option value="">' +
    t('strains.selectPlaceholder') +
    '</option>' +
    mushroomStrains.map((ms) => `<option value="${ms.id}">${esc(ms.name)} (${esc(ms.kuerzel)})</option>`).join('');
  const hint = mushroomStrains.length === 0;
  ['nb-strain-sel', 'lw-st'].forEach((id) => {
    const el = document.getElementById(id);
    if (!el) return;
    // Skip rewrite when options are unchanged: SSE-pushed re-syncs (any other
    // user moving bags / scanning / harvesting) would otherwise clobber the
    // <select> mid-tap, which on Android closes the native picker and drops
    // the selection.
    if (el.innerHTML === opts) return;
    const cur = el.value;
    el.innerHTML = opts;
    if (cur) el.value = cur;
  });
  const nbHint = document.getElementById('nb-no-strains-hint');
  if (nbHint) nbHint.style.display = hint ? 'block' : 'none';
}

// Navigate to the Pilzsorten page and focus the name input so the user can
// create a strain without hunting for it. Called from the "Create now →"
// shortcut in the new-batch form and from createBatch / createGrainBatch
// when no strains are defined yet.
function goCreateStrain() {
  go('strains', 'n-strains');
  setTimeout(() => {
    const el = document.getElementById('ms-name');
    if (el) el.focus();
  }, 60);
}

function renderStrains() {
  const body = document.getElementById('strains-body');
  if (!body) return;
  // Die Stämme stehen auf derselben Seite und hängen an denselben Daten — also
  // werden sie mit ihr gezeichnet, an jeder Stelle, die die Sorten neu zeichnet.
  renderStaemme();
  _msFillRecCopyOptions(parseInt((document.getElementById('ms-edit-id') || {}).value, 10) || null);
  if (!mushroomStrains.length) {
    body.innerHTML = '<tr><td colspan="7" class="empty">' + t('strains.empty') + '</td></tr>';
    return;
  }
  // Count usage
  const batchCount = (id) => batches.filter((b) => b.strainId === id).length;
  const cultureCount = (id) => cultures.filter((c) => c.strainId === id).length;
  body.innerHTML = mushroomStrains
    .map((ms) => {
      const bc = batchCount(ms.id),
        cc = cultureCount(ms.id);
      const inUse = bc > 0 || cc > 0;
      const usageParts = [];
      if (bc > 0) usageParts.push(bc + ' ' + t('strains.batches'));
      if (cc > 0) usageParts.push(cc + ' ' + t('strains.cultures'));
      const usageText = usageParts.join(', ') || '—';
      // Quick-create straight from this Sorte. "+ Charge" needs a recipe;
      // "+ Labor" only needs the Sorte (cultures carry no substrate recipe).
      const chargeBtn = ms.recBatchType
        ? `<button class="btn btn-sm btn-p" onclick="msQuickCharge(${ms.id})" style="padding:2px 7px" title="${t('strains.addChargeHint')}">${t('strains.addCharge')}</button> `
        : '';
      // One tap, no dialog, no save button. This gets flipped twice a year for
      // a handful of Sorten; a confirm step would cost more than a mis-tap,
      // which is undone by tapping again.
      const prog = ms.imProgramm !== false;
      return `<tr data-find="strain:${ms.id}"${prog ? '' : ' class="ms-off"'}>
      <td><label class="ms-prog"><input type="checkbox" ${prog ? 'checked' : ''} data-action="toggle-programm" data-id="${ms.id}" aria-label="${esc(t('strains.imProgrammAria', { name: ms.name }))}" /><span>${prog ? esc(t('strains.progOn')) : esc(t('strains.progOff'))}</span></label></td>
      <td style="font-weight:500">${esc(ms.name)}</td>
      <td><span class="fs-meta" style="font-family:monospace;background:var(--c-bg);padding:2px 7px;border-radius:4px">${esc(ms.kuerzel)}</span></td>
      <td class="fs-meta" style="color:var(--c-text-sec)">${ms.description ? esc(ms.description) : '<span style="color:var(--c-text-muted)">—</span>'}</td>
      <td class="fs-meta" style="color:var(--c-text-sec)">${msRecipeSummary(ms)}</td>
      <td class="fs-meta" style="color:var(--c-text-sec)">${esc(usageText)}</td>
      <td style="white-space:nowrap">
        ${chargeBtn}<button class="btn btn-sm" onclick="msQuickLabor(${ms.id})" style="padding:2px 7px" title="${t('strains.addLaborHint')}">${t('strains.addLabor')}</button>
        <button class="btn btn-sm" onclick="editMStrain(${ms.id})" style="padding:2px 7px">${t('strains.editBtn')}</button>
        <button class="btn btn-sm btn-r" onclick="deleteMStrain(${ms.id})" ${inUse ? 'disabled title="' + t('strains.deleteProtected') + '"' : ''} style="padding:2px 7px">&#x2715;</button>
      </td>
    </tr>`;
    })
    .join('');
}

function saveMStrain() {
  const name = document.getElementById('ms-name').value.trim();
  const kuerzel = document.getElementById('ms-kuerzel').value.trim().toUpperCase();
  const desc = document.getElementById('ms-desc').value.trim();
  const editId = document.getElementById('ms-edit-id').value;
  if (!name || !kuerzel) {
    fieldError(name ? 'ms-kuerzel' : 'ms-name', t('strains.required'));
    return;
  }
  if (kuerzel.length < 2 || kuerzel.length > 4) {
    fieldError('ms-kuerzel', t('strains.kuerzelLength'));
    return;
  }
  const rec = _msReadRecipe();
  const payload = { name, kuerzel, description: desc, ...rec };
  const num = (v, d) => (isFinite(parseFloat(v)) ? parseFloat(v) : d);
  const recLocal = {
    recBatchType: rec.recBatchType || '',
    recSubstrate: rec.recSubstrate || 'holzkleie',
    recBagKg: num(rec.recBagKg, 0),
    recRhPct: num(rec.recRhPct, 0),
    recHardwoodPct: num(rec.recHardwoodPct, 0),
    recWheatbranPct: num(rec.recWheatbranPct, 0),
    recCoirPct: num(rec.recCoirPct, 0),
    recGypsum: !!rec.recGypsum,
    recGrainKg: num(rec.recGrainKg, 0),
    recGrainRhPct: num(rec.recGrainRhPct, 52),
    recIncDays: num(rec.recIncDays, 14)
  };
  const req = editId ? apiPatch('/api/mushroom-strains/' + editId, payload) : apiPost('/api/mushroom-strains', payload);
  req.then((r) => {
    if (r && r.error) {
      toast(t('common.error') + ': ' + r.error, 'err');
      return;
    }
    if (!editId && r && r.id) {
      mushroomStrains.push({
        id: r.id,
        name,
        kuerzel,
        description: desc,
        created: new Date().toISOString(),
        ...recLocal
      });
    } else if (editId) {
      const ms = mushroomStrains.find((x) => x.id === parseInt(editId));
      if (ms) {
        ms.name = name;
        ms.kuerzel = kuerzel;
        ms.description = desc;
        Object.assign(ms, recLocal);
      }
    }
    mushroomStrains.sort((a, b) => a.name.localeCompare(b.name));
    fillStrainSelects();
    renderStrains();
    cancelMStrain();
  });
}

function editMStrain(id) {
  const ms = mushroomStrains.find((x) => x.id === id);
  if (!ms) return;
  document.getElementById('ms-name').value = ms.name;
  document.getElementById('ms-kuerzel').value = ms.kuerzel;
  document.getElementById('ms-desc').value = ms.description || '';
  document.getElementById('ms-edit-id').value = id;
  const sv = (eid, val) => {
    const el = document.getElementById(eid);
    if (el) el.value = val;
  };
  sv('ms-rec-type', ms.recBatchType || '');
  sv('ms-rec-substrate', ms.recSubstrate || 'holzkleie');
  sv('ms-rec-bagkg', ms.recBagKg || 0);
  sv('ms-rec-rh', ms.recRhPct || 0);
  sv('ms-rec-hw', ms.recHardwoodPct || 0);
  sv('ms-rec-wb', ms.recWheatbranPct || 0);
  sv('ms-rec-coir', ms.recCoirPct || 0);
  sv('ms-rec-corn', ms.recCornPct || 0);
  sv('ms-rec-gyppct', ms.recGypsumPct || 0);
  sv('ms-rec-spawn', ms.recSpawnPct || 0);
  sv('ms-min-spawn', ms.minSpawnKg || 0);
  sv('ms-min-lc', ms.minLc || 0);
  sv('ms-min-mc', ms.minMc || 0);
  sv('ms-min-pd', ms.minPd || 0);
  msRecShowRef(ms);
  const gyp = document.getElementById('ms-rec-gyp');
  if (gyp) gyp.checked = !!ms.recGypsum;
  sv('ms-rec-grainkg', ms.recGrainKg || 0);
  sv('ms-rec-grainrh', ms.recGrainRhPct != null ? ms.recGrainRhPct : 52);
  sv('ms-rec-days', ms.recIncDays != null ? ms.recIncDays : 14);
  sv('ms-rec-fruitdays', ms.recFruitDays || 0);
  msRecTypeChange();
  _msFillRecCopyOptions(id);
  document.getElementById('ms-save-btn').textContent = t('strains.saveChanges');
  document.getElementById('ms-cancel-btn').style.display = '';
  document.getElementById('ms-name').focus();
}

function cancelMStrain() {
  document.getElementById('ms-name').value = '';
  document.getElementById('ms-kuerzel').value = '';
  document.getElementById('ms-desc').value = '';
  document.getElementById('ms-edit-id').value = '';
  document.getElementById('ms-save-btn').setAttribute('data-i18n', 'strains.save');
  document.getElementById('ms-save-btn').textContent = t('strains.save');
  document.getElementById('ms-cancel-btn').style.display = 'none';
  const sv = (eid, val) => {
    const el = document.getElementById(eid);
    if (el) el.value = val;
  };
  sv('ms-rec-type', '');
  sv('ms-rec-substrate', 'holzkleie');
  sv('ms-rec-bagkg', 0);
  sv('ms-rec-rh', 0);
  sv('ms-rec-hw', 75);
  sv('ms-rec-wb', 25);
  sv('ms-rec-coir', 100);
  // 1 % gypsum and 5 % spawn are common starting points, so a blank Sorte starts
  // there rather than at 0, which would silently mix without either.
  sv('ms-rec-corn', 0);
  sv('ms-rec-gyppct', 1);
  sv('ms-rec-spawn', 5);
  sv('ms-min-spawn', 0);
  sv('ms-min-lc', 0);
  sv('ms-min-mc', 0);
  sv('ms-min-pd', 0);
  msRecShowRef(null);
  const gyp = document.getElementById('ms-rec-gyp');
  if (gyp) gyp.checked = false;
  sv('ms-rec-grainkg', 0);
  sv('ms-rec-grainrh', 52);
  sv('ms-rec-days', 14);
  sv('ms-rec-fruitdays', 0);
  msRecTypeChange();
  _msFillRecCopyOptions(null);
}

function deleteMStrain(id) {
  const ms = mushroomStrains.find((x) => x.id === id);
  if (!ms) return;
  confirm2(t('strains.deleteTitle'), t('strains.deleteMsg', { name: ms.name }), t('strains.delete'), () => {
    apiDelete('/api/mushroom-strains/' + id).then((r) => {
      if (r && r.error) {
        toast(t('common.error') + ': ' + r.error, 'err');
        return;
      }
      mushroomStrains = mushroomStrains.filter((x) => x.id !== id);
      fillStrainSelects();
      renderStrains();
    });
  });
}

// ─── STÄMME ──────────────────────────────────────────────────
// Die Linien einer Pilzsorte (v87): Nordlicht, Blue Seestern 01, SHIKQ07. An Charge
// und Kultur steht der Name in strainText — dort, wo vorher der frei getippte
// Text stand; die Liste ist das Vokabular, aus dem er jetzt gewählt wird. Siehe
// db.js, listStaemme.

// Wie in der Datenbank zählt Groß- und Kleinschreibung nicht: "nordlicht" ist der
// Stamm "Nordlicht". Leerzeichen am Rand und doppelte in der Mitte auch nicht.
function stammNameSauber(v) {
  return String(v == null ? '' : v)
    .trim()
    .replace(/\s+/g, ' ');
}
function stammGleich(a, b) {
  return stammNameSauber(a).toLowerCase() === stammNameSauber(b).toLowerCase();
}
function staemmeFor(strainId) {
  return staemme
    .filter((s) => s.strainId === strainId)
    .sort((a, b) => a.name.localeCompare(b.name, undefined, { sensitivity: 'base' }));
}

// Der Wähler im Schnelldialog ('ms-q') und im Chargen-Assistenten ('wkb'). `wert`
// ist der gewählte Name, '' für ohne Stamm; `neu` heißt, dass statt der Auswahl
// gerade das Feld für einen neuen Stamm dasteht, und `getippt`, was darin steht.
// Der Zustand lebt hier und nicht im DOM, weil beide Dialoge sich bei jedem
// Wechsel von Sorte, Art oder Schritt neu zeichnen.
const STAMM = {};
function stammState(prefix) {
  return STAMM[prefix] || (STAMM[prefix] = { strainId: null, wert: '', neu: false, getippt: '' });
}
function stammReset(prefix) {
  STAMM[prefix] = { strainId: null, wert: '', neu: false, getippt: '' };
}
// Der Name, mit dem gleich angelegt wird — auch einer, der noch getippt im Feld
// steht (siehe stammFertig). '' für ohne Stamm.
function stammAnzeige(prefix) {
  const st = stammState(prefix);
  return (st.neu && stammNameSauber(st.getippt)) || st.wert;
}
// Vor dem Anlegen: Steht noch ein neuer Name im Feld, ohne dass "Hinzufügen"
// gedrückt wurde, ist das trotzdem die Antwort auf die Frage — also wird er
// jetzt angelegt, statt still unter den Tisch zu fallen. Gibt den Namen zurück,
// '' für ohne Stamm, null wenn das Anlegen fehlschlug (gemeldet ist es dann).
async function stammFertig(prefix) {
  const st = stammState(prefix);
  const sel = document.getElementById(prefix + '-stamm');
  if (sel && !st.neu) st.wert = sel.value;
  const feld = document.getElementById(prefix + '-stamm-neu');
  if (feld && st.neu) st.getippt = feld.value;
  if (st.neu && stammNameSauber(st.getippt)) {
    const s = await stammAnlegen(st.strainId, st.getippt);
    if (!s) return null;
    st.wert = s.name;
    st.neu = false;
    st.getippt = '';
  }
  return st.wert;
}

// Zeichnet den Wähler in `<prefix>-stamm-wrap`. Ohne Sorte bleibt er leer —
// welche Stämme es gibt, hängt an ihr. Wechselt die Sorte, fällt ein Name, den
// die neue nicht kennt, auf "ohne Stamm" zurück: Nordlicht beim Lions Mane ist kein
// Stamm des Shiitake.
//
// "+ Neu" legt einen Stamm gleich hier an. Bei der Inventur steht das Glas in der
// Hand, und der Weg über die Sortenseite verwürfe alles, was im Dialog schon
// eingetragen ist.
function stammRender(prefix, strainId) {
  const box = document.getElementById(prefix + '-stamm-wrap');
  if (!box) return;
  const st = stammState(prefix);
  if (st.strainId !== (strainId || null)) {
    st.strainId = strainId || null;
    st.neu = false;
    st.getippt = '';
    if (st.wert && !staemmeFor(st.strainId).some((s) => stammGleich(s.name, st.wert))) st.wert = '';
  }
  if (!st.strainId) {
    box.innerHTML = '';
    return;
  }
  const zeile = st.neu
    ? `<input type="text" id="${prefix}-stamm-neu" data-stamm-neu="${prefix}" maxlength="60" autocomplete="off" value="${esc(st.getippt)}" placeholder="${esc(t('stamm.newPh'))}" />` +
      // Kein Hauptknopf: der Dialog hat schon einen ("Anlegen"), und der legt
      // einen getippten Stamm ohnehin mit an (stammFertig).
      `<button type="button" class="btn" data-stamm="save" data-prefix="${prefix}">${esc(t('stamm.add'))}</button>` +
      `<button type="button" class="btn" data-stamm="cancel" data-prefix="${prefix}" aria-label="${esc(t('common.cancel'))}">&times;</button>`
    : `<select id="${prefix}-stamm" data-stamm-select="${prefix}"><option value="">${esc(t('stamm.none'))}</option>` +
      staemmeFor(st.strainId)
        .map((s) => `<option value="${esc(s.name)}"${stammGleich(s.name, st.wert) ? ' selected' : ''}>${esc(s.name)}</option>`)
        .join('') +
      '</select>' +
      `<button type="button" class="btn" data-stamm="new" data-prefix="${prefix}">${esc(t('stamm.new'))}</button>`;
  box.innerHTML =
    `<label for="${prefix}-stamm${st.neu ? '-neu' : ''}">${esc(t('stamm.label'))}</label>` +
    `<div class="stamm-row">${zeile}</div>`;
}

async function stammKlick(was, prefix, knopf) {
  const st = stammState(prefix);
  if (was === 'new' || was === 'cancel') {
    st.neu = was === 'new';
    st.getippt = '';
    stammRender(prefix, st.strainId);
    const inp = st.neu && document.getElementById(prefix + '-stamm-neu');
    if (inp) inp.focus();
    return;
  }
  // Das Feld selbst ist die letzte Wahrheit: eine Tastatur mit Wortvorschlägen
  // meldet das letzte Wort manchmal erst beim Verlassen.
  const feld = document.getElementById(prefix + '-stamm-neu');
  if (feld) st.getippt = feld.value;
  const name = stammNameSauber(st.getippt);
  if (!name) {
    fieldError(prefix + '-stamm-neu', t('stamm.nameMissing'));
    return;
  }
  // Gesperrt, solange die Anfrage läuft: ein zweiter Tipp legte sonst denselben
  // Namen noch einmal an, und der Server wiese ihn als doppelt ab.
  if (knopf) knopf.disabled = true;
  const s = await stammAnlegen(st.strainId, name);
  if (knopf) knopf.disabled = false;
  if (!s) return;
  st.wert = s.name;
  st.neu = false;
  st.getippt = '';
  stammRender(prefix, st.strainId);
}

// Legt einen Stamm an und gibt ihn zurück — oder den vorhandenen, wenn die Sorte
// ihn schon hat; dann ohne Anfrage. null bei einem Fehler, der dann schon
// gemeldet ist.
async function stammAnlegen(strainId, roh) {
  const name = stammNameSauber(roh);
  if (!strainId || !name) return null;
  const da = staemmeFor(strainId).find((s) => stammGleich(s.name, name));
  if (da) {
    toast(t('stamm.exists'));
    return da;
  }
  const r = await apiPost('/api/staemme', { strainId, name });
  if (!r || r.error) {
    toast(t('common.error') + ': ' + ((r && r.error) || '?'), 'err');
    return null;
  }
  const s = { id: r.id, strainId, name, notes: '', created: new Date().toISOString(), updated: null };
  staemme.push(s);
  renderStaemme();
  toast(t('stamm.added', { name }));
  return s;
}

// ── Die Karte "Stämme" auf der Sortenseite ──
function renderStaemme() {
  const box = document.getElementById('staemme-list');
  if (!box) return;
  const sorten = mushroomStrains.slice().sort((a, b) => (a.name || '').localeCompare(b.name || ''));
  const sel = document.getElementById('st-sorte');
  if (sel) {
    const opts =
      `<option value="">${esc(t('stamm.pickSorte'))}</option>` +
      sorten.map((ms) => `<option value="${ms.id}">${esc(ms.name)} (${esc(ms.kuerzel)})</option>`).join('');
    // Nur neu schreiben, wenn sich etwas geändert hat — siehe fillStrainSelects.
    if (sel.innerHTML !== opts) {
      const cur = sel.value;
      sel.innerHTML = opts;
      if (cur) sel.value = cur;
    }
  }
  // Wie oft ein Name an Chargen und Kulturen steht, je Sorte. `lebt` heißt: an
  // mindestens einer, die nicht verunreinigt ist — in verunreinigten Kulturen
  // standen Versuchsnotizen im Feld, keine Stämme, und die sollen nicht als
  // Vorschlag zurückkommen.
  const zaehler = new Map();
  const zaehle = (strainId, text, tot) => {
    const name = stammNameSauber(text);
    if (!strainId || !name) return;
    const k = strainId + '|' + name.toLowerCase();
    const e = zaehler.get(k) || { strainId, name, n: 0, lebt: false };
    e.n++;
    if (!tot) e.lebt = true;
    zaehler.set(k, e);
  };
  for (const b of batches) zaehle(b.strainId, b.strainText, false);
  for (const c of cultures) zaehle(c.strainId, c.strainText, c.status === 'contam');
  const gruppen = sorten
    .map((ms) => {
      const liste = staemmeFor(ms.id);
      // Was schon an Chargen und Kulturen steht, aber nicht in der Liste: ein Tipp
      // übernimmt es. So kommt der Bestand aus der Zeit des freien Textes in die
      // Liste, ohne dass jemand ihn abschreibt.
      const fremd = [...zaehler.values()].filter(
        (e) => e.strainId === ms.id && e.lebt && !liste.some((s) => stammGleich(s.name, e.name))
      );
      if (!liste.length && !fremd.length) return '';
      const zeilen = liste
        .map((s) => {
          const e = zaehler.get(ms.id + '|' + s.name.toLowerCase());
          return (
            `<div class="stamm-zeile"><div class="stamm-name">${esc(s.name)}` +
            `<span class="fs-meta stamm-use">${esc(e ? t('stamm.used', { n: e.n }) : t('stamm.unused'))}</span></div>` +
            `<button type="button" class="btn btn-sm" data-st-act="rename" data-id="${s.id}">${esc(t('stamm.rename'))}</button>` +
            `<button type="button" class="btn btn-sm btn-r" data-st-act="delete" data-id="${s.id}" aria-label="${esc(t('stamm.delete'))}" title="${esc(t('stamm.delete'))}">&#x2715;</button></div>`
          );
        })
        .join('');
      const vorschlaege = fremd.length
        ? `<div class="fs-meta stamm-fremd">${esc(t('stamm.adoptHint'))} ` +
          fremd
            .map(
              (e) =>
                `<button type="button" class="btn btn-sm" data-st-act="adopt" data-sorte="${ms.id}" data-name="${esc(e.name)}" title="${esc(t('stamm.adoptTitle'))}">+ ${esc(e.name)}</button>`
            )
            .join(' ') +
          '</div>'
        : '';
      return (
        `<div class="stamm-gruppe"><div class="stamm-sorte">${esc(ms.name)} <span class="fs-meta stamm-kz">${esc(ms.kuerzel)}</span></div>` +
        zeilen +
        vorschlaege +
        '</div>'
      );
    })
    .join('');
  box.innerHTML = gruppen || `<div class="fs-meta stamm-leer">${esc(t('stamm.empty'))}</div>`;
}

async function stammVerwaltungAnlegen() {
  const sel = document.getElementById('st-sorte');
  const inp = document.getElementById('st-name');
  const strainId = parseInt(sel && sel.value, 10) || null;
  if (!strainId) {
    fieldError('st-sorte', t('lab.selectPilzsorte'));
    return;
  }
  if (!stammNameSauber(inp && inp.value)) {
    fieldError('st-name', t('stamm.nameMissing'));
    return;
  }
  const knopf = document.getElementById('st-add-btn');
  if (knopf) knopf.disabled = true;
  const s = await stammAnlegen(strainId, inp.value);
  if (knopf) knopf.disabled = false;
  if (s) {
    inp.value = '';
    inp.focus();
  }
}

// Umbenennen zieht Chargen und Kulturen mit, die den alten Namen tragen — der
// Server tut es in der Datenbank (updateStamm), hier geschieht dasselbe mit dem,
// was schon geladen ist, damit die Tabellen nicht bis zum nächsten Abgleich den
// alten Namen zeigen.
function stammUmbenennen(id) {
  const s = staemme.find((x) => x.id === id);
  if (!s) return;
  prompt2(
    t('stamm.renameTitle'),
    t('stamm.newPh'),
    async (roh) => {
      const name = stammNameSauber(roh);
      if (!name || name === s.name) return;
      if (staemmeFor(s.strainId).some((x) => x.id !== id && stammGleich(x.name, name))) {
        toast(t('stamm.exists'), 'err');
        return;
      }
      const r = await apiPatch('/api/staemme/' + id, { name });
      if (!r || r.error) {
        toast(t('common.error') + ': ' + ((r && r.error) || '?'), 'err');
        return;
      }
      for (const x of [...batches, ...cultures]) {
        if (x.strainId === s.strainId && stammGleich(x.strainText, s.name)) x.strainText = name;
      }
      s.name = name;
      renderStaemme();
    },
    { value: s.name }
  );
}

function stammLoeschen(id) {
  const s = staemme.find((x) => x.id === id);
  if (!s) return;
  confirm2(t('stamm.deleteTitle'), t('stamm.deleteMsg', { name: s.name }), t('stamm.delete'), async () => {
    const r = await apiDelete('/api/staemme/' + id);
    if (r && r.error) {
      toast(t('common.error') + ': ' + r.error, 'err');
      return;
    }
    staemme = staemme.filter((x) => x.id !== id);
    renderStaemme();
  });
}

// ─── ANGESETZT AM ────────────────────────────────────────────
// Bei der Inventur kommt Bestand in die App, der schon steht: eine Flüssigkultur
// von vor drei Wochen, eine Platte vom Monatsanfang. Mit dem heutigen Tag
// angelegt, wäre sie auf dem Papier jung und im Regal alt — und ihr Alter ist
// das, worauf man beim Weiterimpfen schaut. Deshalb darf ein Anlegen einen
// früheren Tag tragen.
//
// Die Vorgabe bleibt heute, und das Feld bleibt zu, bis jemand es braucht: der
// Normalfall kostet keinen Tipp mehr als vorher. Der Zustand gilt je Dialog
// ('ms-q', 'wkb') und wird bei jedem Öffnen zurückgesetzt — ein Datum, das für
// die letzte Inventurzeile galt, soll nicht still an der nächsten hängen.
const ANLAGE = {};
function anlageState(prefix) {
  return ANLAGE[prefix] || (ANLAGE[prefix] = { offen: false, datum: '' });
}
function anlageReset(prefix) {
  ANLAGE[prefix] = { offen: false, datum: '' };
}
function anlageRender(prefix) {
  const box = document.getElementById(prefix + '-anlage-wrap');
  if (!box) return;
  const a = anlageState(prefix);
  if (!a.offen) {
    // Zu ist es eine Zeile, kein Feld: gelesen wird "angesetzt heute", und wer
    // es anders braucht, tippt auf den Rest.
    box.innerHTML =
      `<div class="anlage-zu fs-meta"><span class="anlage-k">${esc(t('anlage.label'))}</span><b>${esc(t('anlage.today'))}</b>` +
      `<button type="button" class="wkf-link" data-anlage="open" data-prefix="${prefix}">${esc(t('anlage.change'))}</button></div>`;
    return;
  }
  const heute = localDateStr(new Date());
  box.innerHTML =
    `<label for="${prefix}-anlage">${esc(t('anlage.label'))}</label>` +
    `<div class="stamm-row"><input type="date" id="${prefix}-anlage" data-anlage-input="${prefix}" max="${heute}" value="${esc(a.datum || heute)}" />` +
    `<button type="button" class="btn" data-anlage="today" data-prefix="${prefix}">${esc(t('anlage.backToday'))}</button></div>` +
    `<div class="wkf-hint">${esc(t('anlage.hint'))}</div>`;
}
function anlageKlick(was, prefix) {
  const a = anlageState(prefix);
  a.offen = was === 'open';
  if (!a.offen) a.datum = '';
  anlageRender(prefix);
  anlageGeaendert(prefix);
  const inp = a.offen && document.getElementById(prefix + '-anlage');
  if (!inp) return;
  inp.focus();
  // Der Tipp auf "anderes Datum" ist schon die Bitte um den Kalender; ohne das
  // müsste man am Telefon ein zweites Mal ins Feld tippen.
  try {
    if (typeof inp.showPicker === 'function') inp.showPicker();
  } catch (e) {
    /* ältere Browser: das Feld hat den Fokus, ein Tipp öffnet ihn */
  }
}

// Der Schnelldialog nennt unter den Feldern, was vom Lager ginge; ob etwas geht,
// hängt jetzt am Datum, also rechnet die Zeile neu, sobald es sich ändert. Der
// Assistent zeichnet seinen zweiten Schritt ohnehin frisch.
function anlageGeaendert(prefix) {
  if (prefix === 'ms-q') msQuickPreview();
  if (prefix === 'bmp') bmpPreview();
}

// Der Tag, an dem angesetzt wurde, als JJJJ-MM-TT — '' heißt heute. null, wenn
// er in der Zukunft liegt; dann steht die Meldung schon am Feld, und der
// Aufrufer bricht ab, solange sein Dialog noch offen ist.
function anlageLesen(prefix) {
  const a = anlageState(prefix);
  const inp = document.getElementById(prefix + '-anlage');
  if (inp) a.datum = inp.value || '';
  if (!a.offen || !a.datum) return '';
  const heute = localDateStr(new Date());
  if (a.datum > heute) {
    fieldError(prefix + '-anlage', t('anlage.future'));
    return null;
  }
  return a.datum === heute ? '' : a.datum;
}

// Liegt der gewählte Tag vor heute? Dann ist es Bestand aus der Inventur, und es
// wird angelegt, ohne etwas abzubuchen: das Material ist längst verbraucht, und
// das Regal wird bei der Inventur gezählt, nicht nachgerechnet. Still — die
// Prüfung mit Meldung am Feld macht anlageLesen.
function anlageFrueher(prefix) {
  const a = anlageState(prefix);
  return !!(a.offen && /^\d{4}-\d{2}-\d{2}$/.test(a.datum || '') && a.datum < localDateStr(new Date()));
}

// JJJJ-MM-TT → der Zeitpunkt, der als `created` gespeichert wird. Ein früherer
// Tag wird Mittag an diesem Tag, Ortszeit: weit genug von beiden Mitternächten,
// dass keine Zeitzone und keine Sommerzeitumstellung ihn in den Nachbartag
// schiebt. Leer heißt jetzt — der Augenblick des Anlegens, wie bisher.
function anlageZeitpunkt(ymd) {
  const m = /^(\d{4})-(\d{2})-(\d{2})$/.exec(ymd || '');
  if (!m) return new Date();
  return new Date(+m[1], +m[2] - 1, +m[3], 12, 0, 0, 0);
}

// nb-created und lw-created werden nur von den Arbeitsgängen gesetzt, direkt vor
// dem Anlegen. Gelesen wird einmal, und dabei geleert: stünde ein Datum still
// weiter darin, bekäme die nächste Charge es mit.
function anlageNehmen(el) {
  const v = el ? el.value : '';
  if (el) el.value = '';
  return v;
}

(function wireStaemme() {
  document.addEventListener('click', (e) => {
    const b = e.target.closest('[data-stamm],[data-anlage],[data-st-act]');
    if (!b || b.disabled) return;
    if (b.dataset.stamm) return stammKlick(b.dataset.stamm, b.dataset.prefix, b);
    if (b.dataset.anlage) return anlageKlick(b.dataset.anlage, b.dataset.prefix);
    const id = parseInt(b.dataset.id, 10);
    if (b.dataset.stAct === 'rename') stammUmbenennen(id);
    else if (b.dataset.stAct === 'delete') stammLoeschen(id);
    else if (b.dataset.stAct === 'adopt') stammAnlegen(parseInt(b.dataset.sorte, 10), b.dataset.name);
  });
  document.addEventListener('change', (e) => {
    const sel = e.target.closest('[data-stamm-select]');
    if (sel) stammState(sel.dataset.stammSelect).wert = sel.value;
    const tag = e.target.closest('[data-anlage-input]');
    if (tag) {
      anlageState(tag.dataset.anlageInput).datum = tag.value;
      anlageGeaendert(tag.dataset.anlageInput);
    }
  });
  // Mitschreiben, was im Feld für den neuen Namen steht: der Dialog zeichnet sich
  // beim Wechsel der Art oder des Schritts neu, und das Getippte soll das
  // überstehen.
  document.addEventListener('input', (e) => {
    const inp = e.target.closest && e.target.closest('[data-stamm-neu]');
    if (inp) stammState(inp.dataset.stammNeu).getippt = inp.value;
  });
  // Enter im Feld für den neuen Namen legt an, wie der Knopf daneben.
  document.addEventListener('keydown', (e) => {
    if (e.key !== 'Enter' || !e.target.closest) return;
    const inp = e.target.closest('[data-stamm-neu]');
    if (!inp) return;
    e.preventDefault();
    const knopf = inp.parentNode && inp.parentNode.querySelector('[data-stamm="save"]');
    stammKlick('save', inp.dataset.stammNeu, knopf);
  });
  const add = document.getElementById('st-add-btn');
  if (add) add.addEventListener('click', stammVerwaltungAnlegen);
  const name = document.getElementById('st-name');
  if (name)
    name.addEventListener('keydown', (e) => {
      if (e.key !== 'Enter') return;
      e.preventDefault();
      stammVerwaltungAnlegen();
    });
})();

// ── Sorte production recipe (rec_*) — editor toggle + per-bag need preview ───
function _msReadRecipe() {
  const v = (id) => {
    const el = document.getElementById(id);
    return el ? el.value : '';
  };
  const chk = (id) => {
    const el = document.getElementById(id);
    return el && el.checked ? 1 : 0;
  };
  return {
    recBatchType: v('ms-rec-type') || '',
    recSubstrate: v('ms-rec-substrate') || 'holzkleie',
    recBagKg: v('ms-rec-bagkg'),
    recRhPct: v('ms-rec-rh'),
    recHardwoodPct: v('ms-rec-hw'),
    recWheatbranPct: v('ms-rec-wb'),
    recCoirPct: v('ms-rec-coir'),
    recCornPct: v('ms-rec-corn'),
    recGypsumPct: v('ms-rec-gyppct'),
    recSpawnPct: v('ms-rec-spawn'),
    // The old flag and the new share have to agree, or a Charge created the
    // per-bag way would skip gypsum that the mix puts in — same recipe, two
    // answers depending on which screen made it.
    recGypsum: chk('ms-rec-gyp') || v('ms-rec-gyppct') > 0,
    minSpawnKg: v('ms-min-spawn'),
    minLc: v('ms-min-lc'),
    minMc: v('ms-min-mc'),
    minPd: v('ms-min-pd'),
    recGrainKg: v('ms-rec-grainkg'),
    recGrainRhPct: v('ms-rec-grainrh'),
    recIncDays: v('ms-rec-days'),
    recFruitDays: v('ms-rec-fruitdays')
  };
}
// Map a recipe (rec_*) onto the product spec shape so we can reuse the shared
// _ohProdNeedCompute charge math (same hydration formula as the Charge form).
function _msRecipeToProd(rec) {
  return {
    prodType: rec.recBatchType || 'buy',
    prodSubstrate: rec.recSubstrate,
    prodBagKg: rec.recBagKg,
    prodRhPct: rec.recRhPct,
    prodHardwoodPct: rec.recHardwoodPct,
    prodWheatbranPct: rec.recWheatbranPct,
    prodCoirPct: rec.recCoirPct,
    prodGypsum: rec.recGypsum,
    prodGrainKg: rec.recGrainKg,
    prodGrainRhPct: rec.recGrainRhPct
  };
}
function _msStrainToRecipe(ms) {
  return {
    recBatchType: ms.recBatchType,
    recSubstrate: ms.recSubstrate,
    recBagKg: ms.recBagKg,
    recRhPct: ms.recRhPct,
    recHardwoodPct: ms.recHardwoodPct,
    recWheatbranPct: ms.recWheatbranPct,
    recCoirPct: ms.recCoirPct,
    recGypsum: ms.recGypsum,
    recGrainKg: ms.recGrainKg,
    recGrainRhPct: ms.recGrainRhPct
  };
}
const _MS_MAT_KEY = {
  grain: 'inv.grain',
  hardwood: 'inv.hardwood',
  wheatbran: 'inv.wheatBran',
  gypsum: 'inv.gypsum',
  coir: 'inv.coir'
};
function _msNeedParts(rec, mult) {
  const fmt = (n) => (Math.round(n * 1000) / 1000).toString();
  const need = _ohProdNeedCompute(_msRecipeToProd(rec));
  const m = mult || 1;
  return Object.keys(need)
    .filter((k) => need[k] > 0)
    .map((k) => `${esc(t(_MS_MAT_KEY[k] || k))} ${fmt(need[k] * m)} kg`);
}
function msRecTypeChange() {
  const type = (document.getElementById('ms-rec-type') || {}).value || '';
  const sub = (document.getElementById('ms-rec-substrate') || {}).value || 'holzkleie';
  const set = (id, disp) => {
    const el = document.getElementById(id);
    if (el) el.style.display = disp;
  };
  set('ms-rec-subgroup', type === 'block' || type === 'allinone' ? 'block' : 'none');
  set('ms-rec-graingroup', type === 'grain' || type === 'allinone' ? 'block' : 'none');
  set('ms-rec-holzgroup', sub === 'holzkleie' ? 'grid' : 'none');
  set('ms-rec-coirgroup', sub === 'cvg' ? 'grid' : 'none');
  set('ms-rec-daysrow', type ? 'grid' : 'none');
  msRecNeed();
}
function msRecNeed() {
  const el = document.getElementById('ms-rec-need');
  if (!el) return;
  const rec = _msReadRecipe();
  if (!rec.recBatchType) {
    el.textContent = '';
    return;
  }
  const parts = _msNeedParts(rec, 1);
  el.textContent = parts.length ? t('orders.p.needPrefix') + ' ' + parts.join(' · ') : '';
}
// Populate the "copy recipe from another Sorte" dropdown with Sorten that have a
// recipe (excluding the one being edited).
function _msFillRecCopyOptions(excludeId) {
  const sel = document.getElementById('ms-rec-copy');
  if (!sel) return;
  const list = mushroomStrains
    .filter((x) => x.recBatchType && x.id !== excludeId)
    .sort((a, b) => (a.name || '').localeCompare(b.name || ''));
  sel.innerHTML =
    '<option value="">' +
    esc(t('strains.recCopyNone')) +
    '</option>' +
    list.map((x) => `<option value="${x.id}">${esc(x.name)}${x.kuerzel ? ' (' + esc(x.kuerzel) + ')' : ''}</option>`).join('');
  sel.value = '';
}
// Copy another Sorte's recipe into the form (most Sorten share the same recipe).
function msRecCopyFrom() {
  const sel = document.getElementById('ms-rec-copy');
  if (!sel || !sel.value) return;
  const src = mushroomStrains.find((x) => x.id === parseInt(sel.value, 10));
  if (!src) return;
  const sv = (eid, val) => {
    const el = document.getElementById(eid);
    if (el) el.value = val;
  };
  sv('ms-rec-type', src.recBatchType || '');
  sv('ms-rec-substrate', src.recSubstrate || 'holzkleie');
  sv('ms-rec-bagkg', src.recBagKg || 0);
  sv('ms-rec-rh', src.recRhPct || 0);
  sv('ms-rec-hw', src.recHardwoodPct || 0);
  sv('ms-rec-wb', src.recWheatbranPct || 0);
  sv('ms-rec-coir', src.recCoirPct || 0);
  sv('ms-rec-corn', src.recCornPct || 0);
  sv('ms-rec-gyppct', src.recGypsumPct || 0);
  sv('ms-rec-spawn', src.recSpawnPct || 0);
  sv('ms-min-spawn', src.minSpawnKg || 0);
  sv('ms-min-lc', src.minLc || 0);
  sv('ms-min-mc', src.minMc || 0);
  sv('ms-min-pd', src.minPd || 0);
  msRecShowRef(src);
  const gyp = document.getElementById('ms-rec-gyp');
  if (gyp) gyp.checked = !!src.recGypsum;
  sv('ms-rec-grainkg', src.recGrainKg || 0);
  sv('ms-rec-grainrh', src.recGrainRhPct != null ? src.recGrainRhPct : 52);
  sv('ms-rec-days', src.recIncDays != null ? src.recIncDays : 14);
  sv('ms-rec-fruitdays', src.recFruitDays || 0);
  sel.value = '';
  msRecTypeChange();
}
function msRecShowRef(ms) {
  const el = document.getElementById('ms-rec-ref');
  if (!el) return;
  const colon = ms && ms.recColonText;
  const steril = ms && ms.recSterilText;
  if (!colon && !steril) {
    el.textContent = '';
    return;
  }
  el.textContent = t('strains.recRef', { colon: colon || '—', steril: steril || '—' });
}
function msRecipeSummary(ms) {
  const type = ms.recBatchType || '';
  if (!type) return '<span style="color:var(--c-text-muted)">—</span>';
  const typeLabel =
    { block: t('strains.recBlock'), allinone: t('strains.recAllinone'), grain: t('strains.recGrain') }[type] || type;
  const parts = [esc(typeLabel)];
  if (type === 'block' || type === 'allinone') {
    if ((ms.recSubstrate || 'holzkleie') === 'cvg') parts.push(esc(t('orders.sub.cvg')));
    else parts.push('HW' + (ms.recHardwoodPct || 0) + '/WB' + (ms.recWheatbranPct || 0));
    if (ms.recBagKg) parts.push((ms.recBagKg || 0) + ' kg');
  }
  if ((type === 'allinone' || type === 'grain') && ms.recGrainKg) parts.push('Grain ' + ms.recGrainKg + ' kg');
  return '<span class="fs-xs">' + parts.join(' · ') + '</span>';
}
function msRecipeSummaryText(ms) {
  // Plain-text variant of msRecipeSummary for the quick-create modal subtitle.
  const div = document.createElement('div');
  div.innerHTML = msRecipeSummary(ms);
  return div.textContent || '';
}

// ── Quick-create: spin a Charge or Laborarbeit straight from a Sorte recipe ──
let _msQuickCtx = null;

function msQuickCharge(id) {
  const ms = mushroomStrains.find((x) => x.id === id);
  if (!ms) return;
  if (!ms.recBatchType) {
    toast(t('msq.noRecipe'), 'err');
    return;
  }
  msQuickOpen('charge', ms);
}
function msQuickLabor(id) {
  const ms = mushroomStrains.find((x) => x.id === id);
  if (!ms) return;
  msQuickOpen('labor', ms);
}
// Dashboard entry points: open the dialog with a Sorte dropdown (none preselected),
// so "Neue Charge" / "Laborarbeit" go straight to the create dialog instead of the
// Pilzsorten list. The recipe still comes from whichever Sorte is then chosen.
function msQuickChargeNew() {
  msQuickOpen('charge', null);
}
function msQuickLaborNew() {
  msQuickOpen('labor', null);
}
// Last quantity used per quick-create mode, so the dialog reopens on the batch
// size actually being run instead of 1. Stored per mode: a Charge is typically
// many bags, a Laborarbeit only a few.
function _msqLastQty(mode) {
  try {
    const s = JSON.parse(localStorage.getItem('mp-msq-qty') || '{}');
    const n = parseInt(s[mode], 10);
    if (n > 0) return n;
  } catch (e) {
    /* storage disabled — fall back to 1 */
  }
  return 1;
}
// Die Art, mit der die Laborarbeit aufgeht: die zuletzt angelegte, sonst
// Petrischale. Vorher stand immer "Slant registrieren" da — die eine Art ohne
// Herkunft, also ohne "Beimpft mit", und genau das Feld fehlte dann.
function _msqLastArt() {
  try {
    const a = localStorage.getItem('mp-msq-art');
    if (a && LAB_PARENT_TYPES[a]) return a;
  } catch (e) {
    /* storage disabled */
  }
  return 'PD';
}
function _msqSaveArt(art) {
  try {
    localStorage.setItem('mp-msq-art', art);
  } catch (e) {
    /* storage disabled — next open starts at Petrischale */
  }
}
// Dübel je Beutel: wie die Größe einer Spritze eine Angabe zum Stück, keine
// Anzahl, also darf sie stehenbleiben. Leer, solange nie eine eingetragen war.
function _msqDuebelStueck() {
  try {
    const n = parseInt(localStorage.getItem('mp-du-stueck'), 10);
    return n > 0 ? n : null;
  } catch (e) {
    return null;
  }
}
function _msqSaveDuebelStueck(n) {
  if (!(n > 0)) return;
  try {
    localStorage.setItem('mp-du-stueck', String(n));
  } catch (e) {
    /* storage disabled — next open asks again */
  }
}
function _msqSaveQty(mode, qty) {
  if (!(qty > 0)) return;
  try {
    const s = JSON.parse(localStorage.getItem('mp-msq-qty') || '{}');
    s[mode] = qty;
    localStorage.setItem('mp-msq-qty', JSON.stringify(s));
  } catch (e) {
    /* storage disabled — next open just starts at 1 */
  }
}
// Why a recipe can't be turned into a Charge, or null if it can.
// A recipe only needs rec_batch_type to qualify for the picker, but the columns
// behind it all default to 0 — so a Sorte could be offered here and then be
// rejected by createBatch for a missing bag weight or a substrate split that
// doesn't total 100. Those rejections fire after msQuickClose(), i.e. against a
// modal that is already gone, discarding whatever was typed. Catch it up front
// and keep the reason on screen instead.
function _msRecipeProblem(ms) {
  const type = ms.recBatchType || '';
  if (!type) return t('msq.noRecipe');
  if (type === 'block' || type === 'allinone') {
    if (!(ms.recBagKg > 0)) return t('msq.recNoBagKg');
    if ((ms.recSubstrate || 'holzkleie') === 'cvg') {
      if (!(ms.recCoirPct > 0)) return t('msq.recNoCoir');
    } else {
      const sum = (ms.recHardwoodPct || 0) + (ms.recWheatbranPct || 0);
      if (Math.abs(sum - 100) > 0.01) return t('msq.recBadSplit', { sum });
    }
  }
  if ((type === 'grain' || type === 'allinone') && !(ms.recGrainKg > 0)) return t('msq.recNoGrainKg');
  return null;
}
// Shared opener. ms === null → show the Sorte picker (charge mode lists only Sorten
// that have a recipe, since a Charge needs one).
function msQuickOpen(mode, ms) {
  // ml gilt nur für eine aufgenommene Spritze (genau eine, eine Größe); sonst
  // zählen Spritzen und Körnerbrut je Größe, und jede Größe fängt bei 0 an.
  // Jedes Öffnen beginnt mit einer Art; "Mehrere" ist ein Tipp
  // (msqMehrereUmschalten).
  _msQuickCtx = { mode, ms: ms || null, ml: 10, mehrere: false, arten: [], n: { MC: 0, PD: 0, LC: 0 } };
  const syBox = document.getElementById('ms-q-sy');
  if (syBox) syBox.innerHTML = syMengenHtml('ms-q', {});
  const kbBox = document.getElementById('ms-q-sizes');
  if (kbBox) kbBox.innerHTML = kbMengenHtml('ms-q', {});
  // Fresh dialog, fresh inoculant list — one left over from an abandoned dialog
  // would otherwise be offered up for the next batch.
  _inoc = [];
  const cSel = document.getElementById('ms-q-culture');
  if (cSel) {
    cSel.value = '';
    cSel.style.display = 'none';
  }
  const wrap = document.getElementById('ms-q-sorte-wrap');
  const sel = document.getElementById('ms-q-sorte');
  if (!ms && wrap && sel) {
    let list = mushroomStrains.slice();
    if (mode === 'charge') list = list.filter((x) => x.recBatchType);
    // No Sorte has a production recipe yet: the dialog would open on an empty
    // dropdown with Anlegen disabled and no hint why. Point at the page where a
    // recipe is actually defined instead of opening a dead end.
    if (mode === 'charge' && !list.length) {
      _msQuickCtx = null;
      confirm2(t('msq.noRecipesTitle'), t('msq.noRecipesMsg'), t('msq.noRecipesGo'), goCreateStrain);
      return;
    }
    list.sort((a, b) => (a.name || '').localeCompare(b.name || ''));
    sel.innerHTML =
      '<option value="">' +
      esc(t('msq.pickSortePrompt')) +
      '</option>' +
      list.map((x) => `<option value="${x.id}">${esc(x.name)}${x.kuerzel ? ' (' + esc(x.kuerzel) + ')' : ''}</option>`).join('');
    sel.value = '';
    wrap.style.display = '';
  } else if (wrap) {
    wrap.style.display = 'none';
  }
  // qty/strain reset only on open (not when the Sorte changes). qty restores the
  // last value used in this mode rather than snapping back to 1: batch size is
  // the one number the recipe cannot supply, it barely changes between runs, and
  // stepping it back up to 20 costs 19 taps on a phone. The manual form already
  // persists its qty the same way (nbSaveDefaults).
  const qtyEl = document.getElementById('ms-q-qty');
  if (qtyEl) qtyEl.value = _msqLastQty(mode);
  // Stamm und Datum gehören zu genau einem Anlegen: jedes Öffnen fängt bei
  // "ohne Stamm" und heute an.
  stammReset('ms-q');
  anlageReset('ms-q');
  const art = document.getElementById('ms-q-labtype');
  if (art && mode === 'labor') art.value = _msqLastArt();
  msQuickRender();
  document.getElementById('ms-quick-modal').style.display = 'flex';
}
// Render the modal for the current ctx. Safe when no Sorte is chosen yet (picker
// mode): shows a prompt and disables "Anlegen" until one is selected.
function msQuickRender() {
  if (!_msQuickCtx) return;
  const mode = _msQuickCtx.mode;
  const ms = _msQuickCtx.ms;
  const titleEl = document.getElementById('ms-q-title');
  const subEl = document.getElementById('ms-q-sub');
  const goEl = document.getElementById('ms-q-go');
  const intake = _msQuickCtx.intake || null;
  if (titleEl)
    titleEl.textContent = intake
      ? t('intake.dialogTitle', { id: intake.id })
      : mode === 'charge'
        ? t('msq.chargeTitle')
        : t('msq.laborTitle');
  const lt = document.getElementById('ms-q-labtype-wrap');
  if (lt) lt.style.display = mode === 'labor' ? '' : 'none';
  const artEl = document.getElementById('ms-q-labtype');
  // Bei mehreren Arten zeigt jede angetippte ihre Felder; die gemeinsame
  // Anzahl fällt weg, jede Art zählt für sich.
  const mehrere = msqMehrere();
  const arten = msqArten();
  // Auch bei einer Charge: was von "Mehrere" noch dasteht, geht weg.
  msqArtenRender();
  if (goEl && !mehrere) goEl.textContent = t('msq.create');
  const mlWrap = document.getElementById('ms-q-ml-wrap');
  const istSy = mode === 'labor' && (mehrere ? arten.includes('SY') : !!artEl && artEl.value === 'SY');
  // Eine aufgenommene Spritze ist genau eine: eine Größe zum Wählen. Sonst je
  // Größe eine Anzahl, und die gemeinsame Anzahl fällt weg.
  const syEine = istSy && !!intake;
  const syViele = istSy && !intake;
  if (mlWrap) mlWrap.style.display = syEine ? '' : 'none';
  if (syEine) document.getElementById('ms-q-ml').innerHTML = syMlKnoepfe('msq-ml', _msQuickCtx.ml);
  const syWrap = document.getElementById('ms-q-sy-wrap');
  if (syWrap) syWrap.style.display = syViele ? '' : 'none';
  // Grain spawn is a Charge in everything but name: it is weighed, incubates,
  // and produces barcoded bags. So it wants the days and kg fields that the
  // count-based culture types don't.
  const isKb = mehrere ? arten.includes('KB') : _msqIsGrainspawn();
  const dw = document.getElementById('ms-q-days-wrap');
  if (dw) dw.style.display = mode === 'charge' || isKb ? '' : 'none';
  const istDu = mode === 'labor' && !mehrere && !!artEl && artEl.value === 'DU';
  const stw = document.getElementById('ms-q-stueck-wrap');
  if (stw) stw.style.display = istDu ? '' : 'none';
  const st = document.getElementById('ms-q-stueck');
  if (istDu && st && !st.value) st.value = _msqDuebelStueck() || '';
  // Koernerbrut zaehlt nach Groesse, alles andere nach Stueck. Die Zeilenliste
  // und der gemeinsame Anzahl-Zaehler sind zwei Antworten auf dieselbe Frage,
  // also steht immer nur eine davon da -- sonst haette ein Ansatz aus 10x1 und
  // 5x2 eine Anzahl darueber, die zu keiner der beiden Zeilen gehoert.
  const grain = mehrere ? isKb : _msqIsGrain();
  const sw = document.getElementById('ms-q-sizes-wrap');
  if (sw) sw.style.display = grain ? '' : 'none';
  const qw = document.getElementById('ms-q-qty-wrap');
  // Ein aufgenommenes Etikett ist genau ein Glas.
  if (qw) qw.style.display = grain || intake || syViele || mehrere ? 'none' : '';
  const grid = document.getElementById('ms-q-grid');
  if (grid) grid.style.gridTemplateColumns = grain ? 'minmax(0, 1fr)' : '';
  // Der Stamm hängt an der Sorte, das Datum an nichts. Beide behalten beim
  // Neuzeichnen, was schon gewählt ist.
  stammRender('ms-q', ms ? ms.id : null);
  anlageRender('ms-q');
  if (!ms) {
    if (subEl) subEl.textContent = t('msq.pickSortePrompt');
    if (goEl) goEl.disabled = true;
    const prev = document.getElementById('ms-q-preview');
    if (prev) prev.textContent = '';
    // Die Herkunft scannen geht schon jetzt: sie bringt die Sorte mit.
    msQuickFillCulture();
    return;
  }
  // An incomplete recipe is rejected downstream by createBatch, long after this
  // dialog has closed — so block it here, while the reason is still readable.
  const problem = mode === 'charge' ? _msRecipeProblem(ms) : null;
  if (goEl) goEl.disabled = !!problem;
  if (subEl)
    subEl.textContent =
      ms.name + (ms.kuerzel ? ' (' + ms.kuerzel + ')' : '') + (mode === 'charge' ? ' — ' + msRecipeSummaryText(ms) : '');
  if (mode === 'charge') {
    const d = document.getElementById('ms-q-days');
    if (d) d.value = ms.recIncDays || 14;
  } else if (isKb) {
    // Körnerbrut als Laborarbeit hat kein Rezept mit Inkubationstagen.
    const d = document.getElementById('ms-q-days');
    if (d && !(parseInt(d.value, 10) > 0)) d.value = 14;
  }
  msQuickPreview();
  msQuickFillCulture();
  inocRender('ms-q');
  if (problem) {
    const prev = document.getElementById('ms-q-preview');
    if (prev) {
      prev.textContent = '⚠ ' + problem;
      prev.style.color = 'var(--c-red-dark)';
    }
  }
}
// Woraus die gewählte Laborarbeit angesetzt werden darf, oder null, wenn der
// Dialog keine Laborarbeit ist.
function msqParentTypes() {
  if (!_msQuickCtx || _msQuickCtx.mode !== 'labor') return null;
  // Mehrere Arten teilen sich die eine Herkunft: sie muss zu jeder passen.
  if (msqMehrere())
    return msqArten().reduce(
      (passt, a) => passt.filter((x) => (LAB_PARENT_TYPES[a] || []).includes(x)),
      ['MC', 'PD', 'LC', 'SY']
    );
  const el = document.getElementById('ms-q-labtype');
  return LAB_PARENT_TYPES[(el && el.value) || 'MC'] || [];
}
// Etwas für "Beimpft mit" im Schnelldialog, gescannt oder gewählt. Bei einer
// Laborarbeit muss es zur Art passen, und es gibt genau eine Herkunft: die
// zweite ersetzt die erste, statt ungenutzt danebenzustehen. Ist noch keine
// Sorte gewählt, kommen Sorte und Stamm von der gescannten Kultur — die steht
// auf dem Glas in der Hand, niemand soll sie noch einmal heraussuchen.
// null wenn genommen, sonst der Grund in Worten.
function msqInocAdd(rawId) {
  const types = msqParentTypes();
  const id = String(rawId || '').trim();
  const c = cultures.find((x) => x.id.toUpperCase() === id.toUpperCase());
  if (types) {
    const art = document.getElementById('ms-q-labtype');
    const artName = art && art.selectedOptions[0] ? art.selectedOptions[0].textContent : '';
    const mehrere = msqMehrere();
    const isKb = !mehrere && art && art.value === 'KB';
    // Körnerbrut darf auch aus einem Körnerbeutel kommen (Körner aus Körnern),
    // Impfdübel ebenso — aber nur allein: eine Petrischale wächst nicht aus
    // einem Körnerbeutel.
    if (!(kornAlsHerkunft(types) && !c) && (!c || !types.includes(c.type)))
      return mehrere
        ? t('msq.parentWrongTypeMulti', {
            id: id,
            art: msqArten()
              .map((a) => t('msq.art.' + a))
              .join(', '),
            types: types.join(', ')
          })
        : t('msq.parentWrongType', { id: id, art: artName, types: types.join(', ') });
    const ms = _msQuickCtx.ms;
    if (c && ms && c.strainId && c.strainId !== ms.id)
      return t('msq.parentOtherSorte', { id: c.id, sorte: c.strainName || c.species || '', ziel: ms.name });
    if (!isKb) _inoc = [];
  }
  const err = inocAdd(id);
  if (err) return err;
  // Noch keine Sorte: die vom gescannten Glas oder Körnerbeutel. Eine Charge
  // nimmt sie nur, wenn die Sorte ein Rezept hat — sonst steht sie nicht in der
  // Liste, und die Wahl bleibt beim Arbeiter.
  const bag = c ? null : nbAvailableSpawnBags().find((b) => b.bag.toUpperCase() === id.toUpperCase());
  const von = c || bag;
  if (von && !_msQuickCtx.ms && von.strainId) {
    const ms = mushroomStrains.find((x) => x.id === von.strainId);
    if (ms && (types || ms.recBatchType)) {
      _msQuickCtx.ms = ms;
      const sel = document.getElementById('ms-q-sorte');
      if (sel) sel.value = String(ms.id);
      const st = stammState('ms-q');
      st.strainId = ms.id;
      const name = (von.strainText || '').trim();
      const hit = staemmeFor(ms.id).find((x) => stammGleich(x.name, name));
      st.wert = hit ? hit.name : '';
    }
  }
  return null;
}
// ── Ein Etikett aufnehmen, das das System nicht kennt ────────
// Ein gedrucktes Kultur-Etikett, zu dem es keine Kultur gibt: meist eine, deren
// Speichern fehlschlug, nachdem das Etikett schon gedruckt war (cprShow druckt
// dann mit der Kennung als Barcode). Statt "gibt es nicht" nimmt die App sie
// wieder auf — mit genau dieser Kennung, damit das Etikett am Glas gilt.
// Art, Sorte, Stamm und Tag stehen in der Kennung und sind vorausgefüllt.
function kulturKennungLesen(id) {
  const parts = String(id).toUpperCase().split('-');
  if (parts.length < 4) return null;
  const type = parts[0];
  const tag = parts[parts.length - 2];
  const kz = parts[1];
  const stamm = parts.length === 5 ? parts[2] : '';
  const ms =
    mushroomStrains.find((x) => (x.kuerzel || '').toUpperCase() === kz) ||
    mushroomStrains.find((x) => abbrev(x.name) === kz) ||
    null;
  // TTMMJJ → JJJJ-MM-TT; ein Tag in der Zukunft oder Unsinn bleibt leer (= heute).
  let datum = '';
  if (/^\d{6}$/.test(tag)) {
    const d = '20' + tag.slice(4, 6) + '-' + tag.slice(2, 4) + '-' + tag.slice(0, 2);
    const dt = new Date(d + 'T12:00:00');
    if (!isNaN(dt) && localDateStr(dt) === d && d <= localDateStr(new Date())) datum = d;
  }
  return { id: String(id).toUpperCase(), type, ms, stamm, datum };
}
function kulturAufnehmenAnbieten(id) {
  _scanBeep(500, 120);
  const k = kulturKennungLesen(id);
  // Aufnehmen geht über den Laborarbeit-Dialog, und der kennt diese Arten.
  if (!k || !['MC', 'PD', 'LC', 'SY'].includes(k.type)) {
    setFb('err', t('scanFb.cultureNotInSystem', { id: id }));
    return;
  }
  closeCamScan();
  confirm2(t('intake.title'), t('intake.msg', { id: k.id }), t('intake.yes'), () => msQuickOpenIntake(k));
}
function msQuickOpenIntake(k) {
  msQuickOpen('labor', null);
  if (!_msQuickCtx) return;
  _msQuickCtx.intake = k;
  const art = document.getElementById('ms-q-labtype');
  if (art) {
    art.value = k.type;
    art.disabled = true;
  }
  if (k.ms) {
    _msQuickCtx.ms = k.ms;
    const sel = document.getElementById('ms-q-sorte');
    if (sel) sel.value = String(k.ms.id);
    if (k.stamm) {
      const st = stammState('ms-q');
      st.strainId = k.ms.id;
      const hit = staemmeFor(k.ms.id).find((x) => x.name.replace(/[^A-Za-z0-9]/g, '').toUpperCase() === k.stamm);
      st.wert = hit ? hit.name : '';
    }
  }
  if (k.datum) ANLAGE['ms-q'] = { offen: true, datum: k.datum };
  const qty = document.getElementById('ms-q-qty');
  if (qty) qty.value = 1;
  msQuickRender();
}
// True when the quick dialog is in Laborarbeit mode with Grainspawn selected.
// Grain spawn (KB) is not a culture: it goes through createGrainBatch, not
// logLabWork, and produces G-prefixed barcoded bags.
function _msqIsGrainspawn() {
  if (!_msQuickCtx || _msQuickCtx.mode !== 'labor') return false;
  const el = document.getElementById('ms-q-labtype');
  return !!el && el.value === 'KB';
}
// Koernerbrut in BEIDEM Sinn: als Laborarbeit (Art = KB) und als Charge einer
// Sorte, deren Rezept auf Koerner lautet. Beide Wege landen in
// createGrainBatch(), beide wiegen ihre Beutel -- und der zweite hatte bisher
// gar kein Gewichtsfeld, sondern nahm stumm recGrainKg aus dem Rezept.
function _msqIsGrain() {
  if (!_msQuickCtx) return false;
  if (_msQuickCtx.mode === 'charge') return !!(_msQuickCtx.ms && _msQuickCtx.ms.recBatchType === 'grain');
  return _msqIsGrainspawn();
}
// Die Größe einer Spritze, im Schnelldialog: ein Tipp auf 10, 20 oder 50 ml.
(function wireMsqMl() {
  document.addEventListener('click', (e) => {
    const b = e.target.closest('[data-msq-ml]');
    if (!b || !_msQuickCtx) return;
    _msQuickCtx.ml = parseInt(b.dataset.msqMl, 10) || 10;
    document.getElementById('ms-q-ml').innerHTML = syMlKnoepfe('msq-ml', _msQuickCtx.ml);
    msQuickPreview();
  });
})();
// ── Mehrere Arten auf einmal ─────────────────────────────────
// Ein Labortag mit einer Sorte: aus demselben Glas gehen Petrischalen,
// Flüssigkulturen und Körnerbrut. Einzeln hieß das, für jede Art den Dialog zu
// öffnen, dieselbe Herkunft neu zu scannen und jedes Mal zu drucken. Der Knopf
// "Mehrere" macht aus der Liste Knöpfe zum Antippen: jede angetippte Art
// bekommt ihre Zahlen, Sorte, Stamm, Tag und die eine Herkunft gelten für alle,
// und am Ende steht ein Etiketten-Fenster mit einem Druck (etikettenFuerAlles).
// Slants gehören dazu: sie kommen meist von derselben Petrischale. Jede Zahl
// fängt bei 0 an.
const MSQ_MEHRERE = ['MC', 'PD', 'LC', 'SY', 'KB'];
// Die Arten, die eine Anzahl zählen, ohne Größen.
const MSQ_STUECK = ['MC', 'PD', 'LC'];
function msqMehrere() {
  return !!(_msQuickCtx && _msQuickCtx.mode === 'labor' && _msQuickCtx.mehrere && !_msQuickCtx.intake);
}
function msqArten() {
  return msqMehrere() ? _msQuickCtx.arten : [];
}
function msqMehrereUmschalten() {
  if (!_msQuickCtx || _msQuickCtx.intake) return;
  const sel = document.getElementById('ms-q-labtype');
  _msQuickCtx.mehrere = !_msQuickCtx.mehrere;
  if (_msQuickCtx.mehrere) {
    // Die Art, die gerade dasteht, ist die erste angetippte.
    _msQuickCtx.arten = sel && MSQ_MEHRERE.includes(sel.value) ? [sel.value] : [];
    _msQuickCtx.n = { MC: 0, PD: 0, LC: 0 };
    const syBox = document.getElementById('ms-q-sy');
    if (syBox) syBox.innerHTML = syMengenHtml('ms-q', {});
    const kbBox = document.getElementById('ms-q-sizes');
    if (kbBox) kbBox.innerHTML = kbMengenHtml('ms-q', {});
  } else if (sel && _msQuickCtx.arten.length) {
    // Zurück zu einer Art: der ersten angetippten.
    sel.value = _msQuickCtx.arten[0];
  }
  msQuickRender();
}
// Die Art als Liste (eine) oder als Knöpfe (mehrere), dazu die Zähler der
// Arten ohne eigene Felder. Spritzen und Körnerbrut bringen ihre mit (ms-q-sy,
// ms-q-sizes). Bei mehreren steht über jeder Art ihr Name, gleich gesetzt wie
// MSQ_ART_KOPF, so dass jede angetippte Art ein Abschnitt für sich ist.
const MSQ_ART_KOPF = 'font-weight:600;padding-top:8px;border-top:1px solid var(--c-border-light)';
function msqArtenRender() {
  const mehrere = msqMehrere();
  const arten = msqArten();
  const sel = document.getElementById('ms-q-labtype');
  if (sel) sel.style.display = mehrere ? 'none' : '';
  const knopf = document.getElementById('ms-q-mehrere');
  if (knopf) {
    knopf.style.display = _msQuickCtx.intake ? 'none' : '';
    knopf.classList.toggle('btn-p', mehrere);
    knopf.setAttribute('aria-pressed', mehrere ? 'true' : 'false');
  }
  const box = document.getElementById('ms-q-arten');
  if (box) {
    box.style.display = mehrere ? 'flex' : 'none';
    box.innerHTML = mehrere
      ? MSQ_MEHRERE.map((a) => {
          const an = arten.includes(a);
          return `<button type="button" class="btn${an ? ' btn-p' : ''}" data-msq-art="${a}" aria-pressed="${an}" style="min-height:var(--tap);font-weight:600">${esc(t('msq.art.' + a))}</button>`;
        }).join('')
      : '';
  }
  const zaehler = document.getElementById('ms-q-multi');
  if (zaehler) {
    const gezaehlt = MSQ_STUECK.filter((a) => arten.includes(a));
    zaehler.style.display = gezaehlt.length ? '' : 'none';
    zaehler.innerHTML = gezaehlt
      .map(
        (a) =>
          `<div style="${MSQ_ART_KOPF};margin-bottom:6px">${esc(t('msq.art.' + a))}</div>` +
          zaehlerZeileHtml('ms-q-n-' + a, _msQuickCtx.n[a], '')
      )
      .join('');
  }
  for (const id of ['ms-q-sy-head', 'ms-q-kb-head']) {
    const h = document.getElementById(id);
    if (h) h.style.display = mehrere ? '' : 'none';
  }
}
// Die Zahlen, so wie sie dastehen: je Art, Spritzen je Größe, Körnerbrut je
// Beutelgröße. Was nicht angetippt ist, zählt nicht mit.
function msqMehrereLesen() {
  const arten = msqArten();
  for (const a of MSQ_STUECK) {
    const el = document.getElementById('ms-q-n-' + a);
    if (el) _msQuickCtx.n[a] = Math.max(0, Math.min(500, parseInt(el.value, 10) || 0));
  }
  const z = {
    MC: arten.includes('MC') ? _msQuickCtx.n.MC : 0,
    PD: arten.includes('PD') ? _msQuickCtx.n.PD : 0,
    LC: arten.includes('LC') ? _msQuickCtx.n.LC : 0,
    sy: arten.includes('SY') ? syMengenLesen('ms-q') : {},
    kb: arten.includes('KB') ? msqReadSizes() : []
  };
  z.summe = z.MC + z.PD + z.LC + sySumme(z.sy) + z.kb.reduce((a, l) => a + l.qty, 0);
  return z;
}
function msqMehrerePreview(el) {
  const z = msqMehrereLesen();
  const teile = [];
  if (z.MC) teile.push(z.MC + ' ' + t('bmp.MC'));
  if (z.PD) teile.push(z.PD + ' ' + t('bmp.PD'));
  if (z.LC) teile.push(z.LC + ' ' + t('bmp.LC'));
  teile.push(...syTeile(z.sy));
  for (const l of z.kb) teile.push(t('bmp.previewGrain', { n: l.qty, kg: String(l.kg).replace('.', ',') }));
  el.textContent = teile.length ? t('bmp.preview', { list: teile.join(' · ') }) : t('bmp.nothing');
  // Früher angesetzte Körnerbrut bucht kein Korn ab, wie im Dialog für eine Art.
  if (z.kb.length && anlageFrueher('ms-q')) el.textContent += ' — ' + t('anlage.notBooked');
  const go = document.getElementById('ms-q-go');
  if (go) go.textContent = z.summe ? t('msq.createN', { n: z.summe }) : t('msq.create');
}
(function wireMsqMehrere() {
  document.addEventListener('click', (e) => {
    if (!_msQuickCtx) return;
    if (e.target.closest('#ms-q-mehrere')) return msqMehrereUmschalten();
    const b = e.target.closest('[data-msq-art]');
    if (!b || !msqMehrere()) return;
    const a = b.dataset.msqArt;
    const arten = _msQuickCtx.arten.includes(a)
      ? _msQuickCtx.arten.filter((x) => x !== a)
      : _msQuickCtx.arten.concat(a);
    _msQuickCtx.arten = MSQ_MEHRERE.filter((x) => arten.includes(x));
    msQuickRender();
  });
})();
function msQuickLabTypeChanged() {
  // Full re-render, not just the culture list: switching to Grainspawn shows
  // the days field and the size rows, and switching away hides them again.
  msQuickRender();
}
function msQuickSorteChanged() {
  if (!_msQuickCtx) return;
  const id = parseInt(document.getElementById('ms-q-sorte').value, 10);
  _msQuickCtx.ms = mushroomStrains.find((x) => x.id === id) || null;
  msQuickRender();
}
function msQuickClose() {
  _msQuickCtx = null;
  const art = document.getElementById('ms-q-labtype');
  if (art) art.disabled = false;
  _inocScanPrefix = null;
  // Drop the inoculant list. Abandoning the dialog must not leave it armed for
  // whatever batch is created next. The confirm path closes the dialog before
  // createBatch runs, so it carries the list across itself — see msQuickConfirm.
  _inoc = [];
  const m = document.getElementById('ms-quick-modal');
  if (m) m.style.display = 'none';
}
// ── Die Größen einer Körnerbrut, im Schnelldialog ─────────
//
// Ein Ansatz geht in Beutel verschiedener Größe: dieselbe Flüssigkultur,
// dieselbe Charge, und trotzdem 1 kg neben 2 neben 5. Beutel gibt es in diesen
// drei Größen, also je Größe ein Zähler wie bei den Spritzen: ein Tipp auf +,
// kein Gewicht zum Eintippen, und jede Zahl fängt bei 0 an. Die Anzahl wandert
// damit aus dem gemeinsamen Zähler in die Zeile; für alles andere im Dialog —
// Petrischalen, Flüssigkultur, Blöcke — bleibt sie oben, dort gibt es nur eine
// Sorte Stück. Das Beimpfen-Fenster zählt Körnerbeutel genauso.
const KB_KG = [1, 2, 5];
function kbMengenHtml(pre, n) {
  return KB_KG.map((kg) => zaehlerZeileHtml(pre + '-kb-' + kg, n && n[kg], kg + ' kg')).join('');
}
// {1: n, 2: n, 5: n} aus den Feldern, 0 bis 500 wie die anderen Zähler.
function kbMengenLesen(pre) {
  const n = {};
  for (const kg of KB_KG) {
    const el = document.getElementById(pre + '-kb-' + kg);
    n[kg] = el ? Math.max(0, Math.min(500, parseInt(el.value, 10) || 0)) : 0;
  }
  return n;
}
// [{kg, qty}] je Größe mit Anzahl, die Form, die gsSetLines() nimmt. Was hier
// herauskommt, ist was angelegt wird.
function msqReadSizes() {
  const n = kbMengenLesen('ms-q');
  return KB_KG.filter((kg) => n[kg] > 0).map((kg) => ({ kg, qty: n[kg] }));
}
function msqQtyStep(d) {
  const el = document.getElementById('ms-q-qty');
  if (!el) return;
  el.value = Math.max(1, (parseInt(el.value, 10) || 0) + d);
  msQuickPreview();
}
function msQuickPreview() {
  const el = document.getElementById('ms-q-preview');
  if (!el) return;
  el.style.color = ''; // clear the recipe-problem styling from a previous render
  if (!_msQuickCtx || !_msQuickCtx.ms) {
    el.textContent = '';
    return;
  }
  if (_msQuickCtx.mehrere) return msqMehrerePreview(el);
  const qty = parseInt(document.getElementById('ms-q-qty').value) || 0;
  // Körnerbrut zuerst, auch wenn sie als Charge kommt: eine Körner-Sorte fiel
  // vorher in den Charge-Zweig und wurde dort mit der Anzahl oben gerechnet —
  // der Zahl, die es für sie nicht mehr gibt.
  //
  // Beide anderen Zweige rechnen die Menge ein, also darf keiner mehr "pro
  // Stück:" darüberschreiben — der Vorspann des Rezepteditors, der dort mit
  // Anzahl 1 rechnet und hier seit jeher die Summe beschriftet hat.
  if (_msqIsGrain()) {
    // Drei Zahlen hingen an einer Überschrift, die zu keiner davon gehörte:
    // "pro Stück: 7.6 kg" stand unter 10 × 2 kg. 2 kg kommt in einen Beutel,
    // 20 kg setzt man an, und 7,6 kg ist davon das trockene Korn, das vom Lager
    // abgeht — ausgerechnet die eine Zahl, die nicht pro Stück gilt. Alle drei
    // stehen jetzt da, jede benannt — und die erste ist jetzt die Aufstellung
    // der Größen, weil ein Ansatz aus mehr als einer bestehen darf.
    //
    // Die Feuchte kommt aus dem Rezept der Sorte, nicht aus getAvgComp():
    // msQuickConfirm schreibt genau diesen Wert nach gs-rh, und createGrainBatch
    // bucht damit (siehe koernerfeuchte-quelle.test.js). Der Schnitt über alle
    // Rezepte kündigte hier eine andere Menge an, als gleich gebucht wird.
    const lines = msqReadSizes();
    const rh = _msQuickCtx.ms.recGrainRhPct != null ? _msQuickCtx.ms.recGrainRhPct : 52;
    const num = (v) => (Math.round(v * 1000) / 1000).toString();
    const totalQty = lines.reduce((a, l) => a + l.qty, 0);
    const totalWet = lines.reduce((a, l) => a + l.kg * l.qty, 0);
    const totalDry = lines.reduce((a, l) => a + l.qty * mtDryKg(l.kg, rh), 0);
    el.textContent = totalQty
      ? t('msq.grainPreview', { n: totalQty }) +
        ' — ' +
        lines.map((l) => l.qty + ' × ' + num(l.kg) + ' kg').join(' + ') +
        ' · ' +
        t('msq.grainTotal', { total: num(totalWet) }) +
        ' · ' +
        t('msq.grainDry', { dry: num(totalDry) })
      : '';
  } else if (_msQuickCtx.mode === 'charge') {
    const parts = qty > 0 ? _msNeedParts(_msStrainToRecipe(_msQuickCtx.ms), qty) : [];
    el.textContent = parts.length ? t('msq.needFor', { n: qty }) + ' ' + parts.join(' · ') : '';
  } else if (document.getElementById('ms-q-labtype').value === 'SY') {
    // Die Größen stehen im Satz, damit vor dem Anlegen noch einmal dasteht, welche.
    const teile = syTeile(_msQuickCtx.intake ? { [_msQuickCtx.ml]: 1 } : syMengenLesen('ms-q'));
    el.textContent = teile.length ? t('bmp.preview', { list: teile.join(' · ') }) : '';
  } else {
    el.textContent = qty > 0 ? t('msq.laborPreview', { n: qty }) : '';
  }
  // Die Mengen oben sind, was ein Ansatz von heute nähme. Bestand aus der
  // Inventur nimmt nichts, und das muss danebenstehen, sonst liest man eine
  // Abbuchung, die nicht kommt. Kulturen buchen nie etwas, dort fehlt der Satz.
  if (el.textContent && (_msqIsGrain() || _msQuickCtx.mode === 'charge') && anlageFrueher('ms-q')) {
    el.textContent += ' — ' + t('anlage.notBooked');
  }
}
// Populate the modal's source-culture select, reusing the same culture filter the
// old forms use (none for a new MC isolation). Re-runs when the lab type changes.
function msQuickFillCulture() {
  const wrap = document.getElementById('ms-q-culture-wrap');
  const sel = document.getElementById('ms-q-culture');
  // Steht vor der Sorte und gilt schon ohne sie: die gescannte Herkunft bringt
  // die Sorte mit.
  if (!wrap || !sel || !_msQuickCtx) {
    if (wrap) wrap.style.display = 'none';
    return;
  }
  let types;
  if (_msQuickCtx.mode === 'charge') {
    // Körner aus Körnern: eine bestehende Körnerbrut darf die nächste ansetzen.
    const ms = _msQuickCtx.ms;
    types = ms && ms.recBatchType === 'grain' ? ['PD', 'LC', 'GS'] : ['PD', 'LC', 'G2G', 'GS'];
  } else {
    types = msqParentTypes();
    // Eine Herkunft, die zur neuen Art nicht mehr passt, fällt heraus.
    _inoc = _inoc.filter((x) => {
      if (x.kind === 'bag') return kornAlsHerkunft(types);
      const c = cultures.find((y) => y.id === x.id);
      return !!c && types.includes(c.type);
    });
  }
  if (!types || !types.length) {
    sel.value = '';
    wrap.style.display = 'none';
    return;
  }
  // The hidden select still carries a culture through to nb-culture/gs-culture.
  fillCultureSelect('ms-q-culture', types);
  wrap.style.display = '';
  inocRender('ms-q');
}
// The camera modal is z-index 200 and this dialog is 1200, so the camera would
// open behind it. Hide the dialog for the duration and put it back on close —
// _msQuickCtx survives, so nothing typed is lost. _inocScanPrefix doubles as the
// record of who opened the camera, so 'ms-q' is what says to restore.
function msqOpenScan(prefix) {
  _inocScanPrefix = prefix;
  const m = document.getElementById('ms-quick-modal');
  if (m) m.style.display = 'none';
  scan.action = null;
  scan.to = null;
  scan.from = null;
  updateSD();
  openCamScan();
}
// Takes the prefix as an argument because closeCamScan clears _inocScanPrefix,
// and reading it here after that would always see null.
function msqRestoreAfterScan(prefix) {
  if (prefix !== 'ms-q') return;
  if (!_msQuickCtx) return; // confirmed or dismissed while the camera was up
  const m = document.getElementById('ms-quick-modal');
  if (m) m.style.display = 'flex';
  msQuickRender();
}
async function msQuickConfirm() {
  if (!_msQuickCtx) return;
  if (!_msQuickCtx.ms) {
    toast(t('msq.pickSortePrompt'), 'err');
    return;
  }
  const ms = _msQuickCtx.ms;
  const mode = _msQuickCtx.mode;
  // Körnerbrut bringt ihre Anzahl je Größe mit, alles andere die eine oben.
  // Geprüft wird HIER, solange der Dialog noch steht: eine leere Liste
  // erreichte createGrainBatch als "keine Zeilen" — dessen Meldung erschien dann
  // gegen einen Dialog, der längst zu war, und alles Getippte war weg.
  // Mehrere Arten zählen je Art (msqMehrereLesen), auch das wird hier geprüft.
  const zahlen = msqMehrere() ? msqMehrereLesen() : null;
  const grain = !zahlen && _msqIsGrain();
  const sizes = grain ? msqReadSizes() : [];
  // Spritzen ebenso je Größe, außer der einen aufgenommenen.
  const artSel = document.getElementById('ms-q-labtype');
  const syN =
    !zahlen && mode === 'labor' && !_msQuickCtx.intake && artSel && artSel.value === 'SY'
      ? syMengenLesen('ms-q')
      : null;
  let qty;
  if (zahlen) {
    qty = zahlen.summe;
    if (qty < 1) {
      toast(t('bmp.nothing'), 'err');
      return;
    }
  } else if (grain) {
    if (!sizes.length) {
      fieldError('ms-q-sizes', t('batch.fillQty'));
      return;
    }
    qty = sizes.reduce((a, l) => a + l.qty, 0);
  } else if (syN) {
    qty = sySumme(syN);
    if (qty < 1) {
      fieldError('ms-q-sy', t('batch.fillQty'));
      return;
    }
  } else {
    qty = parseInt(document.getElementById('ms-q-qty').value) || 0;
    if (qty < 1) {
      fieldError('ms-q-qty', t('batch.fillQty'));
      return;
    }
    if (!_msQuickCtx.intake) _msqSaveQty(mode, qty);
  }
  // Ein Tag in der Zukunft wird hier abgewiesen, solange der Dialog noch steht.
  const angesetzt = anlageLesen('ms-q');
  if (angesetzt === null) return;
  // Steht noch ein getippter, nicht hinzugefügter Stamm im Feld, wird er jetzt
  // angelegt. Solange das läuft, nimmt der Knopf keinen zweiten Tipp an.
  const goBtn = document.getElementById('ms-q-go');
  if (goBtn) goBtn.disabled = true;
  const strainText = await stammFertig('ms-q');
  if (goBtn) goBtn.disabled = false;
  // Fehlgeschlagen (gemeldet ist es), oder der Dialog wurde währenddessen zu.
  if (strainText === null || !_msQuickCtx) return;
  const setv = (id, val) => {
    const el = document.getElementById(id);
    if (el) el.value = val;
  };
  // Die Kultur, mit der beimpft wird, steht in der Beimpf-Liste (gescannt oder
  // gewählt). Das versteckte Feld hier setzt seit dieser Liste niemand mehr —
  // so kam ein gescanntes Elternteil bei der Laborarbeit nie an.
  const sourceCulture =
    (document.getElementById('ms-q-culture') && document.getElementById('ms-q-culture').value) || inocCultureId();
  // msQuickClose() leert die Liste, damit ein abgebrochener Dialog nichts in die
  // nächste Charge trägt. Wer anlegt, nimmt sie mit hinüber.
  const inocMit = _inoc.slice();
  const intake = _msQuickCtx.intake || null;
  if (zahlen) {
    const days = parseInt(document.getElementById('ms-q-days').value) || 14;
    msQuickClose();
    msqMehrereAnlegen({ ms, strainText, angesetzt, quelle: sourceCulture, inoc: inocMit, zahlen, days });
    return;
  }
  if (mode === 'labor') {
    const labType = document.getElementById('ms-q-labtype').value || 'MC';
    if (!intake) _msqSaveArt(labType);
    // Grainspawn is not a culture: it is weighed, incubates and yields
    // G-prefixed barcoded bags, so it goes through createGrainBatch like the
    // full Körnerbrut form rather than logLabWork.
    if (labType === 'KB') {
      setv('lw-st', ms.id);
      setv('lw-strain-text', strainText);
      setv('lw-created', angesetzt);
      gsSetLines(sizes);
      setv('gs-days', parseInt(document.getElementById('ms-q-days').value) || 14);
      // Die Feuchte der Sorte, nicht der Schnitt über alle: ms steht hier, und
      // der Zweig 40 Zeilen tiefer liest sie längst so. getAvgComp() mittelt
      // recGrainRhPct über die Rezepte — für eine Sorte, deren Rezept den Wert
      // trägt, ist das die ungenauere Zahl, und sie entscheidet, wie viel
      // trockenes Korn vom Lagerbestand abgeht.
      setv('gs-rh', ms.recGrainRhPct != null ? ms.recGrainRhPct : 52);
      fillCultureSelect('gs-culture', ['PD', 'LC', 'SY', 'GS']);
      const gsc = document.getElementById('gs-culture');
      if (gsc) gsc.value = sourceCulture;
      setv('lw-notes', '');
      msQuickClose();
      // createGrainBatch() liest die Liste: die Kultur wird Herkunft, ein
      // gescannter Körnerbeutel (Körner aus Körnern) geht als verbraucht raus.
      _inoc = inocMit;
      createGrainBatch();
      return;
    }
    // Impfdübel aus einem Körnerbeutel: der Beutel steht als Quelle an den
    // Dübeln und geht als verbraucht raus, sobald sie gespeichert sind.
    const korn = labType === 'DU' ? inocMit.filter((x) => x.kind === 'bag').map((x) => x.id) : [];
    const stueckEl = document.getElementById('ms-q-stueck');
    const stueck = labType === 'DU' && stueckEl ? parseInt(stueckEl.value, 10) || null : null;
    if (stueck) _msqSaveDuebelStueck(stueck);
    setv('lw-type', labType);
    setv('lw-st', ms.id);
    setv('lw-strain-text', strainText);
    setv('lw-created', angesetzt);
    setv('lw-qty', qty);
    setv('lw-ml', _msQuickCtx.ml);
    setv('lw-source', korn.join(', '));
    setv('lw-notes', '');
    msQuickClose();
    // Kein Wechsel auf die Laborseite. Der ging dorthin, damit openStab()
    // lwUpdate() rief — und ließ den Arbeiter dann auf dem langen Formular
    // stehen, ohne ein Etikett. lwUpdate() füllt lw-parent auch so; das
    // Etiketten-Fenster kommt aus logLabWork() von selbst, egal wo man steht.
    lwUpdate();
    const parent = document.getElementById('lw-parent');
    if (parent) parent.value = sourceCulture; // valid: the modal used the same culture types
    logLabWork(intake ? { id: intake.id } : syN ? { sy: syN } : labType === 'DU' ? { korn, stueck } : undefined);
    return;
  }
  // Charge: prefill the existing Charge form from the recipe and reuse its
  // create logic (validation, inventory deduction, zone picker, barcodes).
  const days = parseInt(document.getElementById('ms-q-days').value) || ms.recIncDays || 14;
  if (ms.recBatchType === 'grain') {
    setv('lw-st', ms.id);
    setv('lw-strain-text', strainText);
    setv('lw-created', angesetzt);
    // Die Größen aus dem Dialog, nicht mehr recGrainKg: das Rezept hat die
    // Zeilen beim Öffnen gefüllt, danach gehören sie diesem einen Ansatz.
    gsSetLines(sizes);
    setv('gs-days', days);
    setv('gs-rh', ms.recGrainRhPct != null ? ms.recGrainRhPct : 52);
    fillCultureSelect('gs-culture', ['PD', 'LC', 'SY', 'GS']);
    const gsc = document.getElementById('gs-culture');
    if (gsc) gsc.value = sourceCulture;
    setv('lw-notes', '');
    msQuickClose();
    _inoc = inocMit;
    createGrainBatch();
    return;
  }
  // block / all-in-one — die Liste geht über nbFillFromStrain mit (inocMit).
  // Formular bereitmachen, BEVOR das Rezept hineingeschrieben wird: beim ersten
  // Mal in einer Sitzung setzt nbEnsureReady() die gemerkten Vorgaben, und die
  // überschrieben sonst jedes Feld, das das Rezept gleich setzt. Ein Wechsel auf
  // die Chargenseite ist dafür nicht nötig — der Etiketten-Dialog kommt von
  // selbst hoch, egal wo man steht.
  msQuickClose();
  nbEnsureReady();
  nbFillFromStrain(ms, { qty, days, strainText, culture: sourceCulture, inoc: inocMit, created: angesetzt });
  createBatch();
}
// Mehrere Arten aus einer Herkunft anlegen: jede Art ihre eigenen Nummern, alle
// mit derselben Herkunft, Sorte, Stamm und demselben Tag. Erst die Kulturen,
// dann die Körnerbrut über denselben Weg wie aus dem Dialog für eine Art, und
// am Ende ein Etiketten-Fenster für alles.
// spec: { ms, strainText, angesetzt, quelle, inoc, zahlen, days }
function msqMehrereAnlegen(spec) {
  const { ms, strainText, angesetzt, zahlen } = spec;
  const wann = anlageZeitpunkt(angesetzt);
  const posten = [];
  if (zahlen.MC > 0) posten.push(['MC', zahlen.MC, null]);
  if (zahlen.PD > 0) posten.push(['PD', zahlen.PD, null]);
  if (zahlen.LC > 0) posten.push(['LC', zahlen.LC, null]);
  for (const ml of SY_ML) if (zahlen.sy[ml] > 0) posten.push(['SY', zahlen.sy[ml], ml]);
  const ids = [];
  const saves = [];
  for (const [type, qty, ml] of posten) {
    const r = kulturenAnlegen({ type, ms, wann, qty, parentId: spec.quelle || null, strainText, ml });
    ids.push(...r.newC.map((x) => x.id));
    saves.push(r.saved);
  }
  let korn = null;
  if (zahlen.kb.length) {
    const setv = (id, val) => {
      const el = document.getElementById(id);
      if (el) el.value = val;
    };
    setv('lw-st', ms.id);
    setv('lw-strain-text', strainText);
    setv('lw-created', angesetzt);
    gsSetLines(zahlen.kb);
    setv('gs-days', spec.days || 14);
    setv('gs-rh', ms.recGrainRhPct != null ? ms.recGrainRhPct : 52);
    setv('lw-notes', '');
    // createGrainBatch nimmt die Herkunft aus der Beimpf-Liste.
    _inoc = spec.inoc.slice();
    korn = createGrainBatch({ ohneFenster: true }) || null;
  }
  renderLabLog();
  etikettenFuerAlles(ids, Promise.all(saves), korn);
}

// Das lange Chargenformular aus einem Rezept füllen.
//
// Zwei Wege führen hierher: der Schnelldialog (msQuickConfirm) und der
// geführte Assistent (wkbCreateFromShelf). Beide schrieben ihre eigene
// Feldliste, und die waren schon auseinandergelaufen — dem Assistenten
// fehlten Gips, Kultur und Körnerfeuchte, bis die Nachprüfung sie fand.
// createBatch() liest all diese Felder; wer eines vergisst, bucht den Altwert
// des letzten Benutzers mit. Deshalb steht die Liste nur noch hier.
//
// `ms` ist die Sorte. Alles in `o` überschreibt deren Rezept: qty, bagKg,
// days, hw, wb, rh kommen als Zahlen aus dem Assistenten, strainText und
// notes als Text, culture als Kultur-Id, inoc als Beimpf-Auswahl und created
// als der Tag, an dem angesetzt wurde (JJJJ-MM-TT, leer für heute).
function nbFillFromStrain(ms, o) {
  const opt = o || {};
  const setv = (id, v) => {
    const el = document.getElementById(id);
    if (el) el.value = v;
  };
  const oder = (v, ersatz) => (v != null ? v : ersatz);
  const isCvg = (ms.recSubstrate || 'holzkleie') === 'cvg';
  // Ein Ansatz aus einer früheren Charge steht sonst noch in der Auswahl, und
  // createBatch nimmt dann den Weg über den Ansatz und übergeht die
  // Zusammensetzung, die hier gerade gesetzt wird. Der Schnelldialog hat das
  // nie geleert.
  setv('nb-substrate-batch', '');
  setv('nb-strain-sel', ms.id);
  setv('nb-strain-text', opt.strainText || '');
  // Angesetzt am, JJJJ-MM-TT; leer heißt heute. Immer gesetzt, auch leer — ein
  // Datum aus dem letzten Anlegen darf nicht an diesem hängen bleiben.
  setv('nb-created', opt.created || '');
  setv('nb-qty', oder(opt.qty, 1));
  setv('nb-days', oder(opt.days, ms.recIncDays || 14));
  setBagWeight(parseDecimal(oder(opt.bagKg, ms.recBagKg)) || 0);
  setv('nb-rh', oder(opt.rh, ms.recRhPct || 0));
  // Eine CVG-Sorte hat ihre ganze Masse im Kokos, eine All-in-One ihre
  // Körnerbrut. Hart auf 0 gesetzt legt der Aufrufer sie an, ohne ein Gramm
  // abzubuchen.
  setv('nb-hw', isCvg ? 0 : oder(opt.hw, ms.recHardwoodPct || 0));
  setv('nb-wb', isCvg ? 0 : oder(opt.wb, ms.recWheatbranPct || 0));
  setv('nb-coir', isCvg ? ms.recCoirPct || 100 : 0);
  setv('nb-grainkg', ms.recBatchType === 'allinone' ? ms.recGrainKg || 0 : 0);
  setv('nb-grainrh', oder(ms.recGrainRhPct, 52));
  const gyp = document.getElementById('nb-gyp');
  if (gyp) gyp.checked = !!ms.recGypsum;
  // Die Kultur wird zur Herkunft der Charge, und eine G2G-/GS-Kultur schreibt
  // createBatch anschließend als verbraucht ab — eine stehengebliebene aus
  // einer abgebrochenen Vorbelegung darf hier nicht überleben.
  fillCultureSelect('nb-culture', ['PD', 'LC', 'G2G', 'GS']);
  setv('nb-culture', opt.culture || '');
  _inoc = opt.inoc || [];
  inocRender('nb');
  setv('nb-notes', opt.notes || '');
  setv('nb-ph', opt.ph == null ? '' : String(opt.ph).replace('.', ','));
  // Erst am Ende nachrechnen lassen: jeder dieser Aufrufe zieht eine Vorschau
  // nach sich, und mittendrin gerufen rechnen sie mit halb gefüllten Feldern
  // etwas aus, das die nächste Zeile sofort ersetzt.
  if (typeof nbSubstrateChanged === 'function') nbSubstrateChanged();
  if (typeof nbStrainChanged === 'function') nbStrainChanged();
}

function nbStrainChanged() {
  // The mix line below quotes block weight and spawn rate off the Sorte.
  if (typeof nbSubstrateNeed === 'function') setTimeout(nbSubstrateNeed, 0);
  nbPreview();
}
function renderNbGrainBanner() {
  const banner = document.getElementById('nb-source-banner');
  if (!banner) return;
  const sel = document.getElementById('nb-culture');
  const id = sel ? sel.value : '';
  if (!id) {
    banner.style.display = 'none';
    banner.textContent = '';
    return;
  }
  const c = cultures.find((x) => x.id === id);
  if (!c) {
    banner.style.display = 'none';
    return;
  }
  const isGrain = c.type === 'G2G' || c.type === 'GS';
  const base = t('scanFb.cultureAutofilled', { id: c.id });
  const suffix = isGrain ? ' \u2014 ' + t('batch.willMarkUsed') : '';
  banner.textContent = base + suffix;
  banner.style.display = '';
}

// ─── CULTURES ────────────────────────────────────────────────
// The class comes from a lookup, so it is safe by construction — the label does
// not. It renders a value straight from the cultures table, and it goes into
// the page via innerHTML, so an unescaped label is stored XSS that
// fires on render with no click involved. Escaping here rather than at the
// call sites covers all of them at once, and covers rows already in the
// database, which validating new writes cannot.
const ctBadge = (t) => {
  const m = { MC: 'badge-mc', PD: 'badge-pd', LC: 'badge-lc', G2G: 'badge-g2g', SY: 'badge-sy', DU: 'badge-du' };
  return `<span class="badge ${m[t] || ''}">${esc(t)}</span>`;
};
function fillCultureSelect(id, types) {
  const s = document.getElementById(id);
  if (!s) return;
  const opts =
    '<option value="">— none —</option>' +
    cultures
      .filter((c) => (c.status === 'active' || c.status === 'stored') && (!types || types.includes(c.type)))
      .map((c) => {
        const kz = c.strainKuerzel || c.strain || '';
        const name = c.strainName || c.species || '';
        const st = (c.strainText || '').trim();
        const label =
          (kz ? '[' + esc(kz) + '] ' : '') +
          esc(c.id) +
          ' — ' +
          esc(name) +
          (st ? ' ' + esc(st) : '') +
          ' (' +
          esc(c.type) +
          ')';
        return `<option value="${esc(c.id)}">${label}</option>`;
      })
      .join('');
  // Skip rewrite when options are unchanged — see fillStrainSelects for why.
  if (s.innerHTML === opts) return;
  const cur = s.value;
  s.innerHTML = opts;
  if (cur) s.value = cur;
}
function setCultureStatus(id, status) {
  const c = cultures.find((x) => x.id === id);
  if (!c) return;
  const prev = c.status;
  c.status = status;
  renderCultures();
  apiPatch('/api/cultures/' + encodeURIComponent(id), { status }).then((r) => {
    if (r && r.error) {
      c.status = prev;
      renderCultures();
      setFb('err', t('common.error') + ': ' + r.error);
    }
  });
}
// ─── LAB WORK ────────────────────────────────────────────────
// Woraus eine Laborarbeit angesetzt werden darf, je Art. Dieselben Regeln wie
// VALID_CULTURE_PARENT_TYPES in db.js — standen hier andere, bot das Formular
// eine Herkunft an, die der Server dann abwies. Ein Slant (MC) kommt meist von
// einer guten Petrischale; gekauft oder vom Abdruck hat er keine, und deshalb
// bleibt die Herkunft freiwillig. Körnerbrut (KB) ist keine Kultur und geht
// über createGrainBatch.
const LAB_PARENT_TYPES = {
  MC: ['MC', 'PD', 'LC', 'SY'],
  PD: ['MC', 'PD', 'LC', 'SY'],
  LC: ['MC', 'PD', 'LC', 'SY'],
  SY: ['MC', 'PD', 'LC'],
  KB: ['PD', 'LC', 'SY'],
  // Impfdübel: aus einer Kultur wie die Spritze, oder aus einem Körnerbeutel
  // (kornAlsHerkunft). Der Beutel ist dann verbraucht, wie bei der Körnerbrut.
  DU: ['MC', 'PD', 'LC', 'SY']
};
// Die Arten, die auch aus einem Körnerbeutel angesetzt werden. `types` ist die
// Liste aus LAB_PARENT_TYPES, wie msqParentTypes() sie gibt; bei "Mehrere" ist
// es eine neue Liste, und dann zählt kein Körnerbeutel.
function kornAlsHerkunft(types) {
  return types === LAB_PARENT_TYPES.KB || types === LAB_PARENT_TYPES.DU;
}
// Spritzen gibt es in drei Größen, wie SYRINGE_SIZES in db.js. Eine Spritze
// ohne Angabe ist eine 10er: so war jede, bevor es die Wahl gab.
const SY_ML = [10, 20, 50];
const syMl = (c) => (c && c.type === 'SY' ? c.ml || 10 : null);
// Drei Knöpfe, der gewählte gefüllt — dieselbe Form wie die Gewichte der
// Körnerbrut (gs-wbtn). `attr` ist das data-Attribut, an dem der Klick hängt.
function syMlKnoepfe(attr, aktiv) {
  return (
    '<div role="group" style="display:flex;gap:6px;flex-wrap:wrap">' +
    SY_ML.map(
      (ml) =>
        `<button type="button" class="btn${ml === aktiv ? ' btn-p' : ''}" data-${attr}="${ml}" aria-pressed="${ml === aktiv}" style="min-height:var(--tap);min-width:64px;font-weight:600">${ml} ml</button>`
    ).join('') +
    '</div>'
  );
}
// Eine Zeile mit Zähler: − Zahl + und dahinter, was gezählt wird (ohne
// Beschriftung, wenn eine Überschrift darüber steht). Die Knöpfe hängen an
// data-zaehler (wireZaehler), das Feld an seiner id.
const ZAEHLER_KNOPF =
  'width:var(--tap);height:var(--tap);min-width:44px;min-height:44px;flex:none;border-radius:10px;border:1px solid var(--c-border);background:var(--c-surface);font-size:1.25rem;font-weight:600;cursor:pointer';
function zaehlerZeileHtml(id, n, label) {
  return (
    `<div style="display:flex;align-items:center;gap:8px;margin-bottom:6px">` +
    `<button type="button" data-zaehler="-1" data-zaehler-feld="${id}" aria-label="${esc(t('bmp.less'))}" style="${ZAEHLER_KNOPF}">−</button>` +
    `<input type="number" inputmode="numeric" min="0" max="500" id="${id}" value="${n || 0}" style="width:64px;text-align:center;font-weight:600" />` +
    `<button type="button" data-zaehler="1" data-zaehler-feld="${id}" aria-label="${esc(t('bmp.more'))}" style="${ZAEHLER_KNOPF}">+</button>` +
    (label ? `<span class="fs-base" style="font-weight:600">${esc(label)}</span>` : '') +
    '</div>'
  );
}
// Abgefüllt wird in einem Durchgang oft mehr als eine Größe: 3 × 10, 5 × 20 und
// 3 × 50 ml. Also je Größe eine Zeile mit Zähler, und ein Tipp legt alle an und
// bringt alle Etiketten in ein Fenster. `pre` ist das Präfix der Felder
// (pre-sy-10 …).
function syMengenHtml(pre, n) {
  return SY_ML.map((ml) => zaehlerZeileHtml(pre + '-sy-' + ml, n && n[ml], ml + ' ml')).join('');
}
// {10: n, 20: n, 50: n} aus den Feldern, 0 bis 500 wie die anderen Zähler.
function syMengenLesen(pre) {
  const n = {};
  for (const ml of SY_ML) {
    const el = document.getElementById(pre + '-sy-' + ml);
    n[ml] = el ? Math.max(0, Math.min(500, parseInt(el.value, 10) || 0)) : 0;
  }
  return n;
}
const sySumme = (n) => SY_ML.reduce((a, ml) => a + ((n && n[ml]) || 0), 0);
// "3 Spritzen à 10 ml", "5 Spritzen à 20 ml" — nur die Größen, die vorkommen.
const syTeile = (n) => SY_ML.filter((ml) => n[ml] > 0).map((ml) => t('bmp.previewSy', { n: n[ml], ml }));
// Ein Tipp auf − oder + ändert das Feld und zieht die Vorschau des Fensters
// nach, in dem es steht (getippt macht das der input-Listener des Fensters).
(function wireZaehler() {
  document.addEventListener('click', (e) => {
    const b = e.target.closest('[data-zaehler]');
    if (!b) return;
    const el = document.getElementById(b.dataset.zaehlerFeld);
    if (!el) return;
    el.value = Math.max(0, Math.min(500, (parseInt(el.value, 10) || 0) + parseInt(b.dataset.zaehler, 10)));
    if (b.closest('#m-beimpfen')) bmpPreview();
    else msQuickPreview();
  });
})();
function lwUpdate() {
  const type = document.getElementById('lw-type').value;
  const pr = document.getElementById('lw-parent-row'),
    sr = document.getElementById('lw-source-row'),
    ql = document.getElementById('lw-qty-lbl');
  const kbRows = document.getElementById('lw-kb-rows'),
    qtyRow = document.getElementById('lw-qty-row');
  const strainTextRow = document.getElementById('lw-strain-text-row');
  const mlRow = document.getElementById('lw-ml-row');
  if (mlRow) mlRow.style.display = type === 'SY' ? 'block' : 'none';
  if (type === 'KB') {
    pr.style.display = 'none';
    sr.style.display = 'none';
    if (qtyRow) qtyRow.style.display = 'none';
    if (kbRows) kbRows.style.display = 'flex';
    if (strainTextRow) strainTextRow.style.display = 'block';
    document.getElementById('lw-prev-box').style.display = 'none';
    fillCultureSelect('gs-culture', ['PD', 'LC', 'SY', 'GS']);
    // Prefill grain hydration % from current inventory default
    const gsRh = document.getElementById('gs-rh');
    if (gsRh) gsRh.value = getAvgComp().grainRhPct;
    gsPreview();
  } else {
    if (kbRows) kbRows.style.display = 'none';
    if (strainTextRow) strainTextRow.style.display = type === 'G2G' ? 'none' : 'block';
    if (qtyRow) qtyRow.style.display = 'block';
    if (type === 'MC') {
      // Von einer Petrischale abgeimpft, oder gekauft: beides kann dastehen.
      pr.style.display = 'block';
      document.getElementById('lw-parent-lbl').textContent = t('lab.parentMcPdLc');
      fillParentSelect(LAB_PARENT_TYPES.MC);
      sr.style.display = 'block';
      ql.textContent = t('lab.qtyTubes');
    } else if (type === 'PD') {
      pr.style.display = 'block';
      document.getElementById('lw-parent-lbl').textContent = t('lab.parentMcPdLc');
      fillParentSelect(LAB_PARENT_TYPES.PD);
      sr.style.display = 'none';
      ql.textContent = t('lab.qtyDishes');
    } else if (type === 'LC') {
      pr.style.display = 'block';
      document.getElementById('lw-parent-lbl').textContent = t('lab.sourceLcPdMc');
      fillParentSelect(LAB_PARENT_TYPES.LC);
      sr.style.display = 'none';
      ql.textContent = t('lab.qtyFlasks');
    } else if (type === 'SY') {
      // Drawn from anything liquid or from a plate, which is the same set the
      // lineage rules in db.js allow — grain cannot go into a syringe.
      pr.style.display = 'block';
      document.getElementById('lw-parent-lbl').textContent = t('lab.sourceLcPdMc');
      fillParentSelect(LAB_PARENT_TYPES.SY);
      sr.style.display = 'none';
      ql.textContent = t('lab.qtySyringes');
    } else if (type === 'DU') {
      // Hier nur aus einer Kultur. Aus einem Körnerbeutel geht es über die
      // Laborarbeit im Schnelldialog, die den Beutel scannt und verbucht.
      pr.style.display = 'block';
      document.getElementById('lw-parent-lbl').textContent = t('lab.sourceLcPdMc');
      fillParentSelect(LAB_PARENT_TYPES.DU);
      sr.style.display = 'none';
      ql.textContent = t('lab.qtyBags');
    } else {
      pr.style.display = 'none';
      sr.style.display = 'none';
      ql.textContent = t('lab.qtyBags');
    }
    lwPreview();
  }
}
function fillParentSelect(types) {
  const s = document.getElementById('lw-parent');
  const cur = s.value;
  s.innerHTML =
    '<option value="">' +
    t('lab.noneNewIsolation') +
    '</option>' +
    cultures
      .filter((c) => (c.status === 'active' || c.status === 'stored') && types.includes(c.type))
      .map((c) => {
        const kz = c.strainKuerzel || c.strain || '';
        const name = c.strainName || c.species || '';
        const st = (c.strainText || '').trim();
        const label = (kz ? '[' + esc(kz) + '] ' : '') + esc(c.id) + ' — ' + esc(name) + (st ? ' ' + esc(st) : '');
        return `<option value="${esc(c.id)}">${label}</option>`;
      })
      .join('');
  if (cur) s.value = cur;
}
// Highest numeric suffix currently in use for a culture-id prefix. Generating
// the next id from this (not from the count) means deleting an earlier culture
// and creating a new one can't reuse an id — the server's
// INSERT … ON CONFLICT(id) DO UPDATE would otherwise silently overwrite the
// surviving culture's data.
function maxCultureSuffix(prefix) {
  return cultures.reduce((mx, c) => {
    if (!c.id || !c.id.startsWith(prefix)) return mx;
    const n = parseInt(c.id.slice(prefix.length), 10);
    return Number.isFinite(n) && n > mx ? n : mx;
  }, 0);
}
function lwPreview() {
  const type = document.getElementById('lw-type').value;
  const strainId = parseInt(document.getElementById('lw-st')?.value) || null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  const sp = ms ? ms.name : '';
  const qty = parseInt(document.getElementById('lw-qty').value) || 1;
  const box = document.getElementById('lw-prev-box'),
    prev = document.getElementById('lw-prev');
  if (!sp || type === 'G2G' || type === 'KB') {
    box.style.display = 'none';
    return;
  }
  const stRaw = (document.getElementById('lw-strain-text')?.value || '').replace(/[^A-Za-z0-9]/g, '').toUpperCase();
  const wann = anlageZeitpunkt(document.getElementById('lw-created')?.value);
  const prefix = type + '-' + abbrev(sp) + (stRaw ? '-' + stRaw : '') + '-' + todayStr(wann) + '-';
  const base = maxCultureSuffix(prefix);
  prev.textContent = Array.from({ length: qty }, (_, i) => prefix + String(base + i + 1).padStart(2, '0')).join('\n');
  box.style.display = 'block';
}
// lw-st change and lw-qty input listeners live in initEventListeners()
// opts.id: ein vorhandenes Etikett wird aufgenommen (msQuickOpenIntake) — genau
// eine Kultur mit genau dieser Kennung, und kein neues Etikett, das hängt schon.
function logLabWork(opts) {
  const intakeId = (opts && opts.id) || null;
  // Angesetzt am, wie in createBatch: einmal gelesen und geleert, bevor irgendeine
  // Prüfung abbricht. Die Kennung trägt diesen Tag, wie das Etikett am Glas.
  const angesetzt = anlageNehmen(document.getElementById('lw-created'));
  const wann = anlageZeitpunkt(angesetzt);
  if (intakeId && cultures.some((c) => c.id.toUpperCase() === intakeId)) {
    toast(t('intake.exists', { id: intakeId }), 'err');
    return;
  }
  const type = document.getElementById('lw-type').value;
  const strainSel = document.getElementById('lw-st');
  const strainId = strainSel ? parseInt(strainSel.value) || null : null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  if (!ms) {
    fieldError('lw-st', t('lab.selectPilzsorte'));
    return;
  }
  const parentId = document.getElementById('lw-parent')?.value || null;
  const strainText = (document.getElementById('lw-strain-text')?.value || '').trim();
  const source = document.getElementById('lw-source')?.value.trim() || null;
  const notes = document.getElementById('lw-notes').value.trim();
  // Spritzen kommen aus dem Schnelldialog in mehreren Größen auf einmal
  // (opts.sy = {10: 3, 20: 5, 50: 3}): jede Größe ihre eigenen Nummern, alle
  // Etiketten in einem Fenster. Sonst ein Posten: Anzahl und Größe des Formulars.
  const posten =
    opts && opts.sy
      ? SY_ML.filter((x) => opts.sy[x] > 0).map((x) => [opts.sy[x], x])
      : [
          [
            parseInt(document.getElementById('lw-qty').value) || 1,
            parseInt(document.getElementById('lw-ml')?.value, 10) || 10
          ]
        ];
  const angelegt = posten.map(([qty, ml]) =>
    kulturenAnlegen({
      type,
      ms,
      wann,
      qty,
      id: intakeId,
      parentId,
      strainText,
      source,
      notes,
      ml,
      stueck: opts && opts.stueck
    })
  );
  const newC = angelegt.flatMap((r) => r.newC);
  const saved = Promise.all(angelegt.map((r) => r.saved));
  saved.catch(() => {}); // gemeldet in kulturenAnlegen
  // opts.korn: die Körnerbeutel, aus denen Impfdübel angesetzt wurden. Wie bei
  // einer Charge (inocVerbrauchtBuchen) ein REMOVE mit "spawn:<Kennung>", erst
  // wenn die Dübel gespeichert sind — sonst wäre der Beutel weg und die Dübel nicht da.
  if (opts && opts.korn && opts.korn.length && newC.length)
    saved.then(
      () => spawnBuchen(opts.korn, 'spawn:' + newC[0].id),
      () => {}
    );
  document.getElementById('lw-notes').value = '';
  document.getElementById('lw-qty').value = '1';
  if (document.getElementById('lw-source')) document.getElementById('lw-source').value = '';
  lwPreview();
  if (intakeId) {
    saved.then(
      () => toast(t('intake.done', { id: intakeId })),
      () => {}
    );
    return;
  }
  // Der Schluss jedes Weges, der Kulturen anlegt: das Etiketten-Fenster, wie
  // nbPlaceAndPrint() für Beutel. Vorher stand hier eine Ergebniskarte mit
  // Druckknopf im langen Formular — und der Schnelldialog, der dieses Formular
  // nur noch als Ablage benutzt, ließ den Arbeiter ohne ein Etikett stehen.
  cprShow(
    newC.map((c) => c.id),
    saved
  );
}
// Legt qty Kulturen einer Art an, mit Kennung, Speichern und Barcodes — ohne ein
// Formular zu lesen. logLabWork() und das Beimpfen-Fenster (bmpGo) teilen sich
// das; jeder Weg zeigt danach sein eigenes Etiketten-Fenster.
// spec: { type, ms, wann, qty, id?, parentId?, strainText?, source?, notes?, ml?, stueck? }
// ml zählt nur bei Spritzen; ohne Angabe eine 10er. stueck nur bei Impfdübeln.
function kulturenAnlegen(spec) {
  const { type, ms, wann } = spec;
  const sp = ms.name,
    st = ms.kuerzel;
  const strainText = spec.strainText || '';
  const stId = strainText.replace(/[^A-Za-z0-9]/g, '').toUpperCase();
  const prefix = type + '-' + abbrev(sp) + (stId ? '-' + stId : '') + '-' + todayStr(wann) + '-';
  const base = maxCultureSuffix(prefix);
  const newC = Array.from({ length: spec.id ? 1 : spec.qty }, (_, i) => ({
    id: spec.id || prefix + String(base + i + 1).padStart(2, '0'),
    type,
    species: sp,
    strain: st || '',
    strainId: ms.id,
    strainName: sp,
    strainKuerzel: st || null,
    strainText,
    parentId: spec.parentId || null,
    source: spec.source || null,
    status: 'active',
    notes: spec.notes || '',
    created: wann.toISOString(),
    ml: type === 'SY' ? (SY_ML.includes(spec.ml) ? spec.ml : 10) : null,
    stueck: type === 'DU' && spec.stueck > 0 ? spec.stueck : null
  }));
  cultures.push(...newC);
  const saved = apiPost('/api/cultures', { cultures: newC }).then((r) => {
    // Abgewiesen: vorher blieb die Kultur hier stehen, bis die App neu lud, und
    // das Etikett druckte trotzdem — ein Glas mit einem Etikett, das danach
    // "nicht im System" hieß. Jetzt geht sie gleich wieder raus, und es steht da.
    if (r && r.error) {
      const ids = new Set(newC.map((c) => c.id));
      cultures = cultures.filter((c) => !ids.has(c.id));
      renderLabLog();
      cprClose();
      toast(t('lab.saveFailed', { msg: r.error }), 'err');
      throw new Error(r.error);
    }
    if (r && r.cultureBarcodes) {
      for (const [id, bc] of Object.entries(r.cultureBarcodes)) {
        barcodeRegistry.set(bc, { type: 'culture', id });
        barcodeByEntity.set('culture:' + id, bc);
      }
    }
  });
  saved.catch(() => {}); // gemeldet im then oben; gedruckt wird nur nach Erfolg
  renderLabLog();
  fillCultureSelect('nb-culture', ['PD', 'LC', 'G2G', 'GS']);
  fillCultureSelect('gs-culture', ['PD', 'LC', 'SY', 'GS']);
  return { newC, saved };
}
function renderLabLog() {
  const body = document.getElementById('lab-log-body');
  const rows = [...cultures].sort((a, b) => b.created.localeCompare(a.created)).slice(0, 50);
  body.innerHTML = rows.length
    ? rows
        .map((c) => {
          const name = c.strainName || c.species || '';
          const kz = c.strainKuerzel || c.strain || '';
          return `<tr><td class="fs-micro" style="color:var(--c-text-muted)">${fmtDt(c.created)}</td><td>${ctBadge(c.type)}</td><td class="fs-xs" style="font-family:monospace">${esc(c.id)}</td><td class="fs-micro" style="font-family:monospace;color:var(--c-text-muted)">${esc(c.parentId) || '\u2014'}</td><td>${spDot(name)}${esc(name)}${kz ? ' / ' + esc(kz) : ''}</td></tr>`;
        })
        .join('')
    : '<tr><td colspan="5" class="empty">' + t('lab.noLabWork') + '</td></tr>';
}

// ─── GRAIN SPAWN (Lab tab) ──────────────────────────────────
// `d` ist der Tag, an dem angesetzt wurde (Inventur), sonst heute. Nummeriert
// nach der höchsten vergebenen Nummer, aus demselben Grund wie genBatchId.
const genGrainBatchId = (sp, strainText, d) => {
  const ab = abbrev(sp),
    dt = todayStr(d),
    st = (strainText || '').replace(/[^A-Za-z0-9]/g, '').toUpperCase();
  const prefix = 'G-' + ab + (st ? '-' + st : '') + '-' + dt + '-';
  const n = batches.reduce((mx, b) => {
    const k = b.batchId.startsWith(prefix) ? parseInt(b.batchId.slice(prefix.length), 10) : 0;
    return Number.isFinite(k) && k > mx ? k : mx;
  }, 0);
  return prefix + String(n + 1).padStart(2, '0');
};
/** Read all weight-line rows from the grain spawn form */
function gsReadLines() {
  const lines = [];
  for (const row of document.querySelectorAll('.gs-wline')) {
    const kg = parseDecimal(row.querySelector('.gs-line-kg').value) || 0;
    const qty = parseInt(row.querySelector('.gs-line-qty').value) || 0;
    if (kg > 0 && qty > 0) lines.push({ kg, qty });
  }
  return lines;
}
/** Set weight for a specific weight-line row and highlight its preset button */
function gsLineSetWeight(row, kg) {
  row.querySelector('.gs-line-kg').value = kg;
  row.querySelectorAll('.gs-wbtn').forEach((btn) => {
    btn.className = 'btn btn-sm gs-wbtn' + (parseFloat(btn.dataset.kg) === kg ? ' btn-p' : '');
  });
  gsPreview();
}
/** Add a new weight line to the grain spawn form */
function gsAddLine() {
  const container = document.getElementById('gs-weight-lines');
  const first = container.querySelector('.gs-wline');
  const clone = first.cloneNode(true);
  clone.querySelector('.gs-line-kg').value = '1';
  clone.querySelector('.gs-line-qty').value = '10';
  clone.querySelectorAll('.gs-wbtn').forEach((btn) => {
    btn.className = 'btn btn-sm gs-wbtn' + (parseFloat(btn.dataset.kg) === 1 ? ' btn-p' : '');
  });
  container.appendChild(clone);
  gsUpdateRemoveButtons();
  gsPreview();
}
/** Remove a weight line */
function gsRemoveLine(row) {
  row.remove();
  gsUpdateRemoveButtons();
  gsPreview();
}
/** Show/hide remove buttons based on line count */
function gsUpdateRemoveButtons() {
  const rows = document.querySelectorAll('.gs-wline');
  const multi = rows.length > 1;
  rows.forEach((r) => {
    r.querySelector('.gs-line-rm').style.display = multi ? '' : 'none';
  });
}
// Die Gewichtszeilen des langen Formulars von aussen setzen.
//
// Der Schnelldialog fuellte sie vorher selbst: gsResetLines(), dann
// querySelector('.gs-wline') und zwei Werte hineinschreiben -- an zwei Stellen,
// und beide konnten nur EINE Zeile fuellen. Genau das war die Grenze: ein
// Ansatz, eine Groesse. Hier steht der Weg fuer beliebig viele, einmal.
function gsSetLines(lines) {
  gsResetLines();
  const container = document.getElementById('gs-weight-lines');
  if (!container || !lines || !lines.length) return;
  for (let i = 1; i < lines.length; i++) gsAddLine();
  const rows = container.querySelectorAll('.gs-wline');
  lines.forEach((l, i) => {
    const row = rows[i];
    if (!row) return;
    row.querySelector('.gs-line-kg').value = l.kg;
    row.querySelector('.gs-line-qty').value = l.qty;
    row.querySelectorAll('.gs-wbtn').forEach((btn) => {
      btn.className = 'btn btn-sm gs-wbtn' + (parseFloat(btn.dataset.kg) === l.kg ? ' btn-p' : '');
    });
  });
  gsUpdateRemoveButtons();
}
/** Reset grain spawn form to single default line */
function gsResetLines() {
  const container = document.getElementById('gs-weight-lines');
  const rows = container.querySelectorAll('.gs-wline');
  for (let i = rows.length - 1; i > 0; i--) rows[i].remove();
  const first = container.querySelector('.gs-wline');
  first.querySelector('.gs-line-kg').value = '1';
  first.querySelector('.gs-line-qty').value = '10';
  first.querySelectorAll('.gs-wbtn').forEach((btn) => {
    btn.className = 'btn btn-sm gs-wbtn' + (parseFloat(btn.dataset.kg) === 1 ? ' btn-p' : '');
  });
  gsUpdateRemoveButtons();
}
function gsPreview() {
  const strainSel = document.getElementById('lw-st');
  const strainId = strainSel ? parseInt(strainSel.value) || null : null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  const sp = ms ? ms.name : '';
  const lines = gsReadLines();
  const totalQty = lines.reduce((s, l) => s + l.qty, 0);
  const totalWet = lines.reduce((s, l) => s + l.kg * l.qty, 0);
  const grainRhInput = document.getElementById('gs-rh');
  const defaultGrainRh = getAvgComp().grainRhPct;
  const grainRh = grainRhInput ? parseDecimal(grainRhInput.value) || 0 : defaultGrainRh;
  const hydrationFactor = mtGrainFactor(grainRh);
  const totalDry = totalWet * hydrationFactor;
  const lwStrainText = (document.getElementById('lw-strain-text')?.value || '').trim();
  const wann = anlageZeitpunkt(document.getElementById('lw-created')?.value);
  document.getElementById('gs-prev').textContent = sp
    ? genGrainBatchId(sp, lwStrainText, wann) + ' (' + totalQty + ' bags)'
    : '\u2014';
  const el = document.getElementById('gs-mat-preview');
  if (!totalQty || !totalWet) {
    el.style.display = 'none';
    return;
  }
  const breakdown = lines.map((l) => l.qty + ' \u00d7 ' + l.kg + ' kg').join(' + ');
  const avail = inventory.stock?.grain || 0;
  const enough = avail >= totalDry;
  const hydrationNote =
    grainRh > 0
      ? ` <span class="fs-xs" style="color:var(--c-text-muted)">(${totalWet.toFixed(2)} kg wet − ${grainRh}% water)</span>`
      : '';
  el.innerHTML = `<strong>${t('batch.grainNeeded')}</strong> ${totalDry.toFixed(2)} kg dry${hydrationNote} (${breakdown})<br>${t('batch.inStock')} ${avail.toFixed(2)} kg \u2192 ${enough ? '\u2713 ' + t('batch.sufficient') : '\u26A0 ' + t('batch.notEnough')}`;
  el.style.display = 'block';
}
// opts.ohneFenster: das Fenster zum Einlagern und für die Etiketten kommt nicht
// von hier, sondern vom Aufrufer (bmpGo, nach den Kultur-Etiketten). Zurück kommt
// dann { batchObj, bagIds }, oder null, wenn nichts angelegt wurde.
function createGrainBatch(opts) {
  // Angesetzt am, wie in logLabWork: einmal gelesen und geleert, als Erstes. Ein
  // früherer Tag ist Bestand aus der Inventur und bucht kein Korn ab, wie
  // createBatch keine Pellets.
  const angesetzt = anlageNehmen(document.getElementById('lw-created'));
  const wann = anlageZeitpunkt(angesetzt);
  const bucht = !angesetzt;
  const strainSel = document.getElementById('lw-st');
  const strainId = strainSel ? parseInt(strainSel.value) || null : null;
  const ms = strainId ? mushroomStrains.find((x) => x.id === strainId) : null;
  if (!strainId || !ms) {
    if (!mushroomStrains.length) {
      confirm2(t('strains.noStrainsHint'), '', t('strains.createNow'), goCreateStrain);
    } else {
      toast(t('strains.noStrainsHint'), 'err');
    }
    return;
  }
  const sp = ms.name,
    st = ms.kuerzel;
  const lines = gsReadLines();
  if (!lines.length) {
    toast(t('batch.fillQty'), 'err');
    return;
  }
  const days = parseInt(document.getElementById('gs-days').value) || 14;
  const grainRhInput = document.getElementById('gs-rh');
  const defaultGrainRh = getAvgComp().grainRhPct;
  const grainRh = grainRhInput ? parseDecimal(grainRhInput.value) || 0 : defaultGrainRh;
  const totalQty = lines.reduce((s, l) => s + l.qty, 0);
  const lwStrainText = (document.getElementById('lw-strain-text') || {}).value?.trim() || '';
  const batchId = genGrainBatchId(sp, lwStrainText, wann);
  spColor(sp);
  const due = new Date(wann);
  due.setDate(due.getDate() + days);
  // Generate bags with per-bag weight
  const bags = [];
  const bagWeights = {};
  let idx = 1;
  for (const line of lines) {
    for (let i = 0; i < line.qty; i++) {
      const bagId = batchId + '-' + String(idx).padStart(2, '0');
      bags.push({ id: bagId, bagKg: line.kg });
      bagWeights[bagId] = line.kg;
      idx++;
    }
  }
  const bagIds = bags.map((b) => b.id);
  // Das Gewicht der CHARGE, wo jeder Beutel schon sein eigenes trägt.
  //
  // Bei gemischten Größen stand hier null — und insertBatch schreibt
  // `b.bagKg || 3` in die Spalte, also trug eine Charge aus 1- und 2-kg-Beuteln
  // hinterher eine 3, die nie jemand angesetzt hat. Die Zahl ist nicht
  // folgenlos: addBagsToBatch nimmt sie als Gewicht für nachträglich ergänzte
  // Beutel, und bagWeights fällt auf sie zurück. Also die Größe, aus der die
  // meisten Beutel sind — die Antwort, die am seltensten falsch ist.
  const batchBagKg = lines.reduce((best, l) => (l.qty > best.qty ? l : best), lines[0]).kg;
  batches.push({
    batchId,
    species: sp,
    strain: st,
    strainId,
    strainName: ms.name,
    strainKuerzel: ms.kuerzel,
    qty: totalQty,
    days,
    substrate: null,
    bagKg: batchBagKg,
    batchType: 'grain',
    grainRh,
    sourceId: inocCultureId() || document.getElementById('gs-culture').value || null,
    notes: document.getElementById('lw-notes').value.trim(),
    strainText: lwStrainText,
    created: wann.toISOString(),
    due: due.toISOString(),
    bags: bagIds,
    bagWeights
  });
  const batchObj = batches[batches.length - 1];
  // Deduct grain from inventory — apply hydration so only dry grain is subtracted
  // (wet bag weight includes water added during soaking, typically ~52% for wheat).
  // Computed up front so the delta travels with the POST and the server applies
  // it atomically, exactly like createBatch (I-02). The previous shape fired
  // invDeltas separately and unconditionally after the POST, so a rejected batch
  // (duplicate id, server error) still drained grain for a batch that never
  // existed — and nothing rolled the local stock back either.
  if (!inventory.stock) inventory.stock = { hardwood: 0, wheatbran: 0, gypsum: 0, grain: 0, coir: 0 };
  const stockSnapshot = { ...inventory.stock };
  const hydrationFactor = mtGrainFactor(grainRh);
  const grainUsed = lines.reduce((s, l) => s + l.kg * l.qty * hydrationFactor, 0);
  const deltas = [];
  if (grainUsed > 0 && bucht) {
    inventory.stock.grain = Math.max(0, (inventory.stock.grain || 0) - grainUsed);
    deltas.push({ mat: 'grain', deltaKg: -grainUsed, type: 'batch', ref: batchId });
  }
  // Send bags as [{id, bagKg}] to the server
  const apiPayload = Object.assign({}, batchObj, { bags, deltas });
  // Disable while in flight: genGrainBatchId numbers off the local batches array,
  // which already holds this batch, so a double-tap creates a second distinct
  // batch and deducts the grain twice.
  const createBtn = document.getElementById('btn-26');
  if (createBtn) createBtn.disabled = true;
  // Snapshot the inoculant list: the form is cleared below, before the POST
  // resolves, and nothing is written off until the batch is known to have saved.
  const _inocUsed = _inoc.slice();
  // Festgehalten für das gemeinsame Etiketten-Fenster: die Beutelnummern kommen
  // mit dieser Antwort, und gedruckt wird erst danach (printCultureLabelsInline).
  const saved = apiPost('/api/batches', apiPayload)
    .then((r) => {
      if (r && r.error) {
        const i = batches.findIndex((b) => b.batchId === batchObj.batchId);
        if (i >= 0) batches.splice(i, 1);
        // Roll back the optimistic stock mutation — server didn't apply the deltas.
        inventory.stock = stockSnapshot;
        toast(t('batch.saveFailed') + r.error, 'err');
        renderBatches();
        renderStatus();
        return;
      }
      if (r && r.bagBarcodes) {
        for (const [id, bc] of Object.entries(r.bagBarcodes)) {
          barcodeRegistry.set(bc, { type: 'bag', id });
          barcodeByEntity.set('bag:' + id, bc);
        }
      }
      // Grain spawn is usually made from a liquid culture that survives many
      // uses, so ask rather than assume. Ein Körnerbeutel (Körner aus Körnern)
      // geht dagegen ganz hinein und wird ohne Frage ausgebucht.
      inocAskConsume(batchObj, _inocUsed);
    })
    .finally(() => {
      if (createBtn) createBtn.disabled = false;
    });
  _inoc = [];
  inocRender('nb');
  inocRender('ms-q');
  if (strainSel) strainSel.value = '';
  const lwStrainEl = document.getElementById('lw-strain-text');
  if (lwStrainEl) lwStrainEl.value = '';
  gsResetLines();
  document.getElementById('gs-days').value = '14';
  document.getElementById('lw-notes').value = '';
  document.getElementById('gs-mat-preview').style.display = 'none';
  gsPreview();
  updateTodoBadge();
  renderBatches();
  if (opts && opts.ohneFenster) return { batchObj, bagIds, saved };
  // Einlagern, dann Etiketten — derselbe Schluss wie bei jeder anderen Charge.
  // Die Körnerbrut hatte ihren eigenen: eine Ergebniskarte im langen Formular
  // und ein Sprung auf die Druckseite. Vom Schnelldialog aus hieß das, auf einer
  // Seite zu landen, die man nie aufgemacht hatte, während die Charge aus dem
  // Assistenten ihr Fenster bekam, wo man stand. Ein Weg, ein Fenster.
  nbPlaceAndPrint(batchObj, bagIds);
  return { batchObj, bagIds, saved };
}

// ─── LINEAGE ─────────────────────────────────────────────────
// Lineage intentionally uses the legacy c.species / c.strain fields so that
// historical rows without a strain_id still render with their original
// species/kuerzel values. Do not swap to strainName here — old lineage nodes
// would lose their labels.
function fillLineageSelect() {
  const s = document.getElementById('lineage-sel');
  const cur = s.value;
  s.innerHTML =
    '<option value="">' +
    t('lab.selectCultureBatch') +
    '</option>' +
    (cultures.length
      ? `<optgroup label="Cultures">${cultures.map((c) => `<option value="C:${esc(c.id)}">${esc(c.id)} (${esc(c.type)} — ${esc(c.species)})</option>`).join('')}</optgroup>`
      : '') +
    (batches.length
      ? `<optgroup label="Batches">${batches.map((b) => `<option value="B:${esc(b.batchId)}">${esc(b.batchId)} (${esc(b.species)})</option>`).join('')}</optgroup>`
      : '');
  if (cur) s.value = cur;
}
function buildTree(rootId, rootType) {
  const seen = new Set();
  const getAnc = (id) => {
    if (seen.has(id)) return [];
    seen.add(id);
    const c = cultures.find((x) => x.id === id);
    if (!c) return [];
    const node = { id: c.id, type: c.type, species: c.species, strain: c.strain, status: c.status, created: c.created };
    if (c.parentId) {
      const p = cultures.find((x) => x.id === c.parentId);
      if (p) return [...getAnc(c.parentId), node];
    }
    return [node];
  };
  const getDesc = (id, depth) => {
    if (depth > 6) return [];
    const ch = [];
    cultures
      .filter((c) => c.parentId === id)
      .forEach((c) => ch.push({ ...c, harvest: 0, children: getDesc(c.id, depth + 1) }));
    batches
      .filter((b) => b.sourceId === id)
      .forEach((b) => {
        const { status } = getStatus(b.batchId);
        ch.push({
          id: b.batchId,
          type: 'BATCH',
          species: b.species,
          strain: b.strain,
          status,
          harvest: getHarvested(b.batchId),
          created: b.created,
          children: []
        });
      });
    return ch;
  };
  if (rootType === 'C') {
    const anc = getAnc(rootId);
    const c = cultures.find((x) => x.id === rootId);
    if (!c) return null;
    const root = {
      ...(anc[anc.length - 1] || {
        id: c.id,
        type: c.type,
        species: c.species,
        strain: c.strain,
        status: c.status,
        created: c.created
      })
    };
    root.children = getDesc(rootId, 0);
    if (anc.length > 1) {
      let tree = anc[0],
        cur = tree;
      for (let i = 1; i < anc.length; i++) {
        anc[i].children = i === anc.length - 1 ? root.children : [];
        cur.children = [anc[i]];
        cur = anc[i];
      }
      return tree;
    }
    return root;
  } else {
    const b = batches.find((x) => x.batchId === rootId);
    if (!b) return null;
    const { status } = getStatus(b.batchId);
    const bn = {
      id: b.batchId,
      type: 'BATCH',
      species: b.species,
      strain: b.strain,
      status,
      harvest: getHarvested(b.batchId),
      created: b.created,
      children: []
    };
    if (b.sourceId) {
      const anc = getAnc(b.sourceId);
      if (anc.length) {
        let tree = anc[0],
          cur = tree;
        for (let i = 1; i < anc.length; i++) {
          anc[i].children = [];
          cur.children = [anc[i]];
          cur = anc[i];
        }
        cur.children = [bn];
        return tree;
      }
    }
    return bn;
  }
}
const NODE_BG = { MC: '#f3e8ff', PD: '#dbeafe', LC: '#dcfce7', SY: '#e0f2fe', BATCH: '#fff7ed' };
const NODE_BD = { MC: '#c084fc', PD: '#93c5fd', LC: '#86efac', SY: '#7dd3fc', BATCH: '#fdba74' };
function treeHtml(node, depth) {
  const ch = node.children?.length
    ? `<div style="margin-left:${depth ? 20 : 0}px;padding-left:16px;border-left:2px solid var(--c-border);margin-top:5px">${node.children.map((c) => treeHtml(c, depth + 1)).join('')}</div>`
    : '';
  const harv = node.harvest > 0 ? `<span class="badge b-harvest" style="margin-left:4px">${node.harvest}g</span>` : '';
  return `<div style="margin-bottom:5px"><div style="display:inline-flex;align-items:center;gap:6px;flex-wrap:wrap;background:${NODE_BG[node.type] || '#f5f4f0'};border:1px solid ${NODE_BD[node.type] || '#e5e3dd'};border-radius:7px;padding:5px 10px"><span class="fs-micro" style="font-weight:600;color:var(--c-text-sec)">${esc(node.type)}</span><span class="fs-meta" style="font-family:monospace;font-weight:600">${esc(node.id)}</span><span class="fs-xs" style="color:var(--c-text-sec)">${esc(node.species) || ''}${node.strain ? ' / ' + esc(node.strain) : ''}</span><span class="fs-micro" style="color:var(--c-text-muted)">${esc(node.status) || ''}</span>${harv}<span class="fs-micro" style="color:var(--c-text-muted)">${node.created ? fmtDt(node.created) : ''}</span></div>${ch}</div>`;
}
function renderLineage() {
  const val = document.getElementById('lineage-sel').value,
    body = document.getElementById('lineage-body');
  if (!val) {
    body.innerHTML = '<div class="empty">' + t('lab.selectAbove') + '</div>';
    return;
  }
  const [type, id] = val.split(':');
  const tree = buildTree(id, type);
  body.innerHTML = tree
    ? `<div style="padding:4px 0">${treeHtml(tree, 0)}</div>`
    : '<div class="empty">' + t('lab.noLineageData') + '</div>';
}

// ─── BAG INFO MODAL ──────────────────────────────────────────
let biBagId = null,
  biBatchId = null;
function openBagInfo(bagId, batchId, batch) {
  biBagId = bagId;
  biBatchId = batchId;
  const b = batch || batches.find((x) => x.batchId.toUpperCase() === batchId.toUpperCase());
  const el = document.getElementById('bi-body');
  if (!b) {
    el.innerHTML = '<p style="color:var(--c-red-dark)">' + t('batch.notFound') + ': ' + esc(batchId) + '</p>';
    document.getElementById('bi-actions').innerHTML = '';
    renderBlockGoodButtons();
    renderBiNotes();
    document.getElementById('m-baginfo').classList.add('open');
    return;
  }
  document.getElementById('bi-title').textContent = bagId;
  // Current location
  const bagLogs = scanLog.filter((e) => (e.bag || '').toUpperCase() === bagId.toUpperCase());
  let currentLoc = t('bagInfo.notPlaced');
  if (bagLogs.length) {
    const last = bagLogs[bagLogs.length - 1];
    if (last.action === 'REMOVE') currentLoc = istVerbraucht(last) ? t('bagInfo.usedUp') : t('bagInfo.removed');
    else if (last.action === 'ADD' || last.action === 'MOVE') currentLoc = last.to || 'Unknown';
  }
  // Harvests for this bag
  const bagHarvests = harvests.filter((h) => (h.bag || '').toUpperCase() === bagId.toUpperCase());
  const totalHarv = bagHarvests.reduce((s, h) => s + (h.grams || 0), 0);
  // Pre-build last-scan-per-bag map so the bag-chip render below is O(1)/bag
  // instead of O(M)/bag for an M-length scan log.
  const lastByBag = buildLastScanByBag();
  el.innerHTML = `
    <div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:12px">
      <div class="met"><div class="met-l">${t('batch.species')}</div><div class="fs-base" style="font-weight:600">${spDot(b.species)}${esc(b.species)}</div></div>
      <div class="met"><div class="met-l">${t('batch.strain')}</div><div class="fs-base" style="font-weight:600">${(b.strainText || '').trim() ? esc(b.strainText.trim()) : !b.strainId && b.strain ? esc(b.strain) : '\u2014'}</div></div>
      <div class="met"><div class="met-l">${t('bagInfo.currentLocation')}</div><div class="fs-base" style="font-weight:600;color:var(--c-blue-dark)">${esc(currentLoc)}</div></div>
      <div class="met"><div class="met-l">${t('dash.totalHarvested')}</div><div class="fs-base" style="font-weight:600;color:var(--c-amber-dark)">${totalHarv > 0 ? totalHarv + 'g' : t('bagInfo.noneYet')}</div></div>
    </div>
    ${biHerkunftHtml(b)}
    <div class="fs-xs" style="font-weight:600;color:var(--c-text-muted);text-transform:uppercase;letter-spacing:.06em;margin-bottom:6px">${t('batch.batchId')} ${esc(b.batchId)} \u2014 ${t('bagInfo.allBags')}</div>
    <div style="display:flex;flex-wrap:wrap;gap:4px;max-height:120px;overflow-y:auto">
      ${b.bags
        .map((bag) => {
          const isThis = bag.toUpperCase() === bagId.toUpperCase();
          const bagNum = bag.split('-').pop();
          const bagLast = lastByBag.get(bag.toUpperCase());
          const loc = !bagLast ? '—' : bagLast.action === 'REMOVE' ? '✗' : bagLast.to || '?';
          return `<span class="fs-xs" style="font-family:monospace;padding:3px 8px;border-radius:5px;background:${isThis ? 'var(--c-text)' : 'var(--c-bg)'};color:${isThis ? '#fff' : 'var(--c-text-sec)'};border:1px solid ${isThis ? 'var(--c-text)' : 'var(--c-border)'}" title="${esc(loc)}">
          ${esc(bagNum)} <span class="fs-floor" style="--fs-own:9px;color:${isThis ? 'var(--c-text-muted)' : 'var(--c-border)'}">${esc(loc)}</span>
        </span>`;
        })
        .join('')}
    </div>
    ${bagHarvests.length ? `<div class="fs-meta" style="margin-top:10px;color:var(--c-amber-dark)"><strong>${t('harvest.log')}:</strong> ${bagHarvests.map((h) => `Flush ${h.flush}: ${h.grams}g`).join(' \u00b7 ')}</div>` : ''}
  `;
  closeCamScan();
  closeScanModal();
  biWholeBatch = false;
  renderBiActions();
  renderBlockGoodButtons();
  renderBiNotes();
  document.getElementById('m-baginfo').classList.add('open');
  setFb('info', t('scanFb.bagInfo', { bag: bagId }), { noModal: true });
}
// Die Kette einer Kultur nach oben, älteste zuerst: MC → PD → LC. Eine Herkunft,
// die nicht (mehr) in der Liste steht, wird trotzdem genannt.
function cultureChain(id) {
  const kette = [];
  const seen = new Set();
  let cur = id;
  while (cur && !seen.has(cur) && kette.length < 10) {
    seen.add(cur);
    const c = cultures.find((x) => x.id === cur);
    kette.unshift(c ? { id: c.id, type: c.type } : { id: cur, type: String(cur).split('-')[0] });
    cur = c ? c.parentId : null;
  }
  return kette;
}
function _biChainHtml(id) {
  return cultureChain(id)
    .map(
      (x) =>
        `<span style="display:inline-flex;align-items:center;gap:4px">${ctBadge(x.type)}<span class="fs-meta" style="font-family:monospace;font-weight:600">${esc(x.id)}</span></span>`
    )
    .join('<span class="fs-xs" style="color:var(--c-text-muted)"> → </span>');
}
// Die Körnerbrut einer Charge: die Beutel, die für sie abgebucht wurden, nach
// ihrer Körnerbrut-Charge gruppiert.
function grainSourcesFor(batchId) {
  const byBatch = new Map();
  for (const bag of spawnSourceFor(batchId)) {
    const g = batches.find((x) => (x.bags || []).some((y) => y.toUpperCase() === bag.toUpperCase()));
    const key = g ? g.batchId : '?';
    if (!byBatch.has(key)) byBatch.set(key, { batch: g || null, bags: [] });
    byBatch.get(key).bags.push(bag);
  }
  return [...byBatch.values()];
}
// Woraus der gescannte Beutel gemacht ist, sofort beim Scannen: Kultur,
// Körnerbrut, Substrat-Ansatz mit Soll- und Ist-Feuchte. Bisher stand davon
// nur die Quellkultur, und nur in der Chargenliste. Alles kommt aus dem, was
// das Gerät schon geladen hat — kein Warten beim Scannen.
function biHerkunftHtml(b) {
  const zeile = (label, inhalt) =>
    `<div style="margin-top:6px"><div class="met-l">${esc(label)}</div><div style="display:flex;flex-wrap:wrap;align-items:center;gap:4px;margin-top:2px">${inhalt}</div></div>`;
  const muted = (txt) => `<span class="fs-meta" style="color:var(--c-text-muted)">${esc(txt)}</span>`;
  const pct = (v) => fmtKg(v, v % 1 ? 1 : 0) + ' %';
  let html = '';
  if (b.sourceId) html += zeile(t('bagInfo.culture'), _biChainHtml(b.sourceId));
  for (const g of grainSourcesFor(b.batchId)) {
    const gb = g.batch;
    const teile = [
      `<span class="fs-meta" style="font-family:monospace;font-weight:600">${esc(gb ? gb.batchId : g.bags[0])}</span>`,
      muted(t('bagInfo.nBags', { n: g.bags.length }))
    ];
    if (gb && gb.grainRh) teile.push(muted('RH ' + pct(gb.grainRh)));
    html += zeile(t('bagInfo.grain'), teile.join(muted('·')));
    if (gb && gb.sourceId) html += zeile(t('bagInfo.grainCulture'), _biChainHtml(gb.sourceId));
  }
  const sb = b.substrateSubId ? (_sbList || []).find((x) => x.subId === b.substrateSubId) : null;
  if (sb) {
    const ist =
      sb.actualRhPct == null
        ? muted(t('bagInfo.rhActual') + ' ' + t('sub.rhNotMeasured'))
        : `<span class="fs-meta" style="font-weight:600">${esc(t('bagInfo.rhActual'))} ${esc(pct(sb.actualRhPct))}</span>`;
    html += zeile(
      t('bagInfo.substrate'),
      [
        `<span class="fs-meta" style="font-family:monospace;font-weight:600">${esc(sb.subId)}</span>`,
        muted(sb.recipeLabel),
        muted(t('bagInfo.rhTarget') + ' ' + pct(sb.composition.rhPct || sb.moisturePct)),
        ist
      ].join(muted('·'))
    );
  } else if (b.substrate && b.batchType !== 'grain' && b.substrate.rh) {
    html += zeile(
      t('bagInfo.substrate'),
      muted('HW ' + b.substrate.hardwood + ' % · WB ' + b.substrate.wheatbran + ' % · RH ' + b.substrate.rh + ' %')
    );
  }
  if (b.created) html += zeile(t('bagInfo.made'), muted(fmtDt(b.created)));
  return html
    ? `<div class="met" style="margin-bottom:12px"><div class="met-l" style="font-weight:700">${esc(t('bagInfo.herkunft'))}</div>${html}</div>`
    : '';
}
// Scope of a sheet move action: false = just the scanned bag, true = whole batch.
let biWholeBatch = false;
// Where is the scanned bag right now, and is it still placed?
function _biBagCurrentLoc() {
  const logs = scanLog.filter((e) => (e.bag || '').toUpperCase() === (biBagId || '').toUpperCase());
  if (!logs.length) return { loc: null, removed: false };
  const last = logs[logs.length - 1];
  if (last.action === 'REMOVE') return { loc: null, removed: true };
  if (last.action === 'ADD' || last.action === 'MOVE') return { loc: last.to || null, removed: false };
  return { loc: null, removed: false };
}
// The heart of the idiot-proof flow: render big, context-aware action buttons
// for the scanned bag. The primary action follows where the bag is now — in
// incubation/spawn it's "→ Fruchtung", in a fruiting tent it's "Ernten" — so
// the worker never picks a mode. Everything else (move elsewhere, contam,
// discard) is one tap below. The move actions honour the single/whole-batch
// toggle.
function renderBiActions() {
  const el = document.getElementById('bi-actions');
  if (!el) return;
  const b = batches.find((x) => x.batchId && x.batchId.toUpperCase() === (biBatchId || '').toUpperCase());
  if (!b) {
    el.innerHTML = '';
    return;
  }
  const cur = _biBagCurrentLoc();
  const role = cur.loc && ZONE_BY_ID[toZone(cur.loc)] ? ZONE_BY_ID[toZone(cur.loc)].role : null;
  const nBags = (b.bags || []).length;
  const hasFruiting = !!_fruitingDest();
  // Same as `btn` above: the size is a class at each use. It has to be, because
  // the three buttons built from this string are not all the same size -- the
  // two primary ones are 17px and the contamination one is 15px, and an inline
  // font-size here would silently win over both.
  const big =
    'width:100%;display:flex;align-items:center;justify-content:center;gap:8px;padding:15px;border-radius:12px;border:0;font-weight:600;margin-bottom:8px;cursor:pointer';
  let html = '';
  if (nBags > 1) {
    const seg = 'flex:1;text-align:center;padding:10px;cursor:pointer;border:0';
    html +=
      '<div style="display:flex;border:1px solid var(--c-border);border-radius:10px;overflow:hidden;margin-bottom:10px">' +
      `<button type="button" data-bi="scope-single" class="fs-sm" style="${seg};${!biWholeBatch ? 'background:var(--c-text);color:#fff' : 'background:transparent;color:var(--c-text-sec)'}">${esc(t('bagInfo.scopeSingle'))}</button>` +
      `<button type="button" data-bi="scope-batch" class="fs-sm" style="${seg};border-left:1px solid var(--c-border);${biWholeBatch ? 'background:var(--c-text);color:#fff' : 'background:transparent;color:var(--c-text-sec)'}">${esc(t('bagInfo.scopeBatch', { n: nBags }))}</button>` +
      '</div>';
  }
  // Körnerbrut kommt nie in die Fruchtung: ihr nächster Schritt ist, in Blöcke zu
  // gehen. Stand hier "→ Fruchtung", weil der Beutel im Spawn-Zelt steht, lag der
  // falsche Knopf am größten da.
  if (!cur.removed && b.batchType === 'grain') {
    html += `<button type="button" data-bi="used" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-purple-dark);color:#fff">✓ ${esc(t('bagInfo.used'))}</button>`;
  } else if (!cur.removed && (role === 'incubation' || role === 'spawn') && hasFruiting) {
    html += `<button type="button" data-bi="fruchtung" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-primary);color:#fff">→ ${esc(t('dash.toFruiting'))}</button>`;
  } else if (!cur.removed && role === 'fruiting') {
    html += `<button type="button" data-bi="harvest" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-amber-dark);color:#fff">✂ ${esc(t('bagInfo.harvest'))}</button>`;
  }
  const sec =
    'flex:1;display:flex;align-items:center;justify-content:center;gap:6px;padding:13px;border-radius:10px;cursor:pointer;background:var(--c-surface);border:1px solid var(--c-border)';
  html +=
    '<div style="display:flex;gap:8px;margin-bottom:8px">' +
    `<button type="button" data-bi="move" class="fs-base" style="${sec};color:var(--c-text);font-weight:600">${esc(t('bagInfo.moveElsewhere'))}</button>` +
    `<button type="button" data-bi="remove" class="fs-base" style="${sec};color:var(--c-text-sec)">${esc(t('bagInfo.discard'))}</button>` +
    '</div>';
  html += `<button type="button" data-bi="contam" class="fs-base" style="${big};padding:13px;background:var(--c-red-light);color:var(--c-red-dark);border:1px solid var(--c-red-border)">${esc(t('bagInfo.reportContam'))}</button>`;
  el.innerHTML = html;
}
// Move the scanned bag (or whole batch, per the toggle) to dest, then drop the
// worker straight back into the camera for the next bag. moveBagsTo/moveBatchTo
// call back synchronously, so re-opening the camera stays inside the tap
// gesture (iOS requires that to start the camera).
function biMoveTo(dest) {
  const b = batches.find((x) => x.batchId && x.batchId.toUpperCase() === (biBatchId || '').toUpperCase());
  if (!b || !dest) return;
  document.getElementById('m-baginfo').classList.remove('open');
  // Re-open the camera BEFORE the move so its confirmation shows as a brief,
  // auto-dismissing toast over the live camera (setFb routes to the camera HUD
  // when the scanner is active). If we moved first, setFb would instead pop the
  // scan-log overlay, which the worker then has to close before scanning again.
  biRearmScanner();
  // Snapshot before the move so a mistap here is as reversible as one on the
  // dashboard. The undo bar sits at z-index 900, above the camera modal, so it
  // stays reachable while scanning continues.
  const snapBags = biWholeBatch ? [b] : [{ ...b, bags: [biBagId] }];
  const snap = _snapshotBeforeMove(snapBags, dest, buildLastScanByBag());
  const cb = function (moved, skipped) {
    if (!moved) {
      setFb(
        'ok',
        skipped ? t('batch.allAlreadyAt', { n: skipped, loc: zoneDisplayName(dest) }) : t('batch.noBagsToMove')
      );
    } else {
      setFb('ok', b.batchId + ': ' + moved + ' Bags → ' + zoneDisplayName(dest));
      if (snap.length) showUndoBar(b.batchId + ': ' + moved + ' → ' + zoneDisplayName(dest), () => _undoMove(snap));
    }
    updateSD();
    renderBatches();
    renderStatus();
  };
  if (biWholeBatch) moveBatchTo(b, dest, cb);
  else moveBagsTo(b, [biBagId], dest, cb);
}
// Verbraucht aus dem Beutel-Fenster: der gescannte Körnerbeutel, oder mit
// "Ganze Charge" alle, die noch dastehen. Danach zurück in die Kamera wie beim
// Umziehen, und ein Fehltipp kostet einen Tipp: Rückgängig, oder ↩ in der
// Kamera. Die Kamera geht vor dem Buchen auf, damit die Meldung dort steht.
function biMarkUsed() {
  const b = batches.find((x) => x.batchId && x.batchId.toUpperCase() === (biBatchId || '').toUpperCase());
  if (!b || !biBagId) return;
  document.getElementById('m-baginfo').classList.remove('open');
  biRearmScanner();
  const entries = spawnBuchen(biWholeBatch ? b.bags || [] : [biBagId], 'spawn', { sitzung: true });
  if (!entries.length) {
    setFb('warn', t('scanFb.alreadyUsed', { bag: biBagId }));
    return;
  }
  const msg =
    entries.length === 1 ? t('bagInfo.usedOne', { bag: entries[0].bag }) : t('bagInfo.usedN', { n: entries.length, id: b.batchId });
  setFb('ok', msg, entries.length === 1 ? entries[0] : undefined);
  showUndoBar(msg, () => spawnZuruecknehmen(entries));
  updateSD();
}
// Return to a clean scan state and re-open the camera, so scanning the next bag
// opens its sheet again (no action armed).
function biRearmScanner() {
  scan.action = null;
  scan.to = null;
  scan.from = null;
  scan.harvestBag = null;
  updateSD();
  openCamScan();
}
function biOpenHarvest() {
  if (!biBagId || !biBatchId) return;
  document.getElementById('m-baginfo').classList.remove('open');
  scan.action = 'HARVEST';
  scan.from = null;
  scan.to = null;
  scan.harvestBag = null;
  updateSD();
  showHarvestPanel(biBagId, biBatchId);
}

// Log a REMOVE entry after the confirmation dialog was accepted.
function biPerformRemove() {
  if (!biBagId) return;
  document.getElementById('m-baginfo').classList.remove('open');
  const bagLast = [...scanLog]
    .reverse()
    .find((e) => (e.bag || '').toUpperCase() === biBagId.toUpperCase() && (e.action === 'ADD' || e.action === 'MOVE'));
  const fromLoc = bagLast ? bagLast.to : null;
  const b = batches.find((x) => x.batchId.toUpperCase() === (biBatchId || '').toUpperCase());
  const tempId = 's' + ++_scanTempIdCounter;
  const entry = {
    time: new Date().toISOString(),
    action: 'REMOVE',
    batch: biBatchId,
    bag: biBagId,
    from: fromLoc,
    to: null,
    species: b?.species || null,
    strain: b?.strain || null,
    user: currentUser?.username || null,
    client_uuid: newScanUuid(),
    _tempId: tempId
  };
  scanLog.push(entry);
  movements.push(entry);
  if (!sessionStartTime) sessionStartTime = Date.now();
  sessionEntries.push(entry);
  scan.count++;
  apiPost('/api/scan-log', { entries: [entry] }).then(function (r) {
    if (r && r.ids && r.ids[0]) setEntryServerId(entry, r.ids[0]);
  });
  updateSD();
  const msg = fromLoc
    ? t('scanFb.removeFromLogged', { bag: biBagId, loc: zoneDisplayName(fromLoc) })
    : t('scanFb.removeLogged', { bag: biBagId });
  setFb('ok', msg, entry);
}

function biConfirmRemove() {
  if (!biBagId) return;
  const bagLast = [...scanLog]
    .reverse()
    .find((e) => (e.bag || '').toUpperCase() === biBagId.toUpperCase() && (e.action === 'ADD' || e.action === 'MOVE'));
  const fromLoc = bagLast ? bagLast.to : null;
  const body = fromLoc
    ? t('bagInfo.confirmRemoveBody', { bag: biBagId, loc: zoneDisplayName(fromLoc) })
    : t('bagInfo.confirmRemoveBodyNoLoc', { bag: biBagId });
  confirm2(t('bagInfo.confirmRemoveTitle'), body, t('bagInfo.confirmRemoveOk'), biPerformRemove);
}
document.getElementById('m-baginfo').addEventListener('click', (e) => {
  if (e.target.id === 'm-baginfo') document.getElementById('m-baginfo').classList.remove('open');
});

// ─── BLOCKBUCH ───────────────────────────────────────────────
// Gute Blöcke und Notizen je Block. Wer in der Fruchtung einen Block scannt, der
// besonders gut läuft, vermerkt ihn mit einem Tipp; das Blockbuch hält fest,
// woraus er gemacht war — Ansatz mit Soll- und Ist-Feuchte, Körnerbrut mit ihrer
// Feuchte — und legt die guten Blöcke je Sorte nebeneinander, bis sich zeigt,
// welches Rezept trägt. Notizen kommen aus dem Beutel-Fenster und beim Ernten.
//
// blockNotes reist in /api/data mit, damit das Beutel-Fenster beim Scannen nicht
// wartet. Herkunft und Ernte je Block holt erst der Reiter (/api/block-book).
let _bbEntries = null;
function blockNoteOf(bagId) {
  const k = String(bagId || '').toUpperCase();
  return blockNotes.find((n) => n.bagId.toUpperCase() === k) || null;
}
function _bbNoteFor(bagId, batchId) {
  let n = blockNoteOf(bagId);
  if (!n) {
    n = { bagId, batchId, good: false, goodAt: null, goodBy: null, comments: [] };
    blockNotes.push(n);
  }
  return n;
}
function _bbCanDelete(c) {
  return !!currentUser && (currentUser.role === 'admin' || (!!c.by && c.by === currentUser.username));
}
function _bbOpen() {
  const el = document.getElementById('sp-batch-blocks');
  return !!(el && el.classList.contains('active'));
}
// Körnerbrut ist kein Block: sie wird verbraucht, nicht geerntet.
function biIsBlock() {
  const b = batches.find((x) => x.batchId && x.batchId.toUpperCase() === (biBatchId || '').toUpperCase());
  return !!b && b.batchType !== 'grain';
}
// Beide Gut-Knöpfe, im Beutel-Fenster und in der Ernte-Leiste, zeigen den Stand
// des Beutels, um den es dort gerade geht.
function renderBlockGoodButtons() {
  const set = (id, bagId, show) => {
    const btn = document.getElementById(id);
    if (!btn) return;
    btn.hidden = !show;
    const on = !!(bagId && blockNoteOf(bagId)?.good);
    btn.setAttribute('aria-pressed', on ? 'true' : 'false');
  };
  set('bi-good', biBagId, !!biBagId && biIsBlock());
  set('hp-good', scan.harvestBag && scan.harvestBag.bagId, !!scan.harvestBag);
}
async function setBlockGoodFor(bagId, batchId, on, withUndo) {
  const n = _bbNoteFor(bagId, batchId);
  const vorher = { good: n.good, goodAt: n.goodAt, goodBy: n.goodBy };
  Object.assign(n, {
    good: on,
    goodAt: on ? new Date().toISOString() : null,
    goodBy: on ? currentUser?.username || null : null
  });
  renderBlockGoodButtons();
  const r = await apiPost('/api/block-notes/good', { bag: bagId, on });
  if (!r || r.error) {
    Object.assign(n, vorher);
    renderBlockGoodButtons();
    setFb('err', t('block.saveFailed', { msg: (r && r.error) || 'Network error' }), { noModal: true });
    return;
  }
  const msg = on ? t('block.markedGood', { bag: bagId }) : t('block.unmarkedGood', { bag: bagId });
  setFb('ok', msg, { noModal: true });
  if (withUndo) showUndoBar(msg, () => setBlockGoodFor(bagId, batchId, !on, false));
  if (_bbOpen()) loadBlockBook();
}
function toggleBlockGood(bagId, batchId) {
  if (!bagId) return;
  setBlockGoodFor(bagId, batchId, !blockNoteOf(bagId)?.good, true);
}
async function addBlockComment(bagId, batchId, text, flush) {
  const n = _bbNoteFor(bagId, batchId);
  const c = { id: null, text, flush: flush || null, at: new Date().toISOString(), by: currentUser?.username || null };
  n.comments.push(c);
  renderBiNotesList();
  const r = await apiPost('/api/block-notes/comments', { bag: bagId, text, flush: flush || undefined });
  if (!r || r.error) {
    n.comments.splice(n.comments.indexOf(c), 1);
    renderBiNotesList();
    setFb('err', t('block.saveFailed', { msg: (r && r.error) || 'Network error' }), { noModal: true });
    return false;
  }
  c.id = r.id;
  renderBiNotesList();
  if (_bbOpen()) loadBlockBook();
  return true;
}
// Ein Tipp löscht, Rückgängig schreibt dieselbe Notiz neu.
async function deleteBlockComment(id) {
  let n = null,
    c = null;
  for (const x of blockNotes) {
    const y = x.comments.find((k) => k.id === id);
    if (y) {
      n = x;
      c = y;
      break;
    }
  }
  if (!c) return;
  n.comments.splice(n.comments.indexOf(c), 1);
  renderBiNotesList();
  if (_bbEntries) {
    for (const e of _bbEntries) e.comments = e.comments.filter((k) => k.id !== id);
    renderBlockBook();
  }
  const r = await apiDelete('/api/block-notes/comments/' + id);
  if (!r || r.error) {
    n.comments.push(c);
    renderBiNotesList();
    if (_bbOpen()) loadBlockBook();
    setFb('err', t('block.saveFailed', { msg: (r && r.error) || 'Network error' }), { noModal: true });
    return;
  }
  showUndoBar(t('block.noteDeleted'), () => addBlockComment(n.bagId, n.batchId, c.text, c.flush));
}
function _bbCommentsHtml(comments) {
  return comments
    .map((c) => {
      const meta = [fmtDtTime(c.at), c.by ? esc(c.by) : '', c.flush ? esc(t('block.atFlush', { n: c.flush })) : '']
        .filter(Boolean)
        .join(' · ');
      const del =
        c.id && _bbCanDelete(c)
          ? `<button type="button" class="bb-note-del" data-bb-del="${c.id}" aria-label="${esc(t('block.deleteNote'))}" title="${esc(t('block.deleteNote'))}">×</button>`
          : '';
      return `<div class="bb-note"><div class="bb-note-text fs-meta">${esc(c.text)}</div><div class="bb-note-meta fs-micro">${meta}${del}</div></div>`;
    })
    .join('');
}
// Das Notizfeld wird einmal gebaut, wenn das Fenster aufgeht; danach ändert sich
// nur die Liste darüber. Sonst wischte jede Synchronisierung weg, was gerade
// getippt wird.
function renderBiNotes() {
  const el = document.getElementById('bi-notes');
  if (!el) return;
  if (!biBagId || !biIsBlock()) {
    el.innerHTML = '';
    return;
  }
  el.innerHTML =
    `<div class="met bb-bi-notes"><div class="met-l" style="font-weight:700">${esc(t('block.notes'))}</div>` +
    '<div id="bi-notes-list"></div>' +
    `<textarea id="bi-note-text" rows="2" maxlength="2000" placeholder="${esc(t('block.notePlaceholder'))}"></textarea>` +
    `<div class="bb-bi-save"><button type="button" class="btn btn-sm" id="bi-note-save">${esc(t('block.saveNote'))}</button></div></div>`;
  renderBiNotesList();
}
function renderBiNotesList() {
  const el = document.getElementById('bi-notes-list');
  if (!el || !biBagId) return;
  const n = blockNoteOf(biBagId);
  el.innerHTML = n && n.comments.length ? _bbCommentsHtml(n.comments) : '';
}
function biSaveNote() {
  const ta = document.getElementById('bi-note-text');
  const text = ta ? ta.value.trim() : '';
  if (!text || !biBagId) return;
  const bag = biBagId;
  ta.value = '';
  addBlockComment(bag, biBatchId, text, null).then((ok) => {
    if (ok) setFb('ok', t('block.noteSaved', { bag }), { noModal: true });
    else if (ta.isConnected && !ta.value) ta.value = text;
  });
}

async function loadBlockBook() {
  try {
    const r = await apiGet('/api/block-book');
    _bbEntries = (r && r.entries) || [];
    renderBlockBook();
  } catch (e) {
    const el = document.getElementById('bb-good');
    if (el) el.innerHTML = `<div class="empty">${esc(t('block.loadFailed', { msg: e.message }))}</div>`;
  }
}
const _bbPct = (v) => fmtKg(v, v % 1 ? 1 : 0) + ' %';
const _bbAvg = (a) => a.reduce((s, x) => s + x, 0) / a.length;
function _bbLineageHtml(l) {
  const muted = (txt) => `<span class="bb-muted">${esc(txt)}</span>`;
  const mono = (txt) => `<span class="bb-mono">${esc(txt)}</span>`;
  const zeile = (label, teile) =>
    `<div class="bb-line"><span class="met-l">${esc(label)}</span> ${teile.filter(Boolean).join(muted(' · '))}</div>`;
  let html = '';
  const s = l.substrate;
  if (s) {
    const ist =
      s.actualRh == null
        ? muted(t('bagInfo.rhActual') + ' ' + t('sub.rhNotMeasured'))
        : `<strong>${esc(t('bagInfo.rhActual') + ' ' + _bbPct(s.actualRh))}</strong>`;
    const mix = s.subId
      ? ''
      : muted(
          'HW ' + _bbPct(s.hardwoodPct) + ' · WB ' + _bbPct(s.wheatbranPct)
        );
    html += zeile(t('bagInfo.substrate'), [
      s.subId ? mono(s.subId) : '',
      s.recipe ? muted(s.recipe) : '',
      mix,
      s.targetRh ? muted(t('bagInfo.rhTarget') + ' ' + _bbPct(s.targetRh)) : '',
      ist
    ]);
  }
  for (const g of l.grain || []) {
    html += zeile(t('bagInfo.grain'), [
      g.batchId ? mono(g.batchId) : '',
      g.rh ? `<strong>${esc('RH ' + _bbPct(g.rh))}</strong>` : '',
      muted(t('bagInfo.nBags', { n: g.bags }))
    ]);
  }
  if (l.culture) html += zeile(t('bagInfo.culture'), [mono(l.culture)]);
  return html;
}
function _bbEntryHtml(e, withComments) {
  const l = e.lineage || {};
  const ernte =
    e.harvestG > 0
      ? `${fmtKg(e.harvestG, 0)} g (${e.harvestCount}×)`
      : `<span class="bb-muted">${esc(t('block.noHarvest'))}</span>`;
  const star = e.good ? '<svg class="bb-star" width="14" height="14" viewBox="0 0 24 24" aria-hidden="true"><path d="M12 3l2.7 5.6 6.1.9-4.4 4.3 1 6.1L12 17l-5.4 2.9 1-6.1-4.4-4.3 6.1-.9z" /></svg>' : '';
  const head =
    `<div class="bb-head"><span class="bb-mono"><strong>${esc(e.bagId)}</strong></span>${star}` +
    `<span class="fs-meta">${l.species ? spDot(l.species) + esc(l.species) : ''}${l.strain ? ' / ' + esc(l.strain) : ''}</span>` +
    `<span class="fs-meta bb-harvest">${ernte}</span></div>`;
  const gone = e.live ? '' : `<div class="bb-line bb-muted fs-micro">${esc(t('block.batchGone'))}</div>`;
  const comments = withComments && e.comments.length ? `<div class="bb-notes">${_bbCommentsHtml(e.comments)}</div>` : '';
  return `<div class="bb-entry">${head}<div class="fs-meta">${_bbLineageHtml(l)}</div>${gone}${comments}</div>`;
}
// Je Sorte: wie viele gute Blöcke, aus welchem Rezept, mit welcher Feuchte im
// Substrat (gemessen, wo jemand gemessen hat) und in der Körnerbrut, und was sie
// im Schnitt getragen haben. Das ist die Zeile, die mit der Zeit zum Rezept wird.
function _bbSummaryHtml(good) {
  const bySp = new Map();
  for (const e of good) {
    const l = e.lineage || {};
    const k = l.species || '?';
    if (!bySp.has(k)) bySp.set(k, { n: 0, recipes: new Map(), ist: [], soll: [], grain: [], harvest: [] });
    const a = bySp.get(k);
    a.n++;
    const s = l.substrate;
    if (s) {
      const r = s.recipe || (s.subId ? s.subId : 'HW ' + _bbPct(s.hardwoodPct) + ' · WB ' + _bbPct(s.wheatbranPct));
      a.recipes.set(r, (a.recipes.get(r) || 0) + 1);
      if (s.actualRh != null) a.ist.push(s.actualRh);
      if (s.targetRh) a.soll.push(s.targetRh);
    }
    for (const g of l.grain || []) if (g.rh) a.grain.push(g.rh);
    if (e.harvestG > 0) a.harvest.push(e.harvestG);
  }
  return [...bySp.entries()]
    .sort((x, y) => y[1].n - x[1].n)
    .map(([sp, a]) => {
      const box = (label, wert) =>
        `<div class="met"><div class="met-l">${esc(label)}</div><div class="fs-meta" style="font-weight:600">${wert}</div></div>`;
      const dash = '<span class="bb-muted">—</span>';
      const recipes = [...a.recipes.entries()]
        .sort((x, y) => y[1] - x[1])
        .map(([r, c]) => esc(r) + (a.n > 1 ? ' <span class="bb-muted">×' + c + '</span>' : ''))
        .join('<br>');
      const sub = [
        a.ist.length
          ? esc(t('bagInfo.rhActual') + ' Ø ' + _bbPct(Math.round(_bbAvg(a.ist) * 10) / 10)) +
            ` <span class="bb-muted">(${esc(t('block.nMeasured', { n: a.ist.length }))})</span>`
          : '',
        a.soll.length
          ? `<span class="bb-muted">${esc(t('bagInfo.rhTarget') + ' Ø ' + _bbPct(Math.round(_bbAvg(a.soll) * 10) / 10))}</span>`
          : ''
      ]
        .filter(Boolean)
        .join('<br>');
      return (
        `<div class="bb-sum"><div class="bb-head"><span class="fs-base" style="font-weight:600">${spDot(sp)}${esc(sp)}</span>` +
        `<span class="fs-meta bb-muted">${esc(a.n === 1 ? t('block.oneBlock') : t('block.nBlocks', { n: a.n }))}</span></div>` +
        '<div class="bb-sum-grid">' +
        box(t('block.recipes'), recipes || dash) +
        box(t('block.substrateRh'), sub || dash) +
        box(t('block.grainRh'), a.grain.length ? esc('Ø ' + _bbPct(Math.round(_bbAvg(a.grain) * 10) / 10)) : dash) +
        box(t('block.avgHarvest'), a.harvest.length ? esc(fmtKg(Math.round(_bbAvg(a.harvest)), 0) + ' g') : dash) +
        '</div></div>'
      );
    })
    .join('');
}
function renderBlockBook() {
  const sumEl = document.getElementById('bb-summary'),
    goodEl = document.getElementById('bb-good'),
    notesEl = document.getElementById('bb-notes');
  if (!sumEl || !goodEl || !notesEl || !_bbEntries) return;
  const good = _bbEntries.filter((e) => e.good).sort((a, b) => (b.goodAt || '').localeCompare(a.goodAt || ''));
  const lastAt = (e) => (e.comments.length ? e.comments[e.comments.length - 1].at : '');
  const noted = _bbEntries.filter((e) => e.comments.length).sort((a, b) => lastAt(b).localeCompare(lastAt(a)));
  sumEl.innerHTML = good.length ? _bbSummaryHtml(good) : '';
  goodEl.innerHTML = good.length
    ? good.map((e) => _bbEntryHtml(e, false)).join('')
    : `<div class="empty">${esc(t('block.goodEmpty'))}</div>`;
  notesEl.innerHTML = noted.length
    ? noted.map((e) => _bbEntryHtml(e, true)).join('')
    : `<div class="empty">${esc(t('block.notesEmpty'))}</div>`;
}

document.getElementById('bi-good').addEventListener('click', () => toggleBlockGood(biBagId, biBatchId));
document.getElementById('hp-good').addEventListener('click', () => {
  if (scan.harvestBag) toggleBlockGood(scan.harvestBag.bagId, scan.harvestBag.batchId);
});
document.getElementById('hp-note').addEventListener('keydown', (e) => {
  if (e.key === 'Enter') confirmHarvest();
});
document.getElementById('bi-notes').addEventListener('click', (e) => {
  if (e.target.closest('#bi-note-save')) return biSaveNote();
  const del = e.target.closest('[data-bb-del]');
  if (del) deleteBlockComment(parseInt(del.dataset.bbDel, 10));
});
document.getElementById('sp-batch-blocks').addEventListener('click', (e) => {
  const del = e.target.closest('[data-bb-del]');
  if (del) deleteBlockComment(parseInt(del.dataset.bbDel, 10));
});

// ─── CONTAMINATION REPORT MODAL ──────────────────────────────
// MVP from audit Section 2 / PR 7. Captures bag/batch + type + severity +
// notes + up to 4 photos (compressed client-side to ~200 KB JPEG / ~15 KB
// thumb), POSTs to /api/contamination-reports.
// Die Beutel, über die dieses Formular berichtet: [{ bag, batch }].
//
// Es war ein Beutel, und das war die Reibung. Eine kontaminierte Reihe ist nicht
// ein Beutel, sondern acht, und für jeden ging dasselbe Fenster auf: Typ tippen,
// Schwere tippen, senden, Fenster zu, nächster Scan. Jetzt sammelt der Scanner,
// solange CONTAM steht, und das Formular kommt einmal für alle.
let _crTargets = [];
let _crBatchId = null;
let _crZoneId = null;
// Steht auf true, während die Kamera aus einem offenen Formular heraus geholt
// wurde ("+ Scannen"). closeCamScan() bringt das Formular dann zurück, mit Typ,
// Schwere, Fotos und Notiz so, wie sie vor dem Scannen standen.
let _crResumeForm = false;
let _crTypes = null; // lazily loaded from /api/contamination-types
// Der Typ ist freiwillig: Beutel scannen, Senden, fertig. Er stand vorher als
// Pflichtfeld davor, und für die meisten Meldungen war die Antwort "weiß ich
// nicht". Ohne Wahl legt der Server den Bericht unter "Unbekannt / Sonstiges"
// ab. Er wird auch nicht mehr vom letzten Bericht übernommen — ein Typ, den
// niemand für diesen Beutel gewählt hat, wäre eine stille Falschangabe.
let _crSelectedTypeId = null;
let _crSeverity = 'minor';
let _crPhotos = []; // [{ data_url, thumb_data_url, width, height }]
const CR_MAX_PHOTOS = 4;

function biReportContam() {
  if (!biBagId) return;
  document.getElementById('m-baginfo').classList.remove('open');
  openContamReport(biBagId, biBatchId, null);
}

function openContamReport(bagId, batchId, zoneId) {
  _crTargets = bagId ? [{ bag: bagId, batch: batchId || null }] : [];
  _crBatchId = batchId || null;
  _crZoneId = zoneId || null;
  _crOpenForm(false);
}

// Das Formular über die Beutel öffnen, die der Scanner schon gesammelt hat.
function crOpenCollected() {
  if (!_crTargets.length) return;
  // Bei einem Beutel steht die Charge im Kopf des Formulars; bei mehreren aus
  // verschiedenen Chargen gibt es keine gemeinsame, und jeder Bericht bekommt
  // seine eigene aus der Sammelliste.
  _crBatchId = _crTargets.length === 1 ? _crTargets[0].batch : null;
  _crZoneId = null;
  _crOpenForm(false);
}

// keep = true lässt Typ, Schwere, Fotos und Notiz stehen. Das ist der Rückweg
// aus "+ Scannen": wer zwei Beutel nachträgt, hat sein Foto schon gemacht und
// den Typ schon getippt.
function _crOpenForm(keep) {
  if (!keep) {
    _crSelectedTypeId = null;
    _crSeverity = 'minor';
    _crPhotos = [];
    // Reset form
    document.getElementById('cr-notes').value = '';
    document.getElementById('cr-photo-status').textContent = '';
    // Reset severity buttons to 'minor' active
    document.querySelectorAll('#cr-severity-row .contam-sev-btn').forEach((b) => {
      b.classList.toggle('active', b.dataset.sev === 'minor');
    });
    const autoMoveEl = document.getElementById('cr-auto-move');
    // Kontaminiert heißt raus aus dem Bestand: der Block zieht in die
    // Kontaminationszone, außer jemand nimmt den Haken unter "Mehr" heraus.
    if (autoMoveEl) autoMoveEl.checked = true;
    // "Mehr" geht jedes Mal zu auf: ein neuer Bericht fängt schlank an.
    const mehr = document.getElementById('cr-more');
    if (mehr) mehr.open = false;
  }
  _crRenderTargets();
  _renderCrPhotos();
  // Lazy-load types on first open; refresh on later opens to pick up admin edits
  apiGet('/api/contamination-types')
    .then((types) => {
      _crTypes = Array.isArray(types) ? types : [];
      // Drop a remembered pre-selection if that type was since deleted/renamed.
      if (_crSelectedTypeId != null && !_crTypes.some((tp) => tp.id === _crSelectedTypeId)) _crSelectedTypeId = null;
      _renderCrTypeGrid();
    })
    .catch(() => {
      _crTypes = [];
      _renderCrTypeGrid();
    });
  document.getElementById('m-contam-report').classList.add('open');
}

// Die Beutel im Kopf des Formulars, jeder mit einem × zum Streichen, dahinter
// der Knopf, der die Kamera für weitere holt.
function _crRenderTargets() {
  const el = document.getElementById('cr-target');
  if (!el) return;
  const add =
    '<button type="button" id="cr-scan-more" class="cr-target-add">' + esc(t('contam.scanMore')) + '</button>';
  if (!_crTargets.length) {
    el.innerHTML = '<span class="cr-target-text">' + esc(t('contam.targetBatch', { batch: _crBatchId || '—' })) + '</span>' + add;
    return;
  }
  const chips = _crTargets
    .map(
      (tg) =>
        '<span class="cr-target-chip">' +
        esc(tg.bag) +
        '<button type="button" class="cr-target-x" data-cr-untarget="' +
        esc(tg.bag) +
        '" aria-label="' +
        esc(t('contam.removeBag', { bag: tg.bag })) +
        '">&times;</button></span>'
    )
    .join('');
  const head =
    _crTargets.length === 1
      ? '<span class="cr-target-text">' +
        esc(t('contam.targetBag', { bag: _crTargets[0].bag, batch: _crTargets[0].batch || '—' })) +
        '</span>'
      : '<span class="cr-target-text">' + esc(t('contam.targetBags', { n: _crTargets.length })) + '</span>';
  el.innerHTML = head + '<div class="cr-target-chips">' + chips + add + '</div>';
}

// Beutel in die Sammelliste legen — oder wieder heraus, wenn er schon drin ist.
// Zweimal denselben Beutel zu scannen ist am Regal das übliche Versehen; ihn
// stumm ein zweites Mal aufzunehmen wären zwei Berichte über einen Beutel.
function crToggleTarget(bagId, batchId) {
  const key = (bagId || '').toUpperCase();
  if (!key) return null;
  const i = _crTargets.findIndex((tg) => (tg.bag || '').toUpperCase() === key);
  if (i !== -1) {
    _crTargets.splice(i, 1);
    return { bag: bagId, added: false, count: _crTargets.length };
  }
  _crTargets.push({ bag: bagId, batch: batchId || null });
  return { bag: bagId, added: true, count: _crTargets.length };
}

// Aus dem offenen Formular zurück zum Scannen, ohne das Formular aufzugeben.
//
// Am Telefon ist die Kamera der Scanner. Am Tisch hängt ein Handscanner und oft
// gar keine Kamera — dort tritt das Formular nur zur Seite, und der
// Melden-Knopf in der Scan-Hülle holt es mit allem Ausgefüllten zurück.
function crScanMore() {
  _crResumeForm = true;
  document.getElementById('m-contam-report').classList.remove('open');
  const kamera = !window.matchMedia || window.matchMedia('(pointer: coarse)').matches;
  // Stumm scharfstellen, wo die Kamera aufgeht: die Quittung von
  // armScanAction() klappt sonst die grüne Scan-Hülle auf, und die liegt
  // (z-index 900) über dem Kamerabild.
  if (scan.action !== 'CONTAM') armScanAction('CONTAM', kamera ? { noModal: true } : undefined);
  if (kamera) openCamScan();
  else openScanModal();
  updateSD();
}

// Sammeln beenden: Kamera zu, Formular auf.
//
// Die Kamera muss zu, bevor das Formular aufgeht: beide liegen auf z-index 200,
// und die Kamera steht im Quelltext dahinter — offen läge sie obenauf und das
// Formular unsichtbar darunter.
//
// Die Marke fällt zuerst, sonst holt closeCamScan() das Formular ein zweites
// Mal, und zwar über den Weg, der den Entwurf verwirft.
function crFinishCollect() {
  const keep = _crResumeForm;
  _crResumeForm = false;
  if (document.getElementById('m-camscan').classList.contains('open')) closeCamScan();
  if (keep) _crOpenForm(true);
  else crOpenCollected();
}

// Das Formular zur Seite legen: × oben rechts und der Tipp neben das Fenster.
//
// Beides schloss den Bericht und warf alles weg. Bei einem Beutel war das ein
// Formular; bei acht sind es acht Scans, die ein Fehltipp am Rand kostet — und
// am Telefon ist der Rand da, wo der Daumen hält. Also bleibt beides stehen,
// und der ⚠-Knopf mit seiner Zahl bzw. "Melden (N)" holt es zurück.
function crStashReport() {
  document.getElementById('m-contam-report').classList.remove('open');
  if (_crTargets.length) _crResumeForm = true;
  updateSD();
}

// Abbrechen: weg ist weg. Der eine Weg, der die gesammelten Beutel wirklich
// verwirft — sonst stünden sie beim nächsten Bericht wieder da, und niemand
// würde sie dort suchen.
function closeContamReport() {
  document.getElementById('m-contam-report').classList.remove('open');
  _crPhotos = [];
  _crTargets = [];
  _crResumeForm = false;
  updateSD();
}

function _crLocalizedName(t) {
  if (currentLang === 'de') return t.name_de;
  if (currentLang === 'pt') return t.name_pt;
  return t.name_en;
}

function _renderCrTypeGrid() {
  const grid = document.getElementById('cr-type-grid');
  if (!_crTypes || !_crTypes.length) {
    grid.innerHTML =
      '<div class="fs-meta" style="color:var(--c-text-muted);grid-column:1/-1">' + t('contam.noTypes') + '</div>';
    return;
  }
  grid.innerHTML = _crTypes
    .map((tp) => {
      const isActive = _crSelectedTypeId === tp.id;
      return `<button type="button" class="contam-type-btn${isActive ? ' active' : ''}" data-type-id="${tp.id}" style="color:${esc(tp.color)}">
        <span class="contam-type-dot" style="background:${esc(tp.color)}"></span>
        <span style="color:var(--c-text)">${esc(_crLocalizedName(tp))}</span>
      </button>`;
    })
    .join('');
}

async function _crCompressFile(file) {
  // Decode → resize to 1280px long edge / quality 0.8 → also a 200px thumb.
  // Canvas re-encode strips EXIF (incl. GPS) automatically — privacy win.
  const img = await new Promise((resolve, reject) => {
    const url = URL.createObjectURL(file);
    const i = new Image();
    i.onload = () => {
      URL.revokeObjectURL(url);
      resolve(i);
    };
    i.onerror = (e) => {
      URL.revokeObjectURL(url);
      reject(new Error('image decode failed'));
    };
    i.src = url;
  });
  function draw(maxEdge, quality) {
    const scale = Math.min(1, maxEdge / Math.max(img.width, img.height));
    const w = Math.max(1, Math.round(img.width * scale));
    const h = Math.max(1, Math.round(img.height * scale));
    const c = document.createElement('canvas');
    c.width = w;
    c.height = h;
    c.getContext('2d').drawImage(img, 0, 0, w, h);
    return new Promise((resolve, reject) => {
      c.toBlob(
        (blob) => {
          if (!blob) {
            reject(new Error('encode failed'));
            return;
          }
          const fr = new FileReader();
          fr.onload = () => resolve({ data_url: fr.result, width: w, height: h });
          fr.onerror = () => reject(new Error('read failed'));
          fr.readAsDataURL(blob);
        },
        'image/jpeg',
        quality
      );
    });
  }
  const main = await draw(1280, 0.8);
  const thumb = await draw(200, 0.7);
  return {
    data_url: main.data_url,
    width: main.width,
    height: main.height,
    thumb_data_url: thumb.data_url
  };
}

async function _crAddFiles(fileList) {
  const status = document.getElementById('cr-photo-status');
  const files = Array.from(fileList || []).filter((f) => f && f.type && f.type.startsWith('image/'));
  if (!files.length) return;
  for (const file of files) {
    if (_crPhotos.length >= CR_MAX_PHOTOS) {
      status.textContent = t('contam.photoLimit', { n: CR_MAX_PHOTOS });
      break;
    }
    status.textContent = t('contam.compressing', { name: file.name });
    try {
      const photo = await _crCompressFile(file);
      _crPhotos.push(photo);
      _renderCrPhotos();
    } catch (e) {
      console.error('photo compress failed', e);
      status.textContent = t('contam.compressErr');
      return;
    }
  }
  status.textContent = '';
}

function _renderCrPhotos() {
  const tiles = document.getElementById('cr-photo-tiles');
  const tilesHtml = _crPhotos
    .map(
      (p, i) =>
        `<div class="contam-photo-tile" data-cr-edit="${i}" title="${esc(t('contam.annotateHint'))}"><img src="${esc(p.thumb_data_url)}" alt=""><span class="annot-hint" aria-hidden="true">✏︎</span><button type="button" class="remove" data-cr-remove="${i}" aria-label="Remove">&times;</button></div>`
    )
    .join('');
  const addTile =
    _crPhotos.length < CR_MAX_PHOTOS
      ? `<button type="button" id="cr-add-photo" class="contam-photo-tile add" aria-label="${esc(t('contam.addPhoto'))}">${esc(t('contam.photoTile'))}</button>`
      : '';
  tiles.innerHTML = tilesHtml + addTile;
}

// Ein zweiter Tipp auf denselben Typ nimmt ihn wieder heraus — sonst gäbe es,
// einmal getippt, keinen Weg mehr zurück zu "ohne Typ".
function _crSelectType(typeId) {
  _crSelectedTypeId = _crSelectedTypeId === typeId ? null : typeId;
  _renderCrTypeGrid();
}

// ─── PHOTO ANNOTATION ─────────────────────────────────────────
// Tap a photo tile in the contamination capture modal to open a drawing
// surface over it. Workers circle / mark the contamination spot with a
// finger, hit Done, and the strokes get baked into the JPEG before submit.
// "Trichoderma along the lid seam" is much easier to communicate visually
// than in notes.
let _paIdx = -1;
let _paImg = null; // HTMLImageElement of the photo's full-res copy
let _paDrawing = false;
let _paStrokeWidth = 0;
function openAnnotate(idx) {
  if (idx < 0 || idx >= _crPhotos.length) return;
  _paIdx = idx;
  const photo = _crPhotos[idx];
  const canvas = document.getElementById('pa-canvas');
  const ctx = canvas.getContext('2d');
  const img = new Image();
  _paImg = img;
  img.onload = function () {
    // Fit canvas to image's natural pixels so strokes composite at the
    // same scale on submit (no resampling distortion).
    canvas.width = img.naturalWidth;
    canvas.height = img.naturalHeight;
    ctx.drawImage(img, 0, 0);
    // Stroke width scaled to image size — ~1% of the long edge feels
    // right on phone. Applied via lineWidth at draw time.
    _paStrokeWidth = Math.max(4, Math.round(Math.max(img.naturalWidth, img.naturalHeight) / 100));
    document.getElementById('m-photo-annotate').classList.add('open');
  };
  img.onerror = function () {
    setFb('err', t('contam.annotateLoadErr'));
  };
  img.src = photo.data_url;
}
function closeAnnotate() {
  document.getElementById('m-photo-annotate').classList.remove('open');
  _paIdx = -1;
  _paImg = null;
  _paDrawing = false;
}
function _paClear() {
  if (!_paImg) return;
  const canvas = document.getElementById('pa-canvas');
  const ctx = canvas.getContext('2d');
  ctx.clearRect(0, 0, canvas.width, canvas.height);
  ctx.drawImage(_paImg, 0, 0);
}
function _paPos(e) {
  const canvas = document.getElementById('pa-canvas');
  const r = canvas.getBoundingClientRect();
  // Translate page coords -> canvas coords (canvas is rendered at scaled
  // CSS size but its drawing space matches naturalWidth/Height).
  const sx = canvas.width / r.width;
  const sy = canvas.height / r.height;
  return { x: (e.clientX - r.left) * sx, y: (e.clientY - r.top) * sy };
}
function _paStart(e) {
  if (_paIdx < 0) return;
  e.preventDefault();
  const canvas = document.getElementById('pa-canvas');
  if (canvas.setPointerCapture && e.pointerId !== undefined) {
    try {
      canvas.setPointerCapture(e.pointerId);
    } catch (er) {
      /* ignore — some pointer types reject capture */
    }
  }
  const ctx = canvas.getContext('2d');
  const p = _paPos(e);
  ctx.strokeStyle = '#ef4444';
  ctx.lineWidth = _paStrokeWidth;
  ctx.lineCap = 'round';
  ctx.lineJoin = 'round';
  ctx.beginPath();
  ctx.moveTo(p.x, p.y);
  _paDrawing = true;
}
function _paMove(e) {
  if (!_paDrawing) return;
  e.preventDefault();
  const ctx = document.getElementById('pa-canvas').getContext('2d');
  const p = _paPos(e);
  ctx.lineTo(p.x, p.y);
  ctx.stroke();
}
function _paEnd(e) {
  if (!_paDrawing) return;
  _paDrawing = false;
  e.preventDefault();
}
async function _paDone() {
  if (_paIdx < 0 || !_paImg) {
    closeAnnotate();
    return;
  }
  const canvas = document.getElementById('pa-canvas');
  // Re-encode the annotated full image at the same compression as the
  // original (1280 px long edge, q=0.8) so the photo size budget stays
  // honest and the server-side magic-byte check still sees JPEG.
  const longEdge = Math.max(canvas.width, canvas.height);
  const scale = Math.min(1, 1280 / longEdge);
  const w = Math.max(1, Math.round(canvas.width * scale));
  const h = Math.max(1, Math.round(canvas.height * scale));
  const out = document.createElement('canvas');
  out.width = w;
  out.height = h;
  out.getContext('2d').drawImage(canvas, 0, 0, w, h);
  const dataUrl = await new Promise((resolve) => {
    out.toBlob(
      (blob) => {
        if (!blob) {
          resolve(null);
          return;
        }
        const fr = new FileReader();
        fr.onload = () => resolve(fr.result);
        fr.onerror = () => resolve(null);
        fr.readAsDataURL(blob);
      },
      'image/jpeg',
      0.8
    );
  });
  if (!dataUrl) {
    setFb('err', t('contam.annotateSaveErr'));
    closeAnnotate();
    return;
  }
  // New thumbnail (200 px) from the same annotated canvas.
  const tScale = Math.min(1, 200 / longEdge);
  const tw = Math.max(1, Math.round(canvas.width * tScale));
  const th = Math.max(1, Math.round(canvas.height * tScale));
  const thumb = document.createElement('canvas');
  thumb.width = tw;
  thumb.height = th;
  thumb.getContext('2d').drawImage(canvas, 0, 0, tw, th);
  const thumbUrl = await new Promise((resolve) => {
    thumb.toBlob(
      (blob) => {
        if (!blob) {
          resolve(null);
          return;
        }
        const fr = new FileReader();
        fr.onload = () => resolve(fr.result);
        fr.onerror = () => resolve(null);
        fr.readAsDataURL(blob);
      },
      'image/jpeg',
      0.7
    );
  });
  // Save back to the photo entry. Width/height update to the resized
  // canvas dims so they stay consistent with what the server sees.
  _crPhotos[_paIdx] = {
    data_url: dataUrl,
    thumb_data_url: thumbUrl || _crPhotos[_paIdx].thumb_data_url,
    width: w,
    height: h
  };
  closeAnnotate();
  _renderCrPhotos();
}

// Ein Bericht je Beutel — Typ, Schwere, Fotos und Notiz gelten für alle. Ohne
// gescannten Beutel bleibt der Bericht über die Charge, wie er es immer war.
// Jeder Eintrag bekommt seine eigene report_uuid: die Warteschlange spielt den
// Rumpf unverändert nach, und ohne eigene Kennung fielen die Beutel dabei auf
// einen einzigen Bericht zusammen.
function crReportBags() {
  if (!_crTargets.length) return [{ bag_id: null, batch_id: _crBatchId || null, report_uuid: newScanUuid() }];
  return _crTargets.map((tg) => ({
    bag_id: tg.bag,
    batch_id: tg.batch || _crBatchId || null,
    report_uuid: newScanUuid()
  }));
}

async function _crSubmit() {
  // Alle Beutel wieder aus der Meldung genommen und trotzdem gesendet: ohne
  // Beutel und ohne Charge wäre das ein Bericht über nichts, und niemand könnte
  // ihm hinterher ansehen, worüber er sein sollte.
  if (!_crTargets.length && !_crBatchId && !_crZoneId) {
    setFb('err', t('contam.errNoTarget'));
    return;
  }
  const submitBtn = document.getElementById('cr-submit');
  submitBtn.disabled = true;
  try {
    const bags = crReportBags();
    const body = {
      bags,
      zone_id: _crZoneId,
      type_id: _crSelectedTypeId,
      severity: _crSeverity,
      notes: document.getElementById('cr-notes').value.trim(),
      photos: _crPhotos,
      auto_move: !!document.getElementById('cr-auto-move')?.checked
    };
    const r = await apiPost('/api/contamination-reports', body);
    if (r && r.error) {
      setFb('err', t('contam.errSave', { err: r.error }));
      return;
    }
    closeContamReport();
    if (r && r.queued) {
      // Service worker queued the report because the network was unreachable.
      // The browse list won't have this entry yet — replayed when WiFi returns.
      setFb('warn', t('contam.reportQueued'));
    } else if (bags.length > 1) {
      // Eine ganze Reihe auf einmal: die Nummer eines einzelnen Berichts sagt
      // hier nichts, die Anzahl schon.
      const moved = r.autoMovedCount || 0;
      setFb(
        'ok',
        moved
          ? t('contam.reportsSavedAutoMoved', { n: bags.length, moved: moved })
          : t('contam.reportsSaved', { n: bags.length })
      );
    } else {
      // If the server actually moved the bag to CONTAM, surface that in the
      // toast so the worker isn't surprised by the new scan-log entry.
      const msgKey = r.autoMovedScanId ? 'contam.reportSavedAutoMoved' : 'contam.reportSaved';
      setFb('ok', t(msgKey, { id: r.id, photos: (r.photoIds || []).length }));
      // Refresh browse view if it's the active sub-tab
      if (document.getElementById('sp-lab-contam')?.classList.contains('active')) {
        renderContamReports();
      }
    }
  } catch (e) {
    setFb('err', t('contam.errSave', { err: e.message || 'unknown' }));
  } finally {
    submitBtn.disabled = false;
  }
}

// ─── CONTAMINATION REPORTS — BROWSE / DRILL-DOWN ──────────────
// Lab → Kontaminationen sub-tab. Lists reports as cards, click opens
// the drill-down modal with full-size photos and delete action.
let _clReports = [];
let _cdReportId = null;

function _clTypeName(r) {
  if (currentLang === 'de') return r.name_de;
  if (currentLang === 'pt') return r.name_pt;
  return r.name_en;
}

function _clRelTime(iso) {
  const d = new Date(iso);
  const sec = Math.round((Date.now() - d.getTime()) / 1000);
  if (sec < 60) return t('time.justNow');
  const min = Math.floor(sec / 60);
  if (min < 60) return t('time.minsAgo', { n: min });
  const hr = Math.floor(min / 60);
  if (hr < 24) return t('time.hoursAgo', { n: hr });
  return t('time.daysAgo', { n: Math.floor(hr / 24) });
}

async function _clEnsureTypesLoaded() {
  if (_crTypes && _crTypes.length) return;
  try {
    _crTypes = await apiGet('/api/contamination-types');
  } catch {
    _crTypes = [];
  }
  // Populate the type filter dropdown if it exists
  const sel = document.getElementById('cl-type-filter');
  if (sel && sel.options.length <= 1) {
    for (const tp of _crTypes) {
      const o = document.createElement('option');
      o.value = String(tp.id);
      o.textContent = _clTypeName(tp);
      sel.appendChild(o);
    }
  }
}

async function renderContamReports() {
  await _clEnsureTypesLoaded();
  const list = document.getElementById('contam-list');
  const count = document.getElementById('contam-list-count');
  if (!list) return;
  list.innerHTML = '<div class="empty">' + t('contam.loading') + '</div>';
  const params = new URLSearchParams();
  const typeId = document.getElementById('cl-type-filter')?.value;
  const sev = document.getElementById('cl-sev-filter')?.value;
  const status = document.getElementById('cl-status-filter')?.value;
  const since = document.getElementById('cl-since-filter')?.value;
  if (typeId) params.set('typeId', typeId);
  if (sev) params.set('severity', sev);
  if (status) params.set('status', status);
  if (since) params.set('start', since);
  try {
    _clReports = await apiGet('/api/contamination-reports' + (params.toString() ? '?' + params.toString() : ''));
  } catch (e) {
    list.innerHTML =
      '<div class="empty" style="color:var(--c-red-dark)">' +
      t('contam.errLoad', { err: e.message || 'unknown' }) +
      '</div>';
    return;
  }
  if (!_clReports.length) {
    list.innerHTML = '<div class="empty">' + t('contam.empty') + '</div>';
    count.textContent = '';
    return;
  }
  count.textContent = t('contam.count', { n: _clReports.length });
  list.innerHTML = _clReports
    .map((r) => {
      const sevKey = r.severity === 'major' ? 'sevMajor' : r.severity === 'lost' ? 'sevLost' : 'sevMinor';
      const typeName = esc(_clTypeName(r));
      // first_photo_uuid is included in the list response so we can render a
      // real thumb without a second round-trip. Fall back to a placeholder
      // glyph when the report has no photos at all (rare — usually 1+).
      const thumbHtml = r.first_photo_uuid
        ? `<img src="/api/contamination-reports/${r.id}/photos/${esc(r.first_photo_uuid)}?thumb=1" alt="" loading="lazy">`
        : `<div class="fs-floor" style="--fs-own:1.125rem">—</div>`;
      const target = r.bag_id
        ? `<span class="contam-list-bag">${esc(r.bag_id)}</span><span class="contam-list-batch">${esc(r.batch_id || '')}</span>`
        : `<span class="contam-list-bag">${esc(r.batch_id || '—')}</span>`;
      const notes = r.notes ? `<div class="contam-list-notes">${esc(r.notes)}</div>` : '';
      const resolvedClass = r.resolved_at ? ' is-resolved' : '';
      const resolvedBadge = r.resolved_at
        ? `<span class="contam-resolved-badge">✓ ${esc(t('contam.res.' + r.resolution) || '')}</span>`
        : '';
      return `<div class="contam-list-card${resolvedClass}" data-cl-id="${r.id}">
        <div class="contam-list-thumb">${thumbHtml}</div>
        <div class="contam-list-meta">
          <div class="contam-list-row">${target}<span class="contam-list-when">${esc(_clRelTime(r.reported_at))}</span></div>
          <div class="contam-list-row">
            <span class="contam-type-badge"><span class="dot" style="background:${esc(r.type_color || '#888')}"></span>${typeName}</span>
            <span class="contam-sev-badge sev-${esc(r.severity)}">${esc(t('contam.' + sevKey))}</span>
            ${resolvedBadge}
            ${(r.photo_count || 0) > 0 ? `<span class="fs-xs" style="color:var(--c-text-muted)">${r.photo_count} 📷</span>` : ''}
          </div>
          ${notes}
        </div>
      </div>`;
    })
    .join('');
}

async function openContamDetail(id) {
  _cdReportId = id;
  const body = document.getElementById('cd-body');
  body.innerHTML = '<div class="empty">' + t('contam.loading') + '</div>';
  document.getElementById('m-contam-detail').classList.add('open');
  let r;
  try {
    r = await apiGet('/api/contamination-reports/' + id);
  } catch (e) {
    body.innerHTML =
      '<div class="empty" style="color:var(--c-red-dark)">' +
      t('contam.errLoad', { err: e.message || 'unknown' }) +
      '</div>';
    return;
  }
  const typeName = esc(_clTypeName(r));
  const sevKey = r.severity === 'major' ? 'sevMajor' : r.severity === 'lost' ? 'sevLost' : 'sevMinor';
  const photos = Array.isArray(r.photos) ? r.photos : [];
  const photosHtml = photos.length
    ? `<div class="cd-photos">${photos
        .map(
          (p) =>
            `<a class="cd-photo" href="/api/contamination-reports/${r.id}/photos/${esc(p.uuid)}" target="_blank" rel="noopener"><img src="/api/contamination-reports/${r.id}/photos/${esc(p.uuid)}?thumb=1" alt="" loading="lazy"></a>`
        )
        .join('')}</div>`
    : `<div class="empty" style="margin:8px 0 14px">${t('contam.noPhotos')}</div>`;
  const notesHtml = r.notes ? `<div class="cd-notes">${esc(r.notes)}</div>` : '';
  // Resolution status — when set, show the resolution + when in the metadata
  // grid and offer a Reopen action. When unset, render four resolve-action
  // buttons (Autoclaved / Discarded / Recovered / Other) below the metadata.
  const isResolved = !!r.resolved_at;
  const resolutionLabel = r.resolution ? esc(t('contam.res.' + r.resolution)) : '';
  const statusCell = isResolved
    ? `<div><div class="label">${esc(t('contam.statusLabel'))}</div><div><span class="contam-resolved-badge">✓ ${resolutionLabel}</span><div class="fs-xs" style="color:var(--c-text-muted);margin-top:2px">${esc(fmtDtTime(r.resolved_at))}</div></div></div>`
    : `<div><div class="label">${esc(t('contam.statusLabel'))}</div><div><span class="contam-open-badge">${esc(t('contam.statusOpen'))}</span></div></div>`;
  const resolveActions = isResolved
    ? `<div class="cd-resolve-row"><button id="cd-reopen" type="button" class="btn btn-sm" data-i18n="contam.reopen">Wieder öffnen</button></div>`
    : `<div class="cd-resolve-row">
        <span class="cr-label" style="margin:0 8px 0 0">${esc(t('contam.resolveAs'))}</span>
        <button type="button" class="btn btn-sm" data-cd-resolve="autoclaved" data-i18n="contam.res.autoclaved">Autoklaviert</button>
        <button type="button" class="btn btn-sm" data-cd-resolve="discarded" data-i18n="contam.res.discarded">Entsorgt</button>
        <button type="button" class="btn btn-sm" data-cd-resolve="recovered" data-i18n="contam.res.recovered">Gerettet</button>
        <button type="button" class="btn btn-sm" data-cd-resolve="other" data-i18n="contam.res.other">Sonstiges</button>
      </div>`;
  body.innerHTML = `
    ${photosHtml}
    <div class="cd-meta-grid">
      <div><div class="label">${esc(t('contam.type'))}</div><div><span class="contam-type-badge"><span class="dot" style="background:${esc(r.type_color || '#888')}"></span>${typeName}</span></div></div>
      <div><div class="label">${esc(t('contam.severity'))}</div><div><span class="contam-sev-badge sev-${esc(r.severity)}">${esc(t('contam.' + sevKey))}</span></div></div>
      <div><div class="label">${esc(t('contam.bag'))}</div><div style="font-family:monospace">${esc(r.bag_id || '—')}</div></div>
      <div><div class="label">${esc(t('contam.batch'))}</div><div style="font-family:monospace">${esc(r.batch_id || '—')}</div></div>
      <div><div class="label">${esc(t('contam.reportedBy'))}</div><div>${esc(r.reporter || '—')}</div></div>
      <div><div class="label">${esc(t('contam.reportedAt'))}</div><div>${esc(fmtDtTime(r.reported_at))}</div></div>
      ${statusCell}
    </div>
    ${notesHtml}
    ${resolveActions}
  `;
}

async function _cdResolve(resolution) {
  if (!_cdReportId) return;
  const id = _cdReportId;
  try {
    const r = await apiPatch('/api/contamination-reports/' + id + '/resolve', { resolution });
    if (r && r.error) {
      setFb('err', t('contam.errResolve', { err: r.error }));
      return;
    }
    setFb('ok', t('contam.resolved'));
    await openContamDetail(id); // re-render with resolved state
    renderContamReports();
  } catch (e) {
    setFb('err', t('contam.errResolve', { err: e.message || 'unknown' }));
  }
}

async function _cdReopen() {
  if (!_cdReportId) return;
  const id = _cdReportId;
  try {
    const r = await apiPatch('/api/contamination-reports/' + id + '/resolve', {});
    if (r && r.error) {
      setFb('err', t('contam.errResolve', { err: r.error }));
      return;
    }
    setFb('ok', t('contam.reopened'));
    await openContamDetail(id);
    renderContamReports();
  } catch (e) {
    setFb('err', t('contam.errResolve', { err: e.message || 'unknown' }));
  }
}

function closeContamDetail() {
  document.getElementById('m-contam-detail').classList.remove('open');
  _cdReportId = null;
}

function _cdDelete() {
  if (!_cdReportId) return;
  const id = _cdReportId;
  confirm2(t('contam.confirmDeleteTitle'), t('contam.confirmDeleteBody'), t('contam.delete'), async () => {
    try {
      const r = await apiDelete('/api/contamination-reports/' + id);
      if (r && r.error) {
        setFb('err', t('contam.errDelete', { err: r.error }));
        return;
      }
      setFb('ok', t('contam.deleted'));
      closeContamDetail();
      renderContamReports();
    } catch (e) {
      setFb('err', t('contam.errDelete', { err: e.message || 'unknown' }));
    }
  });
}

// ─── BAG-SELECT MODAL (subset-of-batch move) ─────────────────
// State: which batch we're selecting from, and which bag IDs are chosen.
let bsBatchId = null;
let bsSelected = new Set();

function renderBagSelect() {
  const b = batches.find((x) => x.batchId === bsBatchId);
  if (!b) return;
  document.getElementById('bs-subtitle').textContent = t('bagSelect.subtitle', {
    id: b.batchId,
    n: bsSelected.size,
    total: b.bags.length
  });
  document.getElementById('bs-count').textContent = t('bagSelect.countSelected', { n: bsSelected.size });
  const continueBtn = document.getElementById('bs-continue');
  if (continueBtn) {
    continueBtn.disabled = bsSelected.size === 0;
    continueBtn.style.opacity = bsSelected.size === 0 ? '0.4' : '1';
    continueBtn.style.cursor = bsSelected.size === 0 ? 'not-allowed' : 'pointer';
  }
  const container = document.getElementById('bs-bags');
  container.innerHTML = '';
  b.bags.forEach((bag) => {
    const bagNum = bag.split('-').pop();
    const last = [...scanLog]
      .reverse()
      .find(
        (e) =>
          (e.bag || '').toUpperCase() === bag.toUpperCase() &&
          (e.action === 'ADD' || e.action === 'MOVE' || e.action === 'REMOVE')
      );
    const isRemoved = last && last.action === 'REMOVE';
    const isUnplaced = !last;
    const loc = isUnplaced ? '\u2014' : isRemoved ? '\u2717' : last.to || '?';
    const isSelected = bsSelected.has(bag);
    const disabled = isRemoved || isUnplaced;
    const btn = document.createElement('button');
    btn.type = 'button';
    btn.disabled = disabled;
    btn.title = disabled ? (isRemoved ? t('bagInfo.removed') : t('bagInfo.notPlaced')) : loc;
    btn.innerHTML =
      '<div class="fs-floor" style="--fs-own:0.875rem;font-weight:700;font-family:monospace">' +
      esc(bagNum) +
      '</div>' +
      '<div class="fs-micro" style="margin-top:2px;opacity:0.85">' +
      esc(loc) +
      '</div>';
    btn.style.cssText =
      'min-width:56px;padding:8px 10px;border-radius:8px;text-align:center;cursor:' +
      (disabled ? 'not-allowed' : 'pointer') +
      ';opacity:' +
      (disabled ? '0.35' : '1') +
      ';background:' +
      (isSelected ? 'var(--c-blue-dark, #1e6dd8)' : 'var(--c-bg)') +
      ';color:' +
      (isSelected ? '#fff' : 'var(--c-text)') +
      ';border:2px solid ' +
      (isSelected ? 'var(--c-blue-dark, #1e6dd8)' : 'var(--c-border)') +
      ';';
    if (!disabled) {
      btn.addEventListener('click', () => bsToggleBag(bag));
    }
    container.appendChild(btn);
  });
}

// Toggle a bag in the selection (called from clicks and from scans).
// Returns {toggled: true, added: boolean} if the bag belongs to the current batch.
function bsToggleBag(bag) {
  const b = batches.find((x) => x.batchId === bsBatchId);
  if (!b) return { toggled: false };
  const canonical = b.bags.find((x) => x.toUpperCase() === bag.toUpperCase());
  if (!canonical) return { toggled: false };
  const last = [...scanLog]
    .reverse()
    .find(
      (e) =>
        (e.bag || '').toUpperCase() === canonical.toUpperCase() &&
        (e.action === 'ADD' || e.action === 'MOVE' || e.action === 'REMOVE')
    );
  if (!last || last.action === 'REMOVE') return { toggled: false };
  let added;
  if (bsSelected.has(canonical)) {
    bsSelected.delete(canonical);
    added = false;
  } else {
    bsSelected.add(canonical);
    added = true;
  }
  renderBagSelect();
  return { toggled: true, added: added, bag: canonical };
}

function bsConfirm() {
  const b = batches.find((x) => x.batchId === bsBatchId);
  if (!b) return;
  if (bsSelected.size === 0) {
    setFb('err', t('bagSelect.noneSelected'));
    return;
  }
  const selected = Array.from(bsSelected);
  bsClose();
  _openZonePicker(t('bagSelect.moveMenuTitle', { n: selected.length }), function (dest) {
    moveBagsTo(b, selected, dest, function (moved, skipped) {
      if (!moved) {
        if (skipped > 0) {
          setFb('ok', t('batch.allAlreadyAt', { n: skipped, loc: zoneDisplayName(dest) }));
        } else {
          setFb('err', t('batch.noBagsToMove'));
        }
        return;
      }
      setFb(
        'ok',
        b.batchId +
          ': ' +
          moved +
          ' Bags \u2192 ' +
          zoneDisplayName(dest) +
          (skipped ? ' (' + skipped + ' \u00fcbersprungen)' : '')
      );
      scan.count += moved;
      updateSD();
      renderBatches();
    });
  });
}

// Close the bag-select modal AND reset its module-level state so future scans
// don't get misrouted by stale bsBatchId / bsSelected values.
function bsClose() {
  document.getElementById('m-bagselect').classList.remove('open');
  bsBatchId = null;
  bsSelected = new Set();
}

document.getElementById('m-bagselect').addEventListener('click', (e) => {
  if (e.target.id === 'm-bagselect') bsClose();
});

// ─── PRINT — BAG LABELS ──────────────────────────────────────
// ─── PRINT via server → ZPL → Windows spooler → GK420d ──────
// Correct size/orientation automatically — no browser dialog issues.
// Hyphens encoded as underscores in barcode to fix German keyboard scanning.

// Legacy species abbreviation (only used for scanning old barcode labels).
function spAbbrev(species) {
  if (!species) return 'XX';
  const words = species.trim().split(/\s+/);
  if (words.length === 1) return words[0].slice(0, 2).toUpperCase();
  return (words[0][0] + words[1][0]).toUpperCase();
}
// Calculate Code 128 module width + centered x-offset for ZPL labels.
// Label is 400 dots wide; need 20-dot quiet zone each side → 360 usable dots.
// Code 128 symbol ≈ (35 + chars*11) modules. Use mw=2 if it fits, else mw=1.
// Returns {mw, x} where x centers the barcode horizontally with minimum quiet zones.
// Code 128 quiet zone = 10× module width. Try mw=3, then 2, then 1.
// qzMult: quiet zone multiplier (default 10). Use 5 for lab labels to allow wider bars.
function bcParams(val, qzMult) {
  const mods = 35 + val.length * 11;
  let mw = 3;
  qzMult = qzMult || 10;
  const qz = (m) => m * qzMult;
  while (mw > 1 && mods * mw + 2 * qz(mw) > 400) mw--;
  const w = mods * mw;
  return { mw, x: Math.max(qz(mw), Math.round((400 - w) / 2)) };
}

// ─── Unified label layout: SINGLE SOURCE OF TRUTH for ZPL + preview ───
// Canvas is 400×240 dots (50×30mm @ 203dpi). bagLabelItems/labLabelItems
// describe one label as a plain array of items in that coordinate system;
// itemsToZPL turns them into printer output and buildPreviewCell renders
// the same items as an SVG with viewBox="0 0 400 240". Because both come
// from the same items array the preview cannot drift from what prints.
// Item shapes:
//   {type:'barcode', x, y, w, h, val, mw}
//   {type:'text',    x?, y, blockW?, fontH, fontW?, text, bold?}
//   {type:'qr',      x, y, size, val}

// Sanitize a string for use inside a ZPL ^FD...^FS field.
// ^ starts ZPL commands and ~ starts ZPL control sequences — both must be removed
// so user-supplied text (species names, notes, IDs) cannot inject ZPL commands.
function zplText(s) {
  return String(s || '').replace(/[\^~]/g, '');
}

function itemsToZPL(items) {
  // Label size from server config (LABEL_WIDTH_DOTS / LABEL_HEIGHT_DOTS env).
  // Default 400×240 dots = 50×30mm at 203dpi. Field positions in the
  // callers assume 400 dots wide; significantly different sizes need
  // their own layout.
  // ^LT0/^LS0 reset stored offsets, ^PON/^FWN force normal orientation.
  let z = '^XA^PW' + labelDims.widthDots + '^LL' + labelDims.heightDots + '^CI28^LH0,0^LT0^LS0^PON^FWN';
  for (const it of items) {
    if (it.type === 'barcode') {
      z +=
        '^FO' +
        it.x +
        ',' +
        it.y +
        '^BY' +
        it.mw +
        ',2.0,' +
        it.h +
        '^BCN,' +
        it.h +
        ',N,N,N^FD' +
        zplText(it.val) +
        '^FS';
    } else if (it.type === 'text') {
      const fw = it.fontW || it.fontH;
      const bw = it.blockW || 400;
      const bx = it.x || 0;
      z +=
        '^FO' + bx + ',' + it.y + '^FB' + bw + ',1,0,C^A0N,' + it.fontH + ',' + fw + '^FD' + zplText(it.text) + '^FS';
      // ZPL has no bold flag; double-draw at x+1 thickens strokes.
      if (it.bold)
        z +=
          '^FO' +
          (bx + 1) +
          ',' +
          it.y +
          '^FB' +
          bw +
          ',1,0,C^A0N,' +
          it.fontH +
          ',' +
          fw +
          '^FD' +
          zplText(it.text) +
          '^FS';
    } else if (it.type === 'qr') {
      // Reset label home immediately before QR to ensure ^FO works from true origin.
      z += '^LH0,0^FO' + it.x + ',' + it.y + '^BQN,2,' + (it.mag || 4) + '^FDMA,' + zplText(it.val) + '^FS';
    }
  }
  return z + '^XZ';
}

// Builds one preview cell as an SVG. Returns {cell, deferred} — insert cell
// into the DOM first, then call renderPreviewDeferred(deferred) to attach
// JsBarcode/QRCode content to the live nodes.
function buildPreviewCell(items) {
  const cell = document.createElement('div');
  cell.style.cssText =
    'position:relative;border:1px solid var(--c-border);border-radius:5px;background:#fff;overflow:hidden;aspect-ratio:5/3';
  const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
  svg.setAttribute('viewBox', '0 0 400 240');
  svg.setAttribute('xmlns', 'http://www.w3.org/2000/svg');
  svg.style.cssText = 'position:absolute;inset:0;width:100%;height:100%;display:block';
  cell.appendChild(svg);
  const deferred = [];
  for (const it of items) {
    if (it.type === 'barcode') {
      const inner = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
      inner.setAttribute('x', it.x);
      inner.setAttribute('y', it.y);
      inner.setAttribute('width', it.w);
      inner.setAttribute('height', it.h);
      svg.appendChild(inner);
      deferred.push({ kind: 'bc', el: inner, val: it.val, mw: it.mw, w: it.w, h: it.h });
    } else if (it.type === 'text') {
      const bw = it.blockW || 400;
      const cx = (it.x || 0) + bw / 2;
      // ZPL A0 font height ≈ character height; baseline ≈ 82% from top.
      const by = it.y + it.fontH * 0.82;
      const t = document.createElementNS('http://www.w3.org/2000/svg', 'text');
      t.setAttribute('x', cx);
      t.setAttribute('y', by);
      t.setAttribute('text-anchor', 'middle');
      t.setAttribute('font-family', 'Helvetica,Arial,sans-serif');
      t.setAttribute('font-size', it.fontH);
      t.setAttribute('fill', '#000');
      if (it.bold) t.setAttribute('font-weight', 'bold');
      t.textContent = it.text;
      svg.appendChild(t);
    } else if (it.type === 'qr') {
      // QR as HTML overlay positioned with % from ZPL coords (qrcode.js → img/canvas).
      const qrDiv = document.createElement('div');
      const L = ((it.x / 400) * 100).toFixed(2);
      const T = ((it.y / 240) * 100).toFixed(2);
      const W = ((it.size / 400) * 100).toFixed(2);
      qrDiv.style.cssText =
        'position:absolute;left:' + L + '%;top:' + T + '%;width:' + W + '%;aspect-ratio:1;background:#fff';
      cell.appendChild(qrDiv);
      deferred.push({ kind: 'qr', el: qrDiv, val: it.val });
    }
  }
  return { cell, deferred };
}

function renderPreviewDeferred(deferred, baseDelay) {
  baseDelay = baseDelay || 20;
  // P-02: JsBarcode + QRCode are lazy-loaded. Wait for them before rendering
  // any deferred items. The setTimeout chain that staggered rendering is
  // preserved; we just delay the whole chain until the libs land.
  if (typeof JsBarcode === 'undefined' || typeof QRCode === 'undefined') {
    loadVendorLibs().then(() => renderPreviewDeferred(deferred, baseDelay));
    return;
  }
  deferred.forEach((d, i) => {
    setTimeout(
      () => {
        if (d.kind === 'bc') {
          try {
            JsBarcode(d.el, d.val, {
              format: 'CODE128',
              width: d.mw,
              height: d.h,
              displayValue: false,
              margin: 0,
              background: '#fff',
              lineColor: '#000'
            });
            // JsBarcode rewrites width/height on the svg; capture those as a
            // viewBox and restore our (x,y,w,h) so bars stretch to our cell.
            const w = parseFloat(d.el.getAttribute('width')) || d.w;
            const h = parseFloat(d.el.getAttribute('height')) || d.h;
            d.el.setAttribute('viewBox', '0 0 ' + w + ' ' + h);
            d.el.setAttribute('width', d.w);
            d.el.setAttribute('height', d.h);
            d.el.setAttribute('preserveAspectRatio', 'none');
          } catch {}
        } else if (d.kind === 'qr') {
          try {
            new QRCode(d.el, {
              text: d.val,
              width: 64,
              height: 64,
              colorDark: '#000',
              colorLight: '#fff',
              correctLevel: QRCode.CorrectLevel.L
            });
            const img = d.el.querySelector('img') || d.el.querySelector('canvas');
            if (img) {
              img.style.cssText = 'display:block;width:100%;height:100%';
            }
          } catch {}
        }
      },
      baseDelay + i * 12
    );
  });
}

// detail levels for bag labels:
//   'minimal' — barcode + Line 1 (bag ID) only
//   'sorte'   — + Line 2 (Pilzsorte written out + notes)
//   'full'    — + Line 3 (Fälligkeit)
// No label carries a spelled-out type word. The only band one fitted in was the
// top edge, which this stock clips, and every ID already opens with its type
// (MC-/PD-/LC-/G-) — so it cost a row and told nobody anything.
// Batch size in the bottom-right corner. Which bag this is was already on the
// label — it is the ID's last segment — so only the total was missing: move 9
// of 10 and nothing said one was still out there. Set apart in its own corner
// rather than folded into a line of text, so it reads at arm's length.
// The slash is deliberate: a bare "10" next to bag …-06 invites being read as
// the bag number. "/10" cannot be.
const _BADGE = { w: 72, h: 30 };
function _bagTotalBadge(batch) {
  const total = (batch.bags || []).length;
  if (!total) return null;
  const x = 400 - _BADGE.w - 6; // 322
  const y = 240 - _BADGE.h - 8; // 202 → occupies 202..232
  return {
    x,
    y,
    h: _BADGE.h,
    items: [{ type: 'text', x, y, blockW: _BADGE.w, fontH: 28, text: '/' + total, bold: true }]
  };
}
// Width a centred text line may use. The bottom-right badge sits over the band
// the last line(s) occupy, so any line overlapping it vertically is narrowed to
// stop short — the text re-centres in the space left rather than running under
// the box. Lines clear of the badge keep the full width they always had.
function _lineBlockW(y, fontH, badge) {
  return badge && y < badge.y + badge.h && badge.y < y + fontH ? badge.x - 6 : 400;
}
// ─── Jede Zeile passt ────────────────────────────────────────
// Ein Textfeld auf dem Etikett ist ein ^FB-Block für eine Zeile, und der
// schneidet nichts ab: was nicht hineinpasst, bricht der Drucker um und druckt
// es ÜBER die Zeile. So stand der Stammcode mitten auf "Ganoderma", weil
// "Reishi – 2,0kg – Ganoderma multipileum KQ07" für eine Zeile zu lang war.
// Deshalb geht keine Zeile mehr zum Drucker, die nicht passt: sie wird hier
// gemessen, und was zu lang ist, kommt in die zweite Zeile. Eine Nummer wird
// stattdessen kleiner geschrieben, die liest man in einem Stück.
//
// Die Breiten sind die von Helvetica Bold, in Tausendsteln der Schriftbreite.
// Schrift 0 des Druckers (CG Triumvirate Bold Condensed), an diesem Etikett
// nachgemessen, ist bei Großbuchstaben so breit, bei Ziffern und
// Kleinbuchstaben schmaler; nur den Bindestrich zieht sie breiter, er steht mit
// 600. Dazu 5 % Luft in labelTextW(): was hier passt, passt auf dem Etikett.
// Ein Zeichen, das nicht in der Liste steht, zählt ganz breit.
//
// Dieser Block steht wortgleich in app.js und in mcp-server.js, die beide
// Etiketten drucken; test/etiketten-zeilen.test.js hält die zwei gleich.
const _LABEL_EM = [
  [" \u00a0,./\\|ijlI'\u00b7", 278],
  ['!():;[]ft', 333],
  ['r*{}', 389],
  ['z', 500],
  ['0123456789acekvsxyJ_#$"', 556],
  ['+<=>~', 584],
  ['-', 600],
  ['bdghnopquFLTZ?\u00df', 611],
  ['EPSVXY', 667],
  ['ABCDHKNRU&', 722],
  ['GOQw', 778],
  ['M', 833],
  ['m%', 889],
  ['W', 944],
  ['@', 975]
];
let _labelEmMap = null;
function labelTextW(text, fontW) {
  if (!_labelEmMap) {
    _labelEmMap = new Map();
    for (const [zeichen, breite] of _LABEL_EM) for (const c of zeichen) _labelEmMap.set(c, breite);
  }
  let em = 0;
  // Umlaute und Akzente zählen wie ihr Grundbuchstabe: ä wie a.
  for (const c of String(text)) em += _labelEmMap.get(c) || _labelEmMap.get(c.normalize('NFD')[0]) || 1000;
  return (em * fontW * 1.05) / 1000;
}
// Zeichen, die Schrift 0 nicht hat. Der Gedankenstrich zwischen "Reishi" und
// "2,0kg" kam auf demselben Etikett gar nicht erst heraus, an seiner Stelle
// stand eine Lücke. Ersetzt wird im Text der Zeile selbst und nicht erst beim
// Drucken: so misst labelTextW(), was gedruckt wird, und die Vorschau zeigt es.
const _LABEL_ERSATZ = {
  '\u2013': '-',
  '\u2014': '-',
  '\u2026': '...',
  '\u2190': '<-',
  '\u2192': '->',
  '\u2018': "'",
  '\u2019': "'",
  '\u201a': "'",
  '\u201c': '"',
  '\u201d': '"',
  '\u201e': '"'
};
function labelGlyphs(s) {
  return String(s || '').replace(
    /[\u2013\u2014\u2026\u2190\u2192\u2018-\u201a\u201c-\u201e]/g,
    (c) => _LABEL_ERSATZ[c]
  );
}
// Bricht `text` in höchstens `maxZeilen` Zeilen, keine breiter als `breite(i)`
// — wieviel Platz eine Zeile hat, hängt davon ab, wo sie steht, neben dem
// Zähler unten rechts ist es weniger. Umbrochen wird an Leerzeichen, ein Wort,
// das allein zu lang ist, hinter seinem letzten Bindestrich, der noch passt.
// Bleibt dann noch etwas übrig, endet die letzte Zeile mit "...", und das
// Ergebnis trägt `gekuerzt`.
//
// Der Gedankenstrich zwischen zwei Angaben steht nie am Anfang oder Ende einer
// Zeile, dort trennt schon der Umbruch. Ein geschütztes Leerzeichen hält
// zusammen, was zusammengehört ("<- PD-…"), und wird gedruckt wie ein normales.
function labelWrap(text, fontW, breite, maxZeilen) {
  const w = (s) => labelTextW(s, fontW);
  const rest = String(text || '')
    .split(' ')
    .filter(Boolean)
    .map((s) => ({ s: labelGlyphs(s).replace(/\u00a0/g, ' '), trenner: s === '\u2013' }));
  const alsZeile = (toks) => {
    let a = 0;
    let e = toks.length;
    while (a < e && toks[a].trenner) a++;
    while (e > a && toks[e - 1].trenner) e--;
    return toks
      .slice(a, e)
      .map((x) => x.s)
      .join(' ');
  };
  const zeilen = [];
  while (zeilen.length < maxZeilen) {
    while (rest.length && rest[0].trenner) rest.shift();
    if (!rest.length) break;
    const max = breite(zeilen.length);
    const toks = [];
    while (rest.length && w(alsZeile(toks.concat(rest[0]))) <= max) toks.push(rest.shift());
    if (!toks.length) {
      // Schon das erste Wort allein ist zu breit für die Zeile.
      const wort = rest[0].s;
      let n = Math.max(1, wort.length - 1);
      while (n > 1 && w(wort.slice(0, n)) > max) n--;
      const strich = wort.lastIndexOf('-', n - 1);
      if (strich > 0) n = strich + 1;
      toks.push({ s: wort.slice(0, n), trenner: false });
      if (n < wort.length) rest[0] = { s: wort.slice(n), trenner: false };
      else rest.shift();
    }
    zeilen.push(alsZeile(toks));
  }
  while (rest.length && rest[0].trenner) rest.shift();
  if (rest.length && zeilen.length) {
    // Lieber ein ganzes Wort weglassen als eines anschneiden. Angeschnitten wird
    // nur, was allein in der Zeile steht.
    const max = breite(zeilen.length - 1);
    const woerter = zeilen[zeilen.length - 1].split(' ');
    while (woerter.length > 1 && w(woerter.join(' ') + '...') > max) woerter.pop();
    let letzte = woerter.join(' ');
    while (letzte && w(letzte + '...') > max) letzte = letzte.slice(0, -1);
    zeilen[zeilen.length - 1] = letzte.replace(/[\s-]+$/, '') + '...';
    zeilen.gekuerzt = true;
  }
  return zeilen;
}
// Setzt Absätze untereinander, ab `y`. Ein Absatz ist { text, fontH, bold,
// maxZeilen, minH, kuerzbar }. Jede Zeile bekommt die Breite, die auf ihrer
// Höhe frei ist, und steht 4 Punkte unter der vorigen — die Abstände, die das
// Etikett immer hatte. Zurück kommen die Zeilen und die Unterkante der letzten.
//
// Mit minH ist der Absatz eine Nummer, und die liest man am besten in einem
// Stück: sie wird erst kleiner, bis minH, solange sie dann in eine Zeile
// passt. Passt sie auch so nicht, bekommt sie die größte Schrift, in der sie
// in ihren Zeilen ganz dasteht — umbrochen, aber nicht auch noch winzig.
function labelLines(absaetze, y, badge) {
  const items = [];
  let unten = y;
  for (const a of absaetze) {
    if (!a.text) continue;
    const setze = (h) => {
      const zeileY = (i) => y + i * (h + 4);
      const breite = (i) => _lineBlockW(zeileY(i), h, badge);
      const max = a.maxZeilen === undefined ? 1 : a.maxZeilen;
      return { h, zeileY, breite, zeilen: labelWrap(a.text, h, (i) => breite(i) - 6, max) };
    };
    let satz = null;
    if (a.minH) {
      const groessen = [];
      for (let h = a.fontH; h >= a.minH; h -= 2) groessen.push(h);
      const versuche = groessen.map(setze);
      satz =
        versuche.find((s) => s.zeilen.length === 1 && !s.zeilen.gekuerzt) ||
        versuche.find((s) => !s.zeilen.gekuerzt) ||
        versuche[versuche.length - 1];
    } else {
      satz = setze(a.fontH);
    }
    satz.zeilen.forEach((text, i) => {
      const item = { type: 'text', y: satz.zeileY(i), blockW: satz.breite(i), fontH: satz.h, text: text };
      if (a.bold) item.bold = true;
      items.push(item);
    });
    if (satz.zeilen.length) {
      unten = satz.zeileY(satz.zeilen.length - 1) + satz.h;
      y = unten + 4;
    }
  }
  return { items: items, unten: unten };
}
// Tiefer als die Unterkante des Zählers unten rechts (232) steht kein Text.
const LABEL_UNTEN = 234;
// Code und Zeilen zu einem Etikett. Passt der Text nicht unter den Code, wird
// ein kürzbarer Absatz — die Angaben zur Sorte — eine Zeile kürzer, und seine
// letzte endet mit "...". Reicht auch eine Zeile nicht (unter einem QR, neben
// einer Kultur mit langer Herkunft), fällt er ganz weg. Die Nummer und das
// Datum kürzt nichts.
function labelLayout(bcVal, qr, absaetze, badge) {
  let liste = absaetze;
  for (;;) {
    const versuch = qr ? _labelQr(bcVal, liste, badge) : _labelBarcode(bcVal, liste, badge);
    const i = liste.findIndex((a) => a.kuerzbar && a.maxZeilen > 0);
    if (versuch.passt || i < 0) return versuch.items;
    liste = liste.map((a, j) => (j === i ? Object.assign({}, a, { maxZeilen: a.maxZeilen - 1 }) : a));
  }
}
// Strichcode oben, die Zeilen darunter, das Ganze senkrecht mittig, aber nie
// über y=40: darüber schneidet dieses Material ab. Braucht der Text mehr Platz,
// als unter einem 90 Punkte hohen Code frei ist, gibt der Code Höhe ab, in
// Schritten bis 60 — 7,5 mm liest jede Kamera noch.
function _labelBarcode(bcVal, absaetze, badge) {
  const bc = bcParams(bcVal);
  const hoehe = labelLines(absaetze, 0, null).unten;
  let versuch = null;
  for (let bcH = 90; bcH >= 60; bcH -= 6) {
    const bcY = Math.max(40, Math.round((240 - (bcH + 6 + hoehe)) / 2));
    const text = labelLines(absaetze, bcY + bcH + 6, badge);
    const code = { type: 'barcode', x: bc.x, y: bcY, w: 400 - 2 * bc.x, h: bcH, val: bcVal, mw: bc.mw };
    versuch = { passt: text.unten <= LABEL_UNTEN, items: [code].concat(text.items) };
    if (versuch.passt) break;
  }
  return versuch;
}
// QR oben links, mag 5 → 125 Punkte (25 Module), die Zeilen darunter über die
// ganze Breite.
function _labelQr(bcVal, absaetze, badge) {
  const text = labelLines(absaetze, 155, badge);
  const code = { type: 'qr', x: 0, y: 10, size: 125, mag: 5, val: bcVal };
  return { passt: text.unten <= 240, items: [code].concat(text.items) };
}
// Was auf dem Beutel steht, wenn man sein Gewicht draufschreibt: 1 → "1kg",
// 2.5 → "2,5kg". Der Punkt ist eine Programmiersprache, das Etikett liest ein
// Mensch in einer deutschen Halle.
function labelKg(kg) {
  return String(Math.round(kg * 1000) / 1000).replace('.', ',') + 'kg';
}
// Das Gewicht EINES Beutels, so wie das Etikett es braucht.
//
// bagWeights kommt aus db.js und ist immer gefüllt (bag_kg der Zeile, sonst das
// der Charge). Vorher wurde es nur weitergereicht, wenn eine Charge GEMISCHTE
// Größen trug — die Idee war, nichts zu drucken, was ohnehin für alle gilt. Nur
// steht der Beutel später allein im Regal, und dann gilt für ihn gar nichts
// mehr: 1 kg und 2 kg Körnerbrut sind zwei verschiedene Dinge, und welches man
// in der Hand hält, sagte das Etikett nur in der einen Hälfte der Fälle.
function bagLabelKg(batch, bagId) {
  const w = batch && batch.bagWeights ? batch.bagWeights[bagId] : null;
  if (Number.isFinite(w) && w > 0) return w;
  return Number.isFinite(batch && batch.bagKg) && batch.bagKg > 0 ? batch.bagKg : null;
}
function bagLabelItems(bagId, batch, detail, _legacyFallbackIds, qr, bagKg) {
  // Numeric barcode: lookup from barcode registry, fall back to legacy encoding
  const numBc = barcodeByEntity.get('bag:' + bagId);
  let bcVal;
  if (numBc) {
    bcVal = String(numBc);
  } else {
    // Legacy fallback for bags without barcode assignment
    if (_legacyFallbackIds) _legacyFallbackIds.push(bagId);
    const isGrain = batch.batchType === 'grain';
    const parts = bagId.split('-');
    if (parts.length === 4) {
      const kz = (batch.strainKuerzel || batch.strain || 'BAGX').toUpperCase();
      const mmdd = parts[1].slice(2, 4) + parts[1].slice(0, 2);
      const bagNum = parseInt(parts[3], 10);
      bcVal = (isGrain ? 'G' : '') + kz + '_' + mmdd + '_' + bagNum;
    } else {
      bcVal = bagId.replace(/-/g, '_');
    }
  }
  // Bag labels carry no type word. Grainspawn had one, but the ID already opens
  // with G- and the top of the label is where this printer clips, so it cost a
  // line and printed cut off. Cultures keep theirs (see labLabelItems).
  const _badge = _bagTotalBadge(batch);
  const items = _badge ? _badge.items.slice() : [];
  // Von oben nach unten: die Nummer des Beutels — lieber kleiner als
  // umbrochen, sie muss ganz dastehen —, die Angaben zur Sorte, bis zwei
  // Zeilen, und bei "Vollständig" die Daten. Wo was steht, rechnet
  // labelLayout() aus: QR oben links und der Text darunter, oder der
  // Strichcode oben und alles senkrecht mittig.
  const absaetze = [{ text: bagId, fontH: qr ? 28 : 24, minH: 18, maxZeilen: 2 }];
  if (detail === 'sorte' || detail === 'full') {
    const species = batch.strainName || batch.species || '';
    const strainTxt = (batch.strainText || '').trim();
    const rawNotes = (batch.notes || '').trim();
    const notes = rawNotes.length > 13 ? rawNotes.slice(0, 13) + '\u2026' : rawNotes;
    const parts = [species];
    if (bagKg != null) parts.push(labelKg(bagKg));
    if (strainTxt) parts.push(strainTxt);
    if (notes) parts.push(notes);
    absaetze.push({ text: parts.filter(Boolean).join(' \u2013 '), fontH: 24, maxZeilen: 2, kuerzbar: true });
  }
  if (detail === 'full' && batch.due) {
    const daten = (batch.created ? fmtDt(batch.created) + ' - ' : '') + fmtDt(batch.due);
    absaetze.push({ text: daten, fontH: qr ? 24 : 28, minH: 18, bold: true });
  }
  return items.concat(labelLayout(bcVal, qr, absaetze, _badge));
}

function labLabelItems(id, c, detail, qr) {
  // Build info line matching batch label pattern: strainName – strainText – notes(13)
  const species = c.strainName || c.species || '';
  const strainTxt = (c.strainText || '').trim();
  const rawNotes = (c.notes || '').trim();
  const notes = rawNotes.length > 13 ? rawNotes.slice(0, 13) + '\u2026' : rawNotes;
  const spParts = [species];
  // Die Größe gleich hinter der Sorte: beim Packen ist sie, was man sucht.
  if (c.type === 'SY') spParts.push(syMl(c) + ' ml');
  // Ein Beutel Dübel sieht aus wie jeder andere Beutel: das Wort sagt, was drin ist.
  if (c.type === 'DU') spParts.push(c.stueck ? t('label.duebelCa', { n: c.stueck }) : t('label.duebel'));
  if (strainTxt) spParts.push(strainTxt);
  if (notes) spParts.push(notes);
  // Numeric barcode: lookup from registry, fall back to legacy encoding
  const numBc = barcodeByEntity.get('culture:' + id);
  const bcVal = numBc ? String(numBc) : id.replace(/-/g, '_');
  // No type word: the ID already opens with MC-/PD-/LC-, and the only place one
  // fitted was the top edge, which this label stock clips.
  //
  // Die Herkunft hängt mit einem geschützten Leerzeichen an ihrem Pfeil: muss
  // die erste Zeile umbrechen, steht "<- PD-…" zusammen in der zweiten.
  const absaetze = [
    { text: c.parentId ? id + ' \u2190\u00a0' + c.parentId : id, fontH: qr ? 28 : 24, minH: 18, maxZeilen: 2 }
  ];
  if (detail === 'sorte' || detail === 'full') {
    absaetze.push({ text: spParts.filter(Boolean).join(' \u2013 '), fontH: 24, maxZeilen: 2, kuerzbar: true });
  }
  if (detail === 'full' && c.created) {
    absaetze.push({ text: fmtDt(c.created), fontH: qr ? 24 : 28, minH: 18, bold: true });
  }
  return labelLayout(bcVal, qr, absaetze, null);
}

// Vor dem Drucken: kennt dieses Telefon für einen Beutel die siebenstellige
// Nummer nicht, erst den Stand vom Server holen. Der Server vergibt sie beim
// Anlegen jedem Beutel; fehlt sie hier, ist nur die Liste auf dem Telefon alt
// (das Nachladen nach dem Anlegen kann still scheitern). Ohne diesen Schritt
// ging das Etikett mit dem alten Text-Strichcode hinaus, und der fand den
// Beutel beim Scannen nicht wieder.
async function ensureBagBarcodes(bags) {
  if ((bags || []).every((id) => barcodeByEntity.has('bag:' + id))) return;
  await loadData();
}

function makeBagZPL(bags, batch, detail, qr) {
  const legacyFallbackIds = [];
  const zpl = bags
    .map((bagId) =>
      itemsToZPL(bagLabelItems(bagId, batch, detail, legacyFallbackIds, qr, bagLabelKg(batch, bagId)))
    )
    .join('\n');
  if (legacyFallbackIds.length) {
    console.warn('makeBagZPL: numeric barcodes not found for bags, used legacy fallback:', legacyFallbackIds);
    toast(t('print.warnNumericBarcodes', { list: legacyFallbackIds.join(', ') }), 'err');
  }
  return zpl;
}

function makeLabZPL(ids, detail, qr) {
  return ids
    .map((id) => {
      const c = cultures.find((x) => x.id === id);
      return c ? itemsToZPL(labLabelItems(id, c, detail, qr)) : '';
    })
    .filter(Boolean)
    .join('\n');
}

function toggleBagRange() {
  document.getElementById('bag-range-inputs').style.display =
    document.getElementById('print-range').value === 'range' ? 'inline-flex' : 'none';
}

async function printBagLabels() {
  const b = batches.find((x) => x.batchId === document.getElementById('print-batch').value);
  if (!b) {
    toast(t('print.selectBatchFirst'), 'err');
    return;
  }
  let bags = b.bags;
  if (document.getElementById('print-range').value === 'range') {
    const from = parseInt(document.getElementById('bag-from').value) || 1;
    const to = parseInt(document.getElementById('bag-to').value) || b.bags.length;
    bags = b.bags.filter((bagId) => {
      const n = parseInt(bagId.split('-').pop());
      return n >= from && n <= to;
    });
    if (!bags.length) {
      toast(t('print.noBagsInRange'), 'err');
      return;
    }
  }
  await ensureBagBarcodes(bags);
  const zpl = makeBagZPL(
    bags,
    b,
    document.getElementById('print-mode').value,
    document.getElementById('bag-qr').checked
  );
  if (!zpl || !zpl.includes('^XA')) {
    toast(t('print.noLabels'), 'err');
    return;
  }
  const err = await sendToPrinter(zpl);
  if (err) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = b.batchId + '_labels.zpl';
    a.click();
  } else {
    // Stand als englischer Satz im Code, in einer App, die drei Sprachen
    // spricht — und es ist dieselbe Meldung, die der andere Beutel-Druckweg
    // längst übersetzt ausgibt.
    printedFb(t('print.printedBatch', { n: bags.length, id: b.batchId }));
  }
}

async function printLabLabels() {
  const ids = [...selectedLabIds];
  if (!ids.length) {
    toast(t('print.selectCulture'), 'err');
    return;
  }
  const zpl = makeLabZPL(ids, document.getElementById('lab-mode').value, document.getElementById('lab-qr').checked);
  if (!zpl || !zpl.includes('^XA')) {
    toast(t('print.noLabels'), 'err');
    return;
  }
  const err = await sendToPrinter(zpl);
  if (err) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = 'lab_labels.zpl';
    a.click();
  } else {
    printedFb(t('print.printedLab', { n: ids.length }));
  }
}

async function quickPrintCulture(id) {
  const zpl = makeLabZPL([id], 'full', false);
  const err = await sendToPrinter(zpl);
  if (err) {
    // fallback: download ZPL
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = id + '_label.zpl';
    a.click();
  }
}

async function sendToPrinter(zpl) {
  try {
    const r = await authFetch('/api/print', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ zpl })
    });
    const d = await r.json();
    if (d.ok) return null;
    refreshPrinterStatus();
    return d.error || 'Print failed';
  } catch (e) {
    refreshPrinterStatus();
    return 'Could not reach server: ' + e.message;
  }
}

// Reflect /api/printer-status into the Print-tab status banner. Called when
// the page is opened, when the banner is clicked, and after each print
// attempt so the user sees if the bridge / printer state changed.
const PRINTER_STATUS_STYLES = {
  online: {
    key: 'print.status.online',
    bg: 'var(--c-primary-light)',
    border: 'var(--c-green-border)',
    color: 'var(--c-green-dark)'
  },
  printer_offline: { key: 'print.status.printerOffline', bg: '#fef3c7', border: '#fbbf24', color: '#92400e' },
  bridge_unreachable: { key: 'print.status.bridgeUnreachable', bg: '#fee2e2', border: '#fca5a5', color: '#991b1b' },
  no_bridge: { key: 'print.status.noBridge', bg: '#dbeafe', border: '#93c5fd', color: '#1e40af' },
  local_unavailable: { key: 'print.status.localUnavailable', bg: '#fee2e2', border: '#fca5a5', color: '#991b1b' }
};
async function refreshPrinterStatus() {
  const banner = document.getElementById('printer-status-banner');
  const text = document.getElementById('printer-status-text');
  const detail = document.getElementById('printer-status-detail');
  if (!banner || !text) return;
  let payload;
  try {
    const r = await authFetch('/api/printer-status');
    payload = await r.json();
  } catch (e) {
    text.textContent = t('print.status.checkFailed');
    if (detail) detail.textContent = e.message || '';
    return;
  }
  const style = PRINTER_STATUS_STYLES[payload.state] || PRINTER_STATUS_STYLES.printer_offline;
  banner.style.background = style.bg;
  banner.style.borderColor = style.border;
  text.style.color = style.color;
  text.textContent = t(style.key, { name: payload.name || '' });
  if (detail) detail.textContent = payload.error || '';
}

// ── Settings → Drucker tab ──────────────────────────────────────────────
async function renderPrinterSettings() {
  const platformEl = document.getElementById('printer-cfg-platform');
  const nameEl = document.getElementById('printer-cfg-printername');
  const sourceEl = document.getElementById('printer-cfg-source');
  const enabledEl = document.getElementById('printer-bridge-enabled');
  const urlEl = document.getElementById('printer-bridge-url');
  const tokenEl = document.getElementById('printer-bridge-token');
  if (!platformEl) return;
  let cfg;
  try {
    const r = await authFetch('/api/printer/config');
    cfg = await r.json();
  } catch (e) {
    setPrinterCfgStatus('error', e.message || 'Failed to load printer config');
    return;
  }
  platformEl.textContent = cfg.platform || '—';
  nameEl.textContent = cfg.printerName || '—';
  const sourceKey =
    cfg.bridge.effectiveSource === 'db'
      ? 'printer.sourceDb'
      : cfg.bridge.effectiveSource === 'env'
        ? 'printer.sourceEnv'
        : 'printer.sourceNone';
  sourceEl.textContent = t(sourceKey);
  enabledEl.checked = !!cfg.bridge.enabled;
  urlEl.value = cfg.bridge.url || '';
  tokenEl.value = '';
  tokenEl.placeholder = cfg.bridge.hasToken ? '••••• ' + t('printer.tokenPlaceholder') : t('printer.tokenPlaceholder');
}

function setPrinterCfgStatus(kind, msg) {
  const el = document.getElementById('printer-cfg-status');
  if (!el) return;
  el.style.display = msg ? 'block' : 'none';
  el.textContent = msg || '';
  if (kind === 'ok') {
    el.style.background = 'var(--c-primary-light)';
    el.style.color = 'var(--c-green-dark)';
    el.style.border = '1px solid var(--c-green-border)';
  } else if (kind === 'error') {
    el.style.background = '#fee2e2';
    el.style.color = '#991b1b';
    el.style.border = '1px solid #fca5a5';
  }
}

async function savePrinterSettings() {
  const enabled = document.getElementById('printer-bridge-enabled').checked;
  const url = document.getElementById('printer-bridge-url').value.trim();
  const tokenInput = document.getElementById('printer-bridge-token').value;
  const body = { enabled, url };
  // Only send token field if user typed something — otherwise the server
  // would clear the existing token.
  if (tokenInput.length > 0) body.token = tokenInput;
  try {
    const r = await authFetch('/api/printer/config', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify(body)
    });
    if (!r.ok) {
      const err = await r.json().catch(() => ({}));
      setPrinterCfgStatus('error', err.error || 'Save failed');
      return;
    }
    setPrinterCfgStatus('ok', t('printer.saved'));
    await renderPrinterSettings();
    refreshPrinterStatus();
  } catch (e) {
    setPrinterCfgStatus('error', e.message);
  }
}

async function testPrintBridge() {
  setPrinterCfgStatus('', '');
  try {
    const r = await authFetch('/api/printer/test', { method: 'POST' });
    const d = await r.json();
    if (r.ok && d.ok) {
      setPrinterCfgStatus('ok', t('printer.testOk'));
    } else {
      setPrinterCfgStatus('error', t('printer.testFail', { err: d.error || 'Unknown error' }));
    }
    refreshPrinterStatus();
  } catch (e) {
    setPrinterCfgStatus('error', t('printer.testFail', { err: e.message }));
  }
}

async function downloadBridgeScript() {
  try {
    const r = await authFetch('/api/printer/bridge-script');
    if (!r.ok) {
      const err = await r.json().catch(() => ({}));
      setPrinterCfgStatus('error', t('printer.downloadFailed', { err: err.error || 'HTTP ' + r.status }));
      return;
    }
    const text = await r.text();
    const blob = new Blob([text], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = 'print-bridge.ps1';
    a.click();
    URL.revokeObjectURL(a.href);
  } catch (e) {
    setPrinterCfgStatus('error', t('printer.downloadFailed', { err: e.message }));
  }
}

function copyToClipboardWithFeedback(text, btn) {
  const restore = btn.textContent;
  navigator.clipboard
    .writeText(text)
    .then(() => {
      btn.textContent = t('printer.copied');
      setTimeout(() => {
        btn.textContent = restore;
      }, 1200);
    })
    .catch(() => {
      btn.textContent = '!';
      setTimeout(() => {
        btn.textContent = restore;
      }, 1200);
    });
}

function batchOptionLabel(b) {
  const kz = b.strainKuerzel || b.strain || '';
  const name = b.strainName || b.species || '';
  const st = (b.strainText || '').trim();
  return (kz ? '[' + esc(kz) + '] ' : '') + esc(b.batchId) + ' — ' + esc(name) + (st ? ' ' + esc(st) : '');
}
function fillBatchSelect(filter) {
  const s = document.getElementById('print-batch');
  const cur = s.value;
  const searchInput = document.getElementById('print-batch-search');
  const q = (filter != null ? filter : searchInput ? searchInput.value : '').toLowerCase().trim();
  // Newest first; when no search, limit to 50 most recent
  let list = [...batches].reverse();
  if (q) {
    list = list.filter((b) => batchOptionLabel(b).toLowerCase().includes(q));
  } else {
    list = list.slice(0, 50);
  }
  s.innerHTML =
    '<option value="">— ' +
    t('print.chooseBatch') +
    ' —</option>' +
    list.map((b) => `<option value="${esc(b.batchId)}">${batchOptionLabel(b)}</option>`).join('');
  if (cur) s.value = cur;
}

function renderBagPreview() {
  const id = document.getElementById('print-batch').value;
  const el = document.getElementById('bag-preview');
  const mode = document.getElementById('print-mode').value;
  const qr = document.getElementById('bag-qr').checked;
  if (!id) {
    el.innerHTML = '<div class="empty">' + t('print.selectBatchAbove') + '</div>';
    return;
  }
  const batch = batches.find((b) => b.batchId === id);
  if (!batch) return;
  const wrap = document.createElement('div');
  wrap.style.cssText = 'display:grid;grid-template-columns:repeat(4,minmax(0,1fr));gap:6px';
  const allDeferred = [];
  batch.bags.forEach((bagId) => {
    const bk = bagLabelKg(batch, bagId);
    const { cell, deferred } = buildPreviewCell(bagLabelItems(bagId, batch, mode, null, qr, bk));
    wrap.appendChild(cell);
    allDeferred.push(...deferred);
  });
  el.innerHTML = '';
  el.appendChild(wrap);
  renderPreviewDeferred(allDeferred, 30);
}

let selectedLabIds = new Set();
let lastCreatedCultureIds = [];
// Die Speicherung, auf die das Fenster wartet, bevor es druckt: die Nummern-
// Barcodes kommen mit der Antwort des Servers, und ein Etikett, das vorher
// gedruckt wird, trägt die alte Kodierung aus der ID (siehe labLabelItems).
let _cprSaved = null;
function goToPrintLabCulture() {
  selectedLabIds = new Set(lastCreatedCultureIds);
  go('print', 'n-print');
  setTimeout(() => {
    openStab('print', 'lab');
    renderLabList();
    renderLabPreview();
  }, 150);
}
// Der Schluss jedes Weges, der Kulturen anlegt: das Etiketten-Fenster — was
// nbPlaceAndPrint() für Beutel ist, ohne die Zonenwahl davor, weil eine Kultur
// keinen Standort hat. Kommt von selbst hoch, egal wo man steht; die Seite mit
// dem langen Formular ist seit dem Schnelldialog nur noch dessen Ablage.
// korn: { batchObj, bagIds, saved } — Körnerbeutel, die mit diesen Kulturen
// entstanden und schon eingelagert sind. Ihre Etiketten gehen im selben Druck
// mit (etikettenFuerAlles).
let _cprKorn = null;
function cprShow(ids, saved, korn) {
  lastCreatedCultureIds = ids.slice();
  _cprSaved = saved || null;
  _cprKorn = korn || null;
  const beutel = korn ? korn.bagIds : [];
  const head = document.getElementById('cpr-head');
  if (head)
    head.textContent = beutel.length
      ? t('lab.printForAll', { n: ids.length + beutel.length, kulturen: ids.length, beutel: beutel.length })
      : t('lab.printFor', { n: ids.length });
  const titel = document.getElementById('cpr-ids-title');
  if (titel) titel.textContent = t(beutel.length ? 'lab.createdIdsAll' : 'lab.createdIds');
  const knopf = document.getElementById('prt-cpr');
  if (knopf) knopf.textContent = t(beutel.length ? 'lab.printAllNow' : 'lab.printLabelsNow');
  const list = document.getElementById('cpr-ids');
  if (list)
    list.innerHTML = ids
      .concat(beutel)
      .map(
        (id) =>
          `<span class="fs-micro" style="font-family:monospace;background:var(--c-bg);padding:2px 6px;border-radius:4px;color:var(--c-text-sec)">${esc(id)}</span>`
      )
      .join('');
  const m = document.getElementById('m-culture-print');
  if (m) m.classList.add('open');
}
function cprClose() {
  const m = document.getElementById('m-culture-print');
  if (m) m.classList.remove('open');
}
// Der Schluss, wenn Kulturen und Körnerbrut zusammen entstehen (Mehrere,
// Beimpfen): erst die Körnerbeutel einlagern — die Zonenwahl ist ein Tor wie
// bei jeder Charge —, dann ein Etiketten-Fenster für alles und ein Druck.
// Vorher kamen zwei Fenster nacheinander, jedes mit seinem eigenen Druck.
function etikettenFuerAlles(ids, saved, korn) {
  if (korn && !ids.length) return nbPlaceAndPrint(korn.batchObj, korn.bagIds);
  if (!korn) {
    if (ids.length) cprShow(ids, saved);
    return;
  }
  openZonePickModal(korn.batchObj, korn.bagIds, () => cprShow(ids, saved, korn));
}
async function printCultureLabelsInline() {
  const ids = lastCreatedCultureIds;
  if (!ids.length) {
    toast(t('print.selectCulture'), 'err');
    return;
  }
  // Ein schneller Daumen schlägt sonst die Antwort des Servers: erst speichern
  // lassen, dann drucken. Schlägt das Speichern fehl, gibt es die Kultur nicht —
  // dann kein Etikett: eins am Glas hieße beim nächsten Scan "nicht im System".
  // Was schiefging, hat logLabWork schon gesagt.
  if (_cprSaved && !(await _cprSaved.then(() => true).catch(() => false))) return;
  const modeEl = document.getElementById('lab-mode');
  const qrEl = document.getElementById('lab-qr');
  let zpl = makeLabZPL(ids, modeEl ? modeEl.value : 'sorte', !!(qrEl && qrEl.checked));
  // Die Körnerbeutel im selben Druck, mit den Einstellungen der Beutel-Etiketten.
  // Ihre Nummern kommen mit der Antwort auf die Charge; ist die fehlgeschlagen
  // (gemeldet hat es createGrainBatch), gibt es die Beutel nicht, und gedruckt
  // werden nur die Kulturen.
  const korn = _cprKorn;
  let n = ids.length;
  if (korn) {
    if (korn.saved) await korn.saved.catch(() => {});
    const b = batches.find((x) => x.batchId === korn.batchObj.batchId);
    if (b) {
      const pm = document.getElementById('print-mode');
      const bq = document.getElementById('bag-qr');
      await ensureBagBarcodes(korn.bagIds);
      zpl += '\n' + makeBagZPL(korn.bagIds, b, pm ? pm.value : 'full', bq ? bq.checked : true);
      n += korn.bagIds.length;
    }
  }
  if (!zpl || !zpl.includes('^XA')) {
    toast(t('print.noLabels'), 'err');
    return;
  }
  const err = await sendToPrinter(zpl);
  if (err) {
    const blob = new Blob([zpl], { type: 'text/plain' });
    const a = document.createElement('a');
    a.href = URL.createObjectURL(blob);
    a.download = 'lab_labels.zpl';
    a.click();
  } else {
    printedFb(korn ? t('print.printedAll', { n }) : t('print.printedLab', { n: ids.length }));
    cprClose();
  }
}
function renderLabList() {
  const filter = document.getElementById('lab-filter').value,
    el = document.getElementById('lab-list'),
    today = todayStr();
  const rows = cultures
    .filter((c) => {
      if (filter === 'all') return c.status === 'active' || c.status === 'stored';
      if (filter === 'today') {
        const d = new Date(c.created);
        // Must match todayStr()'s DDMMYY order — building YYMMDD here made the
        // "today" filter match only when day-of-month equalled the 2-digit year.
        return (
          String(d.getDate()).padStart(2, '0') +
            String(d.getMonth() + 1).padStart(2, '0') +
            String(d.getFullYear()).slice(2) ===
          today
        );
      }
      return c.type === filter;
    })
    .sort((a, b) => b.created.localeCompare(a.created));
  el.innerHTML = rows.length
    ? rows
        .map(
          (c) =>
            `<label class="fs-meta" style="display:flex;align-items:center;gap:7px;padding:4px 0;cursor:pointer;border-bottom:0.5px solid #f0ede8"><input type="checkbox" ${selectedLabIds.has(c.id) ? 'checked' : ''} onchange="toggleLabId('${esc(c.id)}',this.checked)" style="width:14px;height:14px;margin:0" /><span style="font-family:monospace;font-weight:500">${esc(c.id)}</span><span class="badge ${c.type === 'MC' ? 'badge-mc' : c.type === 'PD' ? 'badge-pd' : 'badge-lc'}">${esc(c.type)}</span><span style="color:var(--c-text-muted)">${esc(c.species)}${c.strain ? ' / ' + esc(c.strain) : ''}</span></label>`
        )
        .join('')
    : '<div class="fs-meta" style="color:var(--c-text-muted);padding:6px">No cultures match.</div>';
}
function toggleLabId(id, on) {
  if (on) selectedLabIds.add(id);
  else selectedLabIds.delete(id);
  renderLabPreview();
}
function renderLabPreview() {
  const el = document.getElementById('lab-preview');
  const ids = [...selectedLabIds];
  if (!ids.length) {
    el.innerHTML = '<div class="empty">' + t('print.tickCulturesPreview') + '</div>';
    return;
  }
  const detail = document.getElementById('lab-mode').value;
  const qr = document.getElementById('lab-qr').checked;
  const wrap = document.createElement('div');
  wrap.style.cssText = 'display:grid;grid-template-columns:repeat(3,minmax(0,1fr));gap:8px';
  const allDeferred = [];
  ids.forEach((id) => {
    const c = cultures.find((x) => x.id === id);
    if (!c) return;
    const { cell, deferred } = buildPreviewCell(labLabelItems(id, c, detail, qr));
    wrap.appendChild(cell);
    allDeferred.push(...deferred);
  });
  el.innerHTML = '';
  el.appendChild(wrap);
  renderPreviewDeferred(allDeferred, 30);
}

// ─── REF BARCODES ────────────────────────────────────────────
async function makeQR(val) {
  // P-02: QRCode is lazy-loaded.
  if (typeof QRCode === 'undefined') await loadVendorLibs();
  return new Promise((resolve) => {
    const div = document.createElement('div');
    div.style.cssText = 'display:inline-block';
    try {
      new QRCode(div, {
        text: val,
        width: 120,
        height: 120,
        colorDark: '#000',
        colorLight: '#fff',
        correctLevel: QRCode.CorrectLevel.L
      });
      setTimeout(() => {
        const img = div.querySelector('img') || div.querySelector('canvas');
        if (img) {
          img.style.cssText = 'display:block;width:100%;height:auto';
          resolve(img);
        } else resolve(null);
      }, 100);
    } catch {
      resolve(null);
    }
  });
}

async function renderRefBarcodes() {
  // P-02: JsBarcode + QRCode are lazy-loaded.
  if (typeof JsBarcode === 'undefined' || typeof QRCode === 'undefined') await loadVendorLibs();
  const grid = document.getElementById('ref-grid');
  grid.innerHTML = '';
  const useQR = document.getElementById('ref-qr').checked;
  for (const group of REF_GROUPS) {
    const card = document.createElement('div');
    card.className = 'card';
    card.innerHTML = `<div class="sec">${group.g}</div>`;
    const row = document.createElement('div');
    row.style.cssText = 'display:flex;flex-wrap:wrap;gap:20px;margin-top:12px;align-items:flex-end';
    for (const item of group.items) {
      const val = item.val,
        label = item.label;
      const cell = document.createElement('div');
      cell.className = 'bc-cell';
      cell.style.cssText =
        'min-width:140px;text-align:center;padding:8px 12px;border:1px solid var(--c-border);border-radius:6px;background:var(--c-surface)';
      if (useQR) {
        const img = await makeQR(val);
        if (img) cell.appendChild(img);
        const lbl = document.createElement('div');
        lbl.className = 'fs-meta';
        lbl.style.cssText = 'font-weight:700;color:var(--c-text-sec);margin-top:5px';
        lbl.textContent = label;
        cell.appendChild(lbl);
      } else {
        const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
        svg.style.cssText = 'display:block';
        cell.appendChild(svg);
        setTimeout(() => {
          try {
            JsBarcode(svg, val, {
              format: 'CODE128',
              width: 2,
              height: 60,
              displayValue: false,
              margin: 14,
              background: '#fff',
              lineColor: '#000'
            });
          } catch {}
        }, 20);
        const lbl = document.createElement('div');
        lbl.className = 'fs-meta';
        lbl.style.cssText = 'font-weight:700;color:var(--c-text-sec);margin-top:5px;text-align:center';
        lbl.textContent = label;
        cell.appendChild(lbl);
      }
      row.appendChild(cell);
    }
    card.appendChild(row);
    grid.appendChild(card);
  }
}
async function printRef() {
  // P-02: JsBarcode + QRCode are lazy-loaded.
  if (typeof JsBarcode === 'undefined' || typeof QRCode === 'undefined') await loadVendorLibs();
  const sheet = document.getElementById('ref-print-sheet');
  sheet.innerHTML = '';
  const useQR = document.getElementById('ref-qr').checked;
  const title = document.createElement('div');
  // px-auf-papier: this is a printed sheet, and 15px there is a sixth of an
  // inch of paper. A rem would follow the reader's browser setting and change
  // how much fits on the page, which is not what a browser setting is for.
  title.style.cssText = 'font-family:Arial,sans-serif;font-size:15px;font-weight:bold;margin-bottom:12px;padding:8px';
  title.textContent = 'Reference ' + (useQR ? 'QR Codes' : 'Barcodes');
  sheet.appendChild(title);
  let delay = 0;
  for (const group of REF_GROUPS) {
    const sec = document.createElement('div');
    sec.className = 'fs-micro';
    sec.style.cssText =
      'font-family:Arial,sans-serif;font-weight:bold;text-transform:uppercase;letter-spacing:.08em;color:var(--c-text-muted);margin:14px 8px 8px';
    sec.textContent = group.g;
    sheet.appendChild(sec);
    const row = document.createElement('div');
    row.style.cssText = 'display:flex;flex-wrap:wrap;gap:20px;padding:0 8px';
    for (const item of group.items) {
      const val = item.val,
        label = item.label;
      const cell = document.createElement('div');
      cell.style.cssText =
        'border:1px solid var(--c-border);border-radius:6px;padding:12px 16px;text-align:center;background:var(--c-surface);page-break-inside:avoid';
      if (useQR) {
        const img = await makeQR(val);
        if (img) {
          img.style.width = '90px';
          img.style.height = '90px';
          cell.appendChild(img);
        }
        const lbl = document.createElement('div');
        lbl.className = 'fs-xs';
        lbl.style.cssText = 'font-weight:bold;font-family:Arial,sans-serif;margin-top:5px';
        lbl.textContent = label;
        cell.appendChild(lbl);
      } else {
        const svg = document.createElementNS('http://www.w3.org/2000/svg', 'svg');
        cell.appendChild(svg);
        setTimeout(() => {
          try {
            JsBarcode(svg, val, {
              format: 'CODE128',
              width: 2,
              height: 60,
              displayValue: false,
              margin: 14,
              background: '#fff',
              lineColor: '#000'
            });
          } catch {}
        }, delay);
        delay += 25;
        const lbl = document.createElement('div');
        lbl.className = 'fs-xs';
        lbl.style.cssText = 'font-weight:bold;font-family:Arial,sans-serif;margin-top:5px';
        lbl.textContent = label;
        cell.appendChild(lbl);
      }
      row.appendChild(cell);
    }
    sheet.appendChild(row);
  }
  setTimeout(() => window.print(), useQR ? 800 : delay + 200);
}

// ─── GLOBAL SCAN ENGINE ──────────────────────────────────────
// Session tracking
let sessionEntries = [];
let sessionStartTime = null;
let sessionErrors = 0;
let _lastScanVal = null;
// Audio feedback
let _scanAudioCtx = null;
let scanAudioEnabled = true;
// iOS requires AudioContext creation during a user gesture; call this from gesture handlers
function _initScanAudio() {
  if (!_scanAudioCtx) {
    try {
      _scanAudioCtx = new (window.AudioContext || window.webkitAudioContext)();
    } catch {}
  }
  if (_scanAudioCtx && _scanAudioCtx.state === 'suspended') _scanAudioCtx.resume().catch(function () {});
}
function _scanBeep(freq, dur) {
  if (!scanAudioEnabled) return;
  try {
    _initScanAudio();
    if (!_scanAudioCtx) return;
    const o = _scanAudioCtx.createOscillator();
    const g = _scanAudioCtx.createGain();
    o.connect(g);
    g.connect(_scanAudioCtx.destination);
    o.frequency.value = freq;
    g.gain.value = 0.15;
    o.start();
    g.gain.exponentialRampToValueAtTime(0.001, _scanAudioCtx.currentTime + dur / 1000);
    o.stop(_scanAudioCtx.currentTime + dur / 1000);
  } catch {}
}
// Pleasant success chirp: 880Hz sine, 120ms with soft attack/release envelope
function _scanBeepOk() {
  if (!scanAudioEnabled) return;
  try {
    _initScanAudio();
    if (!_scanAudioCtx) return;
    const ctx = _scanAudioCtx;
    const now = ctx.currentTime;
    const o = ctx.createOscillator();
    const g = ctx.createGain();
    o.type = 'sine';
    o.frequency.setValueAtTime(880, now);
    o.connect(g);
    g.connect(ctx.destination);
    g.gain.setValueAtTime(0.0001, now);
    g.gain.exponentialRampToValueAtTime(0.22, now + 0.015);
    g.gain.exponentialRampToValueAtTime(0.0001, now + 0.12);
    o.start(now);
    o.stop(now + 0.13);
  } catch {}
}
// Sharp error buzz: two dissonant square waves (280Hz + 350Hz), 350ms with gap
function _scanBeepErr() {
  if (!scanAudioEnabled) return;
  try {
    _initScanAudio();
    if (!_scanAudioCtx) return;
    const ctx = _scanAudioCtx;
    const t0 = ctx.currentTime;
    function tone(start, dur) {
      const o1 = ctx.createOscillator();
      const o2 = ctx.createOscillator();
      const g = ctx.createGain();
      o1.type = 'square';
      o2.type = 'square';
      o1.frequency.setValueAtTime(280, start);
      o2.frequency.setValueAtTime(350, start);
      o1.connect(g);
      o2.connect(g);
      g.connect(ctx.destination);
      g.gain.setValueAtTime(0.0001, start);
      g.gain.exponentialRampToValueAtTime(0.18, start + 0.01);
      g.gain.setValueAtTime(0.18, start + dur - 0.02);
      g.gain.exponentialRampToValueAtTime(0.0001, start + dur);
      o1.start(start);
      o2.start(start);
      o1.stop(start + dur);
      o2.stop(start + dur);
    }
    tone(t0, 0.14);
    tone(t0 + 0.21, 0.14);
  } catch {}
}
// Tab navigation for 3-tab scan modal
function switchScanTab(tab) {
  const tabs = document.querySelectorAll('.scan-tab');
  const panels = document.querySelectorAll('.scan-tab-panel');
  for (let i = 0; i < tabs.length; i++) {
    const t = tabs[i];
    if (t.getAttribute('data-scan-tab') === tab) t.classList.add('active');
    else t.classList.remove('active');
  }
  for (let j = 0; j < panels.length; j++) {
    const p = panels[j];
    if (p.getAttribute('data-scan-panel') === tab) p.classList.add('active');
    else p.classList.remove('active');
  }
}
// Render the "Letzte Erfolge" tab from sessionEntries (session successes)
function renderScanSuccesses() {
  const list = document.getElementById('scan-successes-list');
  if (!list) return;
  list.innerHTML = '';
  const succ = (sessionEntries || []).filter(function (e) {
    return e && e.action && (e.batch || e.bag);
  });
  const cnt = document.getElementById('scan-tab-succ-count');
  if (cnt) cnt.textContent = String(succ.length);
  // Newest first
  for (let i = succ.length - 1; i >= 0; i--) {
    const e = succ[i];
    const row = document.createElement('div');
    row.className = 'scan-success-row';
    if (e._tempId) row.setAttribute('data-succ-id', e._tempId);
    const tm = e.time ? new Date(e.time) : new Date();
    const timeStr =
      tm.getHours().toString().padStart(2, '0') +
      ':' +
      tm.getMinutes().toString().padStart(2, '0') +
      ':' +
      tm.getSeconds().toString().padStart(2, '0');
    const label = e.bag || e.batch || '';
    const locStr =
      e.action === 'MOVE'
        ? (e.from || '?') + ' → ' + (e.to || '?')
        : e.action === 'ADD'
          ? '→ ' + (e.to || '')
          : e.action === 'REMOVE'
            ? '✕ ' + (e.from || '')
            : e.action === 'HARVEST'
              ? '🍄'
              : '';
    row.innerHTML =
      '<span class="scan-success-time">' +
      timeStr +
      '</span>' +
      '<span class="badge b-' +
      esc((e.action || '').toLowerCase()) +
      '">' +
      esc(e.action || '') +
      '</span>' +
      '<span class="scan-success-body"><b>' +
      esc(label) +
      '</b>' +
      (locStr ? ' <span class="scan-success-loc">' + esc(locStr) + '</span>' : '') +
      '</span>' +
      '<button class="scan-success-undo" onclick="undoSuccessRow(this)" title="Undo">↩ Undo</button>';
    list.appendChild(row);
  }
}
// Undo from "Letzte Erfolge" tab row
function undoSuccessRow(btn) {
  const row = btn.closest('.scan-success-row');
  const tempId = row ? row.getAttribute('data-succ-id') : null;
  if (!tempId) return;
  // Delegate to existing undoScanEntry via a matching log-entry button, or perform undo directly
  const logBtn = document.querySelector('.scan-log-entry[data-scan-id="' + tempId + '"] .sle-undo');
  if (logBtn) {
    undoScanEntry(logBtn);
    renderScanSuccesses();
    return;
  }
  // Fallback: mirror undoScanEntry logic for entries not in the visible log
  const idx = sessionEntries.findIndex(function (e) {
    return e._tempId === tempId;
  });
  if (idx === -1) return;
  const entry = sessionEntries[idx];
  const si = scanLog.findIndex(function (e) {
    return e._tempId === tempId;
  });
  if (si !== -1) scanLog.splice(si, 1);
  const mi = movements.findIndex(function (e) {
    return e._tempId === tempId;
  });
  if (mi !== -1) movements.splice(mi, 1);
  sessionEntries.splice(idx, 1);
  modeRunUntally(entry);
  if (entry._serverId) apiDelete('/api/scan-log/' + entry._serverId);
  // _queued: the SW holds it offline, so there is no server row to DELETE and
  // none is coming until replay — pull it out of the queue instead.
  else if (entry._queued && dropQueuedScanEntry(entry)) entry._queued = false;
  else entry._undoPending = true; // POST not resolved yet — delete once its id arrives
  scan.count = Math.max(0, scan.count - 1);
  _scanBeep(400, 100);
  setFb('info', undoneMsg(entry));
  updateSD();
  renderStatus();
  renderScanSuccesses();
}
// Transient overlay background flash to reinforce feedback
var _scanBgFlashTimer = null;
function _flashScanBg(type) {
  const ov = document.getElementById('scan-overlay');
  if (!ov) return;
  ov.classList.remove('scan-bg-ok', 'scan-bg-err');
  if (type === 'ok') ov.classList.add('scan-bg-ok');
  else if (type === 'err') ov.classList.add('scan-bg-err');
  else return;
  clearTimeout(_scanBgFlashTimer);
  _scanBgFlashTimer = setTimeout(function () {
    ov.classList.remove('scan-bg-ok', 'scan-bg-err');
  }, 800);
}
// Multi-tab scan dedup via BroadcastChannel
const scanChannel = typeof BroadcastChannel !== 'undefined' ? new BroadcastChannel('meister-scans') : null;
if (scanChannel) {
  scanChannel.onmessage = function (ev) {
    if (ev.data && ev.data.type === 'scan-entry') {
      // Add to sessionEntries for dedup checking across tabs
      sessionEntries.push(ev.data.entry);
    }
  };
}
// Duplicate detection
let _pendingDupe = null;
let _pendingDupeTimer = null;
// Beim Umziehen ein Beutel ohne Platz im System (nie eingelagert, oder als
// entfernt gebucht): der zweite Scan desselben Beutels legt ihn am Ziel ein.
let _pendingPlace = null;
let _pendingPlaceTimer = null;
// Wie lange ein "nochmal scannen zum Bestätigen" gilt. Die Kamera nimmt dasselbe
// Etikett frühestens nach SCAN_DEDUP_MS (3 s) wieder an — mit den 3 s, die die
// Doppel-Warnung hier hatte, ließ sich der zweite Scan mit der Kamera nie treffen.
const CONFIRM_SCAN_MS = 8000;

function openScanModal() {
  document.getElementById('scan-overlay').classList.add('open');
  if (window.innerWidth <= 768) document.body.style.overflow = 'hidden';
}
function closeScanModal() {
  document.getElementById('scan-overlay').classList.remove('open');
  document.body.style.overflow = '';
}
function _addLogEntry(type, msg, entryData) {
  const log = document.getElementById('scan-modal-log');
  const el = document.createElement('div');
  el.className = 'scan-log-entry log-' + type;
  if (entryData && entryData._tempId) el.setAttribute('data-scan-id', entryData._tempId);
  const tm = new Date();
  const timeStr =
    tm.getHours().toString().padStart(2, '0') +
    ':' +
    tm.getMinutes().toString().padStart(2, '0') +
    ':' +
    tm.getSeconds().toString().padStart(2, '0');
  if (entryData && entryData.action && entryData.batch) {
    const sp = entryData.species || '';
    const bagLabel = entryData.bag || entryData.batch;
    const locStr =
      entryData.action === 'MOVE'
        ? entryData.from + ' → ' + entryData.to
        : entryData.action === 'ADD'
          ? '→ ' + entryData.to
          : entryData.action === 'REMOVE'
            ? '✕ ' + (entryData.from || '')
            : entryData.action === 'HARVEST'
              ? entryData.grams
                ? entryData.grams + 'g (Flush ' + (entryData.flush || 1) + ')'
                : ''
              : '';
    // Harvest entries are not undoable via the scan-log endpoint (harvests live in a separate table)
    const canUndo = entryData.action !== 'HARVEST';
    el.innerHTML =
      '<span class="sle-time">' +
      timeStr +
      '</span>' +
      '<span class="badge b-' +
      esc(entryData.action.toLowerCase()) +
      '">' +
      esc(entryData.action) +
      '</span> ' +
      '<span class="sle-msg"><b>' +
      esc(bagLabel) +
      '</b>' +
      (sp ? ' <span class="fs-micro" style="color:var(--c-text-muted)">' + esc(sp) + '</span>' : '') +
      (locStr ? ' <span style="color:var(--c-text-muted)">' + esc(locStr) + '</span>' : '') +
      '</span>' +
      (canUndo ? '<button class="sle-undo" onclick="undoScanEntry(this)" title="Undo">↩</button>' : '');
  } else {
    el.innerHTML = '<span class="sle-time">' + timeStr + '</span><span class="sle-msg">' + esc(msg) + '</span>';
  }
  log.prepend(el);
  while (log.children.length > 80) log.lastChild.remove();
}
let _toastTimer = null;
let _camHudToastTimer = null;
function setFb(type, msg, opts) {
  const entryData = opts && opts._tempId ? opts : null;
  // When camera is active, show feedback on camera HUD instead of scan overlay
  if (_camScanner && (!opts || !opts.noModal)) {
    _showCamHudToast(type, msg);
    updateCamHud();
  } else {
    if (!opts || !opts.noModal) openScanModal();
  }
  // Always update scan overlay toast + log (for when user opens it later)
  const el = document.getElementById('scan-toast');
  el.className = 'scan-toast-inline fb-' + type;
  el.textContent = msg;
  requestAnimationFrame(() => el.classList.add('visible'));
  clearTimeout(_toastTimer);
  _toastTimer = setTimeout(() => el.classList.remove('visible'), fbShowMs(type));
  if (type === 'err') sessionErrors++;
  if (type === 'ok') {
    _scanBeepOk();
    _flashScanBg('ok');
    if (typeof switchScanTab === 'function') switchScanTab('current');
  } else if (type === 'err') {
    _scanBeepErr();
    _flashScanBg('err');
    if (typeof switchScanTab === 'function') switchScanTab('current');
  }
  _addLogEntry(type, msg, entryData);
  if (type === 'ok' && typeof renderScanSuccesses === 'function') renderScanSuccesses();
}
function _showCamHudToast(type, msg) {
  const el = document.getElementById('cam-hud-toast');
  el.className = 'cam-hud-toast ht-' + type;
  el.textContent = msg;
  requestAnimationFrame(() => el.classList.add('visible'));
  clearTimeout(_camHudToastTimer);
  _camHudToastTimer = setTimeout(() => el.classList.remove('visible'), fbShowMs(type));
}
// Wie lange eine Rückmeldung stehen bleibt. Fehler sagen jetzt, was los ist und
// was hilft — das liest niemand in vier Sekunden. Der nächste Scan ersetzt die
// Meldung ohnehin; lang steht sie nur, wenn man sie braucht.
function fbShowMs(type) {
  return type === 'err' ? 7000 : type === 'warn' ? 5000 : 3000;
}
function updateCamHud() {
  document.getElementById('ch-action').textContent = scan.action || '—';
  document.getElementById('ch-from').textContent = scan.from || '—';
  // Der Name des Platzes, wie auf dem Umziehen-Knopf daneben — nicht "TENT1".
  document.getElementById('ch-to').textContent = scan.to ? zoneDisplayName(scan.to) : '—';
  document.getElementById('ch-count').textContent = scan.count;
  // Action chip color
  const actionChip = document.getElementById('cam-chip-action');
  actionChip.className = 'cam-chip' + (scan.action ? ' ch-set ch-' + scan.action.toLowerCase() : '');
  // Show/hide from/arrow chips based on action
  const fromChip = document.getElementById('cam-chip-from');
  const arrowChip = document.getElementById('cam-chip-arrow');
  const toChip = document.getElementById('cam-chip-to');
  // MOVE no longer needs FROM — FROM is auto-derived per bag
  fromChip.style.display = 'none';
  arrowChip.style.display = 'none';
  // MOVE_BATCH needs a destination too, so show the chip for it as well —
  // otherwise the HUD hides the one field the worker still has to fill (and
  // with it the tap target that opens the destination picker).
  //
  // Und "noch gar kein Vorgang" gehört dazu, denn das ist der Zustand, in dem
  // der Scanner aufmacht. scanPickDestination() setzt selbst MOVE, wenn keiner
  // gesetzt ist — dieses Feld anzutippen IST also der Einstieg ins Umziehen.
  // Ausgeblendet, solange kein Vorgang steht, lag der Einstieg hinter dem
  // Zustand, den er herstellt: am Telefon blieb nur, einen gedruckten
  // MOVE-Barcode zu scannen, und den hat in der Kammer niemand dabei.
  const wantsTo =
    !scan.action || scan.action === 'ADD' || scan.action === 'MOVE' || scan.action === 'MOVE_BATCH';
  toChip.className = 'cam-chip' + (wantsTo && scan.to ? ' ch-set' : '');
  toChip.style.display = wantsTo ? '' : 'none';
  // Pulsieren nur, wenn ein Vorgang wirklich auf sein Ziel wartet. Ohne Vorgang
  // ist Scannen ein vollwertiger Zustand (Beutel scannen zeigt seine Infos), und
  // der Weg ins Umziehen ist jetzt der beschriftete Knopf darunter — ein
  // blinkendes Feld daneben zog den Blick auf die kleinere der zwei Türen.
  const toPulse = !!scan.action && wantsTo && !scan.to;
  toChip.classList.toggle('ch-pulse', toPulse);
  // Count chip highlight
  const countChip = document.getElementById('cam-chip-count');
  countChip.className = 'cam-chip' + (scan.count > 0 ? ' ch-set' : '');
  // Die ganze Reihe nur, wenn sie etwas sagt, was kein Knopf sagt: ein Vorgang
  // von einem gedruckten Etikett, für den es keinen Knopf gibt (ADD,
  // MOVE_BATCH), oder ein Umzug, dem das Ziel noch fehlt. Sonst sagt der
  // leuchtende Knopf, was läuft, und seine Zahl, wieviel — "ACTION — TO — 0"
  // daneben war nur Rauschen in der Sprache der Etiketten.
  const reihe = document.getElementById('cam-hud-chips');
  if (reihe) {
    const brauchtReihe =
      scan.action === 'ADD' || scan.action === 'MOVE_BATCH' || (scan.action === 'MOVE' && !scan.to);
    reihe.style.display = brauchtReihe ? '' : 'none';
  }
}
// Put the scanner into an action mode.
//
// This was the body of the `if (ACTIONS.includes(val))` branch in the barcode
// handler, which meant an action could be armed exactly one way: by scanning a
// printed barcode with the word on it. That is fine at the bench where the
// sheet is taped to the wall, and no use at all on a phone in a tent — and
// reporting contamination is precisely the thing you do standing in front of a
// bad bag, with the phone already in your hand.
//
// Nothing about the modes changed; they simply have a second door now. Toggling
// the same action off returns to plain scanning, so the button that armed it is
// also the way back out.
// opts.noModal: quittieren, ohne die grüne Scan-Hülle aufzuklappen. Die liegt
// über der Kamera, und wer den Vorgang setzt, um gleich zu scannen, will das
// Bild sehen und nicht die Hülle davor.
function armScanAction(val, opts) {
  if (!ACTIONS.includes(val)) return;
  const keepTo = val === scan.action && scan.to;
  scan.action = val;
  scan.from = null;
  scan.to = keepTo ? scan.to : null;
  scan.harvestBag = null;
  const hp = document.getElementById('harvest-panel');
  if (hp) hp.style.display = 'none';
  _pendingDupe = null;
  clearTimeout(_pendingDupeTimer);
  updateSD();
  setFb(
    'ok',
    {
      ADD: t('scanFb.actionAdd'),
      MOVE: t('scanFb.actionMove'),
      MOVE_BATCH: 'MOVE BATCH — Ziel scannen',
      REMOVE: t('scanFb.actionRemove'),
      HARVEST: t('scanFb.actionHarvest'),
      CONTAM: t('scanFb.actionContam')
    }[val],
    opts && opts.noModal ? { noModal: true } : undefined
  );
  // Ten places assign scan.action and only two used to refresh this, so the
  // button could sit lit while ADD was armed — and the next bag scanned got
  // added to a location instead of reported contaminated.
  updateCamContamBtn();
}
// Arm CONTAM, or stand down if it is already armed. The camera stays open
// either way: a worker walking a rack reports several bags in a row.
//
// Liegen Beutel in der Sammelliste, heißt derselbe Knopf "fertig, jetzt
// melden": das Formular geht auf, statt die gescannten Beutel wegzuwerfen.
// Wegwerfen kann man sie weiter — mit dem ✗ daneben, das den Scan zurücksetzt.
function toggleContamScan() {
  if (scan.action === 'CONTAM') {
    if (_crTargets.length) {
      crFinishCollect();
      return;
    }
    scan.action = null;
    updateSD();
    setFb('ok', t('scanFb.actionCleared'));
  } else {
    armScanAction('CONTAM');
  }
  updateCamContamBtn();
}
function updateCamContamBtn() {
  const b = document.getElementById('btn-cam-contam');
  if (!b) return;
  const on = scan.action === 'CONTAM';
  b.classList.toggle('on', on);
  b.setAttribute('aria-pressed', on ? 'true' : 'false');
  // Der Zähler ist die einzige Rückmeldung darüber, wieviel schon gesammelt
  // ist, solange die Kamera das Bild füllt.
  const badge = document.getElementById('cam-contam-count');
  if (badge) {
    const n = _crTargets.length;
    badge.textContent = String(n);
    badge.hidden = !n;
  }
  b.setAttribute(
    'aria-label',
    _crTargets.length ? t('contam.reportN', { n: _crTargets.length }) : t('scan.contamAria')
  );
}

// ── Vorgänge in Serie: Umziehen, Ernten, Kontamination, Entsorgen, Verbraucht ─
// Ein Knopf, dann Beutel für Beutel scannen, bis der Knopf wieder aus ist. So
// einfach muss es sein, sonst benutzt es niemand. Der Scanner konnte das schon
// (ein gesetzter Vorgang bleibt stehen), nur lag die Tür dazu hinter gedruckten
// Etiketten (MOVE, HARVEST, REMOVE) oder dem kleinen "Nach"-Feld, dessen Liste
// hinter der Kamera aufging. Am Telefon blieb so nur der Umweg über das
// Beutel-Fenster — für jeden Beutel von vorn.
//
// _modeRun zählt den Durchgang: welcher Vorgang, wohin (nur beim Umziehen),
// wieviele Beutel schon, wann zuletzt etwas geschah. Ob ein Knopf an ist, steht
// NICHT hier, sondern in scan — ein MOVE mit Ziel ist ein Umzug, egal durch
// welche Tür er kam. Die Kontamination zählt ihre Beutel selbst (_crTargets).
let _modeRun = null;
// Wie lange ein Umzug oder eine Ernte die geschlossene Kamera überlebt. Ein
// Anruf, die Bildschirmsperre oder ein Tipp neben das Bild schließen sie mitten
// in der Reihe; wer gleich weitermacht, soll nicht wieder bei null anfangen. Wer
// erst nach einer Pause wiederkommt, bekommt den neutralen Scanner wie bisher.
// Entsorgen und Verbraucht überleben sie nie: wer die Kamera später aufmacht, um
// nach einem Beutel zu sehen, darf ihn nicht versehentlich wegbuchen.
const MODE_RUN_KEEP_MS = 15 * 60 * 1000;

function toggleMoveScan() {
  if (scan.action === 'MOVE' && scan.to) {
    const to = scan.to;
    const n = modeRunCount('MOVE', to);
    endModeRun();
    setFb('ok', t('cam.moveEnded', { n: n, loc: zoneDisplayName(to) }));
    return;
  }
  if (contamPending()) return;
  _openZonePicker(t('cam.movePick'), armMoveRun);
}

// Ernten, Entsorgen und Verbraucht: ein Tipp stellt den Vorgang scharf, der
// zweite nimmt ihn zurück — wie beim Umziehen, nur ohne Ziel.
function toggleModeScan(action) {
  const [an, aus] = {
    HARVEST: ['cam.harvestArmed', 'cam.harvestEnded'],
    REMOVE: ['cam.trashArmed', 'cam.trashEnded']
  }[action];
  if (scan.action === action) {
    const n = modeRunCount(action, null);
    endModeRun();
    setFb('ok', t(aus, { n: n }));
    return;
  }
  if (contamPending()) return;
  armMode(action, null);
  setFb('ok', t(an));
}

// Gesammelte Kontaminations-Beutel gingen beim Umschalten still verloren:
// CONTAM wäre weg, die Liste bliebe liegen, und kein Knopf zeigte sie mehr an.
function contamPending() {
  if (scan.action !== 'CONTAM' || !_crTargets.length) return false;
  setFb('err', t('cam.moveContamPending', { n: _crTargets.length }));
  return true;
}

function endModeRun() {
  scan.action = null;
  scan.to = null;
  scan.from = null;
  scan.harvestBag = null;
  _modeRun = null;
  updateSD();
}

// Stellt einen Vorgang scharf: dieselben Aufräumschritte wie armScanAction().
// Derselbe Vorgang mit demselben Ziel noch einmal (das Platz-Etikett des
// laufenden Umzugs gescannt, das Ziel erneut gewählt) setzt den Durchgang fort,
// statt die Zahl auf dem Knopf zu löschen.
function armMode(action, to) {
  const weiter =
    scan.action === action && scan.to === to && _modeRun && _modeRun.action === action && _modeRun.to === to;
  scan.action = action;
  scan.to = to;
  scan.from = null;
  scan.harvestBag = null;
  const hp = document.getElementById('harvest-panel');
  if (hp) hp.style.display = 'none';
  _pendingDupe = null;
  _pendingPlace = null;
  clearTimeout(_pendingDupeTimer);
  clearTimeout(_pendingPlaceTimer);
  _modeRun = { action: action, to: to, n: weiter ? _modeRun.n : 0, at: Date.now() };
  updateSD();
}

function armMoveRun(dest) {
  armMode('MOVE', dest);
  rememberDest(dest);
  setFb('ok', t('cam.moveArmed', { loc: zoneDisplayName(dest) }));
}

// Wieviele Beutel der laufende Durchgang schon hat.
function modeRunCount(action, to) {
  return _modeRun && _modeRun.action === action && _modeRun.to === to ? _modeRun.n : 0;
}
// Ein Beutel mehr im Durchgang. Ein Vorgang, der durch eine andere Tür kam
// (gedrucktes Etikett, Platz-Etikett), beginnt hier seinen Durchgang. Der
// Eintrag wird markiert, damit nur zurückgenommen wird, was auch gezählt wurde.
function modeRunTally(action, to, entry) {
  if (!_modeRun || _modeRun.action !== action || _modeRun.to !== to) {
    _modeRun = { action: action, to: to, n: 0, at: Date.now() };
  }
  _modeRun.n++;
  _modeRun.at = Date.now();
  if (entry) entry._run = action;
  return _modeRun.n;
}
// Rückgängig, oder vom Server abgelehnt: der Beutel zählt doch nicht.
function modeRunUntally(entry) {
  if (!entry || !entry._run || !_modeRun || _modeRun.action !== entry._run) return;
  if (entry._run === 'MOVE' && _modeRun.to !== entry.to) return;
  _modeRun.n = Math.max(0, _modeRun.n - 1);
}
// Darf der Scannen-Knopf den Vorgang stehen lassen, statt neutral aufzumachen?
function modeRunResumable() {
  if (!_modeRun || scan.action !== _modeRun.action) return false;
  if (_modeRun.action !== 'MOVE' && _modeRun.action !== 'HARVEST') return false;
  if (_modeRun.action === 'MOVE' && (!scan.to || scan.to !== _modeRun.to)) return false;
  return Date.now() - _modeRun.at < MODE_RUN_KEEP_MS;
}

// Die Knöpfe, die hier gezählt werden. Die Kontamination hat ihren eigenen
// (updateCamContamBtn), weil ihr Knopf mehr tut: mit gesammelten Beuteln öffnet
// er das Formular.
function updateCamModeBtns() {
  const moveOn = scan.action === 'MOVE' && !!scan.to;
  const loc = moveOn ? zoneDisplayName(scan.to) : '';
  const knoepfe = [
    ['move', moveOn, moveOn ? t('cam.moveOnAria', { loc: loc }) : t('cam.moveAria'), modeRunCount('MOVE', scan.to)],
    ['harvest', scan.action === 'HARVEST', t('cam.harvestAria'), modeRunCount('HARVEST', null)],
    ['trash', scan.action === 'REMOVE', t('cam.trashAria'), modeRunCount('REMOVE', null)]
  ];
  for (const [name, on, aria, zahl] of knoepfe) {
    const b = document.getElementById('btn-cam-' + name);
    if (!b) continue;
    b.classList.toggle('on', on);
    b.setAttribute('aria-pressed', on ? 'true' : 'false');
    b.setAttribute('aria-label', aria);
    const badge = document.getElementById('cam-' + name + '-count');
    if (badge) {
      const n = on ? zahl : 0;
      badge.textContent = String(n);
      badge.hidden = !n;
    }
  }
  // Umziehen an zeigt statt des Worts sein Ziel. Nur der Name: der Pfeil davor
  // ist schon das Zeichen des Knopfs.
  const idle = document.getElementById('cam-move-idle');
  if (idle) idle.hidden = moveOn;
  const ziel = document.getElementById('cam-move-to');
  if (ziel) {
    ziel.hidden = !moveOn;
    ziel.textContent = loc;
  }
}

function updateSD() {
  document.getElementById('s-action').textContent = scan.action || '—';
  document.getElementById('s-from').textContent = scan.from || '—';
  document.getElementById('s-to').textContent = scan.to || '—';
  document.getElementById('s-count').textContent = scan.count;
  // Action-colored header
  const modal = document.getElementById('scan-modal');
  modal.className = 'scan-modal' + (scan.action ? ' scan-action-' + scan.action.toLowerCase() : '');
  // MOVE: hide FROM chip — FROM is auto-derived per bag
  const fromChip = document.getElementById('chip-from');
  fromChip.style.display = scan.action === 'MOVE' || scan.action === 'MOVE_BATCH' ? 'none' : '';
  // Chip pulse hints
  const chipTo = document.getElementById('chip-to');
  const toPulse =
    (scan.action === 'ADD' && !scan.to) ||
    (scan.action === 'MOVE' && !scan.to) ||
    (scan.action === 'MOVE_BATCH' && !scan.to);
  chipTo.classList.toggle('chip-pulse', toPulse);
  // Last scan chip
  const lastChip = document.getElementById('chip-last');
  if (_lastScanVal) {
    lastChip.style.display = '';
    document.getElementById('s-last').textContent = _lastScanVal;
  }
  // Count bump animation
  const countChip = document.getElementById('chip-count');
  countChip.classList.remove('count-bump');
  void countChip.offsetWidth;
  if (scan.count > 0) countChip.classList.add('count-bump');
  // Session end button
  document.getElementById('btn-end-session').style.display = sessionEntries.length > 0 ? '' : 'none';
  // Der Weg ins Kontaminations-Formular für alle, die am Tisch mit dem
  // Handscanner sammeln: die Kamera-Leiste mit dem ⚠-Knopf sehen die nicht.
  const collectBtn = document.getElementById('btn-contam-collect');
  if (collectBtn) {
    collectBtn.style.display = _crTargets.length ? '' : 'none';
    collectBtn.textContent = t('contam.reportN', { n: _crTargets.length });
  }
  // Also sync camera HUD if it exists
  updateCamHud();
  updateCamContamBtn();
  updateCamModeBtns();
}
// Tap the To chip (scan modal or camera HUD) to set the destination by hand.
// Normally it comes from scanning a location barcode, but a shelf label can be
// missing, damaged or out of reach — this opens the same zone picker the other
// move flows use, so the scanner is no longer barcode-only. Mirrors what
// scanning a location does: sets the target for ADD/MOVE/MOVE_BATCH, and with
// no action chosen yet it starts a MOVE to that destination — the same Umzug
// the Umziehen button starts, so it counts and lights up the same way.
function scanPickDestination() {
  const act = scan.action;
  if (act && act !== 'ADD' && act !== 'MOVE' && act !== 'MOVE_BATCH') return;
  _openZonePicker(t('scan.pickDest'), function (dest) {
    if (!scan.action || scan.action === 'MOVE') {
      armMoveRun(dest);
      return;
    }
    scan.to = dest;
    updateSD();
    setFb('ok', t('scanFb.to', { loc: zoneDisplayName(dest) }));
  });
}
function resetScan() {
  scan = { action: null, from: null, to: null, count: scan.count, harvestBag: null };
  // Zurücksetzen heißt auch: die gesammelten Beutel sind weg. Sie hier stehen
  // zu lassen hieße, sie zu einem späteren Bericht mitzunehmen, den niemand
  // über sie schreiben wollte.
  _crTargets = [];
  _crResumeForm = false;
  // Und ein laufender Umzug ist vorbei — der Scannen-Knopf soll ihn danach
  // nicht wieder aufnehmen.
  _modeRun = null;
  // It clears scan.action, and it is bound to a button inside the open camera
  // HUD — so without this the CONTAM toggle beside it stayed lit and pressed
  // over a disarmed scanner, and the next bad bag got the neutral sheet.
  updateCamContamBtn();
  document.getElementById('harvest-panel').style.display = 'none';
  _pendingDupe = null;
  _pendingPlace = null;
  clearTimeout(_pendingDupeTimer);
  clearTimeout(_pendingPlaceTimer);
  updateSD();
  setFb('info', t('scanFb.setAction'));
}
// Was ein Rückgängig gerade bewirkt hat, in Worten statt "Undo: MOVE BO-…-03".
function undoneMsg(entry) {
  const was = entry.bag || entry.batch;
  if (entry.action === 'MOVE' && entry.from) {
    return t('scanFb.undoneMove', { bag: was, loc: zoneDisplayName(entry.from) });
  }
  return t('scanFb.undone', { bag: was });
}
// Nimmt einen Scan-Eintrag zurück: aus dem Log auf dem Telefon, aus der
// laufenden Runde samt ihrer Zeile im Verlauf, und vom Server — auch einen,
// dessen Speichern noch läuft oder der offline in der Warteschlange steht. Der
// ↩-Knopf und das Rückgängig nach "Verbraucht" nehmen denselben Weg.
function scanEintragZuruecknehmen(entry) {
  const tempId = entry._tempId;
  const si = scanLog.findIndex((e) => e._tempId === tempId);
  if (si !== -1) scanLog.splice(si, 1);
  const mi = movements.findIndex((e) => e._tempId === tempId);
  if (mi !== -1) movements.splice(mi, 1);
  const ri = sessionEntries.findIndex((e) => e._tempId === tempId);
  if (ri !== -1) {
    sessionEntries.splice(ri, 1);
    scan.count = Math.max(0, scan.count - 1);
    const row = document.querySelector('.scan-log-entry[data-scan-id="' + tempId + '"]');
    if (row) row.remove();
  }
  modeRunUntally(entry);
  // Delete from server
  if (entry._serverId) apiDelete('/api/scan-log/' + entry._serverId);
  // _queued: the SW holds it offline, so there is no server row to DELETE and
  // none is coming until replay — pull it out of the queue instead.
  else if (entry._queued && dropQueuedScanEntry(entry)) entry._queued = false;
  else entry._undoPending = true; // POST not resolved yet — delete once its id arrives
}
// Undo a single scan entry by clicking the ↩ button
function undoScanEntry(btn) {
  const row = btn.closest('.scan-log-entry');
  const tempId = row ? row.getAttribute('data-scan-id') : null;
  if (!tempId) return;
  const entry = sessionEntries.find((e) => e._tempId === tempId);
  if (entry) scanRueckgaengig(entry);
}
// Nimmt einen Eintrag der laufenden Runde zurück und sagt es. ↩ in der Kamera
// kommt direkt hierher und sucht nicht erst die Zeile im Verlauf: die gibt es
// nicht für jeden Eintrag (mehrere Beutel auf einmal verbraucht schreiben eine
// Meldung, keine je Beutel), und der Verlauf behält nur die letzten 80.
function scanRueckgaengig(entry) {
  scanEintragZuruecknehmen(entry);
  _scanBeep(400, 100);
  setFb('info', undoneMsg(entry));
  updateSD();
  renderStatus();
  if (typeof renderScanSuccesses === 'function') renderScanSuccesses();
}
// Ctrl+Z undo support
let _ctrlZPending = false;
let _ctrlZTimer = null;
document.addEventListener('keydown', function (e) {
  if (!document.getElementById('scan-overlay').classList.contains('open')) return;
  if (e.ctrlKey && e.key === 'z') {
    e.preventDefault();
    if (sessionEntries.length === 0) {
      setFb('info', 'Nichts zum Rückgängig machen');
      return;
    }
    if (!_ctrlZPending) {
      _ctrlZPending = true;
      setFb('info', 'Ctrl+Z nochmal drücken zum Bestätigen');
      _ctrlZTimer = setTimeout(() => {
        _ctrlZPending = false;
      }, 2000);
      return;
    }
    _ctrlZPending = false;
    clearTimeout(_ctrlZTimer);
    // Walk backwards to find the most recent undoable entry (skip HARVEST)
    let lastUndoable = null;
    for (let i = sessionEntries.length - 1; i >= 0; i--) {
      if (sessionEntries[i].action !== 'HARVEST') {
        lastUndoable = sessionEntries[i];
        break;
      }
    }
    if (!lastUndoable) {
      setFb('info', 'Keine Scans zum Rückgängig machen');
      return;
    }
    const btn = document.querySelector('[data-scan-id="' + lastUndoable._tempId + '"] .sle-undo');
    if (btn) undoScanEntry(btn);
  }
});
// End session → show summary
function endScanSession() {
  if (sessionEntries.length === 0) return;
  // Summary lives in the "current" tab panel — make sure it's visible
  if (typeof switchScanTab === 'function') switchScanTab('current');
  const sumEl = document.getElementById('scan-session-summary');
  // Hide log, show summary
  document.getElementById('scan-modal-log').style.display = 'none';
  document.getElementById('scan-toast').style.display = 'none';
  sumEl.style.display = 'block';
  const dur = sessionStartTime ? Math.round((Date.now() - sessionStartTime) / 60000) : 0;
  const startStr = sessionStartTime
    ? new Date(sessionStartTime).toLocaleTimeString('de', { hour: '2-digit', minute: '2-digit' })
    : '';
  const endStr = new Date().toLocaleTimeString('de', { hour: '2-digit', minute: '2-digit' });
  // Count by action
  const counts = { ADD: 0, MOVE: 0, REMOVE: 0, HARVEST: 0 };
  const touchedBatches = new Map();
  sessionEntries.forEach((e) => {
    if (counts[e.action] !== undefined) counts[e.action]++;
    if (e.batch && !touchedBatches.has(e.batch)) touchedBatches.set(e.batch, e.species || '');
  });
  // Location summary
  const locSummary = [];
  if (counts.ADD > 0) {
    const locs = {};
    sessionEntries
      .filter((e) => e.action === 'ADD')
      .forEach((e) => {
        locs[e.to] = (locs[e.to] || 0) + 1;
      });
    Object.entries(locs).forEach(([l, n]) => locSummary.push(n + ' Bags → ' + esc(l)));
  }
  if (counts.MOVE > 0) {
    const moves = {};
    sessionEntries
      .filter((e) => e.action === 'MOVE')
      .forEach((e) => {
        const k = esc(e.from) + ' → ' + esc(e.to);
        moves[k] = (moves[k] || 0) + 1;
      });
    Object.entries(moves).forEach(([k, n]) => locSummary.push(n + ' Bags ' + k));
  }
  let batchHtml = '';
  touchedBatches.forEach((sp, bid) => {
    batchHtml += '<span>' + esc(bid) + (sp ? ' (' + esc(sp) + ')' : '') + '</span>';
  });
  sumEl.innerHTML =
    '<h3>' +
    t('scan.sessionSummary') +
    '</h3>' +
    '<div class="scan-summary-grid">' +
    '<div class="scan-summary-stat"><div class="ss-num">' +
    scan.count +
    '</div><div class="ss-lbl">' +
    t('scan.totalCount') +
    '</div></div>' +
    (counts.ADD
      ? '<div class="scan-summary-stat" style="border-top:3px solid #86efac"><div class="ss-num">' +
        counts.ADD +
        '</div><div class="ss-lbl">ADD</div></div>'
      : '') +
    (counts.MOVE
      ? '<div class="scan-summary-stat" style="border-top:3px solid #93c5fd"><div class="ss-num">' +
        counts.MOVE +
        '</div><div class="ss-lbl">MOVE</div></div>'
      : '') +
    (counts.REMOVE
      ? '<div class="scan-summary-stat" style="border-top:3px solid #fca5a5"><div class="ss-num">' +
        counts.REMOVE +
        '</div><div class="ss-lbl">REMOVE</div></div>'
      : '') +
    (counts.HARVEST
      ? '<div class="scan-summary-stat" style="border-top:3px solid #fcd34d"><div class="ss-num">' +
        counts.HARVEST +
        '</div><div class="ss-lbl">HARVEST</div></div>'
      : '') +
    (sessionErrors
      ? '<div class="scan-summary-stat" style="border-top:3px solid #fca5a5"><div class="ss-num">' +
        sessionErrors +
        '</div><div class="ss-lbl">' +
        t('scan.sessionErrors') +
        '</div></div>'
      : '') +
    '</div>' +
    '<div class="fs-meta" style="color:var(--c-text-muted);margin-bottom:8px">' +
    t('scan.duration') +
    ': ' +
    dur +
    ' Min' +
    (startStr ? ' (' + startStr + ' – ' + endStr + ')' : '') +
    '</div>' +
    (batchHtml ? '<div class="scan-summary-batches">' + t('scan.batches') + ': ' + batchHtml + '</div>' : '') +
    (locSummary.length ? '<div class="fs-meta" style="margin-bottom:12px">' + locSummary.join(' · ') + '</div>' : '') +
    '<div class="scan-summary-actions">' +
    '<button class="btn-xs" onclick="closeScanSession()">' +
    t('scan.close') +
    '</button>' +
    '<button class="btn-xs green" onclick="newScanSession()">' +
    t('scan.newSession') +
    '</button>' +
    '</div>';
}
function closeScanSession() {
  document.getElementById('scan-session-summary').style.display = 'none';
  document.getElementById('scan-modal-log').style.display = '';
  document.getElementById('scan-toast').style.display = '';
  closeScanModal();
}
function newScanSession() {
  document.getElementById('scan-session-summary').style.display = 'none';
  document.getElementById('scan-modal-log').style.display = '';
  document.getElementById('scan-toast').style.display = '';
  document.getElementById('scan-modal-log').innerHTML = '';
  sessionEntries = [];
  sessionStartTime = null;
  sessionErrors = 0;
  _lastScanVal = null;
  scan.count = 0;
  if (typeof renderScanSuccesses === 'function') renderScanSuccesses();
  resetScan();
}
let _scanTempIdCounter = 0;

// I-12: handle a 409 zone_mismatch response from POST /api/scan-log. The server
// rejected the MOVE because another user moved the bag while this client's
// view was stale (typical flow: offline scan that replayed after the bag was
// moved by someone else online). We discard the local in-memory entry and
// surface a toast so the user knows their MOVE didn't apply.
function handleZoneMismatch(r, entries) {
  if (!r || r.error !== 'zone_mismatch') return false;
  const list = Array.isArray(entries) ? entries : [entries];
  // The server rejects the ENTIRE POST on a single conflict, so none of these
  // entries persisted. Drop them all from local state — not just the offending
  // bag — or the other N-1 entries of a bulk move linger as phantom moves on
  // the dashboard until the next resync silently reverts them.
  for (const e of list) {
    if (!e) continue;
    const i = scanLog.lastIndexOf(e);
    if (i >= 0) scanLog.splice(i, 1);
    const j = movements.lastIndexOf(e);
    if (j >= 0) movements.splice(j, 1);
    modeRunUntally(e);
  }
  if (typeof setFb === 'function') setFb('err', movedMeanwhileMsg(r.bag, r.current_zone));
  if (typeof renderStatus === 'function') renderStatus();
  if (typeof updateSD === 'function') updateSD();
  // Der eigene Stand war alt, sonst gäbe es den Konflikt nicht. Gleich den neuen
  // holen: dann geht der nächste Scan desselben Beutels durch, statt wieder
  // gegen denselben alten Platz zu laufen.
  if (typeof syncNow === 'function') syncNow();
  return true;
}
// Ein Umzug, den der Server abgelehnt hat, weil der Beutel inzwischen woanders
// ist. Auf Deutsch, mit dem Namen des Platzes, und mit dem, was jetzt zu tun ist
// — vorher stand hier "MOVE rejected: bag … was moved by another user".
function movedMeanwhileMsg(bag, zone) {
  return zone
    ? t('scanFb.movedMeanwhile', { bag: bag || '', loc: zoneDisplayName(zone) })
    : t('scanFb.movedMeanwhileGone', { bag: bag || '' });
}

// I-11: idempotency key for scan-log POSTs. The offline queue (sw.js) replays
// queued POSTs verbatim; without a stable per-entry key, a network partition
// that times out on the client but succeeds on the server would leave the
// entry queued and replay it next time, creating a duplicate. The server
// upserts on client_uuid (UNIQUE INDEX), so retries are safe.
// crypto.randomUUID is available in all modern browsers and Node 16+; the
// fallback covers very old browsers (no offline support there anyway).
function newScanUuid() {
  if (typeof crypto !== 'undefined' && typeof crypto.randomUUID === 'function') {
    return crypto.randomUUID();
  }
  // Fallback: 16 random bytes formatted as UUID v4. Not cryptographically
  // strong, but the only consumer is the unique index; sufficient for dedup.
  const r = Math.random;
  const hex = (n) =>
    Math.floor(r() * 16 ** n)
      .toString(16)
      .padStart(n, '0');
  return `${hex(8)}-${hex(4)}-4${hex(3)}-${(8 + Math.floor(r() * 4)).toString(16)}${hex(3)}-${hex(12)}`;
}

// Etwas Gescanntes ist auf diesem Telefon unbekannt. Bevor die Meldung "nicht
// im System" lautet, einmal den Stand vom Server holen und denselben Scan noch
// einmal durchlaufen lassen: die Listen hier sind nur so neu wie die letzte
// Abfrage, und eine App, die im Hintergrund lag oder kurz kein Netz hatte, kann
// weit zurück sein. "Unbekannter Barcode: 1234567" stand dann über einem
// Etikett, das der Server sehr wohl kannte — und der einzige Ausweg, den man
// fand, war die App neu zu starten.
function scanAfterSync(raw) {
  setFb('info', t('scanFb.checking'));
  syncNow().then(function (ok) {
    if (!ok) {
      // Weder hier bekannt noch nachzufragen: dann sagen, woran es liegt, und
      // was hilft — nicht so tun, als gäbe es das Etikett nicht.
      setFb('err', t('scanFb.unknownOffline'));
      return;
    }
    processScan(raw, { synced: true });
  });
}

// Ein Strichcode aus der Zeit vor den siebenstelligen Nummern, oder einer, der
// gedruckt wurde, als dieses Telefon die Nummer des Beutels noch nicht kannte:
//   KUERZEL_MMDD_N  → nach _ → - drei Teile
//   SP_ST_MMDD_N    → vier Teile (altes spAbbrev + Stammpräfix)
// Gibt null zurück, wenn val keins von beiden ist; sonst { bag, batch }, oder
// { ambiguous: [...] }, oder {} für "keine passende Charge".
//
// Der Beutel wird über seine NUMMER gesucht, nicht über einen zusammengesetzten
// Text. Vorher hieß "_7" immer "-07" — aber Blöcke aus einem Substratansatz
// tragen in einer Charge unter zehn Beuteln "-7", und der Scan suchte einen
// Beutel, den es nicht gibt: "nicht im System" über einem Block, der dort stand.
// Und es galt die erste Charge mit Kürzel und Tag; zwei Chargen vom selben Tag
// (-01, -02) haben beide einen Beutel 7, und der Scan nahm stumm den falschen.
function legacyBagMatch(val) {
  const parts = val.split('-');
  let num, passt;
  if (parts.length === 3 && /^\d{4}$/.test(parts[1]) && /^\d{1,2}$/.test(parts[2])) {
    const [kz, mmdd] = parts;
    num = parseInt(parts[2], 10);
    passt = (b) => (b.strainKuerzel || b.strain || '').toUpperCase() === kz && _batchMmdd(b) === mmdd;
  } else if (parts.length === 4 && /^\d{4}$/.test(parts[2]) && /^\d{1,2}$/.test(parts[3])) {
    const [sp, st, mmdd] = parts;
    num = parseInt(parts[3], 10);
    passt = (b) =>
      spAbbrev(b.species) === sp && (b.strain || '000').slice(0, 3).toUpperCase() === st && _batchMmdd(b) === mmdd;
  } else {
    return null;
  }
  const kandidaten = batches.filter(passt);
  const treffer = [];
  for (const b of kandidaten) {
    for (const bag of b.bags || []) {
      if (parseInt(String(bag).split('-').pop(), 10) === num) treffer.push({ bag, batch: b.batchId });
    }
  }
  if (treffer.length === 1) return treffer[0];
  if (treffer.length > 1) return { ambiguous: treffer.map((x) => x.bag) };
  // Die Charge gibt es, den Beutel in ihr nicht: so wie früher weiterreichen,
  // damit die Meldung danach den Beutel nennt, statt die Charge zu verneinen.
  if (kandidaten.length) {
    return { bag: kandidaten[0].batchId + '-' + String(num).padStart(2, '0'), batch: kandidaten[0].batchId };
  }
  return {};
}
function _batchMmdd(b) {
  const d = b.batchId.split('-')[1];
  return d ? d.slice(2, 4) + d.slice(0, 2) : '';
}

function processScan(raw, opts) {
  // Underscore/hyphen convention:
  // - Location barcodes use UNDERSCORES (e.g. INC_MUSTER_01, SPAWN_R1) — kept as-is
  // - Action commands use UNDERSCORES — kept as-is
  // - Bag/batch IDs use HYPHENS internally (e.g. BLUES-260101-01-06)
  // German HID barcode scanners send underscores for hyphens, so we convert
  // only for non-location, non-action values. Adding new location formats that
  // use hyphens would break this logic — always use underscores for locations.
  let val = raw.trim().toUpperCase();
  if (!val) return;
  // Zweiter Durchlauf nach frischem Stand (scanAfterSync): was jetzt noch
  // unbekannt ist, ist es wirklich, und die Meldung darf das sagen.
  const synced = !!(opts && opts.synced);

  // ── Numeric barcode lookup (new system: 7+ digit numbers) ──
  const numVal = parseInt(val, 10);
  if (/^\d{7,}$/.test(val) && numVal >= 1000000) {
    const entry = barcodeRegistry.get(numVal);
    if (!entry) {
      if (!synced) {
        scanAfterSync(raw);
        return;
      }
      // Die Nummern, die diese App druckt, haben sieben Stellen. Längere sind
      // Produkt-Barcodes (EAN hat dreizehn) — die kennt hier niemand, und es
      // hilft, das zu sagen, statt "gelöscht?" zu fragen.
      setFb('err', val.length <= 8 ? t('scanFb.labelNotInSystem') : t('scanFb.notOurLabel'));
      return;
    }
    if (entry.type === 'bag') {
      val = entry.id; // e.g. "SHI-260101-01-06"
      setFb('info', t('scanFb.matched', { val: val, batch: val.split('-').slice(0, -1).join('-') }));
    } else if (entry.type === 'culture') {
      val = entry.id; // e.g. "MC-SHI-260101-01"
    } else if (entry.type === 'zone' || entry.type === 'rack') {
      val = entry.id; // e.g. "INC" or "INC_R1"
    }
  } else {
    // ── Legacy barcode fallback ──
    if (ACTIONS.includes(val) || LOCS.includes(val)) {
      /* keep underscores */
    } else {
      val = val.replace(/_/g, '-');
    } // German HID keyboard fix for bag IDs
    const legacy = legacyBagMatch(val);
    if (legacy) {
      if (legacy.bag) {
        val = legacy.bag;
        setFb('info', t('scanFb.matched', { val: val, batch: legacy.batch }));
      } else if (!synced) {
        scanAfterSync(raw);
        return;
      } else if (legacy.ambiguous) {
        setFb('err', t('scanFb.legacyAmbiguous', { list: legacy.ambiguous.join(', ') }));
        return;
      } else {
        setFb('err', t('scanFb.noBatchFound', { val: val }));
        return;
      }
    }
  }
  if (ACTIONS.includes(val)) {
    // Ein gedrucktes USED-Etikett aus der Zeit vor dem einen Raus-Knopf stellt
    // Raus scharf: Körnerbrut geht darüber ohnehin als verbraucht raus.
    armScanAction(val === 'USED' ? 'REMOVE' : val);
    return;
  }
  if (LOCS.includes(val)) {
    // Warn if scanning a zone that has racks — suggest using a rack instead
    const zoneObj = zones.find((z) => z.id === val);
    const isZoneWithRacks = zoneObj && zoneObj.racks.length > 0;
    if (scan.action === 'ADD') {
      scan.to = val;
      updateSD();
      setFb(
        isZoneWithRacks ? 'warn' : 'ok',
        isZoneWithRacks
          ? t('scanFb.preferRack', { loc: val, example: zoneObj.racks[0].id })
          : t('scanFb.location', { loc: val })
      );
      return;
    }
    // Kein Vorgang oder Umziehen: ein Platz-Etikett heißt "ab jetzt hierhin" —
    // derselbe Umzug, den der Umziehen-Knopf startet. Mit schon gesetztem Ziel
    // war das vorher ein Fehler, der mitten im laufenden Umzug verlangte, man
    // solle erst einen Vorgang scannen.
    if (!scan.action || scan.action === 'MOVE') {
      armMoveRun(val);
      if (isZoneWithRacks) setFb('warn', t('scanFb.preferRack', { loc: val, example: zoneObj.racks[0].id }));
      return;
    }
    if (scan.action === 'MOVE_BATCH') {
      scan.to = val;
      updateSD();
      setFb(
        isZoneWithRacks ? 'warn' : 'ok',
        isZoneWithRacks
          ? t('scanFb.preferRack', { loc: val, example: zoneObj.racks[0].id })
          : t('scanFb.to', { loc: zoneDisplayName(val) })
      );
      return;
    }
    // Ernten, Entfernen, Kontamination: da gibt es keinen Platz zu wählen.
    setFb('err', t('scanFb.locNotNeeded', { loc: zoneDisplayName(val), action: scanActionName(scan.action) }));
    return;
  }
  // Culture ID scan → auto-fill parent (lab work) or source (new batch), else open lineage
  // Die Kennung einer Kultur: Art, Kürzel der Sorte, der Stamm, wenn einer gewählt
  // war (logLabWork hängt ihn an), Tag und Nummer — PD-KO-KOKQ07-090926-05. Ohne
  // den Stamm-Teil hier lief so ein Etikett in die Beutel-Logik und kam als "nicht
  // im System" zurück, obwohl die Kultur in der Liste stand. SY: Spritzen genauso.
  // Dasselbe Muster steht in isKnownBarcode.
  if (/^(MC|PD|LC|SY|G2G|GS)-[A-Z0-9]+(?:-[A-Z0-9]+)?-\d{6}-\d{2}$/.test(val)) {
    // Lab stocktake: a scan means "this culture is on the shelf in front of me",
    // so it ticks the check list rather than running the normal culture flow.
    // Checked before the used/contam guard below — finding a written-off culture
    // is exactly the correction the check exists to make.
    if (_zcScanMode && _zcMode === 'culture') {
      labCheckScanned(val);
      return;
    }
    // Quick dialog asked for a source culture: take it there instead of opening
    // the lineage view. Refused if it is not a type this dialog state accepts.
    if (_inocScanPrefix) {
      const hit = cultures.find((x) => x.id.toUpperCase() === val);
      if (!hit) {
        if (!synced) {
          scanAfterSync(raw);
          return;
        }
        _scanBeep(300, 150);
        setFb('err', t('scanFb.cultureNotInSystem', { id: val }));
        return;
      }
      if (cultureGone(hit)) {
        _scanBeep(300, 150);
        setFb('err', cultureRefusal(hit));
        return;
      }
      const addErr =
        _inocScanPrefix === 'wkb'
          ? wkbInocAdd(hit.id)
          : _inocScanPrefix === 'ms-q'
            ? msqInocAdd(hit.id)
            : inocAdd(hit.id);
      if (addErr) {
        _scanBeep(300, 150);
        setFb('err', addErr);
        return;
      }
      if (_inocScanPrefix === 'ms-q') msQuickRender();
      else inocRender(_inocScanPrefix);
      _scanBeep(800, 60);
      setFb('ok', t('scanFb.cultureAutofilled', { id: hit.id }));
      closeCamScan();
      return;
    }
    const c = cultures.find((x) => x.id.toUpperCase() === val);
    if (c && scan.action === 'REMOVE') {
      kulturRausScan(c);
      return;
    }
    if (c) {
      if (cultureGone(c)) {
        setFb('err', cultureRefusal(c));
        return;
      }
      closeCamScan();
      // If new-batch form is visible, auto-fill source + strain
      const nbPanel = document.getElementById('sp-batch-new');
      if (nbPanel && nbPanel.classList.contains('active')) {
        const cultureSel = document.getElementById('nb-culture');
        if (cultureSel) cultureSel.value = c.id;
        if (c.strainId) document.getElementById('nb-strain-sel').value = String(c.strainId);
        const nbStInput = document.getElementById('nb-strain-text');
        if (nbStInput && c.strainText) nbStInput.value = c.strainText;
        renderNbGrainBanner();
        setFb('ok', t('scanFb.cultureAutofilled', { id: c.id }));
        return;
      }
      // If lab work form is visible, auto-fill parent instead of opening lineage
      const lwPanel = document.getElementById('sp-lab-work');
      const parentSel = document.getElementById('lw-parent');
      const parentRow = document.getElementById('lw-parent-row');
      if (lwPanel && lwPanel.classList.contains('active') && parentRow && parentRow.style.display !== 'none') {
        parentSel.value = c.id;
        if (c.strainId) document.getElementById('lw-st').value = String(c.strainId);
        const stInput = document.getElementById('lw-strain-text');
        if (stInput && c.strainText) stInput.value = c.strainText;
        lwPreview();
        setFb('ok', 'Parent gesetzt: ' + c.id);
        return;
      }
      // Ein Fenster mit Knöpfen, wie beim Beutel. Vorher ging die Kamera zu und
      // der Stammbaum auf, ohne einen Knopf — gescannt, und dann nichts.
      openCultureSheet(c);
      setFb('ok', t('scanFb.cultureScanned', { val: val }), { noModal: true });
      return;
    }
    // Eine Kultur-Nummer, die hier keiner kennt. Ohne diese Stelle lief sie
    // weiter in die Beutel-Logik (sie endet auf -NN wie ein Beutel) und kam als
    // "Charge MC-… gibt es nicht" heraus.
    if (!synced) {
      scanAfterSync(raw);
      return;
    }
    kulturAufnehmenAnbieten(val);
    return;
  }
  // Ein Beutel ist, was eine Charge als Beutel führt — nicht nur, was auf zwei
  // Ziffern endet. Blöcke aus einem Substratansatz werden nur so breit gezählt,
  // wie die Charge groß ist: der siebte von acht heißt "-7". Die Zwei-Ziffern-
  // Regel allein ließ jeden davon als "kein Etikett aus diesem System" durchfallen,
  // obwohl er dastand. Für Beutel, die dieses Telefon noch nicht kennt, gilt sie
  // weiter: die fragen erst beim Server nach.
  const bagOwner = batches.find((b) => (b.bags || []).some((x) => String(x).toUpperCase() === val));
  const isBag = !!bagOwner || /-\d{2}$/.test(val);
  const batchId = bagOwner ? bagOwner.batchId : isBag ? val.split('-').slice(0, -1).join('-') : val;
  const batch = batches.find((b) => b.batchId.toUpperCase() === batchId.toUpperCase());
  // Ein Beutel, dessen Charge hier niemand kennt. Vorher ging er trotzdem in die
  // Vorgänge und kam als "hat keinen bekannten Standort — erst mit ADD
  // platzieren" heraus: eine Anweisung, die nicht helfen kann, weil es die
  // Charge gar nicht gibt — oder weil das Telefon sie noch nicht kennt. Die
  // Inventur ist ausgenommen; ihr Abgleich will auch fremde Beutel sehen.
  if (isBag && !batch && !_zcScanMode) {
    if (!synced) {
      scanAfterSync(raw);
      return;
    }
    setFb('err', t('scanFb.batchNotInSystem', { bag: val, batch: batchId }));
    return;
  }
  // When the bag-select modal is open and we scan a bag, toggle it in the selection
  // instead of opening a new bag-info modal.
  if (
    isBag &&
    bsBatchId &&
    document.getElementById('m-bagselect').classList.contains('open') &&
    batchId.toUpperCase() === bsBatchId.toUpperCase()
  ) {
    const res = bsToggleBag(val);
    if (res.toggled) {
      _scanBeep(800, 60);
      setFb(
        'ok',
        t('bagSelect.toggled', { bag: val, action: res.added ? t('bagSelect.added') : t('bagSelect.removed') })
      );
    } else {
      _scanBeep(300, 150);
      setFb('err', t('scanFb.bagNotPlaced', { bag: val }));
    }
    return;
  }
  // Scan belongs to a different batch while the select modal is open: warn.
  if (
    isBag &&
    bsBatchId &&
    document.getElementById('m-bagselect').classList.contains('open') &&
    batchId.toUpperCase() !== bsBatchId.toUpperCase()
  ) {
    _scanBeep(300, 150);
    setFb('err', t('bagSelect.notInBatch', { bag: val, id: bsBatchId }));
    return;
  }
  if (batch || isBag) {
    // Stocktake: a scan means "this bag is physically in front of me", so it
    // ticks off the check list instead of running the normal action flow.
    if (_zcScanMode && isBag) {
      zoneCheckScanned(val, batchId);
      return;
    }
    // A "Beimpft mit" field has the camera: the worker is naming the grain bag
    // they inoculated from, not asking about the bag. Only with no action armed,
    // so an explicit MOVE/REMOVE still wins. Closing the camera is what brings
    // the quick dialog back into view (it steps aside for the camera).
    if (isBag && !scan.action && _inocScanPrefix) {
      const err =
        _inocScanPrefix === 'wkb' ? wkbInocAdd(val) : _inocScanPrefix === 'ms-q' ? msqInocAdd(val) : inocAdd(val);
      if (err) {
        _scanBeep(300, 150);
        setFb('err', err);
        return;
      }
      if (_inocScanPrefix === 'ms-q') msQuickRender();
      else inocRender(_inocScanPrefix);
      _scanBeep(800, 60);
      setFb('ok', t('inoc.added', { id: val }));
      closeCamScan();
      return;
    }
    if (!scan.action) {
      openBagInfo(val, batchId, batch);
      return;
    }
    if (scan.action === 'HARVEST') {
      showHarvestPanel(isBag ? val : batchId, batchId);
      return;
    }
    if (scan.action === 'CONTAM') {
      // Eine ganze Charge hat keine Beutelnummer — dafür gibt es nichts zu
      // sammeln, das Formular geht wie bisher sofort auf.
      if (!isBag) {
        // Es sei denn, es liegen schon Beutel in der Liste: die Meldung über
        // die ganze Charge würde sie ersetzen, ohne dass jemand es sieht.
        if (_crTargets.length) {
          setFb('err', t('contam.batchWhileCollecting', { n: _crTargets.length }));
          return;
        }
        // Die Kamera muss zu, sonst läge sie über dem Formular (beide z-index
        // 200, die Kamera steht im Quelltext dahinter).
        closeCamScan();
        openContamReport(null, batchId, null);
        return;
      }
      // Sonst wird gesammelt: der Scanner bleibt in CONTAM, die Kamera bleibt
      // offen, und der Beutel legt sich zu den anderen. Das Formular kommt
      // einmal am Ende — vorher stand es nach jedem einzelnen Scan im Weg.
      const r = crToggleTarget(val, batchId);
      _scanBeep(r.added ? 800 : 500, 60);
      setFb(
        'ok',
        r.added ? t('contam.collected', { bag: val, n: r.count }) : t('contam.uncollected', { bag: val, n: r.count })
      );
      // Ein offenes Formular zeigt die Liste mit — am Tisch scannt man mit dem
      // Handscanner weiter, während es aufsteht.
      if (document.getElementById('m-contam-report').classList.contains('open')) _crRenderTargets();
      updateSD();
      return;
    }
    // Raus mit einem Körnerbeutel heißt: er ging in Blöcke. Gebucht wie
    // "Verbraucht", damit er nicht als weggeworfen zählt.
    if (scan.action === 'REMOVE' && isBag && batch && batch.batchType === 'grain') {
      verbrauchtScan(val, batch);
      return;
    }
    if (scan.action === 'ADD' && !scan.to) {
      setFb('err', t('scanFb.scanLocFirst'));
      return;
    }
    if ((scan.action === 'MOVE' || scan.action === 'MOVE_BATCH') && !scan.to) {
      setFb('err', t('scanFb.scanToFirst'));
      return;
    }
    // MOVE_BATCH: scan any bag or batch ID → move entire batch
    if (scan.action === 'MOVE_BATCH' && batch) {
      moveBatchTo(batch, scan.to, function (moved, skipped) {
        if (!moved) {
          _scanBeep(500, 120);
          // Alle schon am Ziel ist kein Fehler, sondern nichts zu tun.
          setFb(
            skipped ? 'warn' : 'err',
            batch.batchId +
              ': ' +
              (skipped
                ? t('batch.allAlreadyAt', { n: skipped, loc: zoneDisplayName(scan.to) })
                : t('batch.noBagsToMove'))
          );
          updateSD();
          return;
        }
        setFb(
          'ok',
          'MOVE BATCH ' +
            batch.batchId +
            ': ' +
            moved +
            ' Bags → ' +
            scan.to +
            (skipped ? ' (' + skipped + ' übersprungen)' : '')
        );
        scan.count += moved;
        updateSD();
      });
      return;
    }
    // Was dieser Scan bucht. Meist der Vorgang selbst — beim Umziehen wird ein
    // Beutel ohne Platz im System am Ziel eingelagert statt umgezogen (unten).
    let act = scan.action;
    // MOVE: auto-derive FROM from bag's last known location
    if (scan.action === 'MOVE') {
      // Umgezogen wird Beutel für Beutel; eine Chargen-Nummer allein hat keinen
      // Platz, den man ändern könnte.
      if (!isBag) {
        _scanBeep(300, 150);
        setFb('err', t('scanFb.moveNeedsBag', { batch: batchId }));
        return;
      }
      const bagLast = [...scanLog]
        .reverse()
        .find(
          (e) =>
            (e.bag || '').toUpperCase() === val.toUpperCase() &&
            (e.action === 'ADD' || e.action === 'MOVE' || e.action === 'REMOVE')
        );
      if (!bagLast || bagLast.action === 'REMOVE') {
        // Laut System liegt der Beutel nirgends: nie eingelagert, oder als
        // entfernt gebucht. Wer ihn in der Hand hat, weiß es besser. Hier stand
        // "erst mit ADD platzieren" — ein Weg, den es am Telefon nicht gibt, und
        // die Reihe blieb an diesem Beutel hängen. Jetzt reicht derselbe Beutel
        // ein zweites Mal, dann wird er am Ziel eingelagert; ein einzelner
        // versehentlicher Scan bucht nichts.
        const key = val + '>' + scan.to;
        if (_pendingPlace !== key) {
          _pendingPlace = key;
          clearTimeout(_pendingPlaceTimer);
          _pendingPlaceTimer = setTimeout(() => {
            _pendingPlace = null;
          }, CONFIRM_SCAN_MS);
          _scanBeep(300, 150);
          setFb(
            'warn',
            t(bagLast ? 'scanFb.bagRemovedPlace' : 'scanFb.bagNotPlacedPlace', {
              bag: val,
              loc: zoneDisplayName(scan.to)
            })
          );
          return;
        }
        clearTimeout(_pendingPlaceTimer);
        _pendingPlace = null;
        act = 'ADD';
        scan.from = null;
      } else {
        const curLoc = bagLast.to || null;
        if (curLoc && curLoc.toUpperCase() === scan.to.toUpperCase()) {
          // Schon da: kein Fehler, nur nichts zu tun.
          _scanBeep(500, 120);
          setFb('warn', t('scanFb.bagAlreadyAt', { bag: val, loc: zoneDisplayName(scan.to) }));
          return;
        }
        scan.from = curLoc;
      }
    }
    // REMOVE: auto-derive FROM from bag's last known location.
    //
    // Entsorgen ist ein Scan pro Beutel. Hier stand eine Doppel-Bestätigung:
    // jeden Beutel zweimal scannen, mit drei Sekunden dazwischen, weil die
    // Kamera dasselbe Etikett so lange nicht wieder annimmt. Für eine Reihe
    // verschimmelter Beutel hieß das: niemand benutzt es. Die Bestätigung ist
    // jetzt der Knopf, der dafür an sein muss; jeder Beutel steht mit seinem
    // Rückgängig im Protokoll, und ↩ in der Kamera nimmt den letzten zurück.
    if (scan.action === 'REMOVE') {
      const bagLastR = [...scanLog]
        .reverse()
        .find(
          (e) =>
            (e.bag || '').toUpperCase() === val.toUpperCase() &&
            (e.action === 'ADD' || e.action === 'MOVE' || e.action === 'REMOVE')
        );
      // Schon entsorgt: nichts zu tun. Vorher bekam er einen zweiten Eintrag.
      if (isBag && bagLastR && bagLastR.action === 'REMOVE') {
        _scanBeep(500, 120);
        setFb('warn', t('scanFb.alreadyRemoved', { bag: val }));
        return;
      }
      scan.from = bagLastR ? bagLastR.to : null;
    }
    // Duplicate detection: warn if same bag+action+to already in session
    const dupeKey = val + '|' + act + '|' + scan.to;
    if (act !== 'REMOVE') {
      const hasDupe = sessionEntries.some((e) => (e.bag || e.batch) + '|' + e.action + '|' + e.to === dupeKey);
      if (hasDupe) {
        if (_pendingDupe === dupeKey) {
          clearTimeout(_pendingDupeTimer);
          _pendingDupe = null;
          // Confirmed duplicate — fall through
        } else {
          _pendingDupe = dupeKey;
          clearTimeout(_pendingDupeTimer);
          _pendingDupeTimer = setTimeout(() => {
            _pendingDupe = null;
          }, CONFIRM_SCAN_MS);
          _scanBeep(500, 120);
          setFb('warn', t('scanFb.dupeConfirm', { bag: val }));
          return;
        }
      }
    }
    const tempId = 's' + ++_scanTempIdCounter;
    const isMove = act === 'MOVE' || act === 'MOVE_BATCH';
    const entry = {
      time: new Date().toISOString(),
      action: act,
      batch: batchId,
      bag: isBag ? val : null,
      from: act === 'ADD' ? null : scan.from,
      to: scan.to,
      species: batch?.species,
      strain: batch?.strain,
      user: currentUser?.username || null,
      client_uuid: newScanUuid(),
      // I-12: optimistic concurrency snapshot for offline-queue replays.
      // Only meaningful for MOVE/MOVE_BATCH (ADD has no expected zone).
      expected_current_zone: isMove && scan.from ? toZone(scan.from) : null,
      _tempId: tempId
    };
    scanLog.push(entry);
    movements.push(entry);
    if (!sessionStartTime) sessionStartTime = Date.now();
    sessionEntries.push(entry);
    if (scanChannel)
      scanChannel.postMessage({
        type: 'scan-entry',
        entry: { bag: entry.bag, batch: entry.batch, action: entry.action, to: entry.to }
      });
    scan.count++;
    // I-12 applies: on a zone_mismatch the server rejected the MOVE because the
    // bag has since been moved by someone else — postScanEntries drops the local
    // entry and toasts, without retrying into the same 409.
    postScanEntries([entry]);
    _lastScanVal = isBag ? val : batchId;
    // Umziehen: mit den Namen der Plätze statt ihrer Kürzel, und mitgezählt —
    // die Zahl steht auch auf dem Knopf, solange die Kamera das Bild füllt.
    if (scan.action === 'MOVE') {
      const n = modeRunTally('MOVE', entry.to, entry);
      const zu = zoneDisplayName(entry.to);
      setFb(
        'ok',
        act === 'ADD'
          ? t('scanFb.placedLogged', { bag: val, to: zu, n: n })
          : t('scanFb.moveLogged', { bag: val, from: entry.from ? zoneDisplayName(entry.from) : '?', to: zu, n: n }),
        entry
      );
      updateSD();
      return;
    }
    // Entsorgen: der Beutel beim Namen, und mitgezählt wie beim Umziehen.
    if (act === 'REMOVE') {
      const n = modeRunTally('REMOVE', null, entry);
      setFb('ok', t('scanFb.trashLogged', { bag: val, n: n }), entry);
      updateSD();
      return;
    }
    const fbTo = scan.to ? ' \u2192 ' + zoneDisplayName(scan.to) : '';
    setFb('ok', t('scanFb.logged', { action: scan.action, val: val, to: fbTo, n: scan.count }), entry);
    updateSD();
    return;
  }
  // URL QR codes: inform user instead of showing "unknown"
  if (/^https?:\/\//i.test(raw.trim())) {
    setFb('info', 'QR-Code enthält URL: ' + raw.trim().slice(0, 80) + (raw.trim().length > 80 ? '…' : ''));
    return;
  }
  // Nichts davon. Ein neuer Platz oder eine neue Charge kann aber jünger sein als
  // der Stand auf diesem Telefon — erst nachfragen, dann urteilen.
  if (!synced) {
    scanAfterSync(raw);
    return;
  }
  setFb('err', t('scanFb.unknown', { val: val }));
}

// Der Vorgang in Worten, für Meldungen. Die Kürzel (MOVE, HARVEST …) stehen auf
// den gedruckten Etiketten und im Log; wer eine Meldung liest, braucht das Wort.
function scanActionName(a) {
  const s = t('scanAct.' + a);
  return s === 'scanAct.' + a ? a : s;
}
// Raus aus dem Bestand: verbraucht, verkauft oder kontaminiert.
function cultureGone(c) {
  return c.status === 'used' || c.status === 'sold' || c.status === 'contam';
}
// Warum eine Kultur nicht genommen werden kann, in Worten statt "ist contam".
function cultureRefusal(c) {
  if (c.status === 'contam') return t('scanFb.cultureContam', { id: c.id });
  if (c.status === 'sold') return t('scanFb.cultureSold', { id: c.id });
  return t('scanFb.cultureUsed', { id: c.id });
}
// ── Verbraucht: Körnerbrut aus dem Bestand ──────────────────
// Ein Körnerbeutel, mit dem Blöcke beimpft wurden, stand weiter im Bestand, bis
// ihn jemand entsorgte — und dann zählte er als weggeworfen. "Verbraucht" bucht
// ihn aus wie Entsorgen: ein Knopf, dann Beutel für Beutel scannen, ↩ nimmt den
// letzten zurück. Gebucht wird, was das Anlegen einer Charge bucht, wenn dort
// Körnerbrut als verbraucht angegeben wird (inocVerbrauchtBuchen): ein REMOVE mit
// dem Grund "spawn". Ohne die Charge dahinter — in welche der Beutel ging, weiß
// der Scanner nicht; das weiß "Charge anlegen", und dort wird sie mitgeschrieben.
function verbrauchtScan(val, batch) {
  const bag = (batch.bags || []).find((x) => x.toUpperCase() === val.toUpperCase()) || val;
  const last = buildLastPlacementByBag().get(bag.toUpperCase());
  if (last && last.action === 'REMOVE') {
    _scanBeep(500, 120);
    setFb('warn', t(istVerbraucht(last) ? 'scanFb.alreadyUsed' : 'scanFb.alreadyRemoved', { bag: bag }));
    return;
  }
  const [entry] = spawnBuchen([bag], 'spawn', { sitzung: true });
  _lastScanVal = bag;
  const n = modeRunTally('REMOVE', null, entry);
  setFb('ok', t('scanFb.usedLogged', { bag: bag, n: n }), entry);
  updateSD();
}
// ── Raus: eine Kultur aus dem System ─────────────────────────
// Im Raus-Modus der Kamera ist eine gescannte Kultur verbraucht — derselbe
// Status, den "Verbraucht" in der Kulturliste setzt. ↩ nimmt die letzte zurück
// (camUndoLastScan), darum merkt sich _kulturRaus, was vorher war.
const _kulturRaus = [];
function kulturRausScan(c) {
  if (cultureGone(c)) {
    _scanBeep(500, 120);
    setFb('warn', cultureRefusal(c));
    return;
  }
  _kulturRaus.push({ id: c.id, prev: c.status, at: Date.now() });
  if (_kulturRaus.length > 50) _kulturRaus.shift();
  setCultureStatus(c.id, 'used');
  _lastScanVal = c.id;
  const n = modeRunTally('REMOVE', null, null);
  _scanBeep(800, 60);
  setFb('ok', t('scanFb.cultureOut', { id: c.id, n: n }));
  updateSD();
}
// ── Das Kultur-Fenster ───────────────────────────────────────
// Eine gescannte Kultur zeigt, was sie ist, und was man mit ihr tun kann — im
// selben Fenster wie ein Beutel (m-baginfo), mit eigenen Knöpfen (data-bi="ci-…").
let ciCultureId = null;
function openCultureSheet(c) {
  biBagId = null;
  biBatchId = null;
  ciCultureId = c.id;
  document.getElementById('bi-title').textContent = c.id;
  const STATUS = { active: 'lab.active', stored: 'lab.stored', used: 'lab.usedUp', sold: 'lab.sold', contam: 'lab.contaminated' };
  const status = STATUS[c.status];
  const kinder = cultures.filter((x) => x.parentId === c.id).length;
  const met = (k, v) =>
    `<div class="met"><div class="met-l">${esc(k)}</div><div class="fs-base" style="font-weight:600">${v}</div></div>`;
  const name = c.strainName || c.species || '';
  document.getElementById('bi-body').innerHTML =
    ciVerfuegbarHtml(c) +
    '<div style="display:grid;grid-template-columns:1fr 1fr;gap:8px;margin-bottom:12px">' +
    met(t('ci.type'), esc(t('ci.type.' + c.type))) +
    met(t('batch.species'), spDot(name) + esc(name)) +
    met(t('batch.strain'), (c.strainText || '').trim() ? esc(c.strainText.trim()) : '\u2014') +
    met(t('ci.status'), esc(status ? t(status) : c.status || '')) +
    met(t('ci.created'), esc(c.created ? fmtDt(c.created) : '\u2014')) +
    '</div>' +
    ciGroesseHtml(c) +
    ciHerkunftHtml(c) +
    (kinder
      ? `<div class="fs-meta muted" style="margin-bottom:10px">${esc(t('ci.children', { n: kinder }))}</div>`
      : '');
  renderCiActions(c);
  closeCamScan();
  closeScanModal();
  document.getElementById('m-baginfo').classList.add('open');
}
// Wieviele aus demselben Ansatz noch da sind: dieselbe Kennung bis auf die
// letzte Nummer (SY-…-011026-01 bis -04). Das ist die erste Frage, wenn man ein
// Glas oder eine Spritze in der Hand hat, also steht es zuoberst — die Zahl groß,
// darunter die Nummern, die gemeinsam angesetzten, die schon raus sind,
// durchgestrichen und die gescannte hervorgehoben.
// Spritzen nur gleicher Größe: eine 10er und eine 50er vom selben Tag tragen
// dieselbe Kennung bis auf die Nummer, sind aber nicht dasselbe Angebot.
function ciGeschwister(c) {
  const stamm = c.id.slice(0, c.id.lastIndexOf('-') + 1);
  return cultures
    .filter(
      (x) =>
        x.id.startsWith(stamm) &&
        /^\d+$/.test(x.id.slice(stamm.length)) &&
        (x.type !== 'SY' || (x.ml || 10) === (c.ml || 10))
    )
    .sort((a, b) => a.id.localeCompare(b.id));
}
function ciVerfuegbarHtml(c) {
  const alle = ciGeschwister(c);
  const da = (x) => x.status === 'active' || x.status === 'stored';
  const n = alle.filter(da).length;
  const chips = alle
    .map((x) => {
      const nr = x.id.slice(x.id.lastIndexOf('-') + 1);
      const ich = x.id === c.id;
      const stil = ich
        ? 'background:var(--c-text);color:#fff;border-color:var(--c-text)'
        : da(x)
          ? 'background:var(--c-bg);color:var(--c-text-sec)'
          : 'background:transparent;color:var(--c-text-muted);text-decoration:line-through';
      return `<span class="fs-xs" style="font-family:monospace;padding:3px 8px;border-radius:5px;border:1px solid var(--c-border);${stil}">${esc(nr)}</span>`;
    })
    .join('');
  return (
    `<div class="met" style="margin-bottom:12px"><div class="met-l">${esc(t('ci.availableLbl'))}</div>` +
    `<div style="font-size:1.75rem;font-weight:700;line-height:1.1;color:${n ? 'var(--c-primary)' : 'var(--c-red-dark)'}">` +
    `${esc(t('ci.available', { n: n, total: alle.length }))}</div>` +
    (alle.length > 1 ? `<div style="display:flex;flex-wrap:wrap;gap:4px;margin-top:6px">${chips}</div>` : '') +
    '</div>'
  );
}
// Die Größe einer Spritze, mit den drei Knöpfen: falsch gewählt beim Abfüllen
// ist ein Tipp zum Richtigstellen, mit Rückgängig unten. Solange sie da ist —
// eine verkaufte oder verbrauchte zeigt ihre Größe nur noch an.
function ciGroesseHtml(c) {
  if (c.type !== 'SY') return '';
  const da = c.status === 'active' || c.status === 'stored';
  const inhalt = da
    ? `<div style="margin-top:4px">${syMlKnoepfe('ci-ml', syMl(c))}</div>`
    : `<div class="fs-base" style="font-weight:600">${syMl(c)} ml</div>`;
  return `<div class="met" style="margin-bottom:12px"><div class="met-l">${esc(t('sy.size'))}</div>${inhalt}</div>`;
}
function setCultureMl(id, ml) {
  const c = cultures.find((x) => x.id === id);
  if (!c || c.type !== 'SY') return;
  const prev = syMl(c);
  c.ml = ml;
  renderCultures();
  if (ciCultureId === id) openCultureSheet(c);
  apiPatch('/api/cultures/' + encodeURIComponent(id), { ml }).then((r) => {
    if (r && r.error) {
      c.ml = prev;
      renderCultures();
      if (ciCultureId === id) openCultureSheet(c);
      setFb('err', t('common.error') + ': ' + r.error);
    }
  });
}
(function wireCiMl() {
  document.addEventListener('click', (e) => {
    const b = e.target.closest('[data-ci-ml]');
    if (!b || !ciCultureId) return;
    const c = cultures.find((x) => x.id === ciCultureId);
    const ml = parseInt(b.dataset.ciMl, 10);
    if (!c || !SY_ML.includes(ml) || ml === syMl(c)) return;
    const prev = syMl(c);
    setCultureMl(c.id, ml);
    showUndoBar(t('ci.sizeDone', { id: c.id, ml: ml }), () => setCultureMl(c.id, prev));
  });
})();
// Der Stammbaum nach oben, gleich im Fenster: Slant → Petrischale → … → diese.
// Wer eine Spritze in der Hand hat, will wissen, woher sie kommt, und dafür
// musste man sonst auf die Laborseite. Ohne Herkunft steht da, dass es keine gibt.
function ciHerkunftHtml(c) {
  const kette = [];
  const seen = new Set([c.id]);
  let p = c.parentId ? cultures.find((x) => x.id === c.parentId) : null;
  while (p && !seen.has(p.id) && kette.length < 10) {
    seen.add(p.id);
    kette.unshift(p);
    p = p.parentId ? cultures.find((x) => x.id === p.parentId) : null;
  }
  const zeile = (x, ich) =>
    `<div style="display:flex;align-items:center;gap:6px;flex-wrap:wrap">${ctBadge(x.type)}<span class="fs-meta" style="font-family:monospace;${ich ? 'font-weight:700' : ''}">${esc(x.id)}</span></div>`;
  // Eine Herkunft, die nicht (mehr) in der Liste steht, wird trotzdem genannt.
  const oben = kette.length ? kette[0] : c;
  if (oben.parentId && !cultures.some((x) => x.id === oben.parentId))
    kette.unshift({ id: oben.parentId, type: oben.parentId.split('-')[0] });
  const inhalt = kette.length
    ? kette.map((x) => zeile(x, false)).join('<div class="fs-xs muted" style="margin-left:10px">↓</div>') +
      '<div class="fs-xs muted" style="margin-left:10px">↓</div>' +
      zeile(c, true)
    : `<div class="fs-meta muted">${esc(t('ci.noParent'))}</div>`;
  return (
    `<div class="met" style="margin-bottom:12px"><div class="met-l">${esc(t('ci.herkunft'))}</div>` +
    `<div style="display:flex;flex-direction:column;gap:2px;margin-top:4px">${inhalt}</div></div>`
  );
}
// Was als Kultur auch im Shop steht.
const CI_VERKAUFBAR = ['SY', 'PD'];
function renderCiActions(c) {
  const el = document.getElementById('bi-actions');
  if (!el) return;
  const aktiv = c.status === 'active' || c.status === 'stored';
  // Dieselben Formen wie renderBiActions.
  const big =
    'width:100%;display:flex;align-items:center;justify-content:center;gap:8px;padding:15px;border-radius:12px;border:0;font-weight:600;margin-bottom:8px;cursor:pointer';
  const sec =
    'flex:1;display:flex;align-items:center;justify-content:center;gap:6px;padding:13px;border-radius:10px;cursor:pointer;background:var(--c-surface);border:1px solid var(--c-border)';
  // Ob aus dieser Kultur überhaupt etwas angesetzt werden kann.
  const alsHerkunft = bmpArten(c.type).length > 0;
  let html = '';
  // Spritzen und Petrischalen gehen auch in den Versand. Verkauft steht dann
  // zuoberst: es ist der haeufigste Weg hinaus, und es haelt die Zahl ehrlich,
  // die Billbee den Shops meldet (syringe-stock.js).
  if (aktiv && CI_VERKAUFBAR.includes(c.type))
    html += `<button type="button" data-bi="ci-sold" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-primary);color:#fff">✓ ${esc(t('ci.sold'))}</button>`;
  if (aktiv)
    html += `<button type="button" data-bi="ci-out" class="fs-floor" style="--fs-own:1.0625rem;${big};background:var(--c-purple-dark);color:#fff">✓ ${esc(t('ci.out'))}</button>`;
  html += '<div style="display:flex;gap:8px;margin-bottom:8px">';
  if (aktiv && alsHerkunft)
    html += `<button type="button" data-bi="ci-beimpfen" class="fs-base" style="${sec};color:var(--c-text);font-weight:600">${esc(t('ci.beimpfen'))}</button>`;
  html += `<button type="button" data-bi="ci-lineage" class="fs-base" style="${sec};color:var(--c-text-sec)">${esc(t('ci.lineage'))}</button>`;
  html += '</div>';
  if (aktiv)
    html += `<button type="button" data-bi="ci-contam" class="fs-base" style="${big};padding:13px;background:var(--c-red-light);color:var(--c-red-dark);border:1px solid var(--c-red-border)">${esc(t('ci.contam'))}</button>`;
  // Was die Tabelle der Kulturbibliothek je Zeile hatte: drucken, löschen, und
  // eine erledigte wieder in den Bestand holen, wenn sie doch noch da ist.
  if (!aktiv)
    html += `<button type="button" data-bi="ci-active" class="fs-base" style="${big};padding:13px;background:var(--c-primary-light);color:var(--c-primary);border:1px solid var(--c-border)">${esc(t('ci.backActive'))}</button>`;
  html += '<div style="display:flex;gap:8px">';
  html += `<button type="button" data-bi="ci-print" class="fs-base" style="${sec};color:var(--c-text)">${esc(t('ci.print'))}</button>`;
  if (_lbDarfWeg(c))
    html += `<button type="button" data-bi="ci-delete" class="fs-base" style="${sec};color:var(--c-red-dark)">${esc(t('ci.delete'))}</button>`;
  html += '</div>';
  el.innerHTML = html;
}
// Ein Tipp, mit Rückgängig unten — wie überall, wo etwas aus dem System geht.
function ciSetStatus(status, msgKey) {
  const c = cultures.find((x) => x.id === ciCultureId);
  if (!c) return;
  const prev = c.status;
  document.getElementById('m-baginfo').classList.remove('open');
  setCultureStatus(c.id, status);
  showUndoBar(t(msgKey, { id: c.id }), () => setCultureStatus(c.id, prev));
}
function ciAction(a) {
  const c = cultures.find((x) => x.id === ciCultureId);
  if (!c) return;
  if (a === 'ci-out') return ciSetStatus('used', 'ci.outDone');
  if (a === 'ci-sold') return ciSetStatus('sold', 'ci.soldDone');
  if (a === 'ci-contam') return ciSetStatus('contam', 'ci.contamDone');
  if (a === 'ci-active') return ciSetStatus('active', 'ci.activeDone');
  document.getElementById('m-baginfo').classList.remove('open');
  if (a === 'ci-print') return quickPrintCulture(c.id);
  if (a === 'ci-delete') return kulturenLoeschen([c]);
  if (a === 'ci-lineage') {
    go('lab', 'n-lab');
    openStab('lab', 'lineage');
    setTimeout(() => {
      const sel = document.getElementById('lineage-sel');
      if (sel) sel.value = 'C:' + c.id;
      renderLineage();
      // Am Telefon steht über dem Stammbaum der Laborbestand; ohne das hier sah
      // man nur den oberen Teil der Laborseite, und der Baum lag darunter.
      const sp = document.getElementById('sp-lab-lineage');
      if (sp) sp.scrollIntoView({ block: 'start' });
    }, 100);
    return;
  }
  if (a === 'ci-beimpfen') bmpOpen(c);
}
// ── Beimpfen: aus einer Kultur vieles auf einmal ─────────────
// Eine Spritze, 40 ml aus dem Glas: daraus gehen 4 Körnerbeutel, 3 neue
// Flüssigkulturen und 10 Petrischalen, in einem Durchgang am Tisch. Einzeln
// hieß das: für jede Art den Dialog öffnen und dieselbe Spritze neu scannen.
// Hier steht je Art eine Zahl, und ein Tipp legt alles an — jede neue Kultur
// mit dieser als Herkunft, so dass der Stammbaum zeigt, wohin sie ging.
let _bmp = null;
// Was aus einer Kultur dieser Art angesetzt werden darf, in der Reihenfolge der
// Zeilen. KB ist Körnerbrut (eine Charge mit Beuteln), der Rest sind Kulturen.
function bmpArten(type) {
  return ['KB', 'LC', 'PD', 'MC', 'SY'].filter((k) => (LAB_PARENT_TYPES[k] || []).includes(type));
}
function bmpOpen(c) {
  // Jede Anzahl fängt bei 0 an: was letztes Mal angesetzt wurde, ist nicht, was
  // heute ansteht, und eine stehengebliebene Zahl legt unbemerkt zu viel an.
  // Körnerbeutel und Spritzen zählen je Größe.
  _bmp = {
    id: c.id,
    n: Object.fromEntries(bmpArten(c.type).map((k) => [k, 0])),
    sy: Object.fromEntries(SY_ML.map((ml) => [ml, 0])),
    kb: Object.fromEntries(KB_KG.map((kg) => [kg, 0]))
  };
  anlageReset('bmp');
  document.getElementById('bmp-title').textContent = t('bmp.title', { id: c.id });
  const name = c.strainName || c.species || '';
  document.getElementById('bmp-sub').textContent =
    name + ((c.strainText || '').trim() ? ' · ' + c.strainText.trim() : '');
  bmpRender();
  document.getElementById('m-beimpfen').style.display = 'flex';
}
function bmpClose() {
  _bmp = null;
  document.getElementById('m-beimpfen').style.display = 'none';
}
function bmpRender() {
  if (!_bmp) return;
  const c = cultures.find((x) => x.id === _bmp.id);
  if (!c) return;
  const knopf =
    'width:var(--tap);height:var(--tap);min-width:44px;min-height:44px;flex:none;border-radius:10px;border:1px solid var(--c-border);background:var(--c-surface);font-size:1.25rem;font-weight:600;cursor:pointer';
  document.getElementById('bmp-rows').innerHTML = bmpArten(c.type)
    .map((k) => {
      // Spritzen und Körnerbeutel zählen je Größe: drei Zähler unter einer
      // Überschrift.
      if (k === 'SY' || k === 'KB')
        return (
          `<div style="padding:8px 0;border-bottom:1px solid var(--c-border-light)">` +
          `<div class="fs-base" style="font-weight:600;margin-bottom:6px">${esc(t('bmp.' + k))}</div>` +
          (k === 'SY' ? syMengenHtml('bmp', _bmp.sy) : kbMengenHtml('bmp', _bmp.kb)) +
          '</div>'
        );
      const zeile =
        `<div style="display:flex;align-items:center;gap:8px">` +
        `<button type="button" data-bmp="minus" data-k="${k}" aria-label="${esc(t('bmp.less'))}" style="${knopf}">−</button>` +
        `<input type="number" inputmode="numeric" min="0" max="500" id="bmp-n-${k}" data-bmp-n="${k}" value="${_bmp.n[k]}" style="width:64px;text-align:center;font-weight:600" />` +
        `<button type="button" data-bmp="plus" data-k="${k}" aria-label="${esc(t('bmp.more'))}" style="${knopf}">+</button>` +
        `<span class="fs-base" style="font-weight:600">${esc(t('bmp.' + k))}</span></div>`;
      return `<div style="padding:8px 0;border-bottom:1px solid var(--c-border-light)">${zeile}</div>`;
    })
    .join('');
  anlageRender('bmp');
  bmpPreview();
}
function _bmpLesen() {
  if (!_bmp) return;
  for (const k of Object.keys(_bmp.n)) {
    const el = document.getElementById('bmp-n-' + k);
    if (el) _bmp.n[k] = Math.max(0, Math.min(500, parseInt(el.value, 10) || 0));
  }
  if ('SY' in _bmp.n) {
    _bmp.sy = syMengenLesen('bmp');
    _bmp.n.SY = sySumme(_bmp.sy);
  }
  if ('KB' in _bmp.n) {
    _bmp.kb = kbMengenLesen('bmp');
    _bmp.n.KB = KB_KG.reduce((a, kg) => a + _bmp.kb[kg], 0);
  }
}
function bmpPreview() {
  if (!_bmp) return;
  _bmpLesen();
  const teile = Object.entries(_bmp.n)
    .filter(([, n]) => n > 0)
    .flatMap(([k, n]) =>
      k === 'KB'
        ? KB_KG.filter((kg) => _bmp.kb[kg] > 0).map((kg) => t('bmp.previewGrain', { n: _bmp.kb[kg], kg }))
        : k === 'SY'
          ? syTeile(_bmp.sy)
          : [n + ' ' + t('bmp.' + k)]
    );
  const summe = Object.values(_bmp.n).reduce((a, n) => a + n, 0);
  const prev = document.getElementById('bmp-preview');
  if (prev) prev.textContent = teile.length ? t('bmp.preview', { list: teile.join(' · ') }) : t('bmp.nothing');
  const go = document.getElementById('bmp-go');
  if (go) {
    go.disabled = !summe;
    go.textContent = summe ? t('bmp.goN', { n: summe }) : t('bmp.go');
  }
}
function bmpGo() {
  if (!_bmp) return;
  _bmpLesen();
  const c = cultures.find((x) => x.id === _bmp.id);
  if (!c) return;
  const ms = c.strainId ? mushroomStrains.find((x) => x.id === c.strainId) : null;
  if (!ms) {
    toast(t('bmp.noSorte', { id: c.id }), 'err');
    return;
  }
  const n = _bmp.n;
  if (!Object.values(n).some((x) => x > 0)) return;
  const angesetzt = anlageLesen('bmp');
  if (angesetzt === null) return;
  const wann = anlageZeitpunkt(angesetzt);
  // Alles aus dem Fenster jetzt: bmpClose() setzt _bmp auf null, und ein
  // Lesen aus _bmp danach brach das Anlegen mit einem Fehler ab.
  const sy = _bmp.sy || {};
  const kb = _bmp.kb || {};
  bmpClose();
  // Erst die Kulturen: jede Art ihre eigenen Kennungen, alle mit dieser als
  // Herkunft. Spritzen je Größe, jede Größe ihre eigenen Nummern.
  const ids = [];
  const saves = [];
  for (const k of ['LC', 'PD', 'MC', 'SY']) {
    if (!(n[k] > 0)) continue;
    const posten = k === 'SY' ? SY_ML.filter((ml) => sy[ml] > 0).map((ml) => [sy[ml], ml]) : [[n[k], null]];
    for (const [qty, ml] of posten) {
      const r = kulturenAnlegen({
        type: k,
        ms,
        wann,
        qty,
        parentId: c.id,
        strainText: (c.strainText || '').trim(),
        ml
      });
      ids.push(...r.newC.map((x) => x.id));
      saves.push(r.saved);
    }
  }
  // Dann die Körnerbrut, über denselben Weg wie aus dem Schnelldialog — mit der
  // Kultur als Herkunft und ohne eigenes Fenster: ihre Etiketten kommen mit
  // denen der Kulturen in eines (etikettenFuerAlles).
  let korn = null;
  if (n.KB > 0) {
    const setv = (id, val) => {
      const el = document.getElementById(id);
      if (el) el.value = val;
    };
    setv('lw-st', ms.id);
    setv('lw-strain-text', (c.strainText || '').trim());
    setv('lw-created', angesetzt);
    gsSetLines(KB_KG.filter((kg) => kb[kg] > 0).map((kg) => ({ kg, qty: kb[kg] })));
    setv('gs-days', 14);
    setv('gs-rh', ms.recGrainRhPct != null ? ms.recGrainRhPct : 52);
    setv('lw-notes', '');
    _inoc = [{ kind: 'culture', id: c.id }];
    korn = createGrainBatch({ ohneFenster: true }) || null;
  }
  renderLabLog();
  etikettenFuerAlles(ids, Promise.all(saves), korn);
}
(function wireBeimpfen() {
  document.addEventListener('click', (e) => {
    const b = e.target.closest('[data-bmp]');
    if (!b || !_bmp) return;
    const a = b.dataset.bmp;
    if (a === 'go') return bmpGo();
    if (a === 'cancel') return bmpClose();
    _bmpLesen();
    const k = b.dataset.k;
    if (!(k in _bmp.n)) return;
    _bmp.n[k] = Math.max(0, Math.min(500, _bmp.n[k] + (a === 'plus' ? 1 : -1)));
    const el = document.getElementById('bmp-n-' + k);
    if (el) el.value = _bmp.n[k];
    bmpPreview();
  });
  document.addEventListener('input', (e) => {
    if (_bmp && e.target.closest('#m-beimpfen')) bmpPreview();
  });
})();
// ─── GLOBAL BARCODE BUFFER (timing-based scanner detection) ──
const _scanBuf = { chars: [], timer: null };
const SCAN_MAX_GAP = 50;
const SCAN_MIN_LEN = 3;

function isKnownBarcode(val) {
  val = val.toUpperCase();
  // Numeric barcode (new system)
  if (/^\d{7,}$/.test(val) && parseInt(val, 10) >= 1000000) return true;
  // Check actions/locations with underscores intact (barcode locations use underscores)
  if (ACTIONS.includes(val)) return true;
  if (LOCS.includes(val)) return true;
  // For bag/batch patterns, convert underscores to hyphens
  const h = val.replace(/_/g, '-');
  if (/^[A-Z]{2,6}-[A-Z]{2,6}-\d{4}-\d{1,2}$/.test(h)) return true;
  if (/^(MC|PD|LC|SY|G2G|GS)-[A-Z0-9]+(?:-[A-Z0-9]+)?-\d{6}-\d{2}$/.test(h)) return true; // wie in processScan
  // Beutel: die Nummer hat eine bis drei Stellen ("-7" bei einer Charge unter zehn).
  if (/^[A-Z]+-\d{6}-\d{2}-\d{1,3}$/.test(h)) return true;
  if (/^[A-Z]+-\d{6}-\d{2}$/.test(h)) return true;
  return false;
}

function _flushScanBuf() {
  const raw = _scanBuf.chars.map((c) => c.ch).join('');
  _scanBuf.chars = [];
  if (raw.length < SCAN_MIN_LEN) return;
  const cleaned = raw.trim().toUpperCase();
  if (!isKnownBarcode(cleaned)) {
    setFb(
      'err',
      t('scanFb.unknownFormat', { val: cleaned }) || 'Unbekanntes Format: ' + cleaned + ' — Barcode prüfen.'
    );
    return;
  }
  processScan(raw);
}

document.addEventListener('keydown', (e) => {
  if (e.ctrlKey || e.metaKey || e.altKey) return;
  // Ignore keystrokes while user is typing in form fields — prevents the scan buffer
  // from swallowing Enter on form submits or mis-firing on fast typing in search boxes.
  // The scan modal and camera modal are exceptions: keep the buffer active there.
  const ae = document.activeElement;
  if (ae && (ae.tagName === 'INPUT' || ae.tagName === 'TEXTAREA' || ae.tagName === 'SELECT' || ae.isContentEditable)) {
    const scanOpen = document.getElementById('scan-overlay')?.classList.contains('open');
    const camOpen = document.getElementById('m-camscan')?.classList.contains('open');
    // The search palette is the search box this comment already warns about,
    // and it is the one that resolves a scanned code itself. Two readers of the
    // same keystrokes would open a result and log a movement off one scan.
    const gsOpenNow = document.getElementById('m-search')?.classList.contains('open');
    if (gsOpenNow || (!scanOpen && !camOpen)) {
      _scanBuf.chars = [];
      clearTimeout(_scanBuf.timer);
      return;
    }
  }
  const now = performance.now();
  if (e.key === 'Enter') {
    if (_scanBuf.chars.length >= SCAN_MIN_LEN) {
      clearTimeout(_scanBuf.timer);
      const allFast = _scanBuf.chars.every((c, i) => i === 0 || c.t - _scanBuf.chars[i - 1].t < SCAN_MAX_GAP);
      if (allFast) {
        e.preventDefault();
        e.stopPropagation();
        _flushScanBuf();
        return;
      }
    }
    _scanBuf.chars = [];
    clearTimeout(_scanBuf.timer);
    return;
  }
  if (e.key.length !== 1) return;
  if (_scanBuf.chars.length > 0 && now - _scanBuf.chars[_scanBuf.chars.length - 1].t > SCAN_MAX_GAP) {
    _scanBuf.chars = [];
  }
  _scanBuf.chars.push({ ch: e.key, t: now });
  clearTimeout(_scanBuf.timer);
  _scanBuf.timer = setTimeout(() => {
    _scanBuf.chars = [];
  }, SCAN_MAX_GAP * 2);
});

// ─── USER MANAGEMENT ─────────────────────────────────────────
async function doLogout() {
  try {
    await authFetch('/api/auth/logout', { method: 'POST' });
  } catch {}
  window.location.href = '/login.html';
}

async function loadUsersTab() {
  const c = document.getElementById('sp-settings-users');
  if (!c) return;
  const acct = document.getElementById('users-account');
  if (acct && currentUser)
    acct.innerHTML =
      t('users.loggedInAs', { user: esc(currentUser.username), role: esc(currentUser.role) }) +
      ` <button class="btn fs-xs" style="padding:2px 8px;margin-left:8px" onclick="showChangePasswordModal()">${t('chpw.title')}</button>`;
  if (!currentUser || currentUser.role !== 'admin') {
    const tbl = document.getElementById('users-table');
    if (tbl) tbl.innerHTML = '<p style="color:var(--c-text-muted)">' + t('users.adminRequiredManage') + '</p>';
    return;
  }
  try {
    const r = await authFetch('/api/users');
    const users = await r.json();
    const tbl = document.getElementById('users-table');
    if (!tbl) return;
    tbl.innerHTML =
      '<table class="t-cards us-tab" role="table"><thead role="rowgroup"><tr role="row">' +
      '<th role="columnheader">Username</th>' +
      '<th role="columnheader">Role</th>' +
      '<th role="columnheader" title="Darf Labels kaufen + Versanddaten sehen">Versand</th>' +
      '<th role="columnheader" title="Darf Ernte für den Verkauf freigeben — die Menge, die der Shop anbietet">Freigabe</th>' +
      '<th role="columnheader">Created</th>' +
      '<th role="columnheader"></th></tr></thead><tbody role="rowgroup">' +
      users
        .map(
          (u) =>
            `<tr><td data-mlabel="Username">${esc(u.username)}</td><td data-mlabel="Role">${esc(u.role)}</td><td data-mlabel="Versand">${u.role === 'admin' ? '<input type="checkbox" checked disabled title="Admins dürfen immer versenden">' : `<input type="checkbox" data-action="toggle-ship" data-user-id="${esc(u.id)}" ${u.can_ship ? 'checked' : ''}>`}</td><td data-mlabel="Freigabe">${u.role === 'admin' ? '<input type="checkbox" checked disabled title="Admins dürfen immer freigeben">' : `<input type="checkbox" data-action="toggle-release" data-user-id="${esc(u.id)}" ${u.can_release ? 'checked' : ''}>`}</td><td data-mlabel="Created">${u.created ? fmtDt(u.created) : ''}</td><td class="us-actions">${u.username !== currentUser.username ? `<button class="btn btn-r fs-xs" style="padding:2px 8px" data-action="delete-user" data-user-id="${esc(u.id)}">Delete</button>` : ''}</td></tr>`
        )
        .join('') +
      '</tbody></table>';
    // Diese Tabelle entsteht erst hier, also kann der Beobachter aus
    // watchCardTables() sie beim Aufbau der Seite nicht gekannt haben.
    watchCardTables(tbl);
    tbl.onclick = onUsersTableClick;
  } catch (e) {
    console.error('Failed to load users:', e);
  }
}

function onUsersTableClick(e) {
  const ship = e.target.closest('input[data-action="toggle-ship"]');
  if (ship) {
    const sid = parseInt(ship.dataset.userId, 10);
    if (Number.isFinite(sid)) toggleUserShip(sid, ship.checked);
    return;
  }
  const rel = e.target.closest('input[data-action="toggle-release"]');
  if (rel) {
    const rid = parseInt(rel.dataset.userId, 10);
    if (Number.isFinite(rid)) toggleUserRelease(rid, rel.checked);
    return;
  }
  const btn = e.target.closest('button[data-action="delete-user"]');
  if (!btn) return;
  const id = parseInt(btn.dataset.userId, 10);
  if (Number.isFinite(id)) deleteUser(id);
}
// Grant/revoke the shipping capability for a non-admin user. Reloads to reflect
// the server's truth (and revert the checkbox if the PATCH failed).
async function toggleUserShip(id, canShip) {
  try {
    const r = await authFetch('/api/users/' + id, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ canShip })
    });
    if (!r.ok) {
      const d = await r.json();
      toast(d.error || 'Failed', 'err');
    }
  } catch (e) {
    toast(e.message, 'err');
  }
  loadUsersTab();
}

// Grant/revoke the release capability. Same shape as toggleUserShip, and the
// reload matters for the same reason: the checkbox must end up showing what the
// server stored, not what was clicked.
async function toggleUserRelease(id, canRelease) {
  try {
    const r = await authFetch('/api/users/' + id, {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ canRelease })
    });
    if (!r.ok) {
      const d = await r.json();
      toast(d.error || 'Failed', 'err');
    }
  } catch (e) {
    toast(e.message, 'err');
  }
  loadUsersTab();
}

async function addUser() {
  const u = document.getElementById('new-username').value.trim();
  const p = document.getElementById('new-password').value;
  const role = document.getElementById('new-role').value;
  if (!u || !p) {
    fieldError(u ? 'new-password' : 'new-username', t('users.required'));
    return;
  }
  if (p.length < 8) {
    fieldError('new-password', t('users.minPw'));
    return;
  }
  try {
    const r = await authFetch('/api/users', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ username: u, password: p, role })
    });
    if (!r.ok) {
      const d = await r.json();
      toast(d.error || 'Failed', 'err');
      return;
    }
    document.getElementById('new-username').value = '';
    document.getElementById('new-password').value = '';
    loadUsersTab();
  } catch (e) {
    toast(e.message, 'err');
  }
}

async function deleteUser(id) {
  if (!(await askConfirm(t('common.delete'), t('users.deleteConfirm'), t('common.delete')))) return;
  try {
    const r = await authFetch('/api/users/' + id, { method: 'DELETE' });
    if (!r.ok) {
      const d = await r.json();
      toast(d.error || 'Failed', 'err');
      return;
    }
    loadUsersTab();
  } catch (e) {
    toast(e.message, 'err');
  }
}

function showChangePasswordModal() {
  const m = document.getElementById('change-pw-modal');
  if (m) {
    m.style.display = 'flex';
    document.getElementById('chpw-current').value = '';
    document.getElementById('chpw-new').value = '';
    document.getElementById('chpw-status').textContent = '';
    // Populate the hidden username companion so iOS Keychain knows which
    // credential entry this dialog is updating.
    const helper = document.getElementById('chpw-username-helper');
    if (helper && currentUser && currentUser.username) helper.value = currentUser.username;
  }
}
function hideChangePasswordModal() {
  const m = document.getElementById('change-pw-modal');
  if (m) m.style.display = 'none';
}
async function submitChangePassword() {
  const cur = document.getElementById('chpw-current').value;
  const nw = document.getElementById('chpw-new').value;
  const st = document.getElementById('chpw-status');
  if (!cur || !nw) {
    st.textContent = t('chpw.required');
    st.style.color = 'red';
    return;
  }
  if (nw.length < 8) {
    st.textContent = t('chpw.minLength');
    st.style.color = 'red';
    return;
  }
  try {
    const r = await authFetch('/api/auth/password', {
      method: 'PATCH',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ currentPassword: cur, newPassword: nw })
    });
    if (!r.ok) {
      const d = await r.json().catch(() => ({}));
      st.textContent = d.error || 'Failed';
      st.style.color = 'red';
      return;
    }
    st.textContent = t('chpw.success');
    st.style.color = 'green';
    setTimeout(() => hideChangePasswordModal(), 1500);
  } catch (e) {
    st.textContent = t('common.error') + ': ' + e.message;
    st.style.color = 'red';
  }
}

// ─── INIT ────────────────────────────────────────────────────
// Set initial language
// P-03: locale files are loaded on demand. The user's saved choice (or
// default 'de') is fetched up front; until it lands, translatePage() will
// no-op gracefully (`t()` falls back to the key when no locale is loaded).
// We translate again as soon as the locale resolves.
const _allowedLangs = ['en', 'de', 'pt'];
const savedLang = localStorage.getItem('mp-lang');
if (savedLang && _allowedLangs.indexOf(savedLang) !== -1) currentLang = savedLang;
document.getElementById('lang-sel').value = currentLang;
loadLang(currentLang)
  .then(() => translatePage())
  .catch((err) => console.error('Initial locale load failed:', err));

// ─── CALENDAR ───────────────────────────────────────────────
if (typeof calendarEvents === 'undefined') var calendarEvents = [];
if (typeof MS_PER_DAY === 'undefined') var MS_PER_DAY = 86400000;
let calYear = new Date().getFullYear(),
  calMonth = new Date().getMonth(),
  calView = 'month';
let calSelectedDate = new Date(),
  caldavImports = [];
function calDays() {
  return (t('cal.days') || 'Mo,Di,Mi,Do,Fr,Sa,So').split(',');
}
function calMonths() {
  return (
    t('cal.months') || 'Januar,Februar,März,April,Mai,Juni,Juli,August,September,Oktober,November,Dezember'
  ).split(',');
}
const CAL_HOURS_START = 6,
  CAL_HOURS_END = 22;

function fmtDate(y, m, d) {
  return y + '-' + String(m + 1).padStart(2, '0') + '-' + String(d).padStart(2, '0');
}
function localDateStr(d) {
  return d.getFullYear() + '-' + String(d.getMonth() + 1).padStart(2, '0') + '-' + String(d.getDate()).padStart(2, '0');
}
function parseDateStr(s) {
  const p = s.split('-');
  return new Date(+p[0], +p[1] - 1, +p[2]);
}

function getBatchLoc(b, lastByBag) {
  const locs = {};
  // Caller (e.g. collectCalendarEvents) can pass in a pre-built map to avoid
  // O(N×M) when this is called per-batch in a loop.
  const map = lastByBag || buildLastScanByBag();
  b.bags.forEach((bag) => {
    const last = map.get(bag.toUpperCase());
    if (last && last.action !== 'REMOVE' && last.to) locs[last.to] = (locs[last.to] || 0) + 1;
  });
  const entries = Object.entries(locs);
  if (!entries.length) return '';
  entries.sort((a, b) => b[1] - a[1]);
  return entries[0][0];
}
function getCalendarRange() {
  // Window for expanding recurring events — covers any visible view with margin
  const y = calYear,
    m = calMonth;
  const start = new Date(y, m - 2, 1);
  const end = new Date(y, m + 3, 0);
  return { start, end };
}
function addDays(d, n) {
  const x = new Date(d);
  x.setDate(x.getDate() + n);
  return x;
}
// Add n months to `base`, clamping the day to the target month's last day
// (Jan 31 + 1 → Feb 28/29). MUST be computed from the original base each time,
// NOT cumulatively from the previous occurrence — setMonth overflows (Feb 31 →
// Mar 3), which both skips February and permanently shifts every later
// occurrence onto the 3rd.
function addMonthsClamped(base, n) {
  const m = base.getMonth() + n;
  const y = base.getFullYear() + Math.floor(m / 12);
  const tm = ((m % 12) + 12) % 12;
  const day = Math.min(base.getDate(), new Date(y, tm + 1, 0).getDate());
  const r = new Date(base);
  r.setFullYear(y, tm, day);
  return r;
}
function expandRecurringEvent(ev) {
  const out = [];
  if (!ev.recurrence) {
    out.push(ev.startDate);
    return out;
  }
  const exceptions = new Set(Array.isArray(ev.exceptionDates) ? ev.exceptionDates : []);
  const { start: winStart, end: winEnd } = getCalendarRange();
  const base = parseDateStr(ev.startDate);
  const hardEnd = ev.recurrenceUntil ? parseDateStr(ev.recurrenceUntil) : null;
  let cur = new Date(base);
  let guard = 0;
  let monthIdx = 0;
  while (guard++ < 500) {
    if (hardEnd && cur > hardEnd) break;
    if (cur > winEnd) break;
    if (cur >= winStart || cur.getTime() === base.getTime()) {
      const ds = localDateStr(cur);
      if (!exceptions.has(ds)) out.push(ds);
    }
    if (ev.recurrence === 'daily') cur = addDays(cur, 1);
    else if (ev.recurrence === 'weekly') cur = addDays(cur, 7);
    else if (ev.recurrence === 'monthly') cur = addMonthsClamped(base, ++monthIdx);
    else break;
  }
  return out;
}
function expandRecurringTaskDates(task) {
  const out = [];
  const startStr = task.dueDate ? task.dueDate.split('T')[0] : null;
  if (!startStr) return out;
  if (!task.recurrence) {
    out.push(startStr);
    return out;
  }
  const { start: winStart, end: winEnd } = getCalendarRange();
  const base = parseDateStr(startStr);
  const hardEnd = task.recurrenceUntil ? parseDateStr(task.recurrenceUntil) : null;
  let cur = new Date(base);
  let guard = 0;
  let monthIdx = 0;
  while (guard++ < 500) {
    if (hardEnd && cur > hardEnd) break;
    if (cur > winEnd) break;
    if (cur >= winStart || cur.getTime() === base.getTime()) {
      out.push(localDateStr(cur));
    }
    if (task.recurrence === 'daily') cur = addDays(cur, 1);
    else if (task.recurrence === 'weekly') cur = addDays(cur, 7);
    else if (task.recurrence === 'monthly') cur = addMonthsClamped(base, ++monthIdx);
    else break;
  }
  return out;
}
function collectCalendarEvents() {
  const events = [];
  const lastByBag = buildLastScanByBag();
  batches.forEach((b) => {
    if (!b.due) return;
    const d = new Date(b.due);
    const loc = getBatchLoc(b, lastByBag);
    events.push({
      date: localDateStr(d),
      label: b.batchId + (loc ? ' — ' + loc : ''),
      type: 'batch-due',
      id: b.batchId,
      draggable: true,
      allDay: true,
      color: '#ef4444',
      species: b.species
    });
  });
  manualTasks.forEach((t) => {
    if (!t.dueDate) return;
    const dates = expandRecurringTaskDates(t);
    const hasTime = !!t.dueTime;
    dates.forEach((ds, idx) => {
      // Only the base occurrence is draggable; recurring instances are locked
      const isBase = idx === 0 && ds === t.dueDate.split('T')[0];
      events.push({
        date: ds,
        label: t.text,
        type: 'task-due',
        id: t.created,
        draggable: !t.done && !t.recurrence && isBase,
        allDay: !hasTime,
        startTime: hasTime ? t.dueTime : undefined,
        endTime: hasTime ? t.dueEndTime || undefined : undefined,
        color: '#3b82f6',
        recurrence: t.recurrence || null
      });
    });
  });
  harvests.forEach((h) => {
    if (!h.time) return;
    const d = new Date(h.time);
    events.push({
      date: localDateStr(d),
      label: (h.batch || '?') + ' ' + h.grams + 'g',
      type: 'harvest',
      id: null,
      draggable: false,
      allDay: true,
      color: '#f59e0b',
      species: h.species
    });
  });
  const filterName = document.getElementById('cal-filter-user')?.value || '';
  calendarEvents.forEach((ev) => {
    const teamList = Array.isArray(ev.teamAssignees) ? ev.teamAssignees : [];
    if (filterName && teamList.length && !teamList.includes(filterName)) return;
    const dates = expandRecurringEvent(ev);
    const displayAssignees = teamList.map((n) => ({ userId: 0, username: n }));
    dates.forEach((ds) => {
      events.push({
        date: ds,
        label: ev.title,
        type: 'custom',
        id: ev.id,
        draggable: !ev.recurrence,
        allDay: ev.allDay,
        startTime: ev.startTime,
        endTime: ev.endTime,
        color: CATEGORY_COLORS[ev.category] || ev.color || '#16a34a',
        description: ev.description,
        assignees: displayAssignees,
        recurrence: ev.recurrence || null
      });
    });
  });
  caldavImports.forEach((ev) => {
    events.push({
      date: ev.date,
      label: ev.summary,
      type: 'caldav-import',
      id: ev.uid,
      draggable: false,
      allDay: ev.allDay !== false,
      startTime: ev.startTime,
      endTime: ev.endTime,
      color: '#6366f1'
    });
  });
  return events;
}

// One place decides whether this is a phone, and both the router and the
// navigation read it. The breakpoint is duplicated in styles.css — where it
// hides the view toggle — and that pair is exactly the split-brain
// test/mobile-nav.test.js exists to catch, so it is asserted there too.
// A group heading whose entries are all in the bottom bar would be left over
// the gap where they used to be — "Arbeiten" loses all three. Derived from what
// is actually marked rather than named, so it follows the list above.
function markEmptyDrawerGroups() {
  document.querySelectorAll('.sb-group-label').forEach((label) => {
    const entries = [];
    for (let el = label.nextElementSibling; el && !el.classList.contains('sb-group-label'); el = el.nextElementSibling) {
      if (el.classList.contains('sb-btn')) entries.push(el);
    }
    const allInBar = entries.length > 0 && entries.every((e) => e.classList.contains('sb-in-bottom-nav'));
    label.classList.toggle('sb-in-bottom-nav', allInBar);
  });
}

// The same question the sidebar asks, so the same query answers it. It used to
// build a fresh MediaQueryList on every renderCalendar() call and carry its own
// copy of the 768, which meant two predicates that could disagree about which
// arrangement the window is in. Disagreeing predicates are what this branch is
// about.
function calAgendaOnly() {
  return sbIsPhone();
}

function renderCalendar() {
  const title = document.getElementById('cal-title');
  if (!title) return;
  document.querySelectorAll('.cal-vbtn').forEach((b) => b.classList.remove('active'));
  const btn = document.getElementById('cv-' + calView);
  if (btn) btn.classList.add('active');
  if (calAgendaOnly()) renderCalAgenda();
  else if (calView === 'month') renderCalMonth();
  else if (calView === 'week') renderCalWeek();
  else if (calView === 'day') renderCalDay();
}

function setCalView(v) {
  calView = v;
  renderCalendar();
}
function calToday() {
  calYear = new Date().getFullYear();
  calMonth = new Date().getMonth();
  calSelectedDate = new Date();
  renderCalendar();
}

function calNav(delta) {
  // The agenda spans the displayed month, so on a phone prev/next moves a
  // month regardless of which grid calView still names — otherwise a stale
  // 'week' from a desktop session steps the title by seven days while the list
  // below it changes by thirty.
  if (calView === 'month' || calAgendaOnly()) {
    calMonth += delta;
    if (calMonth < 0) {
      calMonth = 11;
      calYear--;
    }
    if (calMonth > 11) {
      calMonth = 0;
      calYear++;
    }
  } else if (calView === 'week') {
    calSelectedDate.setDate(calSelectedDate.getDate() + delta * 7);
    calYear = calSelectedDate.getFullYear();
    calMonth = calSelectedDate.getMonth();
  } else if (calView === 'day') {
    calSelectedDate.setDate(calSelectedDate.getDate() + delta);
    calYear = calSelectedDate.getFullYear();
    calMonth = calSelectedDate.getMonth();
  }
  renderCalendar();
}

function printCalendar() {
  const modal = document.getElementById('m-cal-print');
  if (!modal) return;
  modal.classList.add('open');
}
function closeCalPrintModal() {
  const m = document.getElementById('m-cal-print');
  if (m) m.classList.remove('open');
}

// The type of an event, in words. Shared by the printed task list and the
// on-screen agenda, because a dot in one and a word in the other would be two
// vocabularies for one set of five things.
function calTypeLabels() {
  return {
    'batch-due': t('cal.legend.batches'),
    'task-due': t('calDetail.taskDue'),
    harvest: t('cal.legend.harvests'),
    custom: t('calEntry.cat.custom'),
    'caldav-import': t('calDetail.external')
  };
}

// Every day between two dates, each carrying its events in reading order:
// all-day first, then by start time. Empty days are kept — on a task list the
// blank Sunday is information.
//
// This was the middle of printCalendarTaskList() and nothing else could reach
// it, which is the only reason the calendar had no agenda view: the grouping
// and the sort, the two parts that are actually fiddly against recurrence
// expansion, were already written and already correct, three lines below a
// window.print().
function calAgendaDays(startDate, endDate) {
  const DAYS = calDays();
  const startStr = fmtDate(startDate.getFullYear(), startDate.getMonth(), startDate.getDate());
  const endStr = fmtDate(endDate.getFullYear(), endDate.getMonth(), endDate.getDate());
  const byDate = {};
  collectCalendarEvents()
    .filter((e) => e.date >= startStr && e.date <= endStr)
    .forEach((e) => {
      (byDate[e.date] = byDate[e.date] || []).push(e);
    });
  const days = [];
  for (let d = new Date(startDate); d <= endDate; d.setDate(d.getDate() + 1)) {
    const ds = fmtDate(d.getFullYear(), d.getMonth(), d.getDate());
    const dayEvents = (byDate[ds] || []).slice().sort((a, b) => {
      if (a.allDay && !b.allDay) return -1;
      if (!a.allDay && b.allDay) return 1;
      return (a.startTime || '').localeCompare(b.startTime || '');
    });
    days.push({ ds, dayName: DAYS[(d.getDay() + 6) % 7], date: new Date(d), events: dayEvents });
  }
  return days;
}

function printCalendarTaskList(range) {
  const sheet = document.getElementById('print-sheet');
  if (!sheet) return;

  const MONTHS = calMonths();

  // Determine date range — rolling window anchored on today
  const today = new Date();
  today.setHours(0, 0, 0, 0);
  let startDate, endDate, rangeLabel;
  if (range === 'week') {
    startDate = new Date(today);
    endDate = new Date(today);
    endDate.setDate(today.getDate() + 6);
  } else {
    startDate = new Date(today);
    endDate = new Date(today);
    endDate.setDate(today.getDate() + 29);
  }
  const sameYear = startDate.getFullYear() === endDate.getFullYear();
  const rangePrefix = range === 'week' ? t('cal.weekShort') : t('cal.monthShort');
  rangeLabel =
    rangePrefix +
    ': ' +
    startDate.getDate() +
    '. ' +
    MONTHS[startDate.getMonth()] +
    (sameYear ? '' : ' ' + startDate.getFullYear()) +
    ' – ' +
    endDate.getDate() +
    '. ' +
    MONTHS[endDate.getMonth()] +
    ' ' +
    endDate.getFullYear();

  const days = calAgendaDays(startDate, endDate);
  const typeLabels = calTypeLabels();
  const totalEvents = days.reduce((n, d) => n + d.events.length, 0);

  // Render HTML
  const todayStr = localDateStr(new Date());
  let bodyHtml = '';
  days.forEach((day) => {
    const isToday = day.ds === todayStr;
    bodyHtml += '<div class="cal-print-day' + (isToday ? ' today' : '') + '">';
    bodyHtml +=
      '<div class="cal-print-day-hdr">' +
      day.dayName +
      ', ' +
      day.date.getDate() +
      '. ' +
      MONTHS[day.date.getMonth()] +
      ' ' +
      day.date.getFullYear() +
      '</div>';
    if (day.events.length === 0) {
      bodyHtml += '<div class="cal-print-empty">— ' + t('cal.noTasks') + ' —</div>';
    } else {
      bodyHtml += '<ul class="cal-print-list">';
      day.events.forEach((e) => {
        const time = e.allDay ? t('cal.allDay') : (e.startTime || '') + (e.endTime ? ' – ' + e.endTime : '');
        const typeLbl = typeLabels[e.type] || '';
        const dotColor = safeColor(e.color || '#64748b');
        const assigneeStr =
          e.assignees && e.assignees.length
            ? ' <span class="cal-print-assignees">(' + e.assignees.map((a) => esc(a.username)).join(', ') + ')</span>'
            : '';
        const desc = e.description ? '<div class="cal-print-desc">' + esc(e.description) + '</div>' : '';
        bodyHtml +=
          '<li class="cal-print-item">' +
          '<span class="cal-print-dot" style="background:' +
          dotColor +
          '"></span>' +
          '<span class="cal-print-time">' +
          esc(time) +
          '</span>' +
          '<span class="cal-print-type">' +
          typeLbl +
          '</span>' +
          '<span class="cal-print-label">' +
          esc(e.label) +
          assigneeStr +
          desc +
          '</span>' +
          '</li>';
      });
      bodyHtml += '</ul>';
    }
    bodyHtml += '</div>';
  });

  // px-auf-papier: the calendar task list, laid out for a printed page by
  // .cal-print-* in styles.css, whose sizes are px for the same reason.
  sheet.innerHTML =
    '<div class="cal-print-page cal-print-tasklist">' +
    '<div class="cal-print-header">' +
    '<div style="font-size:20px;font-weight:800;color:#111">' +
    esc(t('cal.taskListTitle')) +
    '</div>' +
    '<div style="font-size:13px;color:#444;margin-top:2px">' +
    esc(rangeLabel) +
    '</div>' +
    '<div class="fs-xs" style="color:#666;margin-top:2px">' +
    totalEvents +
    ' ' +
    t('cal.entries') +
    ' — ' +
    t('cal.printed') +
    ' ' +
    new Date().toLocaleDateString(loc()) +
    '</div>' +
    '</div>' +
    '<div class="cal-print-body">' +
    bodyHtml +
    '</div>' +
    '</div>';

  closeCalPrintModal();
  setTimeout(() => window.print(), 150);
}

// ── Agenda View — what the calendar is on a phone ──
//
// Not a preference and not a fourth tab: below 769px the three grids cannot
// work, and the numbers say so rather than taste. Seven columns at the 44px
// WCAG floor need 316px of grid, which fits in 343px of content — and leaves
// each cell 36px wide, so the day-number circle fills it edge to edge with
// nothing left for an event. Today a month cell is 47.9px wide and an event
// label gets 29.9px at 10px type: four glyphs and an ellipsis. Week view is
// worse at 40.7px per column. The constraint is horizontal, and a taller cell
// cannot reach it, which is what settles §9 decision 3.
//
// Empty days are dropped here and kept in print. That is deliberate on both
// sides: on paper the blank Sunday is a line you tick, on a phone it is thirty
// rows of "no tasks" between you and the four that matter.
function renderCalAgenda() {
  const container = document.getElementById('cal-container');
  const title = document.getElementById('cal-title');
  if (!container || !title) return;
  const MONTHS = calMonths();
  title.textContent = MONTHS[calMonth] + ' ' + calYear;

  const days = calAgendaDays(new Date(calYear, calMonth, 1), new Date(calYear, calMonth + 1, 0)).filter(
    (d) => d.events.length
  );
  const typeLabels = calTypeLabels();
  const todayStr = localDateStr(new Date());

  if (!days.length) {
    container.innerHTML = '<div class="cal-agenda-empty">' + esc(t('cal.agendaEmpty')) + '</div>';
    container.onclick = null;
    return;
  }

  container.innerHTML =
    '<div class="cal-agenda">' +
    days
      .map((day) => {
        const rows = day.events
          .map((e) => {
            const when = e.allDay
              ? t('cal.allDay')
              : (e.startTime || '') + (e.endTime ? '–' + e.endTime : '');
            const desc = e.description
              ? '<span class="cal-agenda-desc">' + esc(e.description) + '</span>'
              : '';
            const who =
              e.assignees && e.assignees.length
                ? '<span class="cal-agenda-who">' + e.assignees.map((a) => esc(a.username)).join(', ') + '</span>'
                : '';
            return (
              '<button type="button" class="cal-agenda-row" data-type="' +
              esc(e.type) +
              '" data-id="' +
              esc(e.id || '') +
              '">' +
              '<span class="cal-agenda-dot" style="background:' +
              safeColor(e.color || '#64748b') +
              '"></span>' +
              '<span class="cal-agenda-when">' +
              esc(when) +
              '</span>' +
              '<span class="cal-agenda-what">' +
              '<span class="cal-agenda-label">' +
              esc(e.label) +
              '</span>' +
              '<span class="cal-agenda-meta">' +
              esc(typeLabels[e.type] || '') +
              who +
              '</span>' +
              desc +
              '</span>' +
              '</button>'
            );
          })
          .join('');
        return (
          '<div class="cal-agenda-day' +
          (day.ds === todayStr ? ' today' : '') +
          '" data-date="' +
          day.ds +
          '">' +
          '<div class="cal-agenda-date">' +
          '<span class="cal-agenda-num">' +
          day.date.getDate() +
          '</span>' +
          '<span class="cal-agenda-dow">' +
          esc(day.dayName) +
          '</span>' +
          '</div>' +
          '<div class="cal-agenda-rows">' +
          rows +
          '</div>' +
          '</div>'
        );
      })
      .join('') +
    '</div>';

  // The same opener the month grid uses. No drag-and-drop: rescheduling by
  // dragging is a mouse gesture, and this view exists for the hand.
  container.onclick = function (ev) {
    const row = ev.target.closest('.cal-agenda-row');
    if (!row) return;
    onCalMonthEventClick(row.dataset.type, row.dataset.id);
  };

  const today = container.querySelector('.cal-agenda-day.today');
  if (today) today.scrollIntoView({ block: 'nearest' });
}

// ── Month View ──
function renderCalMonth() {
  const container = document.getElementById('cal-container');
  const title = document.getElementById('cal-title');
  const months = calMonths(),
    days2 = calDays();
  title.textContent = months[calMonth] + ' ' + calYear;
  const firstDay = new Date(calYear, calMonth, 1);
  const daysInMonth = new Date(calYear, calMonth + 1, 0).getDate();
  const startDow = (firstDay.getDay() + 6) % 7;
  const prevLast = new Date(calYear, calMonth, 0).getDate();
  const events = collectCalendarEvents();
  const todayStr = localDateStr(new Date());
  const totalCells = startDow + daysInMonth;
  const rows = Math.max(6, Math.ceil(totalCells / 7));
  const trailing = rows * 7 - totalCells;

  let html = '<div class="cal-grid" id="cal-grid">';
  html += days2.map((d) => '<div class="cal-hdr">' + d + '</div>').join('');

  function eventsForDate(ds) {
    const de = events.filter((e) => e.date === ds);
    const mx = 3;
    let o = de
      .slice(0, mx)
      .map((e) => {
        const drag = e.draggable ? 'draggable="true"' : '';
        const cls = e.draggable ? 'cal-event' : 'cal-event no-drag';
        const bg = e.color ? 'style="background:' + safeColor(e.color) + '"' : '';
        const assigneeStr =
          e.assignees && e.assignees.length
            ? ' <span class="cal-ev-assignees">' + e.assignees.map((a) => esc(a.username)).join(', ') + '</span>'
            : '';
        const dot = e.species ? spDot(e.species) : '';
        return (
          '<div class="' +
          cls +
          '" ' +
          drag +
          ' data-type="' +
          esc(e.type) +
          '" data-id="' +
          esc(e.id || '') +
          '" title="' +
          esc(e.label) +
          '" ' +
          bg +
          '>' +
          dot +
          esc(e.label) +
          assigneeStr +
          '</div>'
        );
      })
      .join('');
    if (de.length > mx)
      o +=
        '<div class="cal-more" onclick="event.stopPropagation();calGotoDay(\'' +
        ds +
        '\')">+' +
        (de.length - mx) +
        ' ' +
        t('cal.more') +
        '</div>';
    return o;
  }

  for (let i = startDow - 1; i >= 0; i--) {
    const day = prevLast - i,
      m = calMonth === 0 ? 11 : calMonth - 1,
      y = calMonth === 0 ? calYear - 1 : calYear,
      ds = fmtDate(y, m, day);
    html +=
      '<div class="cal-cell other" data-date="' +
      ds +
      '" onclick="calCellClick(event,\'' +
      ds +
      '\')"><div class="cal-day" onclick="event.stopPropagation();calGotoDay(\'' +
      ds +
      '\')">' +
      day +
      '</div>' +
      eventsForDate(ds) +
      '</div>';
  }
  for (let d = 1; d <= daysInMonth; d++) {
    const ds = fmtDate(calYear, calMonth, d),
      cls = ds === todayStr ? 'cal-cell today' : 'cal-cell';
    html +=
      '<div class="' +
      cls +
      '" data-date="' +
      ds +
      '" onclick="calCellClick(event,\'' +
      ds +
      '\')"><div class="cal-day" onclick="event.stopPropagation();calGotoDay(\'' +
      ds +
      '\')">' +
      d +
      '</div>' +
      eventsForDate(ds) +
      '</div>';
  }
  for (let d = 1; d <= trailing; d++) {
    const m = calMonth === 11 ? 0 : calMonth + 1,
      y = calMonth === 11 ? calYear + 1 : calYear,
      ds = fmtDate(y, m, d);
    html +=
      '<div class="cal-cell other" data-date="' +
      ds +
      '" onclick="calCellClick(event,\'' +
      ds +
      '\')"><div class="cal-day" onclick="event.stopPropagation();calGotoDay(\'' +
      ds +
      '\')">' +
      d +
      '</div>' +
      eventsForDate(ds) +
      '</div>';
  }
  html += '</div>';
  container.innerHTML = html;
  initCalDragDrop(container);
}
function calCellClick(e, ds) {
  if (e.target.closest('.cal-event') || e.target.closest('.cal-more')) return;
  openEventModal(ds);
}
function calGotoDay(ds) {
  calSelectedDate = parseDateStr(ds);
  calYear = calSelectedDate.getFullYear();
  calMonth = calSelectedDate.getMonth();
  setCalView('day');
}

// ── Week View ──
function getWeekStart(d) {
  const dt = new Date(d);
  const dow = (dt.getDay() + 6) % 7;
  dt.setDate(dt.getDate() - dow);
  dt.setHours(0, 0, 0, 0);
  return dt;
}

function renderCalWeek() {
  const container = document.getElementById('cal-container');
  const title = document.getElementById('cal-title');
  const ws = getWeekStart(calSelectedDate);
  const days = [];
  for (let i = 0; i < 7; i++) {
    const d = new Date(ws);
    d.setDate(ws.getDate() + i);
    days.push(d);
  }
  const todayStr = localDateStr(new Date());
  const MONTHS = calMonths(),
    DAYS = calDays();
  title.textContent =
    days[0].getDate() +
    '. ' +
    (days[0].getMonth() !== days[6].getMonth()
      ? MONTHS[days[0].getMonth()] + ' — ' + days[6].getDate() + '. ' + MONTHS[days[6].getMonth()]
      : ' — ' + days[6].getDate() + '. ' + MONTHS[days[0].getMonth()]) +
    ' ' +
    days[6].getFullYear();
  const events = collectCalendarEvents();
  const dayStrs = days.map((d) => localDateStr(d));

  let html = '<div class="cal-week">';
  html += '<div class="cal-week-hdr"><div class="cal-week-hdr-cell"></div>';
  days.forEach((d, i) => {
    const ds = dayStrs[i];
    html +=
      '<div class="cal-week-hdr-cell' +
      (ds === todayStr ? ' today-col' : '') +
      '" onclick="calGotoDay(\'' +
      ds +
      '\')">' +
      DAYS[i] +
      '<span class="wk-day-num">' +
      d.getDate() +
      '</span></div>';
  });
  html += '</div>';
  html += '<div class="cal-week-allday"><div class="cal-week-allday-label">' + t('cal.allDayShort') + '</div>';
  days.forEach((d, i) => {
    const ds = dayStrs[i];
    const de = events.filter((e) => e.date === ds && e.allDay);
    html += '<div class="cal-week-allday-cell" data-date="' + ds + '">';
    de.forEach((e) => {
      const cls = e.draggable ? 'cal-event' : 'cal-event no-drag';
      const bg = e.color ? 'style="background:' + safeColor(e.color) + '"' : '';
      const dot = e.species ? spDot(e.species) : '';
      html +=
        '<div class="' +
        cls +
        '" ' +
        (e.draggable ? 'draggable="true"' : '') +
        ' data-type="' +
        esc(e.type) +
        '" data-id="' +
        esc(e.id || '') +
        '" title="' +
        esc(e.label) +
        '" ' +
        bg +
        '>' +
        dot +
        esc(e.label) +
        '</div>';
    });
    html += '</div>';
  });
  html += '</div>';
  html += '<div class="cal-week-body">';
  for (let h = CAL_HOURS_START; h <= CAL_HOURS_END; h++) {
    html += '<div class="cal-week-time">' + String(h).padStart(2, '0') + ':00</div>';
    days.forEach((d, i) => {
      const ds = dayStrs[i];
      html +=
        '<div class="cal-week-slot' +
        (ds === todayStr ? ' today-col' : '') +
        '" data-date="' +
        ds +
        '" data-hour="' +
        h +
        '" onclick="openEventModal(\'' +
        ds +
        "','" +
        String(h).padStart(2, '0') +
        ':00\')"></div>';
    });
  }
  html += '</div></div>';
  container.innerHTML = html;

  const body = container.querySelector('.cal-week-body');
  if (body) {
    days.forEach((d, i) => {
      const ds = dayStrs[i];
      const timed = events.filter((e) => e.date === ds && !e.allDay && e.startTime);
      timed.forEach((e) => {
        const [sh, sm] = (e.startTime || '09:00').split(':').map(Number);
        const [eh, em] = (e.endTime || String(sh + 1).padStart(2, '0') + ':00').split(':').map(Number);
        const top = (sh - CAL_HOURS_START) * 48 + (sm / 60) * 48;
        const height = Math.max(24, (eh - sh) * 48 + ((em - sm) / 60) * 48);
        const col = i + 2;
        const el = document.createElement('div');
        el.className = 'cal-week-ev';
        el.style.cssText =
          'top:' + top + 'px;height:' + height + 'px;background:' + safeColor(e.color) + ';grid-column:' + col;
        const wkDot = e.species ? spDot(e.species) : '';
        let wkContent = wkDot + esc(e.label);
        if (e.assignees && e.assignees.length)
          wkContent +=
            ' <span class="cal-ev-assignees">' + e.assignees.map((a) => esc(a.username)).join(', ') + '</span>';
        if (height >= 48 && e.startTime)
          wkContent +=
            '<div class="fs-micro" style="opacity:.8">' + e.startTime + (e.endTime ? ' — ' + e.endTime : '') + '</div>';
        if (height >= 72 && e.description)
          wkContent += '<div class="fs-micro" style="opacity:.7;margin-top:1px">' + esc(e.description) + '</div>';
        el.innerHTML = wkContent;
        el.title = e.label;
        el.dataset.type = e.type;
        el.dataset.id = e.id || '';
        el.dataset.date = ds;
        el.onclick = function () {
          if (!el._dragged) onCalEventClick(e);
        };
        if (e.type === 'custom') {
          const rh = document.createElement('div');
          rh.className = 'ev-resize';
          el.appendChild(rh);
          initEventDrag(el, body, 'week', dayStrs);
          initEventResize(el, rh, body, 'week');
        }
        body.appendChild(el);
      });
    });
    const now = new Date();
    const nowDs = localDateStr(now);
    const todayIdx = dayStrs.indexOf(nowDs);
    if (todayIdx >= 0) {
      const nowH = now.getHours(),
        nowM = now.getMinutes();
      if (nowH >= CAL_HOURS_START && nowH <= CAL_HOURS_END) {
        const top = (nowH - CAL_HOURS_START) * 48 + (nowM / 60) * 48;
        const line = document.createElement('div');
        line.className = 'cal-week-now-line';
        line.style.top = top + 'px';
        body.appendChild(line);
        body.scrollTop = Math.max(0, top - 150);
      }
    }
  }
  initCalDragDrop(container);
}

// ── Day View ──
function renderCalDay() {
  const container = document.getElementById('cal-container');
  const title = document.getElementById('cal-title');
  const d = calSelectedDate;
  const ds = localDateStr(d);
  const DAYS = calDays(),
    MONTHS = calMonths();
  const dayName = DAYS[(d.getDay() + 6) % 7];
  title.textContent = dayName + ', ' + d.getDate() + '. ' + MONTHS[d.getMonth()] + ' ' + d.getFullYear();
  const events = collectCalendarEvents();
  const dayEvents = events.filter((e) => e.date === ds);
  const allDay = dayEvents.filter((e) => e.allDay);
  const timed = dayEvents.filter((e) => !e.allDay && e.startTime);

  let html = '<div class="cal-day-view">';
  html += '<div class="cal-day-allday"><div class="sec">' + t('cal.allDay') + '</div>';
  if (allDay.length) {
    allDay.forEach((e) => {
      const cls = e.draggable ? 'cal-event' : 'cal-event no-drag';
      const bg = e.color ? 'style="background:' + safeColor(e.color) + '"' : '';
      const dot = e.species ? spDot(e.species) : '';
      html +=
        '<div class="' +
        cls +
        '" ' +
        (e.draggable ? 'draggable="true"' : '') +
        ' data-type="' +
        esc(e.type) +
        '" data-id="' +
        esc(e.id || '') +
        '" title="' +
        esc(e.label) +
        '" ' +
        bg +
        '>' +
        dot +
        esc(e.label) +
        '</div>';
    });
  } else {
    html += '<div class="cal-day-allday-empty">' + t('cal.noAllDay') + '</div>';
  }
  html += '</div>';
  html += '<div class="cal-day-body">';
  for (let h = CAL_HOURS_START; h <= CAL_HOURS_END; h++) {
    html += '<div class="cal-day-time">' + String(h).padStart(2, '0') + ':00</div>';
    html +=
      '<div class="cal-day-slot" data-date="' +
      ds +
      '" data-hour="' +
      h +
      '" onclick="openEventModal(\'' +
      ds +
      "','" +
      String(h).padStart(2, '0') +
      ':00\')"></div>';
  }
  html += '</div></div>';
  container.innerHTML = html;

  const body = container.querySelector('.cal-day-body');
  if (body) {
    timed.forEach((e) => {
      const [sh, sm] = (e.startTime || '09:00').split(':').map(Number);
      const [eh, em] = (e.endTime || String(sh + 1).padStart(2, '0') + ':00').split(':').map(Number);
      const top = (sh - CAL_HOURS_START) * 48 + (sm / 60) * 48;
      const height = Math.max(24, (eh - sh) * 48 + ((em - sm) / 60) * 48);
      const el = document.createElement('div');
      el.className = 'cal-day-ev';
      el.style.cssText =
        'top:' + top + 'px;height:' + height + 'px;background:' + safeColor(e.color) + ';grid-column:2';
      const dayDot = e.species ? spDot(e.species) : '';
      let dayContent = dayDot + '<strong>' + esc(e.label) + '</strong>';
      if (e.assignees && e.assignees.length)
        dayContent +=
          ' <span class="cal-ev-assignees">' + e.assignees.map((a) => esc(a.username)).join(', ') + '</span>';
      if (e.startTime)
        dayContent +=
          '<div class="fs-xs" style="opacity:.8;margin-top:2px">' +
          e.startTime +
          (e.endTime ? ' — ' + e.endTime : '') +
          '</div>';
      if (height >= 72 && e.description)
        dayContent += '<div class="fs-micro" style="opacity:.7;margin-top:2px">' + esc(e.description) + '</div>';
      el.innerHTML = dayContent;
      el.title = e.label;
      el.dataset.type = e.type;
      el.dataset.id = e.id || '';
      el.dataset.date = ds;
      el.onclick = function () {
        if (!el._dragged) onCalEventClick(e);
      };
      if (e.type === 'custom') {
        const rh = document.createElement('div');
        rh.className = 'ev-resize';
        el.appendChild(rh);
        initEventDrag(el, body, 'day', null);
        initEventResize(el, rh, body, 'day');
      }
      body.appendChild(el);
    });
    const now = new Date();
    const nowDs = localDateStr(now);
    if (ds === nowDs) {
      const nowH = now.getHours(),
        nowM = now.getMinutes();
      if (nowH >= CAL_HOURS_START && nowH <= CAL_HOURS_END) {
        const top = (nowH - CAL_HOURS_START) * 48 + (nowM / 60) * 48;
        const line = document.createElement('div');
        line.className = 'cal-day-now-line';
        line.style.top = top + 'px';
        body.appendChild(line);
        body.scrollTop = Math.max(0, top - 150);
      }
    }
  }
  initCalDragDrop(container);
}

// ── Calendar Drag-and-Drop ──
function initCalDragDrop(root) {
  if (!root) return;
  root.onclick = function (e) {
    const ev = e.target.closest('.cal-event');
    if (!ev) return;
    e.stopPropagation();
    onCalMonthEventClick(ev.dataset.type, ev.dataset.id);
  };
  root.ondragstart = function (e) {
    const ev = e.target.closest('.cal-event');
    if (!ev || ev.classList.contains('no-drag')) {
      e.preventDefault();
      return;
    }
    e.dataTransfer.setData('text/plain', ev.dataset.type + '|' + ev.dataset.id);
    e.dataTransfer.effectAllowed = 'move';
    ev.style.opacity = '0.4';
  };
  root.ondragend = function (e) {
    const ev = e.target.closest('.cal-event');
    if (ev) ev.style.opacity = '1';
    root.querySelectorAll('.drag-over').forEach((c) => c.classList.remove('drag-over'));
  };
  root.ondragover = function (e) {
    const cell = e.target.closest('[data-date]');
    if (!cell) return;
    e.preventDefault();
    e.dataTransfer.dropEffect = 'move';
    root.querySelectorAll('.drag-over').forEach((c) => c.classList.remove('drag-over'));
    cell.classList.add('drag-over');
  };
  root.ondragleave = function (e) {
    const cell = e.target.closest('[data-date]');
    if (cell) cell.classList.remove('drag-over');
  };
  root.ondrop = function (e) {
    e.preventDefault();
    root.querySelectorAll('.drag-over').forEach((c) => c.classList.remove('drag-over'));
    const cell = e.target.closest('[data-date]');
    if (!cell || !cell.dataset.date) return;
    const data = e.dataTransfer.getData('text/plain');
    if (!data) return;
    const [type, id] = data.split('|');
    handleCalendarDrop(type, id, cell.dataset.date);
  };
}

function handleCalendarDrop(type, id, newDateStr) {
  if (type === 'batch-due') {
    const b = batches.find((x) => x.batchId === id);
    if (!b) return;
    const newDue = new Date(newDateStr + 'T12:00:00');
    b.due = newDue.toISOString();
    const created = new Date(b.created);
    b.days = Math.max(1, Math.round((newDue - created) / MS_PER_DAY));
    apiPatch('/api/batches/' + encodeURIComponent(id), { due: b.due, days: b.days });
    renderCalendar();
    pushBatchCaldav(b);
  } else if (type === 'task-due') {
    const t = manualTasks.find((x) => x.created === id);
    if (!t) return;
    t.dueDate = newDateStr;
    t.caldavSynced = null;
    apiPatch('/api/tasks/' + t.id, { dueDate: newDateStr, caldavSynced: null });
    renderCalendar();
    if (caldav.enabled && t.caldavUid && typeof pushTaskCaldav === 'function') pushTaskCaldav(t);
  } else if (type === 'custom') {
    const ev = calendarEvents.find((x) => x.id === id);
    if (!ev) return;
    // A dragged window is a moved handover. Only recurrence-free events are
    // draggable, so the whole event and the one occurrence are the same thing.
    confirmBookedWindow(ev.id, null, () => {
      ev.startDate = newDateStr;
      ev.caldavSynced = null;
      apiPatch('/api/calendar-events/' + encodeURIComponent(ev.id), { startDate: newDateStr, caldavSynced: null });
      renderCalendar();
      if (typeof pushEventCaldav === 'function') pushEventCaldav(ev);
    });
  }
}

// ── Time-based Drag & Resize for Week/Day views ──
function pxToTime(px) {
  const totalMin = (px / 48) * 60;
  let h = CAL_HOURS_START + Math.floor(totalMin / 60);
  let m = Math.round((totalMin % 60) / 15) * 15;
  if (m >= 60) {
    h++;
    m = 0;
  }
  h = Math.max(CAL_HOURS_START, Math.min(CAL_HOURS_END, h));
  return String(h).padStart(2, '0') + ':' + String(m).padStart(2, '0');
}

function snapPx(px) {
  return Math.round(px / 12) * 12;
}

function updateEventTime(id, newStart, newEnd, newDate) {
  const ev = calendarEvents.find((x) => x.id === id);
  if (!ev) return;
  if (newStart) ev.startTime = newStart;
  if (newEnd) ev.endTime = newEnd;
  if (newDate) ev.startDate = newDate;
  ev.caldavSynced = null;
  const patch = { caldavSynced: null };
  if (newStart) patch.startTime = newStart;
  if (newEnd) patch.endTime = newEnd;
  if (newDate) patch.startDate = newDate;
  apiPatch('/api/calendar-events/' + encodeURIComponent(id), patch);
  renderCalendar();
  if (typeof pushEventCaldav === 'function') pushEventCaldav(ev);
}

function initEventDrag(el, body, viewType, dayStrs) {
  function startDrag(clientX, clientY) {
    if (el._resizing) return;
    const startY = clientY,
      startX = clientX;
    const origTop = parseFloat(el.style.top);
    let dragging = false;
    el._dragged = false;
    const onMove = function (cx, cy) {
      const dy = cy - startY;
      const dx = cx - startX;
      if (!dragging && Math.abs(dy) < 4 && Math.abs(dx) < 4) return;
      dragging = true;
      el._dragged = true;
      el.style.top = snapPx(origTop + dy) + 'px';
      el.style.opacity = '0.7';
      el.style.zIndex = '10';
      if (viewType === 'week' && dayStrs) {
        const bodyRect = body.getBoundingClientRect();
        const timeColW = 56;
        const colW = (bodyRect.width - timeColW) / 7;
        const relX = cx - bodyRect.left - timeColW;
        const newColIdx = Math.max(0, Math.min(6, Math.floor(relX / colW)));
        el.style.gridColumn = String(newColIdx + 2);
      }
    };
    const onUp = function () {
      document.removeEventListener('mousemove', mmh);
      document.removeEventListener('mouseup', muh);
      document.removeEventListener('touchmove', tmh);
      document.removeEventListener('touchend', teh);
      el.style.opacity = '';
      el.style.zIndex = '';
      if (!dragging) return;
      const newTop = Math.max(0, snapPx(parseFloat(el.style.top)));
      const evId = el.dataset.id;
      const newStart = pxToTime(newTop);
      const ce = calendarEvents.find((x) => x.id === evId);
      if (!ce) return;
      const [osh, osm] = (ce.startTime || '09:00').split(':').map(Number);
      const [oeh, oem] = (ce.endTime || '10:00').split(':').map(Number);
      const durMin = oeh * 60 + oem - (osh * 60 + osm);
      const [nsh, nsm] = newStart.split(':').map(Number);
      const endMin = nsh * 60 + nsm + durMin;
      const neh = Math.min(CAL_HOURS_END, Math.floor(endMin / 60));
      const nem = endMin % 60;
      const newEnd = String(neh).padStart(2, '0') + ':' + String(nem).padStart(2, '0');
      let newDate = el.dataset.date;
      if (viewType === 'week' && dayStrs) {
        const newColIdx = parseInt(el.style.gridColumn) - 2;
        if (newColIdx >= 0 && newColIdx < dayStrs.length) newDate = dayStrs[newColIdx];
      }
      updateEventTime(evId, newStart, newEnd, newDate);
    };
    const mmh = function (e) {
      onMove(e.clientX, e.clientY);
    };
    const muh = function () {
      onUp();
    };
    const tmh = function (e) {
      e.preventDefault();
      const t = e.touches[0];
      onMove(t.clientX, t.clientY);
    };
    const teh = function () {
      onUp();
    };
    document.addEventListener('mousemove', mmh);
    document.addEventListener('mouseup', muh);
    document.addEventListener('touchmove', tmh, { passive: false });
    document.addEventListener('touchend', teh);
  }
  el.addEventListener('mousedown', function (e) {
    if (e.target.classList.contains('ev-resize')) return;
    e.preventDefault();
    startDrag(e.clientX, e.clientY);
  });
  el.addEventListener(
    'touchstart',
    function (e) {
      if (e.target.classList.contains('ev-resize')) return;
      const t = e.touches[0];
      startDrag(t.clientX, t.clientY);
    },
    { passive: true }
  );
}

function initEventResize(el, handle, body, viewType) {
  function startResize(clientY) {
    el._resizing = true;
    const startY = clientY;
    const origHeight = parseFloat(el.style.height);
    let resizing = false;
    const onMove = function (cy) {
      const dy = cy - startY;
      if (!resizing && Math.abs(dy) < 4) return;
      resizing = true;
      el._dragged = true;
      const newH = Math.max(12, snapPx(origHeight + dy));
      el.style.height = newH + 'px';
    };
    const onUp = function () {
      document.removeEventListener('mousemove', mmh);
      document.removeEventListener('mouseup', muh);
      document.removeEventListener('touchmove', tmh);
      document.removeEventListener('touchend', teh);
      el._resizing = false;
      if (!resizing) return;
      const evId = el.dataset.id;
      const newHeight = Math.max(12, parseFloat(el.style.height));
      const topPx = parseFloat(el.style.top);
      const endPx = topPx + newHeight;
      const newEnd = pxToTime(endPx);
      const newStart = pxToTime(topPx);
      updateEventTime(evId, newStart, newEnd, null);
    };
    const mmh = function (e) {
      onMove(e.clientY);
    };
    const muh = function () {
      onUp();
    };
    const tmh = function (e) {
      e.preventDefault();
      onMove(e.touches[0].clientY);
    };
    const teh = function () {
      onUp();
    };
    document.addEventListener('mousemove', mmh);
    document.addEventListener('mouseup', muh);
    document.addEventListener('touchmove', tmh, { passive: false });
    document.addEventListener('touchend', teh);
  }
  handle.addEventListener('mousedown', function (e) {
    e.preventDefault();
    e.stopPropagation();
    startResize(e.clientY);
  });
  handle.addEventListener(
    'touchstart',
    function (e) {
      e.stopPropagation();
      startResize(e.touches[0].clientY);
    },
    { passive: true }
  );
}

// ── Calendar Event Click ──
function onCalEventClick(ev) {
  if (ev.type === 'harvest') return;
  openEventDetail(ev);
}

function openEventDetail(ev) {
  const titleEl = document.getElementById('cal-detail-title');
  const metaEl = document.getElementById('cal-detail-meta');
  const badgesEl = document.getElementById('cal-detail-badges');
  const assignEl = document.getElementById('cal-detail-assignee');
  const descEl = document.getElementById('cal-detail-desc');
  const btnsEl = document.getElementById('cal-detail-btns');

  if (ev.type === 'custom') {
    const ce = calendarEvents.find((x) => x.id === ev.id);
    if (!ce) return;
    titleEl.textContent = ce.title;
    const occDate = ev.date || ce.startDate;
    let meta = new Date(occDate).toLocaleDateString(loc(), {
      weekday: 'long',
      day: 'numeric',
      month: 'long',
      year: 'numeric'
    });
    if (!ce.allDay && ce.startTime) meta += ', ' + ce.startTime + (ce.endTime ? ' — ' + ce.endTime : '');
    if (ce.endDate && ce.endDate !== ce.startDate)
      meta +=
        ' ' +
        t('calEntry.until') +
        ' ' +
        new Date(ce.endDate).toLocaleDateString(loc(), { day: 'numeric', month: 'long', year: 'numeric' });
    const place = ce.locationId ? pickupLocations.find((l) => l.id === ce.locationId) : null;
    if (place) meta += ' · ' + place.name;
    metaEl.textContent = meta;
    const catLabels = {
      custom: t('calEntry.cat.custom'),
      meeting: t('calEntry.cat.meeting'),
      delivery: t('calEntry.cat.delivery'),
      maintenance: t('calEntry.cat.maintenance'),
      pickup: t('calEntry.cat.pickup')
    };
    const recLabels = {
      daily: t('calEntry.rec.daily'),
      weekly: t('calEntry.rec.weekly'),
      monthly: t('calEntry.rec.monthly')
    };
    let badges =
      '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:' +
      (CATEGORY_COLORS[ce.category] || safeColor(ce.color)) +
      ';color:#fff">' +
      esc(catLabels[ce.category] || ce.category) +
      '</span>';
    if (ce.recurrence)
      badges +=
        '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-text-muted);color:#fff">🔁 ' +
        esc(recLabels[ce.recurrence] || ce.recurrence) +
        '</span>';
    // Seats, but only where they mean something. A window with no number takes
    // as many as turn up, and saying "unbegrenzt" on every ordinary appointment
    // would be noise.
    if (ce.category === 'pickup' && ce.pickupCapacity !== null && ce.pickupCapacity !== undefined)
      badges +=
        '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-text-muted);color:#fff">' +
        esc(t('calDetail.seats', { n: ce.pickupCapacity })) +
        '</span>';
    badgesEl.innerHTML = badges;
    const teamList = Array.isArray(ce.teamAssignees) ? ce.teamAssignees : [];
    assignEl.innerHTML =
      t('calDetail.assignedTo') +
      ': <strong>' +
      (teamList.length ? teamList.map((n) => esc(n)).join(', ') : esc(t('calDetail.everyone'))) +
      '</strong>';
    descEl.textContent = ce.description || '';
    descEl.style.display = ce.description ? '' : 'none';
    btnsEl.innerHTML =
      '<button class="btn btn-r" data-cal-action="delete-event" data-cal-id="' +
      esc(ce.id) +
      '" data-cal-date="' +
      esc(occDate || '') +
      '">' +
      esc(t('calEntry.delete')) +
      '</button><span style="flex:1"></span><button class="btn" data-cal-action="close">' +
      esc(t('calDetail.close')) +
      '</button><button class="btn btn-p" data-cal-action="edit-event" data-cal-id="' +
      esc(ce.id) +
      '">' +
      esc(t('calDetail.edit')) +
      '</button>';
  } else if (ev.type === 'task-due') {
    const tk = manualTasks.find((x) => x.created === ev.id);
    if (!tk) return;
    titleEl.textContent = tk.text;
    let meta = t('calDetail.taskDue');
    if (tk.dueDate)
      meta +=
        ' — ' +
        t('calDetail.dueLabel') +
        ': ' +
        new Date(tk.dueDate).toLocaleDateString(loc(), { day: 'numeric', month: 'long', year: 'numeric' });
    if (tk.dueTime) meta += ', ' + tk.dueTime + (tk.dueEndTime ? ' — ' + tk.dueEndTime : '');
    metaEl.textContent = meta;
    const prioLabels = {
      high: t('calEntry.prio.high'),
      med: t('calEntry.prio.med'),
      medium: t('calEntry.prio.med'),
      low: t('calEntry.prio.low')
    };
    const prioColors = { high: '#ef4444', med: '#f59e0b', medium: '#f59e0b', low: '#22c55e' };
    const recLabels2 = {
      daily: t('calEntry.rec.daily'),
      weekly: t('calEntry.rec.weekly'),
      monthly: t('calEntry.rec.monthly')
    };
    let tBadges =
      '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-blue);color:#fff">' +
      esc(t('calDetail.taskDue')) +
      '</span>';
    if (tk.priority)
      tBadges +=
        '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:' +
        (prioColors[tk.priority] || '#888') +
        ';color:#fff">' +
        esc(prioLabels[tk.priority] || tk.priority) +
        '</span>';
    if (tk.recurrence)
      tBadges +=
        '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-text-muted);color:#fff">🔁 ' +
        esc(recLabels2[tk.recurrence] || tk.recurrence) +
        '</span>';
    badgesEl.innerHTML = tBadges;
    const assigneeList = parseTaskAssignees(tk.assignee);
    assignEl.innerHTML =
      t('calDetail.assignedTo') +
      ': <strong>' +
      (assigneeList.length ? assigneeList.map((n) => esc(n)).join(', ') : esc(t('calDetail.everyone'))) +
      '</strong>';
    descEl.textContent = tk.description || '';
    descEl.style.display = tk.description ? '' : 'none';
    const doneLabel = tk.done ? t('calDetail.markUndone') : t('calDetail.markDone');
    btnsEl.innerHTML =
      '<button class="btn btn-r" data-cal-action="delete-task" data-cal-id="' +
      esc(ev.id) +
      '">' +
      esc(t('calEntry.delete')) +
      '</button><button class="btn' +
      (tk.done ? '' : ' btn-p') +
      '" data-cal-action="toggle-task" data-cal-id="' +
      esc(ev.id) +
      '">' +
      esc(doneLabel) +
      '</button><span style="flex:1"></span><button class="btn" data-cal-action="close">' +
      esc(t('calDetail.close')) +
      '</button><button class="btn btn-p" data-cal-action="edit-task" data-cal-id="' +
      esc(ev.id) +
      '">' +
      esc(t('calDetail.edit')) +
      '</button>';
  } else if (ev.type === 'batch-due') {
    titleEl.textContent = ev.label;
    const b = batches.find((x) => x.batchId === ev.id);
    let meta = t('calDetail.batchDue');
    if (b && b.due)
      meta += ' — ' + new Date(b.due).toLocaleDateString(loc(), { day: 'numeric', month: 'long', year: 'numeric' });
    metaEl.textContent = meta;
    badgesEl.innerHTML =
      '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-red);color:#fff">' +
      esc(t('calDetail.batchDue')) +
      '</span>';
    const curDate = b && b.due ? b.due.slice(0, 10) : '';
    assignEl.innerHTML =
      '<label class="fs-meta" style="color:var(--c-text-sec)">' +
      esc(t('calDetail.changeDate')) +
      '</label> <input type="date" id="cal-detail-batch-date" value="' +
      curDate +
      '" class="fs-sm" style="margin-left:8px;padding:4px 8px;border:1px solid var(--c-border);border-radius:4px;background:var(--c-bg);color:var(--c-text)">';
    assignEl._currentBatchId = ev.id;
    descEl.textContent = b ? b.species + (b.strain ? ' (' + b.strain + ')' : '') : '';
    descEl.style.display = '';
    btnsEl.innerHTML =
      '<span style="flex:1"></span><button class="btn" data-cal-action="close">' +
      esc(t('calDetail.close')) +
      '</button><button class="btn btn-p" data-cal-action="save-batch-due" data-cal-id="' +
      esc(ev.id) +
      '">' +
      esc(t('calEntry.save')) +
      '</button>';
  } else if (ev.type === 'caldav-import') {
    titleEl.textContent = ev.label;
    let meta = t('calDetail.external');
    if (ev.date)
      meta += ' — ' + new Date(ev.date).toLocaleDateString(loc(), { day: 'numeric', month: 'long', year: 'numeric' });
    if (ev.startTime) meta += ', ' + ev.startTime + (ev.endTime ? ' — ' + ev.endTime : '');
    metaEl.textContent = meta;
    badgesEl.innerHTML =
      '<span class="fs-xs" style="display:inline-block;padding:2px 10px;border-radius:4px;font-weight:500;background:var(--c-indigo);color:#fff">' +
      esc(t('calDetail.external')) +
      '</span>';
    assignEl.innerHTML = '';
    descEl.textContent = ev.description || '';
    descEl.style.display = ev.description ? '' : 'none';
    btnsEl.innerHTML = '<button class="btn" data-cal-action="close">' + esc(t('calDetail.close')) + '</button>';
  }
  document.getElementById('m-cal-detail').classList.add('open');
}

function closeEventDetail() {
  document.getElementById('m-cal-detail').classList.remove('open');
}

// Delegated click handler for calendar detail buttons (avoids inline onclick XSS).
document.getElementById('cal-detail-btns').addEventListener('click', function (e) {
  const btn = e.target.closest('[data-cal-action]');
  if (!btn) return;
  const action = btn.dataset.calAction;
  const id = btn.dataset.calId;
  const date = btn.dataset.calDate || '';
  if (action === 'close') return closeEventDetail();
  if (action === 'delete-event') return deleteCalEventFromDetail(id, date);
  if (action === 'edit-event') return editEventFromDetail(id);
  if (action === 'delete-task') return deleteTaskFromCalendar(id);
  if (action === 'toggle-task') return toggleTaskFromCalendar(id);
  if (action === 'edit-task') return editTaskFromCalendar(id);
  if (action === 'save-batch-due') return saveBatchDueFromDetail(id);
});

// Change handler for batch due-date picker in detail modal.
document.getElementById('cal-detail-assignee').addEventListener('change', function (e) {
  if (e.target.id !== 'cal-detail-batch-date') return;
  const newDate = e.target.value;
  if (!newDate) return;
  const batchId = this._currentBatchId;
  if (!batchId) return;
  handleCalendarDrop('batch-due', batchId, newDate);
  closeEventDetail();
});

function editEventFromDetail(id) {
  closeEventDetail();
  const ce = calendarEvents.find((x) => x.id === id);
  if (ce) openEventModal(ce.startDate, ce.startTime, ce);
}

function saveBatchDueFromDetail(id) {
  const picker = document.getElementById('cal-detail-batch-date');
  if (!picker || !picker.value) return;
  const b = batches.find((x) => x.batchId === id);
  if (!b) return;
  const newDue = new Date(picker.value + 'T12:00:00');
  b.due = newDue.toISOString();
  const created = new Date(b.created);
  b.days = Math.max(1, Math.round((newDue - created) / MS_PER_DAY));
  apiPatch('/api/batches/' + encodeURIComponent(id), { due: b.due, days: b.days });
  renderCalendar();
  pushBatchCaldav(b);
  closeEventDetail();
}

// ── Windows somebody has already booked into ────────────────
// `[{event, date, count}]`, refreshed when the calendar opens. The join between
// a calendar entry and its bookings is made on the server: a booking names the
// window by the id the harvest feed published, and reimplementing that id here
// would give two versions of one key. The one that drifts reads as "nobody has
// booked this", which is the answer that gets somebody sent away at a stall.
let pickupBookings = [];

async function loadPickupBookings() {
  const r = await apiGet('/api/pickup-bookings');
  pickupBookings = r && Array.isArray(r.booked) ? r.booked : [];
}

/** Bookings for one occurrence, or for the whole series when `date` is null. */
function bookedForWindow(eventId, date) {
  return pickupBookings
    .filter((b) => b.event === eventId && (!date || b.date === date))
    .reduce((n, b) => n + (Number(b.count) || 0), 0);
}

/**
 * Run `proceed`, asking first if anyone has booked into this window.
 *
 * Not a block — the lab may well have to cancel a market. It is the difference
 * between deciding to and finding out afterwards.
 */
function confirmBookedWindow(eventId, date, proceed) {
  const n = bookedForWindow(eventId, date);
  if (!n) {
    proceed();
    return;
  }
  confirm2(t('calEntry.bookedTitle'), t('calEntry.bookedMsg', { n }), t('calEntry.bookedGoOn'), proceed);
}

function findSameTitleEvents(ce) {
  if (!ce || !ce.title) return [];
  return calendarEvents.filter((x) => x.id !== ce.id && !x.recurrence && x.title === ce.title);
}

function deleteAllSameTitle(ids) {
  const idSet = new Set(ids);
  calendarEvents = calendarEvents.filter((x) => !idSet.has(x.id));
  renderCalendar();
  ids.forEach((eid) => apiDelete('/api/calendar-events/' + encodeURIComponent(eid)));
}

function deleteCalEventFromDetail(id, date) {
  closeEventDetail();
  const ce = calendarEvents.find((x) => x.id === id);
  const isRecurring = !!(ce && ce.recurrence);
  if (isRecurring && date) {
    confirm3(
      t('calEntry.deleteRecurTitle'),
      t('calEntry.deleteRecurMsg'),
      t('calEntry.deleteOccurrence'),
      t('calEntry.deleteSeries'),
      // One date, so only that date's bookings are at stake…
      () =>
        confirmBookedWindow(id, date, () => {
          if (!Array.isArray(ce.exceptionDates)) ce.exceptionDates = [];
          if (!ce.exceptionDates.includes(date)) ce.exceptionDates.push(date);
          renderCalendar();
          apiDelete('/api/calendar-events/' + encodeURIComponent(id) + '?occurrence=' + encodeURIComponent(date));
        }),
      // …and here every one of them, across the whole series.
      () =>
        confirmBookedWindow(id, null, () => {
          calendarEvents = calendarEvents.filter((x) => x.id !== id);
          renderCalendar();
          apiDelete('/api/calendar-events/' + encodeURIComponent(id));
        })
    );
    return;
  }
  if (!isRecurring) {
    const dups = findSameTitleEvents(ce);
    if (dups.length) {
      confirm3(
        t('calEntry.deleteDupTitle'),
        t('calEntry.deleteDupMsg', { n: dups.length }),
        t('calEntry.deleteOnlyThis'),
        t('calEntry.deleteAllSameTitle', { n: dups.length + 1 }),
        () => {
          calendarEvents = calendarEvents.filter((x) => x.id !== id);
          renderCalendar();
          apiDelete('/api/calendar-events/' + encodeURIComponent(id));
        },
        () => deleteAllSameTitle([id, ...dups.map((d) => d.id)])
      );
      return;
    }
  }
  confirm2(t('calEntry.deleteEvent'), t('calEntry.deleteEventMsg'), t('calEntry.delete'), () =>
    confirmBookedWindow(id, null, () => {
      calendarEvents = calendarEvents.filter((x) => x.id !== id);
      renderCalendar();
      apiDelete('/api/calendar-events/' + encodeURIComponent(id));
    })
  );
}

function toggleTaskFromCalendar(taskId) {
  const t = manualTasks.find((t) => t.created === taskId);
  if (!t) return;
  toggleTask(t.id);
  renderCalendar();
  closeEventDetail();
}

function deleteTaskFromCalendar(taskId) {
  closeEventDetail();
  confirm2(t('calEntry.deleteTask'), t('calEntry.deleteTaskMsg'), t('calEntry.delete'), () => {
    const tk = manualTasks.find((x) => x.created === taskId);
    if (!tk) return;
    manualTasks = manualTasks.filter((x) => x.id !== tk.id);
    apiDelete('/api/tasks/' + tk.id);
    renderCalendar();
    updateTodoBadge();
  });
}

// ─── UNIFIED CALENDAR ENTRY MODAL ─────────────────────────────
const CATEGORY_COLORS = {
  custom: '#16a34a',
  meeting: '#8b5cf6',
  delivery: '#14b8a6',
  maintenance: '#64748b',
  pickup: '#f59e0b'
};
let calEntryType = 'task';

// Fill the location dropdown. Retired locations are offered only when the event
// being edited already points at one — otherwise a window would silently lose
// its place the first time somebody opened it to change the time.
function fillEntryLocationSelect(selectedId) {
  const sel = document.getElementById('cal-entry-location');
  if (!sel) return;
  const chosen = selectedId ? Number(selectedId) : null;
  const options = pickupLocations.filter((l) => l.active !== false || l.id === chosen);
  sel.innerHTML =
    `<option value="">${esc(t('calEntry.placeNone'))}</option>` +
    options
      .map(
        (l) =>
          `<option value="${l.id}"${l.id === chosen ? ' selected' : ''}>${esc(l.name)}${
            l.active === false ? ' (' + t('pickupLoc.retired') + ')' : ''
          }</option>`
      )
      .join('');
  sel.value = chosen ? String(chosen) : '';
}

function setEntryType(type) {
  const isTask = type === 'task';
  calEntryType = isTask ? 'task' : 'event';
  document.getElementById('cal-entry-type-select').value = type;
  document.getElementById('cal-entry-enddate-wrap').style.display = isTask ? 'none' : '';
  // A pickup window without a clock is not a window: "Saturday" is not something
  // anyone can book into, and the feed skips such a row — silently, from the
  // author's point of view. So the option is not offered rather than explained.
  const isPickup = type === 'pickup';
  if (isPickup) document.getElementById('cal-entry-allday').checked = false;
  document.getElementById('cal-entry-allday-wrap').style.display = isPickup ? 'none' : '';
  document.getElementById('cal-entry-prio-wrap').style.display = isTask ? '' : 'none';
  document.getElementById('cal-entry-task-assign-wrap').style.display = isTask ? '' : 'none';
  document.getElementById('cal-entry-ev-assign-wrap').style.display = isTask ? 'none' : '';
  document.getElementById('cal-entry-private-wrap').style.display = isTask ? 'flex' : 'none';
  const recWrap = document.getElementById('cal-entry-recurrence-wrap');
  if (recWrap) recWrap.style.display = 'grid';
  // A place belongs to any appointment; the seat count only to a pickup window,
  // which is the only kind somebody outside the lab books into.
  const placeWrap = document.getElementById('cal-entry-place-wrap');
  if (placeWrap) placeWrap.style.display = isTask ? 'none' : 'grid';
  const capWrap = document.getElementById('cal-entry-capacity-wrap');
  if (capWrap) capWrap.style.display = type === 'pickup' ? '' : 'none';
  document.getElementById('cal-entry-name').placeholder = isTask ? t('calEntry.namePhTask') : t('calEntry.namePhEvent');
  toggleEntryTimeInputs();
  toggleRecurrenceUntil();
}
function toggleRecurrenceUntil() {
  const sel = document.getElementById('cal-entry-recurrence');
  const wrap = document.getElementById('cal-entry-recurrence-until-wrap');
  if (sel && wrap) wrap.style.display = sel.value ? '' : 'none';
}

function openEntryModal(type, date, time, existing) {
  const modal = document.getElementById('m-cal-entry');
  const isEdit = !!existing;
  document.getElementById('cal-entry-name').disabled = false;
  document.getElementById('cal-entry-desc').closest('div').style.display = '';
  document.getElementById('cal-entry-type-select').closest('.g2').style.display = '';
  document.getElementById('cal-entry-type-select').disabled = isEdit;
  setEntryType(type || 'task');
  if (type === 'task' && existing) {
    document.getElementById('cal-entry-title').textContent = t('calEntry.titleEdit');
    document.getElementById('cal-entry-mode').value = 'edit';
    document.getElementById('cal-entry-id').value = existing.id;
    document.getElementById('cal-entry-name').value = existing.text;
    document.getElementById('cal-entry-date').value = existing.dueDate ? existing.dueDate.split('T')[0] : '';
    document.getElementById('cal-entry-allday').checked = !existing.dueTime;
    document.getElementById('cal-entry-start-time').value = existing.dueTime || '09:00';
    document.getElementById('cal-entry-end-time').value = existing.dueEndTime || '10:00';
    document.getElementById('cal-entry-prio').value = existing.priority || 'med';
    calTaskSelectedAssignees = parseTaskAssignees(existing.assignee);
    renderTaskAssigneePicker();
    document.getElementById('cal-entry-desc').value = existing.description || '';
    document.getElementById('cal-entry-private').checked = !!existing.private;
    document.getElementById('cal-entry-recurrence').value = existing.recurrence || '';
    document.getElementById('cal-entry-recurrence-until').value = existing.recurrenceUntil || '';
    toggleRecurrenceUntil();
    document.getElementById('cal-entry-del-btn').style.display = '';
  } else if (type === 'event' && existing) {
    document.getElementById('cal-entry-title').textContent = t('calEntry.titleEdit');
    document.getElementById('cal-entry-mode').value = 'edit';
    document.getElementById('cal-entry-id').value = existing.id;
    document.getElementById('cal-entry-name').value = existing.title;
    document.getElementById('cal-entry-date').value = existing.startDate;
    document.getElementById('cal-entry-end-date').value = existing.endDate || '';
    document.getElementById('cal-entry-allday').checked = existing.allDay;
    document.getElementById('cal-entry-start-time').value = existing.startTime || '09:00';
    document.getElementById('cal-entry-end-time').value = existing.endTime || '10:00';
    setEntryType(existing.category || 'custom');
    fillEntryLocationSelect(existing.locationId);
    document.getElementById('cal-entry-capacity').value =
      existing.pickupCapacity === null || existing.pickupCapacity === undefined ? '' : existing.pickupCapacity;
    document.getElementById('cal-entry-desc').value = existing.description || '';
    calEvSelectedAssignees = Array.isArray(existing.teamAssignees) ? existing.teamAssignees.slice() : [];
    renderAssigneePicker();
    document.getElementById('cal-entry-recurrence').value = existing.recurrence || '';
    document.getElementById('cal-entry-recurrence-until').value = existing.recurrenceUntil || '';
    toggleRecurrenceUntil();
    document.getElementById('cal-entry-del-btn').style.display = '';
  } else {
    document.getElementById('cal-entry-title').textContent = t('calEntry.titleNew');
    document.getElementById('cal-entry-mode').value = 'create';
    document.getElementById('cal-entry-id').value = '';
    document.getElementById('cal-entry-name').value = '';
    document.getElementById('cal-entry-date').value = date || localDateStr(new Date());
    document.getElementById('cal-entry-end-date').value = '';
    document.getElementById('cal-entry-allday').checked = !time;
    document.getElementById('cal-entry-start-time').value = time || '09:00';
    const endH = time ? String(Math.min(23, parseInt(time) + 1)).padStart(2, '0') + ':00' : '10:00';
    document.getElementById('cal-entry-end-time').value = endH;
    document.getElementById('cal-entry-prio').value = 'med';
    calTaskSelectedAssignees = [];
    renderTaskAssigneePicker();
    document.getElementById('cal-entry-desc').value = '';
    document.getElementById('cal-entry-private').checked = false;
    calEvSelectedAssignees = [];
    renderAssigneePicker();
    document.getElementById('cal-entry-recurrence').value = '';
    document.getElementById('cal-entry-recurrence-until').value = '';
    toggleRecurrenceUntil();
    fillEntryLocationSelect(null);
    document.getElementById('cal-entry-capacity').value = '';
    document.getElementById('cal-entry-del-btn').style.display = 'none';
  }
  document.getElementById('cal-ev-assignee-dropdown').style.display = 'none';
  const tdd = document.getElementById('cal-task-assignee-dropdown');
  if (tdd) tdd.style.display = 'none';
  toggleEntryTimeInputs();
  modal.classList.add('open');
  if (!existing) setTimeout(() => document.getElementById('cal-entry-name').focus(), 50);
}

function parseTaskAssignees(val) {
  if (!val) return [];
  if (Array.isArray(val)) return val.slice();
  // Split comma-separated for backward compat with old single-assignee strings
  return String(val)
    .split(',')
    .map((s) => s.trim())
    .filter(Boolean);
}

function openEventModal(date, time, existing) {
  openEntryModal(existing ? 'event' : 'custom', date, time, existing);
}

function closeEntryModal() {
  document.getElementById('m-cal-entry').classList.remove('open');
  const idEl = document.getElementById('cal-entry-id');
  idEl.dataset.moveType = '';
  idEl.dataset.moveId = '';
}

function toggleEntryTimeInputs() {
  const timesEl = document.getElementById('cal-entry-times');
  timesEl.style.display = document.getElementById('cal-entry-allday').checked ? 'none' : 'grid';
}

// Normalize a user-entered time string to 24h HH:MM, or '' if invalid.
// Accepts "9", "9:5", "930", "0930", "9:30", "09:30", etc.
function normalizeTimeInput(raw) {
  if (raw == null) return '';
  const s = String(raw).trim();
  if (!s) return '';
  const digits = s.replace(/\D/g, '');
  let h, m;
  if (digits.length <= 2) {
    h = parseInt(digits, 10);
    m = 0;
  } else if (digits.length === 3) {
    h = parseInt(digits.slice(0, 1), 10);
    m = parseInt(digits.slice(1), 10);
  } else {
    h = parseInt(digits.slice(0, 2), 10);
    m = parseInt(digits.slice(2, 4), 10);
  }
  if (!Number.isFinite(h) || !Number.isFinite(m)) return '';
  if (h < 0 || h > 23 || m < 0 || m > 59) return '';
  return String(h).padStart(2, '0') + ':' + String(m).padStart(2, '0');
}

function wireTimeInput(el) {
  if (!el || el.dataset.timeWired) return;
  el.dataset.timeWired = '1';
  el.addEventListener('blur', () => {
    const n = normalizeTimeInput(el.value);
    if (n) el.value = n;
  });
}

function saveEntry() {
  const mode = document.getElementById('cal-entry-mode').value;
  if (mode === 'move') {
    const idEl = document.getElementById('cal-entry-id');
    const moveType = idEl.dataset.moveType;
    const moveId = idEl.dataset.moveId;
    const newDate = document.getElementById('cal-entry-date').value;
    if (newDate && moveType) handleCalendarDrop(moveType, moveId, newDate);
    closeEntryModal();
    return;
  }
  if (calEntryType === 'task') saveEntryTask();
  else saveEntryEvent();
}

function saveEntryTask() {
  const mode = document.getElementById('cal-entry-mode').value;
  const text = document.getElementById('cal-entry-name').value.trim();
  if (!text) return;
  const prio = document.getElementById('cal-entry-prio').value;
  const due = document.getElementById('cal-entry-date').value || null;
  const allDay = document.getElementById('cal-entry-allday').checked;
  const dueTime =
    !allDay && due ? normalizeTimeInput(document.getElementById('cal-entry-start-time').value) || null : null;
  let dueEndTime =
    !allDay && due ? normalizeTimeInput(document.getElementById('cal-entry-end-time').value) || null : null;
  if (dueTime && dueEndTime && dueEndTime <= dueTime) dueEndTime = null;
  const assignee = calTaskSelectedAssignees.length ? calTaskSelectedAssignees.join(',') : null;
  const desc = document.getElementById('cal-entry-desc').value.trim() || null;
  const priv = document.getElementById('cal-entry-private').checked;
  const recurrence = document.getElementById('cal-entry-recurrence').value || null;
  const recurrenceUntil = recurrence ? document.getElementById('cal-entry-recurrence-until').value || null : null;
  if (mode === 'edit') {
    const id = parseInt(document.getElementById('cal-entry-id').value);
    const tk = manualTasks.find((x) => x.id === id);
    if (!tk) {
      closeEntryModal();
      return;
    }
    tk.text = text;
    tk.priority = prio;
    tk.dueDate = due;
    tk.dueTime = dueTime;
    tk.dueEndTime = dueEndTime;
    tk.assignee = assignee;
    tk.description = desc;
    tk.private = priv;
    tk.recurrence = recurrence;
    tk.recurrenceUntil = recurrenceUntil;
    tk.caldavSynced = null;
    apiPatch('/api/tasks/' + id, {
      text: tk.text,
      priority: tk.priority,
      dueDate: tk.dueDate,
      dueTime: tk.dueTime,
      dueEndTime: tk.dueEndTime,
      assignee: tk.assignee,
      description: tk.description,
      private: priv ? 1 : 0,
      recurrence,
      recurrenceUntil,
      caldavSynced: null
    });
    if (caldav.enabled && tk.caldavUid) pushTaskCaldav(tk);
  } else {
    const task = {
      text,
      priority: prio,
      done: false,
      created: new Date().toISOString(),
      assignee,
      dueDate: due,
      dueTime,
      dueEndTime,
      description: desc,
      caldavUid: null,
      caldavSynced: null,
      private: priv,
      recurrence,
      recurrenceUntil
    };
    manualTasks.push(task);
    apiPost('/api/tasks', task).then((r) => {
      if (r && r.id) {
        task.id = r.id;
        if (caldav.enabled && due) pushTaskCaldav(task);
      }
      renderCalendar();
      updateTodoBadge();
    });
  }
  closeEntryModal();
  if (document.getElementById('cal-entry-id').value) {
    renderCalendar();
    updateTodoBadge();
  }
}

function saveEntryEvent() {
  const mode = document.getElementById('cal-entry-mode').value;
  const name = document.getElementById('cal-entry-name').value.trim();
  if (!name) return;
  const allDay = document.getElementById('cal-entry-allday').checked;
  const category = document.getElementById('cal-entry-type-select').value;
  const recurrence = document.getElementById('cal-entry-recurrence').value || null;
  const recurrenceUntil = recurrence ? document.getElementById('cal-entry-recurrence-until').value || null : null;
  const teamAssignees = calEvSelectedAssignees.slice();
  const locationId = Number(document.getElementById('cal-entry-location').value) || null;
  // Only a pickup window has a seat count; anything else must not carry one
  // out of a field the user could not see. The empty string stays null
  // (uncapped) while a typed 0 survives as 0 (open, but taking nobody).
  const capRaw = document.getElementById('cal-entry-capacity').value;
  const pickupCapacity = category === 'pickup' && capRaw !== '' && capRaw != null ? Number(capRaw) : null;
  const ev = {
    id:
      mode === 'edit'
        ? document.getElementById('cal-entry-id').value
        : 'cev-' + Date.now() + '-' + Math.random().toString(36).slice(2, 6),
    title: name,
    description: document.getElementById('cal-entry-desc').value.trim() || null,
    startDate: document.getElementById('cal-entry-date').value,
    endDate: document.getElementById('cal-entry-end-date').value || null,
    allDay: allDay,
    startTime: allDay ? null : normalizeTimeInput(document.getElementById('cal-entry-start-time').value) || null,
    endTime: allDay ? null : normalizeTimeInput(document.getElementById('cal-entry-end-time').value) || null,
    category: category,
    color: CATEGORY_COLORS[category] || '#16a34a',
    caldavUid: null,
    caldavSynced: null,
    created: new Date().toISOString(),
    recurrence: recurrence,
    recurrenceUntil: recurrenceUntil,
    teamAssignees: teamAssignees,
    assignees: [],
    locationId: locationId,
    pickupCapacity: pickupCapacity
  };
  // Somebody may already have arranged to turn up for this. Ask before the
  // arrangement changes underneath them — but only when the change is one they
  // would notice: a corrected title is not worth a dialog, a new time is.
  const previous = mode === 'edit' ? calendarEvents.find((x) => x.id === ev.id) : null;
  const movesAWindow =
    previous &&
    (previous.category === 'pickup' || category === 'pickup') &&
    (previous.startDate !== ev.startDate ||
      previous.startTime !== ev.startTime ||
      previous.endTime !== ev.endTime ||
      (previous.locationId || null) !== (ev.locationId || null) ||
      (previous.recurrence || null) !== (ev.recurrence || null) ||
      (previous.recurrenceUntil || null) !== (ev.recurrenceUntil || null) ||
      (previous.category === 'pickup' && category !== 'pickup'));
  if (movesAWindow) {
    confirmBookedWindow(ev.id, null, () => applyEntryEvent(ev, mode));
    return;
  }
  applyEntryEvent(ev, mode);
}

function applyEntryEvent(ev, mode) {
  if (mode === 'edit') {
    const idx = calendarEvents.findIndex((x) => x.id === ev.id);
    if (idx >= 0) {
      ev.caldavUid = calendarEvents[idx].caldavUid;
      ev.created = calendarEvents[idx].created;
      calendarEvents[idx] = ev;
    }
    apiPatch('/api/calendar-events/' + encodeURIComponent(ev.id), {
      title: ev.title,
      description: ev.description,
      startDate: ev.startDate,
      endDate: ev.endDate,
      allDay: ev.allDay,
      startTime: ev.startTime,
      endTime: ev.endTime,
      category: ev.category,
      color: ev.color,
      recurrence: ev.recurrence,
      recurrenceUntil: ev.recurrenceUntil,
      teamAssignees: ev.teamAssignees,
      // '' rather than null: updateCalendarEvent skips a field only when the key
      // is absent, and both spellings normalise to NULL — but sending '' keeps
      // "clear the place again" expressible through the same path that set it.
      locationId: ev.locationId === null ? '' : ev.locationId,
      pickupCapacity: ev.pickupCapacity === null ? '' : ev.pickupCapacity
    });
  } else {
    calendarEvents.push(ev);
    apiPost('/api/calendar-events', ev).then((r) => {
      if (r && r.id) ev.id = r.id;
    });
  }
  renderCalendar();
  closeEntryModal();
  if (caldav.enabled && typeof pushEventCaldav === 'function') pushEventCaldav(ev);
}

function deleteEntry() {
  if (calEntryType === 'task') {
    const id = parseInt(document.getElementById('cal-entry-id').value);
    if (!id) {
      closeEntryModal();
      return;
    }
    closeEntryModal();
    confirm2(t('calEntry.deleteTask'), t('calEntry.deleteTaskMsg'), t('calEntry.delete'), () => {
      manualTasks = manualTasks.filter((x) => x.id !== id);
      apiDelete('/api/tasks/' + id);
      renderCalendar();
      updateTodoBadge();
    });
  } else {
    const id = document.getElementById('cal-entry-id').value;
    if (!id) return;
    const ce = calendarEvents.find((x) => x.id === id);
    const isRecurring = !!(ce && ce.recurrence);
    closeEntryModal();
    if (!isRecurring) {
      const dups = findSameTitleEvents(ce);
      if (dups.length) {
        confirm3(
          t('calEntry.deleteDupTitle'),
          t('calEntry.deleteDupMsg', { n: dups.length }),
          t('calEntry.deleteOnlyThis'),
          t('calEntry.deleteAllSameTitle', { n: dups.length + 1 }),
          () => {
            calendarEvents = calendarEvents.filter((x) => x.id !== id);
            apiDelete('/api/calendar-events/' + encodeURIComponent(id));
            renderCalendar();
          },
          () => deleteAllSameTitle([id, ...dups.map((d) => d.id)])
        );
        return;
      }
    }
    const title = isRecurring ? t('calEntry.deleteRecurTitle') : t('calEntry.deleteEvent');
    const body = isRecurring ? t('calEntry.deleteSeriesMsg') : t('calEntry.deleteEventMsg');
    confirm2(title, body, t('calEntry.delete'), () =>
      confirmBookedWindow(id, null, () => {
        calendarEvents = calendarEvents.filter((x) => x.id !== id);
        apiDelete('/api/calendar-events/' + encodeURIComponent(id));
        renderCalendar();
      })
    );
  }
}

function editTaskFromCalendar(taskId) {
  closeEventDetail();
  const tk = manualTasks.find((x) => x.created === taskId);
  if (tk) openEntryModal('task', tk.dueDate, null, tk);
}

function onCalMonthEventClick(type, id) {
  if (!type || !id) return;
  const events = collectCalendarEvents();
  const ev = events.find((e) => e.type === type && String(e.id) === String(id));
  if (ev) onCalEventClick(ev);
}

async function pushEventCaldav(ev) {
  if (!caldav.enabled) return;
  try {
    const r = await authFetch('/api/caldav/push-event', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ event: ev })
    }).then((r) => r.json());
    if (r.ok && r.uid) {
      ev.caldavUid = r.uid;
      ev.caldavSynced = new Date().toISOString();
      apiPatch('/api/calendar-events/' + encodeURIComponent(ev.id), {
        caldavUid: ev.caldavUid,
        caldavSynced: ev.caldavSynced
      });
    }
  } catch (e) {
    console.error('CalDAV event push error:', e);
  }
}

// ── User list + Assignee picker ──
async function loadAppUsers() {
  try {
    const r = await authFetch('/api/usernames');
    if (r.ok) appUsers = await r.json();
    fillCalendarUserFilter();
  } catch {
    appUsers = [];
  }
}
// Combined list of selectable people: registered users + manually-added team members (deduped)
function getSelectableAssignees() {
  const names = new Set();
  const out = [];
  (appUsers || []).forEach((u) => {
    if (u && u.username && !names.has(u.username)) {
      names.add(u.username);
      out.push(u.username);
    }
  });
  (teamMembers || []).forEach((m) => {
    if (m && m.name && !names.has(m.name)) {
      names.add(m.name);
      out.push(m.name);
    }
  });
  return out;
}
function fillCalendarUserFilter() {
  const sel = document.getElementById('cal-filter-user');
  if (!sel) return;
  const cur = sel.value;
  const names = getSelectableAssignees();
  sel.innerHTML =
    '<option value="">' +
    esc(t('calEntry.assignTo.all')) +
    '</option>' +
    names.map((n) => '<option value="' + esc(n) + '">' + esc(n) + '</option>').join('');
  sel.value = cur;
}
function renderAssigneePicker() {
  const box = document.getElementById('cal-ev-assignees');
  if (!box) return;
  const dd = document.getElementById('cal-ev-assignee-dropdown');
  if (!calEvSelectedAssignees.length) {
    box.innerHTML =
      '<span class="fs-meta" style="color:var(--c-text-muted)">' + esc(t('calEntry.allClickToSelect')) + '</span>';
  } else {
    box.innerHTML = calEvSelectedAssignees
      .map(
        (name) =>
          '<span class="assignee-chip">' +
          esc(name) +
          ' <button data-assignee-remove="' +
          esc(name) +
          '">×</button></span>'
      )
      .join('');
  }
  if (dd) {
    const names = getSelectableAssignees();
    if (!names.length) {
      dd.innerHTML =
        '<div class="fs-meta" style="padding:8px;color:var(--c-text-muted)">' + esc(t('calEntry.noMembers')) + '</div>';
    } else {
      dd.innerHTML = names
        .map((n) => {
          const checked = calEvSelectedAssignees.includes(n);
          return (
            '<label class="fs-meta" style="display:flex;align-items:center;padding:6px 8px;cursor:pointer;' +
            (checked ? 'background:#e8f5e9' : '') +
            '" data-assignee-toggle="' +
            esc(n) +
            '"><input type="checkbox" ' +
            (checked ? 'checked' : '') +
            ' style="width:auto;margin-right:6px" data-assignee-checkbox>' +
            esc(n) +
            '</label>'
          );
        })
        .join('');
    }
  }
}
function toggleAssigneeDropdown() {
  const dd = document.getElementById('cal-ev-assignee-dropdown');
  if (!dd) return;
  dd.style.display = dd.style.display === 'none' ? 'block' : 'none';
}
function toggleAssignee(name) {
  const i = calEvSelectedAssignees.indexOf(name);
  if (i >= 0) calEvSelectedAssignees.splice(i, 1);
  else calEvSelectedAssignees.push(name);
  renderAssigneePicker();
}
// Delegated click handlers for assignee picker (avoids inline onclick XSS)
(function () {
  const box = document.getElementById('cal-ev-assignees');
  if (box) {
    box.addEventListener('click', function (e) {
      const rm = e.target.closest('[data-assignee-remove]');
      if (!rm) return;
      e.stopPropagation();
      toggleAssignee(rm.dataset.assigneeRemove);
    });
  }
  const dd = document.getElementById('cal-ev-assignee-dropdown');
  if (dd) {
    dd.addEventListener('click', function (e) {
      const lbl = e.target.closest('[data-assignee-toggle]');
      if (!lbl) return;
      e.stopPropagation();
      e.preventDefault();
      toggleAssignee(lbl.dataset.assigneeToggle);
    });
  }
})();

// ── Task assignee picker (multi-select) ──
function renderTaskAssigneePicker() {
  const box = document.getElementById('cal-task-assignees');
  if (!box) return;
  const dd = document.getElementById('cal-task-assignee-dropdown');
  if (!calTaskSelectedAssignees.length) {
    box.innerHTML =
      '<span class="fs-meta" style="color:var(--c-text-muted)">' + esc(t('calEntry.allClickToSelect')) + '</span>';
  } else {
    box.innerHTML = calTaskSelectedAssignees
      .map(
        (name) =>
          '<span class="assignee-chip">' +
          esc(name) +
          ' <button data-task-assignee-remove="' +
          esc(name) +
          '">×</button></span>'
      )
      .join('');
  }
  if (dd) {
    const names = getSelectableAssignees();
    if (!names.length) {
      dd.innerHTML =
        '<div class="fs-meta" style="padding:8px;color:var(--c-text-muted)">' + esc(t('calEntry.noMembers')) + '</div>';
    } else {
      dd.innerHTML = names
        .map((n) => {
          const checked = calTaskSelectedAssignees.includes(n);
          return (
            '<label class="fs-meta" style="display:flex;align-items:center;padding:6px 8px;cursor:pointer;' +
            (checked ? 'background:#e8f5e9' : '') +
            '" data-task-assignee-toggle="' +
            esc(n) +
            '"><input type="checkbox" ' +
            (checked ? 'checked' : '') +
            ' style="width:auto;margin-right:6px" data-assignee-checkbox>' +
            esc(n) +
            '</label>'
          );
        })
        .join('');
    }
  }
}
function toggleTaskAssigneeDropdown() {
  const dd = document.getElementById('cal-task-assignee-dropdown');
  if (!dd) return;
  dd.style.display = dd.style.display === 'none' ? 'block' : 'none';
}
function toggleTaskAssignee(name) {
  const i = calTaskSelectedAssignees.indexOf(name);
  if (i >= 0) calTaskSelectedAssignees.splice(i, 1);
  else calTaskSelectedAssignees.push(name);
  renderTaskAssigneePicker();
}
// Delegated click handlers for task assignee picker (avoids inline onclick XSS)
(function () {
  const box = document.getElementById('cal-task-assignees');
  if (box) {
    box.addEventListener('click', function (e) {
      const rm = e.target.closest('[data-task-assignee-remove]');
      if (!rm) return;
      e.stopPropagation();
      toggleTaskAssignee(rm.dataset.taskAssigneeRemove);
    });
  }
  const dd = document.getElementById('cal-task-assignee-dropdown');
  if (dd) {
    dd.addEventListener('click', function (e) {
      const lbl = e.target.closest('[data-task-assignee-toggle]');
      if (!lbl) return;
      e.stopPropagation();
      e.preventDefault();
      toggleTaskAssignee(lbl.dataset.taskAssigneeToggle);
    });
  }
})();

async function loadCalDAVImports() {
  try {
    const r = await authFetch('/api/caldav/import');
    if (r.ok) caldavImports = await r.json();
  } catch (e) {
    caldavImports = [];
  }
}

// A plain declaration, like every other function here. It used to be
// `if (typeof pushBatchCaldav === 'undefined') window.pushBatchCaldav = ...`,
// guarding against a redefinition that never existed — nothing else in the repo
// defines this name. Its two call sites guarded in the same spirit
// (`if (typeof pushBatchCaldav === 'function')`), which meant that if this block
// ever failed to run, CalDAV push degraded to a silent no-op: batches would stop
// appearing in the shared calendar with no error and no failed request to notice.
// Declared normally it hoists, so the call sites can just call it — and ESLint can
// now see the binding, which is how this was found.
async function pushBatchCaldav(batch) {
  if (!caldav.enabled) return;
  try {
    await authFetch('/api/caldav/push-batch', {
      method: 'POST',
      headers: { 'Content-Type': 'application/json' },
      body: JSON.stringify({ batch })
    });
  } catch (e) {
    console.warn('CalDAV push failed:', e.message);
  }
}

// All .modal-bg elements ship with a `hidden` attribute in index.html so the
// app degrades gracefully when styles.css fails to load (otherwise every modal
// renders as a visible block — the partner saw this when an SW-cached bad
// styles.css served on Android). The CSS rule .modal-bg.open { display:flex }
// already wins over UA [hidden] visually, but `hidden` also makes the element
// inert for keyboard + screen-reader users. This observer keeps the attribute
// in sync with the .open class so an opened modal is actually interactable.
(function syncModalHiddenWithOpen() {
  const observer = new MutationObserver((muts) => {
    for (const m of muts) {
      const el = m.target;
      if (el.classList.contains('open')) el.removeAttribute('hidden');
      else el.setAttribute('hidden', '');
    }
  });
  document.querySelectorAll('.modal-bg').forEach((el) => {
    observer.observe(el, { attributes: true, attributeFilter: ['class'] });
  });
})();

// ═══ SUCHE ═════════════════════════════════════════════════════════════════
//
// One field over what this client already holds — Chargen, Kulturen, Sorten,
// Zonen, Bestellungen, Kunden — and over the pages and sub-pages themselves,
// because the quickest way to a page in a twelve-entry sidebar is not to go
// looking for it in the sidebar.
//
// What it can index is what is in memory. batches, cultures, mushroomStrains
// and zones arrive with /api/data and are always there; orders and customers
// have their own endpoints and are fetched on the way into Bestellungen, so the
// first open warms those two caches and redraws when they land. Blocking the
// field until every source has answered would make the fast path wait for the
// slow one on every single open, so it does not.
//
// Single bags are deliberately not indexed. There are many per batch, they
// would outnumber everything else by far, and a scanned bag code finds its
// batch anyway — see rank 2.
// One table per kind, rather than four that have to agree.
//
// A kind used to be described in four places: GS_ORDER for the tie-break order,
// GS_GROUP for its heading, a list of type names inside gsRowHtml() deciding
// whether its id is monospaced, and a branch of gsGoto() saying where it opens.
// Forgetting any one of them failed quietly and differently — no heading, a
// proportional id under a column of monospaced ones, or a result that opened
// nothing at all.
//
// Order is the tie-break order in gsMatch(): records before pages, and within
// records the kinds a worker names most often first.
//
//   group  its heading, and the only thing the empty list is grouped by
//   mono   ids that are machine-shaped and read down a column
//   clear  a filter on the destination that would hide the row on arrival
//   go     where it opens, through the controls rather than past them
//   flash  whether gsGoto() marks the row afterwards; the two that say no
//          both land somewhere that has already done it, or has no row
const GS_TYPES = [
  {
    type: 'batch',
    group: 'search.gBatches',
    mono: true,
    // goToBatch() is the whole landing for a Charge and has been since the
    // dashboard's "Zur Charge" button: it clears the attention filter, writes
    // the id into the search box — which renderBatches() lets past the archive
    // filter on purpose — and flashes the row itself.
    go: (rec) => goToBatch(rec.id)
  },
  {
    type: 'culture',
    group: 'search.gCultures',
    mono: true,
    go: (rec) => {
      gsNav('n-lab', 'lab');
      gsStab('lab', 'cultures');
      kbZeige(rec.id);
    },
    flash: true
  },
  {
    type: 'strain',
    group: 'search.gStrains',
    mono: false,
    go: () => gsNav('n-strains', 'strains'),
    flash: true
  },
  {
    type: 'zone',
    group: 'search.gZones',
    mono: true,
    go: () => gsNav('n-zones', 'zones'),
    flash: true
  },
  {
    type: 'order',
    group: 'search.gOrders',
    mono: true,
    // Through the setter, or a chip stays looking selected over a list it is
    // no longer filtering.
    clear: () => setOrdersFilter(''),
    go: () => {
      gsNav('n-orders', 'orders');
      gsStab('orders', 'inbox');
    },
    flash: true
  },
  {
    type: 'customer',
    group: 'search.gCustomers',
    mono: false,
    go: () => {
      gsNav('n-orders', 'orders');
      gsStab('orders', 'customers');
    },
    flash: true
  },
  {
    type: 'page',
    group: 'search.gPages',
    mono: false,
    // No clear: somebody who searched for the page "Kulturen" asked for the
    // page, and what they last had it filtered to is part of it.
    go: (rec) => {
      gsNav(rec.btn, rec.page);
      if (rec.lead) {
        const b = document.getElementById(rec.lead);
        if (b) b.click();
      } else if (rec.stab) gsStab(rec.page, rec.stab);
    }
  }
];
const GS_ORDER = GS_TYPES.map((k) => k.type);
const GS_KIND = (type) => GS_TYPES.find((k) => k.type === type);
const gsSetValue = (ids, v) =>
  ids.forEach((id) => {
    const el = document.getElementById(id);
    if (el) el.value = v;
  });
const GS_CULTURE_STATUS = { active: 'lab.active', stored: 'lab.stored', used: 'lab.usedUp', sold: 'lab.sold', contam: 'lab.contaminated' };
// Seven fits the box without a scrollbar. A list that scrolls is a filtered
// table, and every page worth having one already has one.
const GS_CAP = 7;
let gsHits = [];
let gsSel = 0;
let gsReturnFocus = null;
// The query the results actually answer, which is not always the one in the
// field: a scanned label resolves to the id it stands for. Everything that
// needs the query after a render — the highlight, the auto-open, the "nothing
// found" line — means this one.
let gsQ = '';
let gsJumpTimer = null;

// How well a record answers `q`. Lower is better; -1 is "not an answer".
//
//   0  it IS the id — a scanned code, or an id typed out in full
//   1  the id starts with it — the ordinary case while typing
//   2  it starts with the ID — a scanned bag code (AUS-190826-02-03) naming the
//      batch that owns it (AUS-190826-02), which is the whole reason a worker
//      would type sixteen characters by scanner in the first place
//   3  the id contains it
//   4  only the subtitle does — species, zone, status, customer, Kürzel
//
// Rank 2 needs four characters of id or a three-letter zone (FRU) would claim
// every query that happens to begin with those letters.
function gsRank(rec, q) {
  const id = String((rec && rec.id) || '').toLowerCase();
  const sub = String((rec && rec.sub) || '').toLowerCase();
  if (!id) return -1;
  if (id === q) return 0;
  if (id.startsWith(q)) return 1;
  if (id.length >= 4 && q.startsWith(id)) return 2;
  if (id.indexOf(q) >= 0) return 3;
  if (sub.indexOf(q) >= 0) return 4;
  return -1;
}

// An empty field is not an empty answer: somebody who opened this and typed
// nothing wants a page. Sub-pages stay out of that list — forty of them would
// bury the twelve entries the list exists to offer.
function gsMatch(index, query) {
  const q = String(query || '')
    .trim()
    .toLowerCase();
  if (!q) return index.filter((r) => r.type === 'page' && !r.stab && !r.lead);
  const scored = [];
  index.forEach((rec) => {
    const rank = gsRank(rec, q);
    if (rank >= 0) scored.push({ rec: rec, rank: rank });
  });
  scored.sort(
    (a, b) =>
      a.rank - b.rank ||
      GS_ORDER.indexOf(a.rec.type) - GS_ORDER.indexOf(b.rec.type) ||
      String(a.rec.id).localeCompare(String(b.rec.id))
  );
  return scored.map((s) => s.rec);
}

// A scanner types, and it types the whole code. When the query is answered by
// exactly one record there is nothing left to choose, so the palette gets out
// of the way rather than waiting for a keypress the scanner may not send.
// Eight characters is the floor: every id this app generates is longer, and it
// stops a short Sorte name from teleporting a human mid-word.
//
// The second half is for the code a station actually produces. A bag barcode
// has no record of its own and never will — many per batch would outnumber
// everything else by far — so the batch that owns it answers, at rank 2.
// `isCode` gates that on the string being one this app would recognise as its
// own (isKnownBarcode), because rank 2 is a prefix rule and without the gate it
// would jump a human out of the middle of a long Sorte name after a pause.
function gsAutoOpen(hits, query, isCode) {
  const q = String(query || '')
    .trim()
    .toLowerCase();
  if (q.length < 8) return null;
  const exact = hits.filter((r) => String(r.id).toLowerCase() === q);
  if (exact.length) return exact.length === 1 ? exact[0] : null;
  if (!isCode) return null;
  const owner = hits.filter((r) => gsRank(r, q) === 2);
  return owner.length === 1 ? owner[0] : null;
}

// A scanned label is a lookup key, not an id. The numeric barcode system prints
// a number and keeps the id it stands for in barcodeRegistry, so a scanner at
// the palette types eight digits that appear in no index. processScan() does
// this lookup first and so does this. A number nobody printed a label for is
// left as typed: it ranks nowhere, and the "nothing found" line says so.
function gsScanned(query, registry) {
  const val = String(query || '')
    .trim()
    .toUpperCase();
  if (!/^\d{7,}$/.test(val)) return null;
  const num = parseInt(val, 10);
  if (num < 1000000) return null;
  const entry = registry && registry.get ? registry.get(num) : null;
  return entry && entry.id ? entry.id : null;
}

// One query, read up to three ways, in the order that cannot lose anything.
//
// As typed first — always, because underscores are real here: zone and rack
// barcodes carry them (INC_MUSTER_01, SPAWN_R1) and rewriting them would make
// every zone unfindable. Only when that answers nothing does the German HID
// reading get a turn — those scanners send an underscore where a bag id has a
// hyphen, which is the same fix processScan() applies, but applied as a second
// attempt rather than as a rewrite.
function gsLookup(index, query, registry) {
  const typed = String(query || '').trim();
  const q = gsScanned(typed, registry) || typed;
  const hits = gsMatch(index, q);
  if (hits.length || q.indexOf('_') < 0) return { q: q, hits: hits };
  const dashed = q.replace(/_/g, '-');
  const retry = gsMatch(index, dashed);
  return retry.length ? { q: dashed, hits: retry } : { q: q, hits: hits };
}

// Pages and sub-pages, read off the sidebar and the sub-tab strips rather than
// listed a second time here. A page added to the sidebar is searchable without
// anyone remembering to add it, and a renamed one is renamed once — the same
// reason go() takes the topbar title off the nav entry it was handed.
//
// `style.display !== 'none'` is how this app gates by role (showAdminNav,
// showAdminSubTab, stabLandable), so it is also how the index decides what a
// user may be offered. A packer must not be sent to a blank Admin sub-page.
function gsPageIndex() {
  const out = [];
  const label = (el) => {
    const span = el.querySelector('[data-i18n]');
    return span ? span.textContent.trim() : el.textContent.trim();
  };
  document.querySelectorAll('.sb-nav .sb-btn[data-page], .sb-footer .sb-btn[data-page]').forEach((btn) => {
    if (btn.style.display === 'none') return;
    out.push({ type: 'page', id: label(btn), sub: '', page: btn.dataset.page, btn: btn.id });
  });
  document.querySelectorAll('.page > .stabs').forEach((strip) => {
    const page = strip.parentElement.id.replace('p-', '');
    const nav = document.querySelector('.sb-btn[data-page="' + page + '"]');
    if (!nav || nav.style.display === 'none') return;
    const home = strip.dataset.stabHome ? t(strip.dataset.stabHome) : label(nav);
    // Panels, die ein Leitknopf oeffnet, stehen in keiner Leiste und fielen
    // deshalb aus dem Suchindex: "Neue Charge" und "Laborarbeit" waren ueber
    // die Suche nicht mehr zu finden, seit sie Knoepfe wurden. Sie tragen ihre
    // Beschriftung selbst.
    //
    // Der Treffer drueckt den Leitknopf, nicht das Panel: beide Knoepfe oeffnen
    // inzwischen den Schnelldialog bzw. den gefuehrten Ablauf, und das Panel
    // dahinter ist nur noch dessen Ablage. Der Eintrag nannte vorher ausserdem
    // keinen Seitenknopf — gsNav() lief damit in go(page, undefined) und warf.
    const lead = strip.parentElement.querySelector('.btn-lead');
    strip.parentElement.querySelectorAll('.sp[data-stab-lead]').forEach((sp) => {
      out.push({
        type: 'page',
        id: home + ' › ' + t(sp.dataset.stabLead),
        sub: '',
        page,
        btn: nav.id,
        lead: lead ? lead.id : '',
        stab: lead ? '' : sp.id.replace('sp-' + page + '-', '')
      });
    });
    strip.querySelectorAll('.stab').forEach((st) => {
      if (!stabLandable(st)) return;
      out.push({
        type: 'page',
        id: home + ' \u203a ' + label(st),
        // No subtitle. Every page row used to carry the word "Seiten" under a
        // heading reading "Seiten", and a sub-page already names its page in
        // its own id.
        sub: '',
        page: page,
        btn: nav.id,
        stab: st.id.replace('st-' + page + '-', '')
      });
    });
  });
  return out;
}

// getZoneBags() for every zone in one walk of scanLog instead of one walk per
// zone. The subtitle below wants a bag count per zone, and on a farm with a
// lot of zones and a long scan log that single line was most of what
// the palette cost. The rules are getZoneBags()'s own, kept case for case: a
// bag's zone is the last ADD or MOVE that placed it, a MOVE with no readable
// destination takes it out of the count, a REMOVE only removes it from the zone
// it says it came from, and a HARVEST places nothing — logging a flush does not
// move anything.
function gsZoneCounts() {
  const inZone = {};
  const put = (z, bag) => (inZone[z] || (inZone[z] = new Set())).add(bag);
  const drop = (z, bag) => inZone[z] && inZone[z].delete(bag);
  scanLog.forEach((e) => {
    if (!e.bag) return;
    const tz = toZone(e.to);
    const fz = toZone(e.from);
    if (e.action === 'ADD') {
      if (tz) put(tz, e.bag);
    } else if (e.action === 'MOVE' || e.action === 'MOVE_BATCH') {
      if (tz) put(tz, e.bag);
      // fz !== tz, for the reason spelled out in getZoneBags(): a move within
      // one zone (rack to rack, which toZone() maps back to the zone) would
      // otherwise insert the bag and delete it on the next line.
      if (fz && fz !== tz) drop(fz, e.bag);
    } else if (e.action === 'REMOVE') {
      if (fz) drop(fz, e.bag);
    }
  });
  const out = {};
  for (const z in inZone) out[z] = inZone[z].size;
  return out;
}

// The index, built at most once per open rather than once per keystroke. It
// walks every batch, culture, Sorte and zone and reads the sidebar, which is
// work in proportion to the whole farm; doing it again for each character was
// what made the field feel slow on the phones it is meant for.
//
// Invalidated the same way and in the same place as _statusByBatch — applyData()
// replaces the arrays underneath it — plus on the way in, so a search never
// opens on a picture older than itself.
let _gsIndex = null;
function gsIndexInvalidate() {
  _gsIndex = null;
}

function gsIndex() {
  if (_gsIndex) return _gsIndex;
  const out = [];
  const join = (parts) => parts.filter(Boolean).join(' \u00b7 ');
  const zoneBags = gsZoneCounts();
  batches.forEach((b) => {
    const st = getStatus(b.batchId);
    const where = Object.keys(st.c || {})
      .filter((z) => st.c[z] > 0)
      .map(zoneDisplayName);
    out.push({ type: 'batch', id: b.batchId, sub: join([b.species, st.status, where.join(', ')]) });
  });
  cultures.forEach((c) => {
    out.push({
      type: 'culture',
      id: c.id,
      sub: join([c.strainName || c.species, c.type, GS_CULTURE_STATUS[c.status] ? t(GS_CULTURE_STATUS[c.status]) : ''])
    });
  });
  mushroomStrains.forEach((ms) => {
    const bc = batches.filter((b) => b.strainId === ms.id).length;
    const cc = cultures.filter((c) => c.strainId === ms.id).length;
    out.push({
      type: 'strain',
      id: ms.name,
      key: ms.id,
      sub: join([ms.kuerzel, bc ? bc + ' ' + t('strains.batches') : '', cc ? cc + ' ' + t('strains.cultures') : ''])
    });
  });
  zones.forEach((z) => {
    // zoneDisplayName() and not z.name: the four zones this app knows by name
    // carry a translation, and the rest of the app shows that. Reading the raw
    // column here made the palette the one place that called Fruchtung by
    // whatever is in the database.
    const dn = zoneDisplayName(z.id);
    out.push({
      type: 'zone',
      id: z.id,
      sub: join([
        dn && dn !== z.id ? dn : '',
        ROLE_LABELS[z.role] ? t(ROLE_LABELS[z.role]) : z.role,
        tp('dash.bags', zoneBags[z.id] || 0)
      ])
    });
  });
  _ordersCache.forEach((o) => {
    out.push({
      type: 'order',
      id: o.channelOrderId,
      sub: join([_ohChannelLabel(o.channel), o.customerName, t('orders.status.' + o.status)])
    });
  });
  _ohCustomerCache.forEach((c) => {
    out.push({
      type: 'customer',
      id: c.name || c.email || String(c.id),
      key: c.id,
      // `c.orderCount || 0` was dead twice over: join() filters falsy parts, so a
      // customer with no orders contributed nothing (right answer, wrong route),
      // and one with three contributed a bare "3" with nothing saying three of
      // what. Same shape as the Sorte counts above it.
      sub: join([
        (c.channels || '').split(',').filter(Boolean).map(_ohChannelLabel).join(', '),
        c.orderCount ? c.orderCount + ' ' + t('orders.th.orders') : ''
      ])
    });
  });
  _gsIndex = out.concat(gsPageIndex());
  return _gsIndex;
}

// Orders and customers are the two sources that are not already here. Ask on
// the way in, in the background, and redraw whatever is on screen when the
// answer arrives — the field stays usable throughout, it just has less to
// search until then.
//
// Asked on every open, not once per page load. A once-only latch made three
// promises it could not keep: a customer erased on this machine stayed
// searchable for the life of the tab, one erased on another machine stayed
// searchable for ever, and a warm that failed — offline for a moment, a 500 —
// could never be retried, because the latch was set before the request went
// out and both catches swallowed. The cost of dropping it is two GETs per
// Strg+K, which is what the Bestellungen page already spends per visit; the
// in-flight flags stop a hammered shortcut from stacking them up.
const gsInFlight = { orders: false, customers: false };
function gsWarm() {
  if (!gsInFlight.orders) {
    gsInFlight.orders = true;
    loadOrders()
      .then(() => gsLate())
      .catch(() => {})
      .finally(() => {
        gsInFlight.orders = false;
      });
  }
  if (!gsInFlight.customers) {
    gsInFlight.customers = true;
    loadCustomers()
      .then(() => gsLate())
      .catch(() => {})
      .finally(() => {
        gsInFlight.customers = false;
      });
  }
}

function gsIsOpen() {
  const bg = document.getElementById('m-search');
  return !!(bg && bg.classList.contains('open'));
}

// A warm that lands while the palette is open redraws it; one that lands after
// it closed has nothing to say. Redrawing a closed palette is not harmless —
// it writes aria-activedescendant onto a field nobody is on.
function gsLate() {
  if (gsIsOpen()) gsRender(true);
}

function gsRowHtml(rec, i, q) {
  const on = i === gsSel;
  const kind = GS_KIND(rec.type);
  const mono = !!(kind && kind.mono);
  return (
    '<div class="gs-row' +
    (on ? ' gs-on' : '') +
    '" role="option" id="gs-o-' +
    i +
    '" aria-selected="' +
    (on ? 'true' : 'false') +
    '" data-i="' +
    i +
    '"><span class="gs-row-t' +
    (mono ? ' gs-mono' : '') +
    '">' +
    gsMark(rec.id, q) +
    '</span><span class="gs-row-s">' +
    gsMark(rec.sub, q) +
    '</span></div>'
  );
}

// The matched run, marked in the text it was found in.
//
// Find it in the text, escape the three pieces. Escaping first and then
// measuring was the same operation in the wrong order, and it went wrong in
// both directions on the strings this actually gets — every id and subtitle in
// here has been through a customer name or a channel payload. "Beispiel & Co" is
// "Beispiel &amp; Co" once escaped, so a search for "& co" found nothing, and a
// search for "&" found the ampersand of the entity and cut it in half:
// `Beispiel <mark>&</mark>amp; Co`, an entity split by a tag, rendered as a
// literal "amp;" on the row. Cutting first means no cut can land inside an
// entity, because there are no entities yet.
function gsMark(text, q) {
  const s = String(text == null ? '' : text);
  if (!q) return esc(s);
  const needle = String(q);
  const at = s.toLowerCase().indexOf(needle.toLowerCase());
  if (at < 0) return esc(s);
  return (
    esc(s.slice(0, at)) + '<mark>' + esc(s.slice(at, at + needle.length)) + '</mark>' + esc(s.slice(at + needle.length))
  );
}

// `keep` is for the redraw nobody asked for. Typing means "start at the top"
// and passes nothing; a late answer from gsWarm() re-sorts the list under
// whoever has already arrowed down it, and the row index they were on then
// belongs to a different record. Identity, not position — gsIndex() builds
// fresh objects on every call, so the record they were on is not the same
// object even when it is the same batch.
function gsRender(keep) {
  const box = document.getElementById('gs-results');
  if (!box) return;
  const wasOn = keep ? gsKey(gsHits[gsSel]) : null;
  const found = gsLookup(gsIndex(), document.getElementById('gs-q').value, barcodeRegistry);
  const q = found.q;
  const all = found.hits;
  gsQ = q;
  // An empty field answers with the pages, and there are twelve. Capping that
  // at seven turned the one list the palette offers unprompted into "+5 more —
  // keep typing", which is the opposite of the offer. The box scrolls.
  gsHits = gsGroup(q ? all.slice(0, GS_CAP) : all);
  if (wasOn) {
    const wieder = gsHits.findIndex((r) => gsKey(r) === wasOn);
    if (wieder >= 0) gsSel = wieder;
  }
  if (gsSel >= gsHits.length) gsSel = Math.max(0, gsHits.length - 1);
  let html = '';
  let group = null;
  gsHits.forEach((rec, i) => {
    if (rec.type !== group) {
      group = rec.type;
      // role=presentation: a listbox may hold options, and a heading is not
      // one. Left as a plain div it was an unlabelled child of the list and
      // some screen readers count it as an item.
      const kind = GS_KIND(group);
      html += '<div class="gs-group" role="presentation">' + esc(t(kind ? kind.group : group)) + '</div>';
    }
    html += gsRowHtml(rec, i, q);
  });
  if (!gsHits.length) html = '<div class="gs-empty" role="presentation">' + esc(t('search.none', { q: q })) + '</div>';
  else if (all.length > gsHits.length)
    html +=
      '<div class="gs-more" role="presentation">' + esc(t('search.more', { n: all.length - gsHits.length })) + '</div>';
  box.innerHTML = html;
  // The count, out of sight. The listbox cannot be the live region — it would
  // read every row on every keystroke — and #gs-hint lives in .gs-foot, which a
  // phone does not show at all.
  const live = document.getElementById('gs-live');
  if (live) live.textContent = tp('search.hits', all.length);
  gsSelect();
}

// Move the highlight, and say so, without touching the list itself. gsRender()
// would do this and would also throw away and rebuild every row under the
// pointer — which is fine once per keystroke and not fine once per mouse move.
function gsSelect() {
  const box = document.getElementById('gs-results');
  if (!box) return;
  box.querySelectorAll('.gs-row').forEach((row) => {
    const on = +row.dataset.i === gsSel;
    row.classList.toggle('gs-on', on);
    row.setAttribute('aria-selected', on ? 'true' : 'false');
  });
  const hint = document.getElementById('gs-hint');
  if (hint) hint.textContent = gsHits.length ? t('search.opens', { id: gsHits[gsSel].id }) : '';
  document.getElementById('gs-q').setAttribute('aria-activedescendant', gsHits.length ? 'gs-o-' + gsSel : '');
  const on = box.querySelector('.gs-on');
  if (on) on.scrollIntoView({ block: 'nearest' });
}

// One heading per kind. gsMatch() sorts by rank first, so a kind can come back
// after another one — a batch at rank 1, a page at rank 1, a second batch at
// rank 3 — and the renderer, which opens a heading whenever the type changes,
// wrote "Chargen" twice with "Seiten" in between. This keeps the order the
// ranking chose, because the first kind to appear is the kind with the best
// hit, and puts each kind's rows together under one heading.
function gsGroup(hits) {
  const order = [];
  const by = new Map();
  hits.forEach((rec) => {
    if (!by.has(rec.type)) {
      by.set(rec.type, []);
      order.push(rec.type);
    }
    by.get(rec.type).push(rec);
  });
  const out = [];
  order.forEach((type) => by.get(type).forEach((rec) => out.push(rec)));
  return out;
}

function gsMove(step) {
  if (!gsHits.length) return;
  gsSel = (gsSel + step + gsHits.length) % gsHits.length;
  gsSelect();
}

// Every full-viewport overlay in this app, by the two class conventions plus
// the ones that carry their placement inline. Membership is checked by
// test/global-search.test.js against index.html, so a new one cannot join the
// markup without joining this.
const GS_OVERLAY_SEL = '.modal-bg, .scan-overlay, #ms-quick-modal, #m-beimpfen, #ship-modal';

// Is something already covering the screen?
//
// Asking the class was not enough, and the way it failed is worth keeping in
// mind: `.modal-bg.open` describes how most dialogs open, but #change-pw-modal
// is a .modal-bg that opens by writing style.display, #scan-overlay is not a
// .modal-bg at all, and #ms-quick-modal and #ship-modal are neither. So ask
// what is on the screen instead of how it got there — an element that is not
// displayed has no client rects, whichever route hid it.
function gsCovered() {
  const list = document.querySelectorAll(GS_OVERLAY_SEL);
  for (const el of list) {
    if (el.id === 'm-search') continue;
    if (el.getClientRects().length) return true;
  }
  return false;
}

function gsOpen() {
  // Not on top of another dialog: navigating out from here would leave that one
  // open over a page it was never about — and over the scan overlay it is worse
  // than untidy. The field would take a scanned code into an invisible input at
  // a station whose next Enter commits a bag movement.
  if (gsCovered()) return;
  const bg = document.getElementById('m-search');
  if (!bg) return;
  gsReturnFocus = document.activeElement;
  gsSel = 0;
  gsIndexInvalidate();
  bg.classList.add('open');
  gsWarm();
  const input = document.getElementById('gs-q');
  input.value = '';
  gsRender();
  // Now, inside the gesture that opened this. The 80 ms delay copied from
  // openNote() was there because focusing a display:none element is a no-op —
  // but the class above has already made this one visible, and iOS opens the
  // on-screen keyboard only for a focus() that is still part of the tap. After
  // a timeout the field had the caret and the phone had no keyboard, which for
  // a search box is the whole of it. The timeout stays as a fallback for the
  // case the comment was really about, and does nothing when the first one
  // worked.
  input.focus();
  setTimeout(() => {
    if (document.activeElement !== input) input.focus();
  }, 80);
}

function gsClose() {
  const bg = document.getElementById('m-search');
  if (!bg || !bg.classList.contains('open')) return;
  // A jump that was still pending is a jump nobody asked for any more.
  clearTimeout(gsJumpTimer);
  bg.classList.remove('open');
  // Back where they were, so Escape costs nothing — the palette can be opened
  // by accident mid-form and must not eat the caret.
  if (gsReturnFocus && gsReturnFocus.focus) {
    try {
      gsReturnFocus.focus();
    } catch (e) {
      /* element gone with the page it was on */
    }
  }
  gsReturnFocus = null;
}

function gsToggle() {
  const bg = document.getElementById('m-search');
  if (bg && bg.classList.contains('open')) gsClose();
  else gsOpen();
}

// What makes a record itself: the type and whatever gsGoto() would navigate by.
const gsKey = (r) => (r ? r.type + ':' + (r.key != null ? r.key : r.id) : null);

// The record's page may not have drawn yet — Bestellungen and Kunden fetch on
// arrival, so the row exists a round-trip after the navigation. Keep looking for
// a second and a half, then stop without a word: the page is the right page
// either way, and a missing flash is not worth a message.
function gsFlash(sel) {
  let tries = 0;
  const look = () => {
    const el = document.querySelector(sel);
    if (!el) {
      if (++tries < 15) setTimeout(look, 100);
      return;
    }
    el.scrollIntoView({ behavior: 'smooth', block: 'center' });
    el.classList.remove('gs-flash');
    // Restart the animation. Without the reflow, a second hit on the same row
    // re-adds a class the element never lost and nothing plays.
    void el.offsetWidth;
    el.classList.add('gs-flash');
    setTimeout(() => el.classList.remove('gs-flash'), 1600);
  };
  setTimeout(look, 60);
}

// Take the route a user would take.
//
// go() and openStab() are the last two steps of that route, not the whole of
// it. The nav entry above them clears the Chargen attention filter and draws
// the Sorten list; the sub-tab pill loads the panel for half of Admin, for
// Lieferanten, and for Kamera and Server, because that wiring lives in the
// pill's own handler and nowhere else. Calling the last two steps directly
// skips the first, so Admin ▸ Benutzer opened blank.
//
// So click the control instead. This is the app's own idiom in three places
// already: the mobile bottom nav delegates to its sidebar twin, and go() ends
// by clicking the active pill for Admin and Bestellungen — "the strip handler
// already knows what its panel needs", as the comment there puts it. The
// fallback is for a destination that has no button, which today is none.
function gsNav(btnId, page) {
  const btn = document.getElementById(btnId);
  if (btn) btn.click();
  else go(page, btnId);
}
function gsStab(page, sub) {
  const st = document.getElementById('st-' + page + '-' + sub);
  if (st) st.click();
  else openStab(page, sub);
}

// Four steps, and the kind decides what each of them is.
//
// `clear` is there because a result that lands on a filtered list is a result
// nobody can see. Chargen has had that rule from the start — goToBatch()
// clears the attention filter and renderBatches() lets a query past the
// archive filter on purpose, so a finished batch stays findable — and Kulturen
// and Bestellungen had nothing of the kind. A Kultur found by id can be of any
// type in any state and the two selects above the table remember what the user
// last looked at; an order can be in any status and the chips do the same.
// Either could hide the one row the search had just navigated to, and the
// flash then hunted for it silently until it gave up.
function gsGoto(rec) {
  const kind = GS_KIND(rec && rec.type);
  if (!kind) return;
  // Ask before closing anything. go() asks too, but its "cancel" arrived after
  // the palette had gone and could not reach the steps queued behind it: the
  // page stayed where it was and its sub-tab changed underneath, and the flash
  // hunted for a row on a page nobody had navigated to. One question here
  // settles it — mayLeavePage() discards the guards it got a yes for, so go()'s
  // own call finds nothing left to ask about.
  if (!mayLeavePage()) return;
  gsClose();
  // Before the navigation: the pill that opens a panel is also what renders it,
  // so a filter cleared afterwards would only take effect on the render after
  // this one.
  if (kind.clear) kind.clear();
  kind.go(rec);
  // CSS.escape, which is what this repo uses for the same job in
  // toggleLocBag(). An order id comes out of a channel payload.
  if (kind.flash) gsFlash('[data-find="' + CSS.escape(gsKey(rec)) + '"]');
}

function gsInit() {
  // ⌘K on a Mac, Strg K everywhere else. This is the only label in the app
  // that follows the keyboard in front of the user rather than the language they
  // chose, so the Mac branch takes data-i18n off with it — otherwise the next
  // translatePage() would write the word back over the symbol.
  const key = document.getElementById('sb-search-key');
  if (key && /Mac|iPhone|iPad/.test(navigator.platform || navigator.userAgent || '')) {
    key.removeAttribute('data-i18n');
    key.textContent = '\u2318K';
  }
  const input = document.getElementById('gs-q');
  const box = document.getElementById('gs-results');
  const bg = document.getElementById('m-search');
  if (!input || !box || !bg) return;
  input.addEventListener('input', () => {
    gsSel = 0;
    gsRender();
    // Not while characters are still arriving. A scanner types a bag code one
    // key at a time and the batch id is a prefix of it, so at "AUS-190826-02"
    // the query was already a unique complete id — the jump fired there, thirty
    // milliseconds before the "-03" that says which bag, and those three
    // characters landed in whatever the palette had handed focus back to.
    // SCAN_MAX_GAP * 2 is the same "the scanner has stopped" the global scan
    // buffer uses to decide the very same thing.
    clearTimeout(gsJumpTimer);
    gsJumpTimer = setTimeout(() => {
      const jump = gsAutoOpen(gsHits, gsQ, isKnownBarcode(gsQ.toUpperCase()));
      if (jump) gsGoto(jump);
    }, SCAN_MAX_GAP * 2);
  });
  input.addEventListener('keydown', (e) => {
    if (e.key === 'ArrowDown') {
      e.preventDefault();
      gsMove(1);
    } else if (e.key === 'ArrowUp') {
      e.preventDefault();
      gsMove(-1);
    } else if (e.key === 'Enter') {
      e.preventDefault();
      // And nothing else gets this key. The global scan buffer listens on
      // document and a scanner's Enter would otherwise be read twice: once as
      // "open the highlighted result" and once as "commit the scan".
      e.stopPropagation();
      gsGoto(gsHits[gsSel]);
    }
  });
  box.addEventListener('click', (e) => {
    const row = e.target.closest('.gs-row');
    if (row) gsGoto(gsHits[+row.dataset.i]);
  });
  // The pointer takes the selection with it. A :hover rule beside .gs-on lit a
  // second row instead — arrow down to two, leave the mouse over four, and the
  // list shows two answers to "what does Enter open".
  box.addEventListener('mousemove', (e) => {
    const row = e.target.closest('.gs-row');
    if (!row) return;
    const i = +row.dataset.i;
    if (i === gsSel || !gsHits[i]) return;
    gsSel = i;
    gsSelect();
  });
  bg.addEventListener('click', (e) => {
    if (e.target === bg) gsClose();
  });
  document.getElementById('gs-close').addEventListener('click', gsClose);
  document.querySelectorAll('[data-gs-open]').forEach((btn) => btn.addEventListener('click', gsOpen));
}

// Ctrl+K everywhere, Cmd+K on a Mac. preventDefault because both browsers bind
// it to their own search box, and this one is closer to the work.
document.addEventListener('keydown', (e) => {
  if ((e.metaKey || e.ctrlKey) && !e.altKey && (e.key === 'k' || e.key === 'K')) {
    e.preventDefault();
    gsToggle();
  }
});

// Escape key closes the topmost open modal. Ordered by z-index (top → bottom):
// m-confirm is z-index 210, everything else is 200 — so m-confirm must come first
// so that a stacked confirm (e.g. bag-info → Remove → confirm) closes before the
// modal underneath. m-confirm3 sits with it: it was missing from this list
// entirely, so the recurring-event delete dialog was the one modal in the app
// that Escape could not dismiss.
document.addEventListener('keydown', function (e) {
  if (e.key !== 'Escape') return;
  const modals = [
    'm-confirm',
    'm-confirm3',
    // gsClose() and not a class removal: the palette hands focus back to
    // whatever had it, and Escape is the route that most needs it — it can be
    // opened by accident in the middle of a form.
    'm-search',
    // The zone picker opens on top of whatever asked for it — the camera
    // included, since the Umziehen button — so Escape takes it off first.
    'm-move-batch',
    'm-work-flow',
    'm-camscan',
    'm-cal-entry',
    'm-cal-detail',
    'm-locmove',
    'm-bagselect',
    'm-baginfo',
    'm-addbags',
    'm-batchadd',
    'm-batch-print',
    'm-note',
    'm-prompt',
    // Das Mengenfenster eines Tages. Es hat den prompt2-Dialog abgeloest, und
    // der stand in dieser Liste -- es aber nicht: das eine Fenster der App, das
    // sich nur ueber "Abbrechen" verlassen liess.
    'm-dayqty',
    'm-rhythm',
    // (m-move-batch moved up, above m-camscan: it also sits over the two list
    // modals below, so Escape still dismisses it before them.)
    'm-zonecheck',
    'm-worklist'
  ];
  for (const id of modals) {
    const el = document.getElementById(id);
    if (el && el.classList.contains('open')) {
      // Placement gate: Escape must not strand a freshly created batch.
      if (id === 'm-move-batch' && _zpMandatory()) return;
      if (id === 'm-bagselect') bsClose();
      // Dasselbe für die Arbeitsgang-Hülle: ohne wkfClose() bleibt WKF.kind
      // stehen, und ein spät zurückkommender Ansatz malt seine Quittung in ein
      // Fenster, das niemand mehr sieht.
      else if (id === 'm-work-flow') wkfClose();
      // closeCamScan() stops the MediaStream + decode loop; just removing the
      // 'open' class would leave the camera live (LED on, battery drain,
      // barcodes still firing processScan) behind a hidden modal.
      else if (id === 'm-camscan') closeCamScan();
      // The three ask-a-question dialogs hold a callback for the answer, and
      // taking the class off is not answering: the callback stays set for the
      // next caller to trip over, and — since askConfirm() — the promise behind
      // it never settles, so whatever awaited it is suspended for the life of
      // the page. Their own closers are what say "no".
      else if (id === 'm-search') gsClose();
      else if (id === 'm-confirm') closeConfirm();
      else if (id === 'm-confirm3') closeConfirm3();
      else if (id === 'm-prompt') closePrompt();
      // closeDayQty()/closeRhythmEditor() raeumen ihren Entwurf mit weg. Nur die
      // Klasse zu nehmen liesse _dayQty bzw. _rhythmDraft stehen, und der
      // naechste Aufruf faende einen halben Zustand von vorhin vor.
      else if (id === 'm-dayqty') closeDayQty();
      else if (id === 'm-rhythm') closeRhythmEditor();
      else el.classList.remove('open');
      return;
    }
  }
  // Nothing modal was open, so Escape belongs to the drawer. It is modal in
  // every way that matters, an overlay over the page with the taps behind it
  // swallowed, and it was the one such surface in this application that Escape
  // could not lift. The focus goes back to the button that opened it, the same
  // contract the dialogs above keep.
  const sb = document.getElementById('sidebar');
  if (sb && sb.classList.contains('sb-open')) {
    sbClose();
    const opener = document.getElementById('tgl-17');
    if (opener) opener.focus();
  }
});

initEventListeners();
sbSyncInert();
loadCurrentUser();
loadAppUsers();
loadData();
// Primary: SSE for instant updates. Fallback: poll every 30s (was 5s) for stale detection.
connectSSE();
setInterval(pollSync, 30000);
// Kommt die App aus dem Hintergrund zurück, ist ihr Stand so alt wie die Pause:
// Takt und Ereignisstrom standen still, solange das Telefon sie schlafen ließ.
// Sofort nachfragen, statt bis zu 30 Sekunden gegen den alten Stand zu scannen:
// ein Etikett, das in der Pause gedruckt wurde, wäre in diesem Fenster
// "unbekannt".
//
// Und der Moment, in dem eine veraltete App sich neu lädt: beim Weggehen, weil
// dann niemand hinsieht, und beim Zurückkommen, bevor man etwas anfängt.
document.addEventListener('visibilitychange', function () {
  if (document.hidden) {
    if (appOutdated()) checkForUpdate();
    return;
  }
  _resumedAt = Date.now();
  pollSync();
  connectSSE();
  if (appOutdated()) checkForUpdate();
});

// ── The roles the card mode takes away (finding T7) ────────────────────────
// Below the card breakpoint every table element gets `display: block`, and a
// browser drops a table's implicit roles the moment its display stops being a
// table one. What a screen reader hears after that is not a table with rows and
// columns but a run of paragraphs: no "row 3 of 12", no column association, no
// way to move by cell. Twelve tables do it, and nothing put the roles back.
//
// The shop already fixed the same thing the same way, by hand, 44 times in the
// three files whose CSS builds cards. The tracker cannot: only the header of
// each table stands in index.html, the rows are built in a dozen render
// functions as template literals, and a role written into forty of those
// literals is forty chances to forget one.
//
// So the header carries its roles in the markup and the rows get theirs here.
// The roles are correct at every width -- they are the implicit roles anyway
// while the table is a table -- so nothing has to know where the breakpoint is.
//
// Direct children only. A cell may hold a table of its own, and its rows are
// that table's rows, not this one's.
function stampRowRoles(tbody) {
  for (const tr of tbody.children) {
    if (tr.tagName !== 'TR') continue;
    tr.setAttribute('role', 'row');
    for (const zelle of tr.children) {
      if (zelle.tagName === 'TD') zelle.setAttribute('role', 'cell');
      else if (zelle.tagName === 'TH') zelle.setAttribute('role', 'rowheader');
    }
  }
}

// One observer per table body rather than one call per render: the twelve
// bodies are filled from a dozen places, several of them more than once, and a
// thirteenth place added tomorrow would silently render a table nobody can read
// by row. childList only, so stamping an attribute cannot re-trigger it.
const kartenBeobachtet = new WeakSet();
function watchCardTables(bereich) {
  for (const tbody of (bereich || document).querySelectorAll('.t-cards > tbody')) {
    // Ein zweiter Beobachter auf demselben Rumpf stempelt dasselbe zweimal.
    // Nötig, seit auch Tabellen mitgezählt werden, die erst zur Laufzeit
    // entstehen: die Benutzertabelle wird bei jedem Rendern neu gebaut.
    if (kartenBeobachtet.has(tbody)) continue;
    kartenBeobachtet.add(tbody);
    stampRowRoles(tbody);
    new MutationObserver(() => stampRowRoles(tbody)).observe(tbody, { childList: true });
  }
}

if (document.readyState === 'loading') {
  document.addEventListener('DOMContentLoaded', watchCardTables, { once: true });
} else {
  watchCardTables();
}

// Register service worker for PWA / offline support
if ('serviceWorker' in navigator) {
  window.addEventListener('load', () => {
    navigator.serviceWorker.register('/sw.js').catch(() => {});
  });
  navigator.serviceWorker.addEventListener('message', (e) => {
    if (e.data && e.data.type === 'offline-queue-update') {
      updateOfflineBadge(e.data.pendingCount);
    }
    // Welcher Stand der App diese Seite bekommen hat (sw.js, meldeAppStand).
    if (e.data && e.data.type === 'app-build') noteLoadedBuild(e.data.build);
    // I-12: SW dropped a queued MOVE because the server returned 409
    // (the bag was moved by another user while this entry was offline).
    // Surface a toast so the user knows their MOVE didn't apply.
    if (e.data && e.data.type === 'scan-replay-rejected') {
      try {
        if (typeof setFb === 'function') {
          setFb('err', movedMeanwhileMsg(e.data.bag, e.data.current_zone));
        }
      } catch {
        /* setFb not yet wired — drop silently */
      }
    }
    // R-21: SW dropped the oldest scans because the offline queue hit its cap.
    // Surface a toast so the user knows some scans were lost and can re-scan
    // critical bags if needed before going back online.
    if (e.data && e.data.type === 'scan-queue-overflow') {
      const dropped = e.data.dropped || 0;
      const max = e.data.max || 0;
      try {
        if (typeof setFb === 'function') {
          setFb('err', t('sw.scanQueueOverflow', { dropped, max }));
        }
      } catch {
        /* setFb not yet wired — drop silently */
      }
    }
  });
  window.addEventListener('online', () => {
    if (navigator.serviceWorker.controller) {
      navigator.serviceWorker.controller.postMessage({ type: 'replay-pending' });
    }
  });
}

function updateOfflineBadge(count) {
  let badge = document.getElementById('offline-badge');
  if (count === 0) {
    if (badge) badge.remove();
    return;
  }
  if (!badge) {
    badge = document.createElement('span');
    badge.id = 'offline-badge';
    badge.className = 'fs-micro';
    badge.style.cssText =
      'display:inline-block;background:var(--c-red);color:#fff;padding:2px 6px;border-radius:8px;margin-left:6px;font-weight:600';
    const syncEl = document.getElementById('sync-label');
    if (syncEl) syncEl.parentNode.appendChild(badge);
    else document.querySelector('.topbar')?.appendChild(badge);
  }
  badge.textContent = t('offline.queued', { n: count });
}

// ─── EVENT LISTENERS (CSP-safe, no inline handlers) ─────────────
// Camera lifecycle state machine. Was two booleans (_camScanner !== null +
// _camClosing) which left a sliver between "closed" and "ready-to-reopen"
// where Html5Qrcode raced on the underlying MediaStream — workers reported
// intermittent "camera already in use" errors. Explicit states make the
// transition order obvious and let callers (closeCamScan, flipCamera,
// visibilitychange) bail out cleanly if they're already in a transition.
const CAM_IDLE = 'idle';
const CAM_OPENING = 'opening';
const CAM_OPEN = 'open';
const CAM_CLOSING = 'closing';
let _camState = CAM_IDLE;
let _camScanner = null;
// Dedup window: if the same barcode is decoded again within this many ms,
// the second read is silently dropped. Stops a 1D-barcode that's still in
// frame after the resume from immediately re-firing the same scan.
const SCAN_DEDUP_MS = 3000;
// Pause between accepting consecutive scans. The old 1.5 s value was
// generous safety margin against double-reads; with the dedup window above,
// 800 ms is plenty and lets workers scan a row of 20 bags ~14 s faster.
const SCAN_PAUSE_MS = 800;
// Stocktake pause: every bag is a distinct code and the dedup window above
// already blocks re-reads of the same label, so this only needs to be long
// enough to move the phone to the next bag.
const ZC_SCAN_PAUSE_MS = 250;
let _camLastDecoded = '';
let _camLastDecodedAt = 0;
// Persisted between sessions so workers who flipped to the front camera once
// (e.g. to scan a label they were holding up to themselves) don't have to flip
// every time. Falls back to 'environment' (rear) for first-time / desktop use.
let _camFacingMode = (function () {
  try {
    const v = localStorage.getItem('mp-cam-facing');
    return v === 'user' || v === 'environment' ? v : 'environment';
  } catch {
    return 'environment';
  }
})();
let _camTorchOn = false;
// Returns the active video MediaStreamTrack from the html5-qrcode reader, or
// null if the camera hasn't attached one yet.
function _camActiveTrack() {
  const video = document.querySelector('#cam-reader video');
  if (!video || !video.srcObject) return null;
  const tracks = video.srcObject.getVideoTracks();
  return tracks && tracks.length ? tracks[0] : null;
}
// After scanner.start resolves, html5-qrcode may take a moment to attach the
// <video> element. Poll briefly, then show the torch button if the track
// reports torch capability. Most desktop webcams and the front camera do not.
function _detectTorchSupport() {
  let attempts = 0;
  function check() {
    const track = _camActiveTrack();
    if (!track || !track.getCapabilities) {
      if (attempts++ < 10) setTimeout(check, 100);
      return;
    }
    let caps;
    try {
      caps = track.getCapabilities();
    } catch (e) {
      return;
    }
    const btn = document.getElementById('btn-cam-torch');
    if (btn) btn.hidden = !caps || !caps.torch;
  }
  check();
}
function toggleTorch() {
  const track = _camActiveTrack();
  if (!track || !track.applyConstraints) return;
  const newState = !_camTorchOn;
  track
    .applyConstraints({ advanced: [{ torch: newState }] })
    .then(function () {
      _camTorchOn = newState;
      const btn = document.getElementById('btn-cam-torch');
      if (btn) btn.classList.toggle('torch-on', _camTorchOn);
    })
    .catch(function (err) {
      console.error('Torch toggle failed:', err);
    });
}
function openCamScan() {
  _initScanAudio(); // Init AudioContext during user gesture (required by iOS)
  document.getElementById('m-camscan').classList.add('open');
  updateCamHud(); // Sync HUD with current scan state
  // The mode survives the camera being closed and reopened, so the button has
  // to say what is actually armed rather than what it looked like last time.
  updateCamContamBtn();
  updateCamModeBtns();
  // Anything other than idle is an in-flight transition; the modal is already
  // open visually so this no-op is fine (e.g. user double-tapped the FAB).
  if (_camState !== CAM_IDLE) return;
  _camState = CAM_OPENING;
  // P-02: html5-qrcode is now lazy-loaded. If the idle-time preload hasn't
  // finished yet (user tapped scan within the first ~500 ms of page load),
  // fetch it now. Falls back to synchronous behaviour the moment the
  // promise resolves — which is usually instant because either the idle
  // preload already kicked it off, or the SW has it pre-cached.
  if (typeof Html5Qrcode === 'undefined') {
    loadVendorLibs().then(() => {
      // Re-enter so the scanner state machine sees a proper state transition.
      _camState = CAM_IDLE;
      openCamScan();
    });
    return;
  }
  _camScanner = new Html5Qrcode('cam-reader');
  const scanner = _camScanner;
  scanner
    .start(
      { facingMode: _camFacingMode },
      {
        fps: 10,
        qrbox: function (vw, vh) {
          // Wide-short rectangle — fits 1D barcodes (EAN/Code128) without clipping,
          // and QR codes still sit comfortably inside the width. Bumped from
          // 0.88×0.38 to 0.95×0.45 so 1D barcodes printed at 50×30 mm aren't a
          // hit-or-miss target on phones held at typical reading distance
          // (audit Section 1.5 — scan target was <44 mm wide on screen).
          const w = Math.floor(Math.min(vw, vh) * 0.95);
          const h = Math.max(80, Math.floor(w * 0.45));
          return { width: w, height: h };
        },
        aspectRatio: 1.0
      },
      function (decoded) {
        if (scanner !== _camScanner) return;
        // Solange die Zielliste über dem Bild liegt, wird nichts gelesen: ein
        // Beutel, der dabei noch im Bild ist, würde sonst gebucht, bevor das
        // Ziel feststeht — oder sein Beutel-Fenster öffnete sich über der Liste.
        if (document.getElementById('m-move-batch').classList.contains('open')) return;
        // Dedup: same code re-decoded inside the dedup window is silently
        // dropped. Workers running through 20 bags don't see ghost re-fires
        // when a 1D label lingers in frame across the pause boundary.
        const now = Date.now();
        if (decoded === _camLastDecoded && now - _camLastDecodedAt < SCAN_DEDUP_MS) {
          return;
        }
        _camLastDecoded = decoded;
        _camLastDecodedAt = now;
        scanner.pause(true);
        processScan(decoded);
        // Stocktake runs bag-to-bag at pace, and every bag is a different code,
        // so the 3 s dedup window already covers double-reads — a long pause on
        // top of it just makes the walk feel sluggish.
        const pauseMs = _zcScanMode ? ZC_SCAN_PAUSE_MS : SCAN_PAUSE_MS;
        setTimeout(function () {
          // Only resume if we're still the active scanner AND the state hasn't
          // moved to closing in the meantime.
          if (scanner === _camScanner && _camState === CAM_OPEN) {
            try {
              scanner.resume();
            } catch (e) {}
          }
        }, pauseMs);
      },
      function () {}
    )
    .then(function () {
      // If the modal was closed (or re-opened) while start() was still pending,
      // this scanner is orphaned: closeCamScan ran before the stream existed, so
      // its stop() no-op'd and the camera is now live with no owner. Stop it and
      // don't clobber _camState (which would strand the next openCamScan).
      if (scanner !== _camScanner) {
        try {
          scanner
            .stop()
            .then(function () {
              try {
                scanner.clear();
              } catch (e) {}
            })
            .catch(function () {});
        } catch (e) {}
        return;
      }
      _camState = CAM_OPEN;
      _detectTorchSupport();
    })
    .catch(function (err) {
      _camState = CAM_IDLE;
      _camScanner = null;
      console.error('Camera start failed:', err);
      const s = String(err);
      // Permission-denied is its own path because workers on a brand-new phone
      // see only a one-shot toast and have no idea how to recover. Show the
      // platform-specific recovery steps as a confirm-style modal that stays
      // on screen until they tap OK.
      if (/NotAllowedError|Permission/.test(s)) {
        closeCamScan();
        confirm2(t('cam.permDeniedTitle'), t('cam.permDeniedHelp'), t('common.ok'), function () {});
        return;
      }
      let msg;
      if (/NotFoundError/.test(s)) msg = t('cam.notFound');
      else if (/NotReadableError|TrackStartError/.test(s)) msg = t('cam.inUse');
      else msg = t('cam.unknownError', { err: err });
      setFb('err', msg);
      closeCamScan();
    });
}
function closeCamScan() {
  document.getElementById('m-camscan').classList.remove('open');
  // Die Kamera zuzumachen ist am Telefon das Zeichen "fertig" — der grüne Haken
  // tut nichts anderes. Steht CONTAM und liegen Beutel in der Sammelliste, ist
  // das Formular das, was jetzt drankommt; ohne das führte der Haken ins Leere
  // und acht Scans lägen unsichtbar herum. Dasselbe gilt für den Rückweg aus
  // "+ Scannen", der dabei seinen halb ausgefüllten Entwurf mitbringt.
  //
  // Nur solange CONTAM steht: wer den Vorgang abräumt und einen Beutel
  // nachschlägt, bekommt sein Beutel-Fenster und nicht den alten Entwurf davor.
  // Die Klasse ist oben schon gefallen, crFinishCollect() ruft also nicht
  // zurück hierher.
  if (scan.action === 'CONTAM' && (_crResumeForm || _crTargets.length)) crFinishCollect();
  // Closing the camera ends inoculant-picking; without this every later bag scan
  // would keep feeding a form the worker has already left. Captured first — the
  // restore below needs to know who opened the camera, and clearing it before
  // asking would always read as "nobody".
  const _wasScanning = _inocScanPrefix;
  _inocScanPrefix = null;
  // Bring the quick dialog back if it stepped aside for the camera.
  msqRestoreAfterScan(_wasScanning);
  // Finishing a stocktake scan drops you back on the check sheet, with whatever
  // you scanned already ticked off and the leftovers ready to resolve.
  if (_zcScanMode) {
    _zcScanMode = false;
    renderZoneCheck();
    document.getElementById('m-zonecheck').classList.add('open');
  }
  // Reset torch state and visual: the next openCamScan call will re-detect
  // capability on a fresh track. Keeping torch-on style across closes would
  // lie about the actual hardware state.
  _camTorchOn = false;
  const torchBtn = document.getElementById('btn-cam-torch');
  if (torchBtn) {
    torchBtn.classList.remove('torch-on');
    torchBtn.hidden = true;
  }
  // Already closed (or in the middle of closing) — nothing to do.
  if (_camState === CAM_IDLE || _camState === CAM_CLOSING) return;
  if (!_camScanner) {
    _camState = CAM_IDLE;
    return;
  }
  const scanner = _camScanner;
  _camScanner = null;
  _camState = CAM_CLOSING;
  scanner
    .stop()
    .then(function () {
      scanner.clear();
    })
    .catch(function () {
      // Force-stop media tracks if library cleanup fails (iOS Safari)
      const vids = document.getElementById('cam-reader').querySelectorAll('video');
      vids.forEach(function (v) {
        if (v.srcObject)
          v.srcObject.getTracks().forEach(function (t) {
            t.stop();
          });
      });
      try {
        scanner.clear();
      } catch (e) {}
    })
    .finally(function () {
      _camState = CAM_IDLE;
    });
}
// Stop camera when tab is hidden (saves battery, prevents "camera in use" on other apps)
document.addEventListener('visibilitychange', function () {
  if (document.hidden && _camState !== CAM_IDLE) closeCamScan();
});
function flipCamera() {
  _camFacingMode = _camFacingMode === 'environment' ? 'user' : 'environment';
  try {
    localStorage.setItem('mp-cam-facing', _camFacingMode);
  } catch {
    /* ignore — quota or private mode */
  }
  // Only re-open the modal if the camera is currently visible/running.
  // CAM_OPENING is included so a quick double-flip while opening still
  // restarts with the new facing mode once it lands.
  if (_camState === CAM_OPEN || _camState === CAM_OPENING) {
    closeCamScan();
    setTimeout(openCamScan, 300);
  }
}
// Undo the most recent non-HARVEST scan from inside the camera HUD.
// Reuses undoScanEntry via the hidden scan-log row (created on every successful scan).
function camUndoLastScan() {
  let last = null;
  for (let i = (sessionEntries || []).length - 1; i >= 0; i--) {
    if (sessionEntries[i].action !== 'HARVEST') {
      last = sessionEntries[i];
      break;
    }
  }
  // Eine Kultur, die nach dem letzten Beutel rausging, kommt zuerst zurück.
  const k = _kulturRaus[_kulturRaus.length - 1];
  if (k && (!last || k.at >= Date.parse(last.time || 0))) {
    _kulturRaus.pop();
    setCultureStatus(k.id, k.prev);
    if (_modeRun && _modeRun.action === 'REMOVE') _modeRun.n = Math.max(0, _modeRun.n - 1);
    updateSD();
    _showCamHudToast('info', t('cam.cultureBack', { id: k.id }));
    return;
  }
  if (!last) {
    _showCamHudToast('info', t('cam.nothingToUndo'));
    return;
  }
  scanRueckgaengig(last);
}
function copyCalDavUrl() {
  const url = document.getElementById('caldav-url-display').textContent;
  navigator.clipboard
    .writeText(url)
    .then(() => {
      const b = document.getElementById('btn-45');
      b.textContent = t('common.copied');
      setTimeout(() => {
        b.textContent = t('common.copy');
      }, 2000);
    })
    .catch(() => {});
}

function initEventListeners() {
  const $ = (id) => document.getElementById(id);

  // Modals
  $('addbags-cancel-btn').addEventListener('click', () => {
    document.getElementById('m-addbags').classList.remove('open');
  });
  $('addbags-confirm-btn').addEventListener('click', confirmAddBags);
  $('ab-done-btn').addEventListener('click', () => {
    document.getElementById('m-addbags').classList.remove('open');
  });
  $('ab-print-btn').addEventListener('click', printNewBags);
  $('m-cancel').addEventListener('click', closeConfirm);
  $('change-pw-modal').addEventListener('click', function (e) {
    if (e.target === this) hideChangePasswordModal();
  });
  $('btn-1').addEventListener('click', hideChangePasswordModal);
  $('act-2').addEventListener('click', submitChangePassword);
  $('cls-3').addEventListener('click', closeNote);
  $('act-4').addEventListener('click', saveNote);
  $('m-cal-detail').addEventListener('click', function (e) {
    if (e.target === this) closeEventDetail();
  });
  $('ba-batch').addEventListener('change', baPreview);
  $('ba-loc').addEventListener('change', baPreview);
  $('cls-7').addEventListener('click', closeBatchAdd);
  $('act-8').addEventListener('click', confirmBatchAdd);
  $('m-locmove').addEventListener('click', function (e) {
    if (e.target === this) this.classList.remove('open');
  });
  $('cls-9').addEventListener('click', () => {
    document.getElementById('m-locmove').classList.remove('open');
  });
  // Move-batch modal
  $('mb-cancel-btn').addEventListener('click', () => {
    if (_zpMandatory()) return;
    document.getElementById('m-move-batch').classList.remove('open');
  });
  $('m-move-batch').addEventListener('click', function (e) {
    if (e.target === this && !_zpMandatory()) this.classList.remove('open');
  });
  // Delegated actions for the m-locmove modal. The dashboard bag-move picker no
  // longer uses it (it shares _openZonePicker now); the Zonen page still reuses
  // this modal for its "move loose bags into a rack" grid.
  document.getElementById('m-locmove').addEventListener('click', (e) => {
    const btn = e.target.closest('[data-action]');
    if (!btn) return;
    switch (btn.dataset.action) {
      case 'bulk-rack-target':
        executeBulkMoveToRack(btn.dataset.zone, btn.dataset.rack);
        break;
    }
  });
  $('btn-10').addEventListener('click', locRemoveSelected);
  $('cls-11').addEventListener('click', () => {
    document.getElementById('m-baginfo').classList.remove('open');
  });
  // Im Körper der Karte gibt es nur den pH an der Charge zum Antippen; alles
  // andere steht in der Knopfreihe darunter.
  $('bi-body').addEventListener('click', function (e) {
    const btn = e.target.closest('[data-bi="ch-ph"]');
    if (btn) chAction('ch-ph');
  });
  $('bi-actions').addEventListener('click', function (e) {
    const btn = e.target.closest('[data-bi]');
    if (!btn) return;
    const a = btn.dataset.bi;
    if (a === 'scope-single') {
      biWholeBatch = false;
      renderBiActions();
      return;
    }
    if (a === 'scope-batch') {
      biWholeBatch = true;
      renderBiActions();
      return;
    }
    if (a.startsWith('ci-')) return ciAction(a);
    if (a.startsWith('ch-')) return chAction(a);
    if (!biBatchId) return;
    if (a === 'harvest') return biOpenHarvest();
    if (a === 'contam') return biReportContam();
    if (a === 'remove') return biConfirmRemove();
    if (a === 'used') return biMarkUsed();
    // Same explicit target as the dashboard one-tap — this button names no tent
    // either, so it must not resolve to a different one.
    if (a === 'fruchtung') return biMoveTo(fruitingTarget());
    if (a === 'move') {
      document.getElementById('m-baginfo').classList.remove('open');
      _openZonePicker(t('batch.moveTo') + ' — ' + biBagId, function (dest) {
        biMoveTo(dest);
      });
    }
  });
  $('bs-cancel').addEventListener('click', bsClose);
  $('bs-continue').addEventListener('click', () => {
    bsConfirm();
  });

  // Contamination report modal wiring
  // × und Rand legen zur Seite, Abbrechen verwirft. Vor dem Sammeln war das
  // dasselbe; jetzt hängen acht Scans daran.
  $('cls-cr').addEventListener('click', crStashReport);
  $('cr-cancel').addEventListener('click', closeContamReport);
  $('cr-submit').addEventListener('click', _crSubmit);
  document.getElementById('m-contam-report').addEventListener('click', (e) => {
    if (e.target.id === 'm-contam-report') crStashReport();
  });
  // Beutelliste im Kopf des Formulars — Delegation, weil sie sich mit jedem
  // Scan neu zeichnet.
  $('cr-target').addEventListener('click', (e) => {
    if (e.target.closest('#cr-scan-more')) {
      crScanMore();
      return;
    }
    const x = e.target.closest('[data-cr-untarget]');
    if (!x) return;
    crToggleTarget(x.getAttribute('data-cr-untarget'), null);
    _crRenderTargets();
    updateSD();
  });
  // Type picker — event delegation since the grid is re-rendered on selection
  $('cr-type-grid').addEventListener('click', (e) => {
    const btn = e.target.closest('.contam-type-btn');
    if (!btn) return;
    const id = parseInt(btn.dataset.typeId, 10);
    if (!isNaN(id)) _crSelectType(id);
  });
  $('cr-severity-row').addEventListener('click', (e) => {
    const btn = e.target.closest('.contam-sev-btn');
    if (!btn) return;
    _crSeverity = btn.dataset.sev;
    document.querySelectorAll('#cr-severity-row .contam-sev-btn').forEach((b) => {
      b.classList.toggle('active', b === btn);
    });
    // Die Schwere ändert den Umzug nicht mehr: er ist immer an, bis jemand
    // den Haken selbst herausnimmt. Vorher nahm "Klein" ihn stumm wieder weg.
  });
  // Photo tiles — add tile triggers file input; remove buttons splice the photo;
  // tile body taps open the annotation editor (draw on the photo before submit).
  $('cr-photo-tiles').addEventListener('click', (e) => {
    if (e.target.closest('#cr-add-photo')) {
      $('cr-file-input').click();
      return;
    }
    const rm = e.target.closest('[data-cr-remove]');
    if (rm) {
      const idx = parseInt(rm.dataset.crRemove, 10);
      if (!isNaN(idx)) {
        _crPhotos.splice(idx, 1);
        _renderCrPhotos();
      }
      return;
    }
    const editTile = e.target.closest('[data-cr-edit]');
    if (editTile) {
      const idx = parseInt(editTile.dataset.crEdit, 10);
      if (!isNaN(idx)) openAnnotate(idx);
    }
  });
  $('cr-file-input').addEventListener('change', (e) => {
    _crAddFiles(e.target.files);
    e.target.value = ''; // allow picking the same file twice
  });
  // Photo annotation modal wiring
  const _paCanvas = $('pa-canvas');
  if (_paCanvas) {
    _paCanvas.addEventListener('pointerdown', _paStart);
    _paCanvas.addEventListener('pointermove', _paMove);
    _paCanvas.addEventListener('pointerup', _paEnd);
    _paCanvas.addEventListener('pointercancel', _paEnd);
    _paCanvas.addEventListener('pointerleave', _paEnd);
  }
  $('pa-clear').addEventListener('click', _paClear);
  $('pa-cancel').addEventListener('click', closeAnnotate);
  $('pa-done').addEventListener('click', _paDone);
  // Backdrop tap dismisses (treat as cancel)
  document.getElementById('m-photo-annotate').addEventListener('click', (e) => {
    if (e.target.id === 'm-photo-annotate') closeAnnotate();
  });
  $('m-camscan').addEventListener('click', function (e) {
    if (e.target === this) closeCamScan();
  });
  $('cls-16').addEventListener('click', closeCamScan);
  $('btn-flip-cam').addEventListener('click', flipCamera);
  $('btn-cam-torch').addEventListener('click', toggleTorch);
  $('btn-cam-contam').addEventListener('click', toggleContamScan);
  // Der Knopf im Balken "neue Version": jetzt neu laden, ohne auf einen ruhigen
  // Moment zu warten. Ungespeichertes fragt der Browser vorher selbst ab
  // (beforeunload und die leaveGuards). Abgesichert wie die Serien-Knöpfe:
  // ein altes index.html kennt den Balken nicht.
  const neuLaden = $('update-btn');
  if (neuLaden) neuLaden.addEventListener('click', reloadForUpdate);
  // Die drei neuen Serien-Knöpfe, abgesichert: app.js und index.html kommen
  // getrennt aus dem Netz, und jedes fällt nach drei Sekunden auf den Cache
  // zurück (sw.js). Ein neues app.js über einem alten index.html fände sie
  // nicht, und ein Fehler hier bräche jede Bindung darunter ab.
  for (const [id, fn] of [
    ['btn-cam-move', toggleMoveScan],
    ['btn-cam-harvest', () => toggleModeScan('HARVEST')],
    ['btn-cam-trash', () => toggleModeScan('REMOVE')]
  ]) {
    const knopf = $(id);
    if (knopf) knopf.addEventListener('click', fn);
  }
  $('btn-cam-undo').addEventListener('click', camUndoLastScan);
  $('btn-cam-reset').addEventListener('click', function () {
    resetScan();
    _showCamHudToast('info', t('cam.scanCleared'));
  });

  // Sidebar navigation
  $('sb-toggle').addEventListener('click', toggleSidebar);
  $('n-dash').addEventListener('click', () => {
    go('dash', 'n-dash');
  });
  $('n-cal').addEventListener('click', () => {
    go('cal', 'n-cal');
  });
  // Notifications bell (desktop + mobile share the same dropdown)
  const notifBtn = $('n-notif');
  if (notifBtn) {
    notifBtn.addEventListener('click', (e) => {
      e.stopPropagation();
      openNotifDropdown(notifBtn);
    });
  }
  const notifBtnM = $('n-notif-m');
  if (notifBtnM) {
    notifBtnM.addEventListener('click', (e) => {
      e.stopPropagation();
      openNotifDropdown(notifBtnM);
    });
  }
  const notifMarkRead = $('notif-mark-read');
  if (notifMarkRead) {
    notifMarkRead.addEventListener('click', (e) => {
      e.stopPropagation();
      markAllNotifRead();
    });
  }
  $('n-batch').addEventListener('click', () => {
    batchAttentionFilter = null;
    go('batch', 'n-batch');
  });
  $('n-lab').addEventListener('click', () => {
    go('lab', 'n-lab');
  });
  // Mobile bottom-nav buttons delegate to their sidebar counterparts so any
  // side effects (e.g. n-batch resetting batchAttentionFilter) stay in one place.
  //
  // The same loop marks those counterparts, which is what closes Phase 1's one
  // deferred item: below 769px the drawer repeated all five bottom-nav
  // destinations, 19 rows and 868px of content in a 655px viewport, so five of
  // fourteen sat below the fold — and the five the bar already shows
  // permanently were among them. That note asked for "a real mechanism — the
  // bottom nav emitting the list it owns — not five hardcoded selectors", and
  // the mechanism was already here: this list is the list, and `'n-' +
  // bnId.slice(3)` is already how the two navigations are paired. Marking from
  // inside it cannot drift, because a bottom-nav entry that is added or removed
  // changes both halves in the same edit.
  ['bn-work', 'bn-dash', 'bn-batch', 'bn-lab', 'bn-orders'].forEach((bnId) => {
    const sidebarId = 'n-' + bnId.slice(3);
    const btn = $(bnId);
    if (btn) btn.addEventListener('click', () => $(sidebarId).click());
    const twin = $(sidebarId);
    if (btn && twin) twin.classList.add('sb-in-bottom-nav');
  });
  markEmptyDrawerGroups();
  $('n-inv').addEventListener('click', () => {
    go('inv', 'n-inv');
  });
  $('n-zones').addEventListener('click', () => {
    go('zones', 'n-zones');
  });
  $('n-strains').addEventListener('click', () => {
    go('strains', 'n-strains');
    renderStrains();
  });
  $('n-proj').addEventListener('click', () => go('proj', 'n-proj'));
  $('st-proj-versuch').addEventListener('click', () => openStab('proj', 'versuch'));
  $('st-proj-research').addEventListener('click', () => openStab('proj', 'research'));
  $('st-proj-products').addEventListener('click', () => openStab('proj', 'products'));
  $('st-proj-build').addEventListener('click', () => openStab('proj', 'build'));
  $('p-proj').addEventListener('click', pjClick);
  $('p-proj').addEventListener('change', pjChange);
  $('p-proj').addEventListener('toggle', pjToggle, true);
  const pickupsSchalter = $('pickups-past-btn');
  if (pickupsSchalter)
    pickupsSchalter.addEventListener('click', () => {
      pickupsPast = !pickupsPast;
      renderPickups();
    });
  $('n-pickups').addEventListener('click', () => {
    // Always back to the upcoming half when the page is opened afresh.
    pickupsPast = false;
    go('pickups', 'n-pickups');
  });
  // One entry for the section, and the view it lands on is decided the way Admin
  // decides it — by clicking the strip's own active pill, inside go(). Five
  // entries each naming their own sub-tab was the same wiring written five
  // times, and it is what pushed two of them off a 1366x768 sidebar.
  $('n-orders').addEventListener('click', () => go('orders', 'n-orders'));
  $('st-orders-pack').addEventListener('click', () => openStab('orders', 'pack'));
  $('st-orders-inbox').addEventListener('click', () => openStab('orders', 'inbox'));
  $('st-orders-tomake').addEventListener('click', () => openStab('orders', 'tomake'));
  $('st-orders-mapping').addEventListener('click', () => openStab('orders', 'mapping'));
  $('st-orders-customers').addEventListener('click', () => openStab('orders', 'customers'));
  $('st-orders-versand').addEventListener('click', () => openStab('orders', 'versand'));
  $('p-orders').addEventListener('click', ordersActionHandler);
  const _ohCsv = $('orders-csv-file');
  if (_ohCsv)
    _ohCsv.addEventListener('change', (e) => {
      const f = e.target.files && e.target.files[0];
      if (f) _ordersImportCsv(f);
      e.target.value = '';
    });
  $('btn-add-zone').addEventListener('click', addZone);
  $('rhythm-cancel').addEventListener('click', closeRhythmEditor);
  $('rhythm-close').addEventListener('click', closeRhythmEditor);
  $('rhythm-save').addEventListener('click', saveRhythmEditor);
  $('dayqty-cancel').addEventListener('click', closeDayQty);
  $('dayqty-save').addEventListener('click', saveDayQty);
  // Die Summe rechnet mit, während getippt wird. Sie ist die Zahl, die am Ende
  // zählt, und zwei Felder ohne sie hiessen wieder Kopfrechnen.
  $('dayqty-plan').addEventListener('input', _renderDayQtySum);
  $('dayqty-extra').addEventListener('input', _renderDayQtySum);
  $('m-rhythm').addEventListener('click', (e) => {
    if (e.target.closest('[data-action="rhythm-start"]')) {
      setRhythmStart();
      return;
    }
    if (e.target.closest('[data-action="own-add"]')) {
      addOwnTask();
      return;
    }
    if (e.target.closest('[data-action="own-cancel"]')) {
      _ownEdit = null;
      _renderRhythmOwn();
      return;
    }
    const bearb = e.target.closest('[data-action="own-edit"]');
    if (bearb) {
      _ownEdit = Number(bearb.dataset.id);
      _renderRhythmOwn();
      return;
    }
    const sichern = e.target.closest('[data-action="own-save"]');
    if (sichern) {
      saveOwnTask(sichern.dataset.id);
      return;
    }
    const ruhe = e.target.closest('[data-action="own-pause"]');
    if (ruhe) {
      pauseOwnTask(ruhe.dataset.id);
      return;
    }
    const weg = e.target.closest('[data-action="own-del"]');
    if (weg) delOwnTask(weg.dataset.id);
  });
  $('btn-print-all-zone-qr').addEventListener('click', printAllZoneQrBrowser);
  $('zone-role').addEventListener('change', function () {
    const c = ZONE_ROLE_COLOR[this.value];
    if (c) document.getElementById('zone-color').value = c;
  });
  // Zone list event delegation (CSP blocks inline onclick)
  $('zones-list').addEventListener('click', (e) => {
    const btn = e.target.closest('[data-action]');
    if (!btn) return;
    const action = btn.dataset.action;
    if (action === 'del-zone') removeZone(btn.dataset.zone);
    else if (action === 'rename-zone') renameZone(btn.dataset.zone);
    else if (action === 'zone-capacity') editZoneCapacity(btn.dataset.zone);
    else if (action === 'add-rack') addRackToZone(btn.dataset.zone);
    else if (action === 'del-rack') removeRack(btn.dataset.rack);
    else if (action === 'toggle-qr') renderZoneQrPanel(btn.dataset.zone);
    else if (action === 'print-zone-qr') printZoneQrBrowser(btn.dataset.zone);
    else if (action === 'bulk-move') bulkMoveToRack(btn.dataset.zone);
  });
  // Drag-and-drop zone reordering.
  const zonesList = $('zones-list');
  zonesList.addEventListener('dragstart', onZoneDragStart);
  zonesList.addEventListener('dragover', onZoneDragOver);
  zonesList.addEventListener('drop', onZoneDrop);
  zonesList.addEventListener('dragend', onZoneDragEnd);
  zonesList.addEventListener('dragleave', (e) => {
    // Clear hints only when leaving the list entirely, not when moving between rows.
    if (!zonesList.contains(e.relatedTarget)) clearZoneDropHints();
  });
  $('n-print').addEventListener('click', () => {
    go('print', 'n-print');
  });
  // The admin sidebar forwards to the sub-tab strip rather than duplicating its
  // wiring: every loader already hangs off those buttons, so one click still
  // runs exactly one.
  $('sb-admin-nav').addEventListener('click', (e) => {
    const btn = e.target.closest('.sb-btn');
    if (!btn) return;
    const stab = document.getElementById('st-settings-' + btn.dataset.sub);
    if (stab) stab.click();
    sbCloseMobile();
  });
  // In and out through the same button. Pressing Admin a second time is the
  // way back, which is where a thumb already is and where the eye last looked.
  $('n-settings').addEventListener('click', () => {
    if (document.body.classList.contains('admin-mode')) go(lastMainPage.page, lastMainPage.btnId);
    else go('settings', 'n-settings');
  });
  $('sync-dot').addEventListener('click', loadData);
  $('lang-sel').addEventListener('change', function () {
    setLang(this.value);
  });
  $('tgl-17').addEventListener('click', toggleSidebar);
  $('sync-dot-m').addEventListener('click', loadData);
  // The veil only exists while the drawer is open, so tapping it can only ever
  // mean close. It went through toggleSidebar(), which re-asks which
  // arrangement we are in and would collapse the docked sidebar if the answer
  // had changed since the drawer opened. It is also the busiest way out of the
  // drawer and the one sbClose()'s comment did not list. The divergence was
  // already visible: Escape closed and handed focus back to the opener, a veil
  // tap closed and left focus nowhere.
  $('sb-overlay').addEventListener('click', () => {
    sbClose();
    const opener = document.getElementById('tgl-17');
    if (opener) opener.focus();
  });

  // Scan modal
  $('scan-overlay').addEventListener('click', closeScanModal);
  $('scan-modal').addEventListener('click', (e) => e.stopPropagation());
  $('cls-18').addEventListener('click', closeScanModal);
  $('set-19').addEventListener('click', resetScan);
  $('btn-20').addEventListener('click', openBatchAdd);
  // crFinishCollect, nicht crOpenCollected: wer über "+ Beutel scannen" hier
  // gelandet ist, bekommt seinen Entwurf zurück statt eines leeren Formulars.
  $('btn-contam-collect').addEventListener('click', crFinishCollect);
  $('btn-end-session').addEventListener('click', endScanSession);
  // Destination chips are tappable — pick a target when its barcode can't be scanned.
  $('chip-to').addEventListener('click', scanPickDestination);
  $('cam-chip-to').addEventListener('click', scanPickDestination);
  $('chip-to').title = t('scan.pickDest');
  $('cam-chip-to').title = t('scan.pickDest');
  $('btn-scan-cam').addEventListener('click', function () {
    openCamScan();
  });
  $('btn-scan-audio').addEventListener('click', function () {
    scanAudioEnabled = !scanAudioEnabled;
    this.style.opacity = scanAudioEnabled ? 1 : 0.4;
  });
  // Scan modal tab navigation
  document.querySelectorAll('.scan-tab').forEach(function (tabBtn) {
    tabBtn.addEventListener('click', function () {
      const name = this.getAttribute('data-scan-tab');
      switchScanTab(name);
      if (name === 'successes') renderScanSuccesses();
    });
  });

  // Harvest panel
  $('act-21').addEventListener('click', () => confirmHarvest(false));
  $('hp-next').addEventListener('click', () => confirmHarvest(true));
  $('btn-22').addEventListener('click', cancelHarvest);

  // Dashboard
  $('status-q').addEventListener('input', renderStatus);
  // Delegated clicks for Batch tasks + Ready-to-harvest cards
  function dashTaskCardClick(e) {
    const el = e.target.closest('[data-action]');
    if (!el) return;
    const action = el.dataset.action;
    if (action === 'dash-dest') {
      setFruitingTarget(el.dataset.zone);
      return;
    }
    if (action === 'edit-rhythm') {
      openRhythmEditor();
      return;
    }
    if (action === 'chore-done') {
      setChoreDone(el.dataset.task, el.dataset.date, el.dataset.done !== '1');
      return;
    }
    if (action === 'rhythm-target') {
      editRhythmTarget(el.dataset.date, Number(el.dataset.target));
      return;
    }
    if (action === 'dash-print') {
      // 'move' is the walk this card is mostly about; the modal has its own
      // group switcher for the rest.
      openWorkList('move');
      return;
    }
    if (action === 'dash-room-more') {
      toggleDashRoom(el.dataset.room);
      return;
    }
    if (action === 'dash-day') {
      setDashDay(el.dataset.off);
      return;
    }
    if (action === 'dash-view') {
      setDashView(el.dataset.day === '1');
      return;
    }
    if (action === 'bulk-fruiting') {
      bulkSectionToFruiting(el.dataset.bucket);
      return;
    }
    // Zogen mit den Hinweisen aus der eigenen Karte hierher; ihr alter
    // Zuhörer hängte an #dash-alerts, das es nicht mehr gibt.
    if (action === 'go-attention') {
      goToBatchesAttention(el.dataset.key);
      return;
    }
    if (action === 'go-page') {
      go(el.dataset.page, el.dataset.btn);
      return;
    }
    if (action === 'labgroup-toggle') {
      dashLabGroupOpen = !dashLabGroupOpen;
      renderDashBatchTasks();
      return;
    }
    // Laborarbeit für eine Art: alles, was ihr fehlt, in einem Dialog
    // (lbAnsetzen), wie der Knopf unter Nachproduzieren.
    if (action === 'labmin-make') {
      const id = parseInt(el.dataset.strain, 10);
      if (!_lbSpecies().some((x) => x.strainId === id)) {
        setFb('err', t('todo.supplyNoSorte'));
        return;
      }
      lbAnsetzen(id);
      return;
    }
    // A supply row carries a Sorte, not a batch — the batch is what it is
    // asking for. Both buttons open the quick-create the Pilzsorten page
    // already uses, with the Sorte filled in.
    if (action === 'supply-make-grain' || action === 'supply-make-batch') {
      const ms = _strainByKey(el.dataset.sorte);
      if (!ms) {
        setFb('err', t('todo.supplyNoSorte'));
        return;
      }
      // msQuickCharge() already says so itself when the Sorte carries no
      // recipe, so there is nothing to check here.
      if (action === 'supply-make-grain') {
        msQuickLabor(ms.id);
        _msqPickType('KB');
      } else msQuickCharge(ms.id);
      return;
    }
    const batch = el.dataset.batch;
    if (!batch) return;
    switch (action) {
      // Der Knopf heißt „Ernte erfassen", also erfasst er eine Ernte. Vorher
      // sprang er nur zur Charge, und nach dem Umbau lag sein Fall im
      // Verteiler der Chargenliste — er tat gar nichts mehr.
      case 'harvest-batch':
        wkfOpen('harvest');
        wkfPickBatch(batch);
        break;
      case 'go-to-batch':
        goToBatch(batch);
        break;
      case 'open-move-modal':
        openMoveBatchModal(batch);
        break;
      case 'move-to-fruiting':
        moveBatchToFruiting(batch);
        break;
      case 'inoculate-from':
        inoculateFromBatch(batch);
        break;
    }
  }
  $('dash-batch-tasks').addEventListener('click', dashTaskCardClick);
  $('wl-close').addEventListener('click', () => document.getElementById('m-worklist').classList.remove('open'));
  $('wl-print').addEventListener('click', printWorkList);
  $('m-worklist').addEventListener('click', function (e) {
    if (e.target === this) this.classList.remove('open');
    const seg = e.target.closest('[data-wl-group]');
    if (seg) {
      setWorkListMode(seg.dataset.wlGroup);
      return;
    }
    const row = e.target.closest('[data-wl-batch]');
    if (row) {
      this.classList.remove('open');
      goToBatch(row.dataset.wlBatch);
    }
  });
  initDashCollapse();

  // Chargen and Körnerbrut: the shared Sortenliste, delegated because it is
  // rebuilt on every sync. The banner's button clears the dashboard filter.
  $('sp-batch-list').addEventListener('click', function (e) {
    if (e.target.closest('[data-action="clear-attention"]')) return clearBatchAttentionFilter();
    if (e.target.closest('#ch-list')) slKlick(SL_CHARGEN, e);
  });
  $('ch-scan').addEventListener('click', slScan);
  $('ch-archiv').addEventListener('click', () => slArchiv(SL_CHARGEN));
  $('gr-list').addEventListener('click', (e) => slKlick(SL_KOERNER, e));
  $('gr-scan').addEventListener('click', slScan);
  $('gr-archiv').addEventListener('click', () => slArchiv(SL_KOERNER));
  $('st-batch-list').addEventListener('click', () => {
    openStab('batch', 'list');
  });
  // Was added to the markup and never wired, so the room view — the only place
  // bags can be selected and moved in bulk — was unreachable by tapping.
  $('st-batch-locations').addEventListener('click', () => openStab('batch', 'locations'));
  // Derselbe Weg wie die Kachel auf der Arbeitsgang-Seite: der geführte Ablauf,
  // nicht das lange Formular. Zwei Wege zur selben Charge hießen zwei Formulare
  // mit zwei Verhalten, und das lange endete ohne Fenster. sp-batch-new bleibt
  // als Ablage, aus der createBatch() liest — aufgeschlagen wird es nicht mehr.
  $('btn-batch-new').addEventListener('click', wkbOpen);
  $('st-batch-substrate').addEventListener('click', () => openStab('batch', 'substrate'));
  $('st-batch-harvest').addEventListener('click', () => {
    openStab('batch', 'harvest');
  });
  $('st-batch-blocks').addEventListener('click', () => openStab('batch', 'blocks'));
  // The lab cards are rebuilt wholesale on every sync, so their buttons are
  // delegated rather than carrying inline handlers.
  $('wk-np').addEventListener('click', () => {
    go('lab', 'n-lab');
    const card = document.getElementById('np-card');
    if (card) card.scrollIntoView({ behavior: 'smooth', block: 'start' });
  });
  $('np-rows').addEventListener('click', (e) => {
    if (e.target.closest('[data-np-more]')) {
      _npAlle = !_npAlle;
      renderNachproduzieren(_lbSpecies());
      return;
    }
    const b = e.target.closest('[data-np-strain]');
    if (b) lbAnsetzen(parseInt(b.dataset.npStrain, 10));
  });
  $('lb-list').addEventListener('click', (e) => {
    if (e.target.closest('[data-lb-ruhen]')) {
      _lbRuhenOffen = !_lbRuhenOffen;
      return renderLabStock();
    }
    const b = e.target.closest('[data-lb-strain]');
    if (b) lbSheetOpen(parseInt(b.dataset.lbStrain, 10));
  });
  $('m-lb').addEventListener('click', (e) => {
    if (e.target.id === 'm-lb') return lbSheetClose();
    const st = e.target.closest('[data-lb-step]');
    if (st) return lbSollStep(st.dataset.lbKey, Number(st.dataset.lbStep));
    const mk = e.target.closest('[data-lb-make]');
    if (mk) return lbMakeStep(mk.dataset.lbKey, Number(mk.dataset.lbMake));
    const so = e.target.closest('[data-lb-soll]');
    if (so) return lbSollZeigen(so.dataset.lbSoll);
    const wg = e.target.closest('[data-lb-weg]');
    if (wg) return lbWegZeigen(wg.dataset.lbWeg);
    const wi = e.target.closest('[data-lb-wegid]');
    if (wi) return lbWegWaehlen(wi.dataset.lbWegid);
    const b = e.target.closest('[data-lb-act]');
    if (!b) return;
    if (b.dataset.lbAct === 'weg') lbWegLoeschen();
    else if (b.dataset.lbAct === 'close') lbSheetClose();
    else if (b.dataset.lbAct === 'make' && _lbSheet) lbAnsetzen(_lbSheet.strainId, _lbMengeSumme() ? _lbSheet.make : null);
  });
  $('m-lb-prog').addEventListener('change', (e) => lbProgramm(e.target.checked));
  // Which Sorten are in this season's programme. Delegated: the table is
  // rebuilt on every sync, so a listener on the row would not survive.
  $('strains-body').addEventListener('change', (e) => {
    const box = e.target.closest('[data-action="toggle-programm"]');
    if (!box) return;
    const id = parseInt(box.dataset.id, 10);
    const ms = mushroomStrains.find((x) => x.id === id);
    if (!ms) return;
    const want = box.checked;
    const prev = ms.imProgramm !== false;
    ms.imProgramm = want; // optimistic — the row is already drawn that way
    renderStrains();
    renderBatches();
    renderDashBatchTasks();
    apiPatch('/api/mushroom-strains/' + id, { imProgramm: want }).then((r) => {
      if (r && r.error) {
        ms.imProgramm = prev;
        setFb('err', t('common.error') + ': ' + r.error);
        renderStrains();
        renderBatches();
        renderDashBatchTasks();
      }
    });
  });
  // One listener per registered sortable table, wired the same way, so a new
  // table needs only its entry in SORT_TABLES and data-sort on its headers.
  const SORT_RERENDER = { harvests: renderHarvests };
  for (const table in SORT_TABLES) {
    const body = document.getElementById(SORT_TABLES[table]);
    const thead = body && body.closest('table') ? body.closest('table').tHead : null;
    if (!thead) continue;
    thead.addEventListener('click', (e) => {
      const th = e.target.closest('th[data-sort]');
      if (!th) return;
      cycleTableSort(table, th.dataset.sort);
      const redraw = SORT_RERENDER[table];
      if (redraw) redraw();
    });
  }
  // Ein Zuhörer auf der Reihe statt einer Zeile je Knopf: ein weiteres Gewicht
  // ist dann eine Zeile in index.html und sonst nichts.
  const _wrow = $('nb-weight-btns');
  if (_wrow)
    _wrow.addEventListener('click', (e) => {
      const btn = e.target.closest('[data-kg]');
      if (btn) setBagWeight(parseFloat(btn.dataset.kg));
    });
  const _wother = $('wbtn-other');
  if (_wother) _wother.addEventListener('click', nbOtherWeight);
  $('nb-weight').addEventListener('input', nbPreview);
  $('nb-strain-sel').addEventListener('change', nbPreview);
  $('nb-qty').addEventListener('input', nbPreview);
  $('nb-hw').addEventListener('input', nbSubSum);
  $('nb-wb').addEventListener('input', nbSubSum);
  $('nb-rh').addEventListener('input', nbPreview);
  $('ms-save-btn').addEventListener('click', saveMStrain);
  $('ms-cancel-btn').addEventListener('click', cancelMStrain);
  $('btn-24').addEventListener('click', createBatch);
  // "Beimpft mit" — one control, two places. The quick dialog hides itself for
  // the camera (msqOpenScan); the manual form just arms and opens.
  $('ms-q-inoc-scan').addEventListener('click', () => msqOpenScan('ms-q'));
  $('nb-inoc-scan').addEventListener('click', () => {
    _inocScanPrefix = 'nb';
    scan.action = null;
    scan.to = null;
    scan.from = null;
    updateSD();
    openCamScan();
  });
  ['nb', 'ms-q'].forEach((prefix) => {
    const chips = document.getElementById(prefix + '-inoc-chips');
    if (!chips) return;
    chips.addEventListener('click', (e) => {
      const btn = e.target.closest('[data-action="inoc-drop"]');
      if (!btn) return;
      inocRemove(btn.dataset.id);
      inocRender(prefix);
    });
  });
  const strainShortcut = document.getElementById('nb-create-strain-btn');
  if (strainShortcut) strainShortcut.addEventListener('click', goCreateStrain);
  $('prt-25').addEventListener('click', printBatchLabelsInline);
  $('prt-25-opts').addEventListener('click', () => {
    nbpClose();
    goToPrintBatch();
  });
  $('nbp-later').addEventListener('click', nbpClose);
  $('nbp-close').addEventListener('click', nbpClose);
  document.getElementById('m-batch-print').addEventListener('click', (e) => {
    if (e.target.id === 'm-batch-print') nbpClose();
  });
  // Das Kultur-Gegenstück, gleiche Bauart: siehe cprShow().
  $('prt-cpr').addEventListener('click', printCultureLabelsInline);
  $('prt-cpr-opts').addEventListener('click', () => {
    cprClose();
    goToPrintLabCulture();
  });
  $('cpr-later').addEventListener('click', cprClose);
  $('cpr-close').addEventListener('click', cprClose);
  document.getElementById('m-culture-print').addEventListener('click', (e) => {
    if (e.target.id === 'm-culture-print') cprClose();
  });
  $('harvest-q').addEventListener('input', renderHarvests);

  // Lab
  $('st-lab-cultures').addEventListener('click', () => {
    openStab('lab', 'cultures');
  });
  $('st-lab-grain').addEventListener('click', () => {
    openStab('lab', 'grain');
    renderGrainBatches();
  });
  $('btn-lab-work').addEventListener('click', () => msQuickLaborNew());
  $('st-lab-lineage').addEventListener('click', () => {
    openStab('lab', 'lineage');
  });
  $('st-lab-contam').addEventListener('click', () => {
    openStab('lab', 'contam');
  });
  // Contamination list filters + drill-down + delete
  ['cl-type-filter', 'cl-sev-filter', 'cl-status-filter', 'cl-since-filter'].forEach((id) => {
    const el = $(id);
    if (el) el.addEventListener('change', renderContamReports);
  });
  $('cl-reset').addEventListener('click', () => {
    $('cl-type-filter').value = '';
    $('cl-sev-filter').value = '';
    $('cl-status-filter').value = '';
    $('cl-since-filter').value = '';
    renderContamReports();
  });
  $('contam-list').addEventListener('click', (e) => {
    const card = e.target.closest('[data-cl-id]');
    if (!card) return;
    const id = parseInt(card.dataset.clId, 10);
    if (!isNaN(id)) openContamDetail(id);
  });
  $('cls-cd').addEventListener('click', closeContamDetail);
  $('cd-close').addEventListener('click', closeContamDetail);
  $('cd-delete').addEventListener('click', _cdDelete);
  // Resolve buttons + Reopen are rendered inside cd-body so they're delegated
  // off the body container — refreshes after each action keep wiring intact.
  $('cd-body').addEventListener('click', (e) => {
    const resolveBtn = e.target.closest('[data-cd-resolve]');
    if (resolveBtn) {
      _cdResolve(resolveBtn.dataset.cdResolve);
      return;
    }
    if (e.target.closest('#cd-reopen')) _cdReopen();
  });
  document.getElementById('m-contam-detail').addEventListener('click', (e) => {
    if (e.target.id === 'm-contam-detail') closeContamDetail();
  });
  // Grain spawn weight-lines: event delegation
  $('gs-weight-lines').addEventListener('click', (e) => {
    const btn = e.target.closest('.gs-wbtn');
    if (btn) {
      gsLineSetWeight(btn.closest('.gs-wline'), parseFloat(btn.dataset.kg));
      return;
    }
    const rm = e.target.closest('.gs-line-rm');
    if (rm) {
      gsRemoveLine(rm.closest('.gs-wline'));
      return;
    }
  });
  $('gs-weight-lines').addEventListener('input', gsPreview);
  $('gs-add-line').addEventListener('click', gsAddLine);
  // Die Zähler im Schnelldialog: getippt zieht die Vorschau nach, wie ein Tipp
  // auf − oder + (wireZaehler).
  if ($('ms-q-sizes')) $('ms-q-sizes').addEventListener('input', () => msQuickPreview());
  if ($('ms-q-sy')) $('ms-q-sy').addEventListener('input', () => msQuickPreview());
  if ($('ms-q-multi')) $('ms-q-multi').addEventListener('input', () => msQuickPreview());
  if ($('gs-rh')) $('gs-rh').addEventListener('input', gsPreview);
  $('kb-list').addEventListener('click', (e) => slKlick(SL_KULTUREN, e));
  $('kb-scan').addEventListener('click', slScan);
  $('kb-archiv').addEventListener('click', () => slArchiv(SL_KULTUREN));
  $('lw-type').addEventListener('change', lwUpdate);
  $('lw-st').addEventListener('change', () => {
    const type = document.getElementById('lw-type').value;
    if (type === 'KB') gsPreview();
    else lwPreview();
  });
  $('lw-qty').addEventListener('input', lwPreview);
  $('lw-strain-text').addEventListener('input', () => {
    const type = document.getElementById('lw-type').value;
    if (type === 'KB') gsPreview();
    else lwPreview();
  });
  $('lw-parent').addEventListener('change', () => {
    const parentId = document.getElementById('lw-parent').value;
    if (!parentId) return;
    const parent = cultures.find((c) => c.id === parentId);
    if (!parent) return;
    if (parent.strainId) {
      document.getElementById('lw-st').value = String(parent.strainId);
    }
    const stInput = document.getElementById('lw-strain-text');
    if (stInput && parent.strainText) stInput.value = parent.strainText;
    lwPreview();
  });
  $('nb-culture').addEventListener('change', () => {
    const id = document.getElementById('nb-culture').value;
    if (id) {
      const c = cultures.find((x) => x.id === id);
      if (c) {
        if (c.strainId) document.getElementById('nb-strain-sel').value = String(c.strainId);
        const stInput = document.getElementById('nb-strain-text');
        if (stInput && c.strainText) stInput.value = c.strainText;
        nbPreview();
      }
    }
    renderNbGrainBanner();
  });
  $('btn-26').addEventListener('click', () => {
    const type = document.getElementById('lw-type').value;
    if (type === 'KB') createGrainBatch();
    else logLabWork();
  });
  $('lineage-sel').addEventListener('change', renderLineage);

  // Print
  $('st-print-bags').addEventListener('click', () => {
    openStab('print', 'bags');
  });
  $('st-print-lab').addEventListener('click', () => {
    openStab('print', 'lab');
  });
  $('st-print-ref').addEventListener('click', () => {
    openStab('print', 'ref');
  });
  $('print-batch-search').addEventListener('input', () => fillBatchSelect());
  $('print-batch').addEventListener('change', renderBagPreview);
  $('print-mode').addEventListener('change', renderBagPreview);
  $('bag-qr').addEventListener('change', renderBagPreview);
  $('print-range').addEventListener('change', toggleBagRange);
  $('prt-27').addEventListener('click', printBagLabels);
  $('printer-status-banner').addEventListener('click', refreshPrinterStatus);
  $('lab-filter').addEventListener('change', renderLabList);
  $('lab-mode').addEventListener('change', renderLabPreview);
  $('lab-qr').addEventListener('change', renderLabPreview);
  $('prt-28').addEventListener('click', printLabLabels);
  $('ref-qr').addEventListener('change', renderRefBarcodes);
  $('prt-29').addEventListener('click', printRef);

  // Calendar
  $('btn-33').addEventListener('click', calToday);
  $('btn-34').addEventListener('click', () => {
    calNav(-1);
  });
  $('btn-35').addEventListener('click', () => {
    calNav(1);
  });
  $('cal-filter-user').addEventListener('change', renderCalendar);
  $('cv-month').addEventListener('click', () => {
    setCalView('month');
  });
  $('cv-week').addEventListener('click', () => {
    setCalView('week');
  });
  $('cv-day').addEventListener('click', () => {
    setCalView('day');
  });
  // Crossing the breakpoint has to re-render, not just re-style. Rotate a phone
  // into landscape and the view toggle reappears while the container still
  // holds agenda markup — the grid the toggle claims is showing would not exist
  // until the next navigation. Cheap to fix, invisible until someone turns the
  // device sideways, which in a lab is most of the time.
  if (typeof window.matchMedia === 'function') {
    // Same MediaQueryList as the sidebar's, not a second one built from the
    // same literal.
    if (sbPhone) {
      sbPhone.addEventListener('change', () => {
        if (document.getElementById('cal-title')) renderCalendar();
      });
    }
  }
  // Unified calendar entry modal
  $('btn-cal-print').addEventListener('click', printCalendar);
  $('m-cal-print-week').addEventListener('click', () => printCalendarTaskList('week'));
  $('m-cal-print-month').addEventListener('click', () => printCalendarTaskList('month'));
  $('m-cal-print-cancel').addEventListener('click', closeCalPrintModal);
  $('m-cal-print').addEventListener('click', (e) => {
    if (e.target.id === 'm-cal-print') closeCalPrintModal();
  });
  $('btn-cal-add').addEventListener('click', () => openEntryModal());
  $('cal-entry-cancel-btn').addEventListener('click', closeEntryModal);
  $('cal-entry-save-btn').addEventListener('click', saveEntry);
  $('cal-entry-del-btn').addEventListener('click', deleteEntry);
  $('cal-entry-allday').addEventListener('change', toggleEntryTimeInputs);
  wireTimeInput($('cal-entry-start-time'));
  wireTimeInput($('cal-entry-end-time'));
  $('cal-entry-type-select').addEventListener('change', function () {
    setEntryType(this.value);
  });
  $('cal-entry-recurrence').addEventListener('change', toggleRecurrenceUntil);
  $('m-cal-entry').addEventListener('click', (e) => {
    if (e.target.id === 'm-cal-entry') closeEntryModal();
  });
  $('cal-ev-assignees').addEventListener('click', toggleAssigneeDropdown);
  const taBox = $('cal-task-assignees');
  if (taBox) taBox.addEventListener('click', toggleTaskAssigneeDropdown);

  // Settings
  $('st-settings-log').addEventListener('click', () => {
    openStab('settings', 'log');
  });
  $('st-settings-backup').addEventListener('click', () => {
    openStab('settings', 'backup');
  });
  $('st-settings-users').addEventListener('click', () => {
    openStab('settings', 'users');
    loadUsersTab();
  });
  $('st-settings-caldav').addEventListener('click', () => {
    openStab('settings', 'caldav');
  });
  $('st-settings-duckdns').addEventListener('click', () => {
    openStab('settings', 'duckdns');
  });
  // openStab() already dispatches loadHarvestFeedSettings() for this sub-tab —
  // calling it here as well would fetch the config twice on every click.
  $('st-settings-harvestfeed').addEventListener('click', () => {
    openStab('settings', 'harvestfeed');
  });
  // openStab() renders this sub-tab itself; a second call here would rebuild the
  // table twice on every click.
  $('st-settings-pickuplocations').addEventListener('click', () => {
    openStab('settings', 'pickuplocations');
  });
  $('pickuploc-add-btn').addEventListener('click', () => editPickupLocation());
  $('st-settings-printer').addEventListener('click', () => {
    openStab('settings', 'printer');
    renderPrinterSettings();
  });
  $('st-settings-versand').addEventListener('click', () => {
    openStab('settings', 'versand');
  });
  $('versand-save-btn').addEventListener('click', saveShipSettings);
  $('versand-test-btn').addEventListener('click', testShipConnection);
  $('st-settings-channels').addEventListener('click', () => {
    openStab('settings', 'channels');
  });
  const fixmapChannel = $('oh-fixmap-channel');
  if (fixmapChannel) fixmapChannel.addEventListener('change', renderFixedMappings);
  $('billbee-save-btn').addEventListener('click', () => saveChannel('billbee'));
  $('billbee-test-btn').addEventListener('click', () => testChannel('billbee'));
  $('billbee-sync-btn').addEventListener('click', () => syncChannel('billbee'));
  $('syr-enabled').addEventListener('change', (e) => setSyringeSyncEnabled(e.target.checked));
  $('syr-push-btn').addEventListener('click', pushSyringeStockNow);
  $('wix-save-btn').addEventListener('click', () => saveChannel('wix'));
  $('wix-test-btn').addEventListener('click', () => testChannel('wix'));
  $('wix-sync-btn').addEventListener('click', () => syncChannel('wix'));
  $('ebay-save-btn').addEventListener('click', () => saveChannel('ebay'));
  $('ebay-connect-btn').addEventListener('click', () => connectChannel('ebay'));
  $('ebay-test-btn').addEventListener('click', () => testChannel('ebay'));
  $('ebay-sync-btn').addEventListener('click', () => syncChannel('ebay'));
  $('etsy-save-btn').addEventListener('click', () => saveChannel('etsy'));
  $('etsy-connect-btn').addEventListener('click', () => connectChannel('etsy'));
  $('etsy-test-btn').addEventListener('click', () => testChannel('etsy'));
  $('etsy-sync-btn').addEventListener('click', () => syncChannel('etsy'));
  $('printer-save-btn').addEventListener('click', savePrinterSettings);
  $('printer-test-btn').addEventListener('click', testPrintBridge);
  $('printer-refresh-btn').addEventListener('click', () => {
    renderPrinterSettings();
    refreshPrinterStatus();
  });
  $('printer-download-script').addEventListener('click', downloadBridgeScript);
  $('printer-copy-cmd-1').addEventListener('click', (e) => {
    copyToClipboardWithFeedback(document.getElementById('printer-setup-cmd-1').textContent, e.currentTarget);
  });
  $('st-settings-mcp').addEventListener('click', () => {
    openStab('settings', 'mcp');
  });
  $('st-settings-camera').addEventListener('click', () => {
    openStab('settings', 'camera');
    loadCameraTab();
  });
  $('cam-calib-save').addEventListener('click', saveCameraCalibration);
  $('cam-calib-reload').addEventListener('click', loadCameraTab);
  $('cam-add-btn').addEventListener('click', () => openCameraEdit(null));
  $('cam-edit-cancel').addEventListener('click', closeCameraEdit);
  $('cam-edit-save').addEventListener('click', saveCameraEdit);
  document.getElementById('m-cam-edit').addEventListener('click', (e) => {
    if (e.target.id === 'm-cam-edit') closeCameraEdit();
  });
  initCameraPxCalib();
  $('st-settings-server').addEventListener('click', () => {
    openStab('settings', 'server');
    loadServerTab();
  });
  $('btn-server-restart').addEventListener('click', restartServer);
  $('duckdns-save-btn').addEventListener('click', saveDuckdnsSettings);
  $('duckdns-le-enabled').addEventListener('change', saveLeEnabled);
  $('harvestfeed-save-btn').addEventListener('click', saveHarvestFeedSettings);
  $('harvestfeed-gen-btn').addEventListener('click', generateHarvestFeedSecret);
  $('harvestfeed-test-btn').addEventListener('click', () => testHarvestFeed(false));
  $('harvestfeed-preview-btn').addEventListener('click', () => testHarvestFeed(true));
  $('harvestfeed-pack-add').addEventListener('click', addHarvestPackSize);
  // Am Behälter und nicht am Knopf: Die Kästen werden bei jeder Änderung neu
  // gezeichnet, ein Zuhörer am einzelnen × wäre danach weg.
  $('harvestfeed-packs').addEventListener('click', (e) => {
    const weg = e.target.closest('.hf-pack-del');
    if (weg) removeHarvestPackSize(parseInt(weg.dataset.size, 10));
  });
  // Enter in a number field beside a button reads as "add it", the same as in
  // the release table below.
  $('harvestfeed-pack-new').addEventListener('keydown', (e) => {
    if (e.key === 'Enter') {
      e.preventDefault();
      addHarvestPackSize();
    }
  });
  $('harvestrelease-save-btn').addEventListener('click', saveHarvestReleases);
  $('harvestrelease-add-btn').addEventListener('click', addHarvestReleaseRow);
  $('harvestrelease-new').addEventListener('keydown', (e) => {
    if (e.key === 'Enter') addHarvestReleaseRow();
  });
  guardUnsaved(
    () => (harvestReleaseDirty() ? tp('harvestFeed.leaveWarn', harvestReleaseChanges().length) : null),
    () => {
      // Dropped on purpose, so the table is free to redraw from the server
      // again. Leaving the rows in place would make every later refresh a no-op
      // and keep the count showing changes nobody intends to save.
      harvestReleaseRows = [];
      updateHarvestReleasePending();
    }
  );
  $('duckdns-update-btn').addEventListener('click', triggerDuckdnsUpdate);
  $('le-request-btn').addEventListener('click', requestLeCert);
  $('mcp-save-btn').addEventListener('click', saveMcpSettings);
  $('mcp-gen-token-btn').addEventListener('click', generateMcpToken);
  $('mcp-revoke-token-btn').addEventListener('click', revokeMcpToken);
  $('mcp-enabled').addEventListener('change', function () {
    toggleMcpSections(this.checked);
  });
  $('mcp-copy-url-btn').addEventListener('click', () => {
    navigator.clipboard.writeText($('mcp-url').value);
    showMcpStatus(t('mcp.urlCopied'), 'var(--c-green-dark)');
  });
  $('mcp-diag-btn').addEventListener('click', runMcpDiagnostics);
  $('mcp-copy-token-btn').addEventListener('click', () => {
    navigator.clipboard.writeText(_mcpToken);
    showMcpStatus(t('mcp.keyCopied'), 'var(--c-green-dark)');
  });
  $('log-action-filter').addEventListener('change', renderLog);
  $('log-date-from').addEventListener('change', renderLog);
  $('log-date-to').addEventListener('change', renderLog);
  $('log-q').addEventListener('input', renderLog);
  $('btn-37').addEventListener('click', clearLog);
  $('tgl-38').addEventListener('click', () => {
    toggleLogSort('time');
  });
  $('tgl-39').addEventListener('click', () => {
    toggleLogSort('action');
  });
  $('ctl-40').addEventListener('click', () => {
    logDisplayLimit += 200;
    renderLog();
  });
  $('btn-41').addEventListener('click', downloadBackup);
  initUsbCard();
  $('btn-42').addEventListener('click', restoreBackup);
  $('reset-go').addEventListener('click', runCleanReset);
  $('lab-check-btn').addEventListener('click', openLabCheck);
  $('zc-close').addEventListener('click', () => document.getElementById('m-zonecheck').classList.remove('open'));
  $('m-zonecheck').addEventListener('click', function (e) {
    if (e.target === this) this.classList.remove('open');
    const row = e.target.closest('[data-zc-bag]');
    if (row) {
      const id = row.dataset.zcBag;
      if (_zcFound.has(id)) _zcFound.delete(id);
      else _zcFound.add(id);
      renderZoneCheck();
      return;
    }
    const act = e.target.closest('[data-zc-act]');
    if (!act) return;
    if (act.dataset.zcAct === 'scan') {
      zoneCheckStartScan();
      return;
    }
    if (act.dataset.zcAct === 'used') {
      _zcMarkMissingUsed();
      return;
    }
    if (!_zcSelectMissing()) return;
    if (act.dataset.zcAct === 'move') openLocMovePopup();
    else locRemoveSelected();
  });
  $('btn-43').addEventListener('click', doLogout);
  $('btn-44').addEventListener('click', addUser);
  $('btn-45').addEventListener('click', copyCalDavUrl);
  $('caldav-enabled').addEventListener('change', saveCaldavSettings);
  $('act-46').addEventListener('click', saveCaldavSettings);
  $('caldav-sync-btn').addEventListener('click', syncCaldavNow);
  $('caldav-apppw-create').addEventListener('click', createCaldavAppPassword);
  $('caldav-apppw-list').addEventListener('click', onCaldavAppPwClick);

  // Inventory
  $('st-inv-stock').addEventListener('click', () => {
    openStab('inv', 'stock');
  });
  $('st-inv-delivery').addEventListener('click', () => {
    openStab('inv', 'delivery');
  });
  $('st-inv-log').addEventListener('click', () => {
    openStab('inv', 'log');
  });
  $('st-inv-suppliers').addEventListener('click', () => {
    openStab('inv', 'suppliers');
    renderSuppliers();
  });
  $('del-mat').addEventListener('change', delMatChange);
  $('del-kg').addEventListener('input', delPreview);
  $('btn-47').addEventListener('click', logDelivery);
  $('adj-mat').addEventListener('change', adjMatChange);
  $('adj-absolute').addEventListener('input', () => {
    adjPreview('absolute');
  });
  $('adj-delta').addEventListener('input', () => {
    adjPreview('delta');
  });
  $('btn-48').addEventListener('click', logAdjustment);
  $('inv-log-filter').addEventListener('change', renderInvLog);
}

// Camera FAB is in the HTML *after* the <script> tag, so it doesn't exist
// when initEventListeners() runs. Bind it once the full DOM is ready.
document.addEventListener('DOMContentLoaded', function () {
  const fab = document.getElementById('cam-fab');
  if (fab)
    fab.addEventListener('click', function () {
      // Front-door scan: always start neutral so scanning a bag opens its
      // action sheet, never a leftover armed mode from an earlier session.
      //
      // Bis auf einen Umzug oder eine Ernte, die eben noch liefen: ein Anruf,
      // die Sperre oder ein Tipp neben das Bild schließen die Kamera mitten in
      // der Reihe, und wer gleich weitermacht, soll nicht wieder von vorn
      // anfangen. Was "eben" heißt und warum Entsorgen nie dazugehört, steht an
      // MODE_RUN_KEEP_MS. Die Meldung sagt, dass er noch läuft — ein Vorgang,
      // von dem man nichts weiß, bucht den nächsten Beutel.
      const weiter = modeRunResumable();
      if (!weiter) {
        scan.action = null;
        scan.to = null;
        scan.from = null;
        scan.harvestBag = null;
        _modeRun = null;
      }
      updateSD();
      openCamScan();
      if (weiter) {
        _showCamHudToast(
          'info',
          scan.action === 'MOVE' ? t('cam.moveResumed', { loc: zoneDisplayName(scan.to) }) : t('cam.harvestResumed')
        );
      }
    });

  // Back rows for the sub-tab strips. Here rather than in initEventListeners()
  // for the same reason as the FAB above: this inserts elements, and doing that
  // once the document is settled keeps it off the critical path.
  stabDrillInit();
  gsInit();

  // PWA shortcuts (manifest.json -> shortcuts[]) launch with ?action=...
  // Wait until the rest of the app has had a chance to fetch data + render
  // before dispatching, so go() / openCamScan find the elements they need.
  try {
    const actionParam = new URLSearchParams(window.location.search).get('action');
    if (actionParam) {
      window.setTimeout(function () {
        if (actionParam === 'scan') {
          if (typeof openCamScan === 'function') openCamScan();
        } else if (actionParam === 'newbatch') {
          // Old New-batch form is hidden; open the Sorte-driven create dialog directly.
          if (typeof msQuickChargeNew === 'function') msQuickChargeNew();
        } else if (actionParam === 'dash') {
          if (typeof go === 'function') go('dash', 'n-dash');
        }
        // Clean up the URL so a refresh doesn't re-trigger the action.
        try {
          window.history.replaceState({}, '', window.location.pathname);
        } catch (e) {
          /* ignore */
        }
      }, 400);
    }
  } catch (e) {
    /* ignore — bad URL or no URLSearchParams */
  }
});

// ═══ ARBEITSGÄNGE ════════════════════════════════════════════════════════════
// The launcher page and the click-driven flows behind it.
//
// Every job in here already existed — it just could only be started by scanning
// a barcode. openBagInfo() had exactly one caller, inside the scan engine, and
// the harvest panel's bag field is readonly, so on a laptop (which never scans
// here) most of the app was unreachable. These flows reach the same functions
// from a list instead. The scanner still works and is still faster on the
// tablet; it is no longer the only door.
//
// One modal shell (#m-work-flow) carries all of them, so picking a batch looks
// the same whether you are harvesting, moving or reporting a contamination.

const WKF = {
  kind: null, // 'harvest' | 'move' | 'contam'
  step: null, // 'pick' | 'detail' | 'done'
  batchId: null,
  grams: {}, // bagId -> raw input string (harvest)
  // Leer: jeder Beutel bekommt seinen eigenen nächsten Flush. Eine Zahl gilt
  // für alle Beutel dieses Durchgangs — für Wellen, die über mehrere Tage
  // gepflückt werden und trotzdem eine Welle sind.
  flushOverride: null,
  releaseAll: false,
  dest: null, // destination zone id (move)
  receipt: null
};

function wkf(id) {
  return document.getElementById(id);
}

// Where a bag sits right now. The last placement scan wins; a REMOVE or no
// entry at all means it is not on a shelf, so it is not offered for work.
function wkBagZone(lastByBag, bagId) {
  const last = lastByBag.get(String(bagId).toUpperCase());
  if (!last || last.action === 'REMOVE' || !last.to) return null;
  return toZone(last.to);
}

// What a bag has already yielded. Shown in the harvest list so a second flush
// starts from what the first one brought instead of looking like a fresh bag.
function wkBagHarvested(bagId) {
  const k = String(bagId).toUpperCase();
  let grams = 0;
  let lastFlush = 0;
  for (const h of harvests) {
    if (String(h.bag || '').toUpperCase() !== k) continue;
    grams += Number(h.grams) || 0;
    lastFlush = Math.max(lastFlush, Number(h.flush) || 1);
  }
  return { grams, lastFlush };
}

// Der nächste Flush dieses Beutels. Ein Beutel, der noch nie geerntet wurde,
// liefert Flush 1 — unabhängig davon, wie oft seine Nachbarn schon dran waren.
function wkBagFlush(bag) {
  return (wkBagHarvested(bag).lastFlush || 0) + 1;
}

// Der Flush, der für diesen Beutel gebucht wird. `lastFlush` reicht wkLiveBags()
// schon herum — ohne das Argument liest diese Funktion alle Ernten noch einmal,
// und das je Zeile der Liste.
function wkfBagFlush(bag, lastFlush) {
  if (WKF.flushOverride) return WKF.flushOverride;
  return lastFlush != null ? lastFlush + 1 : wkBagFlush(bag);
}

// Batches that still have bags standing somewhere, newest first. `roles` limits
// it to zone roles that make sense for the job (harvest only offers fruiting).
function wkLiveBatches(roles) {
  const lastByBag = buildLastScanByBag();
  const out = [];
  for (const b of batches) {
    const bags = b.bags || [];
    if (!bags.length) continue;
    const perZone = {};
    let live = 0;
    for (const bag of bags) {
      const z = wkBagZone(lastByBag, bag);
      if (!z) continue;
      const role = (ZONE_BY_ID[z] || {}).role;
      if (roles && roles.indexOf(role) === -1) continue;
      perZone[z] = (perZone[z] || 0) + 1;
      live++;
    }
    if (!live) continue;
    const zoneId = Object.keys(perZone).sort((a, c) => perZone[c] - perZone[a])[0];
    out.push({ batch: b, live, zoneId, zoneName: (ZONE_BY_ID[zoneId] || {}).name || zoneId });
  }
  out.sort((a, c) => String(c.batch.created || '').localeCompare(String(a.batch.created || '')));
  return out;
}

// Bags of one batch that are still standing, with their zone and history.
function wkLiveBags(batchId, roles) {
  const b = batches.find((x) => x.batchId === batchId);
  if (!b) return [];
  const lastByBag = buildLastScanByBag();
  const out = [];
  for (const bag of b.bags || []) {
    const z = wkBagZone(lastByBag, bag);
    if (!z) continue;
    const role = (ZONE_BY_ID[z] || {}).role;
    if (roles && roles.indexOf(role) === -1) continue;
    out.push({ bag, zoneId: z, zoneName: (ZONE_BY_ID[z] || {}).name || z, ...wkBagHarvested(bag) });
  }
  return out;
}

// ─── Modal shell ─────────────────────────────────────────────────────────────

function wkfOpen(kind) {
  WKF.kind = kind;
  WKF.step = 'pick';
  WKF.batchId = null;
  WKF.grams = {};
  WKF.flushOverride = null;
  WKF.releaseAll = false;
  WKF.dest = null;
  WKF.receipt = null;
  wkf('m-work-flow').classList.add('open');
  wkfRender();
}

function wkfClose() {
  wkf('m-work-flow').classList.remove('open');
  // Die Beimpf-Liste gehört zu genau einer Charge. Wer den Ablauf verlässt,
  // nimmt sie nicht in die nächste mit; beim Anlegen ist sie vorher kopiert.
  if (WKF.kind === 'batch') _inoc = [];
  WKF.kind = null;
  WKF.step = null;
  WKF.receipt = null;
}

// Der Kopf-Knopf gehört allen vier Abläufen, aber jeder hat seinen eigenen
// Schrittzähler. Ohne diese Weiche lief er immer durch die Ernte-/Umzugs-
// Maschine — im Chargen-Assistenten landete man damit im Umzugsbildschirm
// und konnte von dort einen echten Umzug buchen.
function wkfBackDispatch() {
  if (WKF.kind === 'batch') return wkbBack();
  if (WKF.kind === 'mix') return wkfClose();
  wkfBack();
}
function wkfBack() {
  if (WKF.step === 'detail') {
    WKF.step = 'pick';
    WKF.batchId = null;
    // Ein Ziel aus der vorigen Charge darf nicht überleben: der Fußknopf ist
    // allein an WKF.dest gebunden, also wäre „Buchen" beim nächsten Schritt
    // sofort aktiv und würde in eine Zone buchen, die niemand gewählt hat.
    WKF.dest = null;
    wkfRender();
    return;
  }
  wkfClose();
}

function wkfTitle() {
  if (WKF.step === 'done') return t('work.receiptTitle');
  if (WKF.kind === 'harvest') return t('work.harvest');
  if (WKF.kind === 'move') return t('work.move');
  if (WKF.kind === 'contam') return t('work.contam');
  return '';
}

// Step chips. They exist so a worker can see how far along the job is and that
// it will end — a two-step form with no end in sight is where people bail out.
function wkfStepChips() {
  const labels =
    WKF.kind === 'harvest'
      ? [t('work.stepBatch'), t('work.stepGrams'), t('work.stepBooked')]
      : WKF.kind === 'move'
        ? [t('work.stepBatch'), t('work.stepTarget'), t('work.stepBooked')]
        : [t('work.stepBatch'), t('work.stepReport')];
  const at = WKF.step === 'pick' ? 0 : WKF.step === 'detail' ? 1 : 2;
  return (
    '<div class="wkf-chips">' +
    labels
      .map((l, i) => {
        const cls = i < at ? 'wkf-chip done' : i === at ? 'wkf-chip now' : 'wkf-chip';
        return `<span class="${cls}">${i < at ? '&#10003; ' : ''}${esc(l)}</span>`;
      })
      .join('') +
    '</div>'
  );
}

function wkfRender() {
  // Nur die drei Abläufe, die diese Hülle selbst zeichnet. Der Assistent und
  // das Mischen bringen ihre eigenen Renderer mit — ein später Rückruf darf
  // deren Bildschirm nicht durch einen Umzugsbildschirm ersetzen.
  if (WKF.kind !== 'harvest' && WKF.kind !== 'move' && WKF.kind !== 'contam') return;
  wkf('wkf-title').textContent = wkfTitle();
  wkf('wkf-back').hidden = WKF.step !== 'detail';
  wkf('wkf-steps').innerHTML = WKF.step === 'done' ? '' : wkfStepChips();
  if (WKF.step === 'pick') return wkfRenderPick();
  if (WKF.step === 'detail') return WKF.kind === 'harvest' ? wkfRenderHarvest() : wkfRenderMove();
  if (WKF.step === 'done') return wkfRenderReceipt();
}

// ─── Step 1: which batch ─────────────────────────────────────────────────────

function wkfRenderPick() {
  const roles = WKF.kind === 'harvest' ? ['fruiting'] : null;
  const rows = wkLiveBatches(roles);
  const hint =
    WKF.kind === 'harvest'
      ? t('work.pickHarvestHint')
      : WKF.kind === 'move'
        ? t('work.pickMoveHint')
        : t('work.pickContamHint');
  if (!rows.length) {
    wkf('wkf-body').innerHTML =
      '<div class="wkf-empty">' +
      esc(WKF.kind === 'harvest' ? t('work.noFruiting') : t('work.noBatches')) +
      '</div>';
    wkf('wkf-foot').innerHTML = `<button class="btn" onclick="wkfClose()">${esc(t('work.close'))}</button>`;
    return;
  }
  wkf('wkf-body').innerHTML =
    `<div class="wkf-hint">${esc(hint)}</div>` +
    '<div class="wkf-list">' +
    rows
      .map(
        (r) => `<button type="button" class="wkf-row" onclick="wkfPickBatch('${esc(r.batch.batchId)}')">
        <span class="wkf-row-id">${esc(r.batch.batchId)}</span>
        <span class="wkf-row-meta">${esc(r.batch.species || '')} &middot; ${r.live} ${esc(t('work.bags'))}</span>
        <span class="wkf-row-zone">${esc(r.zoneName)}</span>
      </button>`
      )
      .join('') +
    '</div>';
  wkf('wkf-foot').innerHTML = `<button class="btn" onclick="wkfClose()">${esc(t('work.cancel'))}</button>`;
}

function wkfPickBatch(batchId) {
  WKF.batchId = batchId;
  // Siehe wkfBack(): eine Zielzone gilt immer nur für die Charge, für die sie
  // gewählt wurde.
  WKF.dest = null;
  // The contamination report is already a finished dialog — it only ever lacked
  // a way in that wasn't a scan. So this flow hands over and gets out of the way.
  if (WKF.kind === 'contam') {
    wkfClose();
    openContamReport(null, batchId, null);
    return;
  }
  if (WKF.kind === 'harvest') {
    // Kein gemeinsamer Flush mehr: jeder Beutel bringt seinen eigenen mit,
    // siehe wkBagFlush(). Ein Durchgang kann Erst- und Zweiternte mischen,
    // und genau das kam vorher falsch heraus.
    WKF.grams = {};
    // Übersteuerung und Freigabe gelten für die Charge, für die sie gewählt
    // wurden. „Alle freigeben" hat vorher jede weitere Charge mit abgeräumt.
    WKF.flushOverride = null;
    WKF.releaseAll = false;
  }
  WKF.step = 'detail';
  wkfRender();
}

// ─── Step 2a: harvest — one row per bag ──────────────────────────────────────

function wkfRenderHarvest() {
  const bags = wkLiveBags(WKF.batchId, ['fruiting']);
  const b = batches.find((x) => x.batchId === WKF.batchId);
  if (!bags.length) {
    wkf('wkf-body').innerHTML = `<div class="wkf-empty">${esc(t('work.noBagsInZone'))}</div>`;
    wkf('wkf-foot').innerHTML = `<button class="btn" data-wk="back">${esc(t('work.back'))}</button>`;
    return;
  }
  const relRow = harvestRelease.on
    ? `<label class="wkf-check"><input type="checkbox" id="wkf-release-all" ${WKF.releaseAll ? 'checked' : ''}
         onchange="WKF.releaseAll = this.checked" /> <span>${esc(t('work.releaseAll'))}</span></label>`
    : '';
  wkf('wkf-body').innerHTML =
    `<div class="wkf-hint">${esc(t('work.gramsHint'))}</div>
     <div class="wkf-bar">
       <label for="wkf-flush">${esc(t('harvest.flush'))}</label>
       <input type="number" id="wkf-flush" min="1" inputmode="numeric"
              value="${WKF.flushOverride || ''}" placeholder="${esc(t('work.flushAuto'))}"
              onchange="WKF.flushOverride = Math.max(0, parseInt(this.value, 10) || 0) || null; wkfRender()" />
       <span class="wkf-bar-sp">${esc(b ? b.species || '' : '')}</span>
     </div>
     ${relRow}
     <div class="wkf-bags">` +
    bags
      .map((x) => {
        // Was der Beutel bisher brachte, und welcher Flush jetzt gebucht wird —
        // beides an der Zeile, weil beides je Beutel verschieden sein kann.
        const fl = esc(t('work.flushN', { n: wkfBagFlush(x.bag, x.lastFlush) }));
        const prev = x.grams
          ? `<span class="wkf-prev">${esc(t('work.already', { g: Math.round(x.grams) }))} · ${fl}</span>`
          : `<span class="wkf-prev">${fl}</span>`;
        const val = WKF.grams[x.bag] != null ? esc(String(WKF.grams[x.bag])) : '';
        return `<div class="wkf-bag">
          <span class="wkf-bag-id">${esc(x.bag)}</span>
          ${prev}
          <input type="text" inputmode="decimal" class="wkf-g" data-bag="${esc(x.bag)}" value="${val}"
                 placeholder="0" aria-label="${esc(t('harvest.grams'))} ${esc(x.bag)}" />
          <span class="wkf-unit">g</span>
        </div>`;
      })
      .join('') +
    '</div>' +
    `<div class="wkf-sum"><b id="wkf-total">0</b> <span id="wkf-total-sub">${esc(t('work.sumEmpty'))}</span></div>`;
  wkf('wkf-foot').innerHTML =
    `<button class="btn" data-wk="back">${esc(t('work.back'))}</button>` +
    `<button class="btn btn-p" id="wkf-book" data-wk="book-harvest">${esc(t('work.book'))}</button>`;
  wkfUpdateTotal();
}

function wkfGramsInput(el) {
  WKF.grams[el.dataset.bag] = el.value;
  wkfUpdateTotal();
}

// Live total. Bags left empty are not booked at all — that is what makes the
// list safe to walk down: you fill in the ones you actually picked.
function wkfUpdateTotal() {
  let total = 0;
  let n = 0;
  for (const k of Object.keys(WKF.grams)) {
    const g = parseDecimal(WKF.grams[k]);
    if (g && g > 0) {
      total += g;
      n++;
    }
  }
  const el = wkf('wkf-total');
  if (!el) return;
  el.textContent = total ? (total >= 1000 ? (total / 1000).toFixed(2) + ' kg' : Math.round(total) + ' g') : '0';
  wkf('wkf-total-sub').textContent = n ? t('work.sumFrom', { n }) : t('work.sumEmpty');
  const book = wkf('wkf-book');
  if (book) book.disabled = n === 0;
}

function wkfBookHarvest() {
  const b = batches.find((x) => x.batchId === WKF.batchId);
  if (!b) return;
  const picked = [];
  for (const bag of Object.keys(WKF.grams)) {
    const g = parseDecimal(WKF.grams[bag]);
    if (g && g > 0) picked.push({ bag, grams: g });
  }
  if (!picked.length) return;
  // Einmal lesen, zweimal benutzen: für den Flush je Beutel und für die Frage,
  // was nach diesem Durchgang noch steht. Sonst läuft wkBagHarvested() je Beutel
  // noch einmal durch alle Ernten.
  const standing = wkLiveBags(WKF.batchId, ['fruiting']);
  const lastFlushByBag = {};
  for (const x of standing) lastFlushByBag[x.bag] = x.lastFlush;
  const time = new Date().toISOString();
  let total = 0;
  const entries = picked.map((p) => {
    total += p.grams;
    return {
      time,
      batch: b.batchId,
      bag: p.bag,
      species: b.species,
      strain: b.strain,
      grams: p.grams,
      flush: wkfBagFlush(p.bag, lastFlushByBag[p.bag])
    };
  });
  const left = standing.filter((x) => !WKF.grams[x.bag] || !parseDecimal(WKF.grams[x.bag]));
  // Zuerst der Zettel, dann die Buchungen: so hat jede Antwort einen festen
  // Adressaten für ihren Fehler, auch wenn der Arbeiter inzwischen weiter ist.
  const receipt = {
    batchId: b.batchId,
    species: b.species || '',
    by: (currentUser && currentUser.username) || '—',
    grams: total,
    bags: picked.length,
    bagsTotal: (b.bags || []).length,
    released: WKF.releaseAll,
    releaseFailed: 0,
    next: left.length ? { label: t('work.nextHarvest', { n: left.length }), action: 'harvest-again' } : null
  };
  wkfHarvestReceiptText(receipt);
  WKF.receipt = receipt;
  WKF.step = 'done';
  wkfRender();
  // Mirror the single-bag panel: push locally so the totals update at once, and
  // roll the entry back if the server refuses it.
  entries.forEach((e) => {
    harvests.push(e);
    const body = WKF.releaseAll ? { ...e, release: e.grams } : e;
    apiPost('/api/harvests', body).then((r) => {
      if (r && r.error) {
        const i = harvests.lastIndexOf(e);
        if (i >= 0) harvests.splice(i, 1);
        // Die Kopfzeile darf die abgelehnten Gramm nicht weiter mitzählen.
        receipt.grams -= e.grams;
        receipt.bags--;
        wkfHarvestReceiptText(receipt);
        wkfReceiptProblem(t('work.bookFailed', { bag: e.bag, err: r.error }), receipt);
        if (typeof renderHarvests === 'function') renderHarvests();
        return;
      }
      if (r && r.releaseError) {
        // Freigegeben stimmt dann nur noch für einen Teil.
        receipt.releaseFailed++;
        wkfHarvestReceiptText(receipt);
        wkfReceiptProblem(t('harvest.releaseFailed', { bag: e.bag }) + ': ' + r.releaseError, receipt);
      }
    });
    const sEntry = {
      time,
      action: 'HARVEST',
      batch: b.batchId,
      bag: e.bag,
      from: null,
      to: null,
      species: b.species,
      strain: b.strain,
      grams: e.grams,
      // Der Flush steht am Eintrag selbst, seit er je Beutel bestimmt wird.
      flush: e.flush,
      _tempId: 's' + ++_scanTempIdCounter
    };
    if (!sessionStartTime) sessionStartTime = Date.now();
    sessionEntries.push(sEntry);
  });
  if (typeof renderHarvests === 'function') renderHarvests();
  if (typeof updateSD === 'function') updateSD();
  if (typeof renderStatus === 'function') renderStatus();
}

// ─── Step 2b: move — where to ────────────────────────────────────────────────

function wkfRenderMove() {
  const bags = wkLiveBags(WKF.batchId, null);
  // Vor dem Aufbau, nicht danach: vorher wurde die Fußzeile mit einem aktiven
  // „Buchen" geschrieben und erst anschließend der Körper durch den Leerfall
  // ersetzt — der Knopf blieb stehen und buchte auf eine Charge ohne Beutel.
  // Die Charge selbst wird nicht mehr mitgeprüft: ist sie zwischen Auswahl und
  // Anzeige verschwunden, liefert wkLiveBags() ohnehin nichts, und der Leerfall
  // muss dann erst recht greifen — sonst steht ein Buchen-Knopf da, den
  // wkfBookMove() anschließend wortlos verweigert.
  if (!bags.length) {
    wkf('wkf-body').innerHTML = `<div class="wkf-empty">${esc(t('work.noBagsStanding'))}</div>`;
    wkf('wkf-foot').innerHTML = `<button class="btn" data-wk="back">${esc(t('work.back'))}</button>`;
    return;
  }
  const here = bags[0].zoneId;
  const targets = zones.filter((z) => z.id !== here);
  wkf('wkf-body').innerHTML =
    `<div class="wkf-hint">${esc(t('work.moveHint', { n: bags.length, batch: WKF.batchId }))}</div>` +
    '<div class="wkf-zones">' +
    targets
      .map(
        (z) => `<button type="button" class="wkf-zone${WKF.dest === z.id ? ' sel' : ''}"
          onclick="WKF.dest='${esc(z.id)}'; wkfRender()">
          <span class="wkf-zone-dot" style="background:${esc(z.color || '#94a3b8')}"></span>
          <span class="wkf-zone-n">${esc(z.name || z.id)}</span>
        </button>`
      )
      .join('') +
    '</div>';
  wkf('wkf-foot').innerHTML =
    `<button class="btn" data-wk="back">${esc(t('work.back'))}</button>` +
    `<button class="btn btn-p" data-wk="book-move" ${WKF.dest ? '' : 'disabled'}>${esc(t('work.book'))}</button>`;
}

function wkfBookMove() {
  const b = batches.find((x) => x.batchId === WKF.batchId);
  if (!b || !WKF.dest) return;
  const destZone = ZONE_BY_ID[WKF.dest] || {};
  moveBatchTo(b, WKF.dest, function (moved, skipped) {
    WKF.receipt = {
      headline: t('work.receiptMove', { n: moved, zone: destZone.name || WKF.dest }),
      lines: [
        [t('work.rBatch'), b.batchId],
        [t('work.rMoved'), String(moved)],
        [t('work.rSkipped'), String(skipped || 0)],
        [t('work.rBy'), (currentUser && currentUser.username) || '—']
      ],
      next: null
    };
    WKF.step = 'done';
    wkfRender();
    if (typeof renderBatches === 'function') renderBatches();
    if (typeof renderStatus === 'function') renderStatus();
    if (typeof updateSD === 'function') updateSD();
  });
}

// ─── Step 3: the receipt ─────────────────────────────────────────────────────
// Shown after every flow. A worker who is new needs to see that something was
// booked, what it changed, and what the obvious next move is — otherwise the
// only feedback is a form that closed.

// Kopfzeile und Beutelzeile der Ernte-Quittung, gerechnet aus den Zahlen, die
// wirklich gebucht sind. Lehnt der Server hinterher eine Zeile ab, wird das hier
// noch einmal aufgerufen — vorher blieb die Kopfzeile auf dem Wunschwert stehen.
function wkfHarvestReceiptText(r) {
  r.headline = t('work.receiptHarvest', {
    kg: r.grams >= 1000 ? (r.grams / 1000).toFixed(2) + ' kg' : Math.round(r.grams) + ' g',
    species: r.species
  });
  r.lines = [
    [t('work.rBatch'), r.batchId],
    [t('work.rBags'), t('work.rBagsVal2', { n: r.bags, total: r.bagsTotal })],
    [
      t('work.rReleased'),
      !r.released
        ? t('work.rReleasedNo')
        : r.releaseFailed
          ? t('work.rReleasedPartial', { n: r.releaseFailed })
          : t('work.rReleasedYes')
    ],
    [t('work.rBy'), r.by]
  ];
}

// Ein Fehler, der eintrifft, nachdem die Quittung schon steht. Er geht immer
// durch setFb — das zählt ihn mit, schreibt ihn ins Scan-Protokoll und piept —
// und zusätzlich auf seinen Zettel. Vorher ging er restlos verloren, sobald der
// Arbeiter die Quittung geschlossen oder die nächste Ernte begonnen hatte.
// `owner` ist der Zettel, zu dem die Buchung gehört: ohne ihn hängt eine späte
// Meldung an der Quittung eines ganz anderen Durchgangs.
function wkfReceiptProblem(msg, owner) {
  setFb('err', msg, { noModal: true });
  const r = owner || WKF.receipt;
  if (!r) return;
  r.problems = (r.problems || []).concat(msg);
  if (WKF.receipt === r && WKF.step === 'done') wkfRenderReceipt();
}

function wkfRenderReceipt() {
  const r = WKF.receipt;
  if (!r) return wkfClose();
  wkf('wkf-body').innerHTML =
    `<div class="wkf-receipt">
       <div class="wkf-r-head"><span class="wkf-r-tick">&#10003;</span><b>${esc(r.headline)}</b></div>
       <div class="wkf-r-lines">` +
    r.lines.map((l) => `<div><span class="wkf-r-k">${esc(l[0])}</span><span>${esc(l[1])}</span></div>`).join('') +
    '</div>' +
    (r.problems && r.problems.length
      ? '<div class="wkf-note bad" style="margin:10px 0 0">' + r.problems.map((x) => esc(x)).join('<br>') + '</div>'
      : '') +
    '</div>';
  wkf('wkf-foot').innerHTML =
    (r.next ? `<button class="btn btn-p" data-wk="receipt-next">${esc(r.next.label)}</button>` : '') +
    `<button class="btn" onclick="wkfClose()">${esc(t('work.done'))}</button>`;
}

function wkfReceiptNext() {
  const r = WKF.receipt;
  if (r && r.next && r.next.action === 'harvest-again') {
    const batchId = WKF.batchId;
    wkfOpen('harvest');
    wkfPickBatch(batchId);
    return;
  }
  wkfClose();
}

// ─── Launcher wiring ─────────────────────────────────────────────────────────

// Körnerbrut is a Laborarbeit type in the data model, so it opens the same
// guided dialog with its type preselected rather than getting a second one.
function wkOpenGrain() {
  msQuickLaborNew();
  const sel = document.getElementById('ms-q-labtype');
  if (sel) {
    sel.value = 'KB';
    if (typeof msQuickLabTypeChanged === 'function') msQuickLabTypeChanged();
  }
}

// ─── Aufs Handy legen ────────────────────────────────────────────────────────
// Chrome meldet beforeinstallprompt, sobald die App installierbar ist, und legt
// das Ereignis für später beiseite; Safari meldet gar nichts und will den Weg
// über Teilen. Beides landet im selben Streifen.
let _installEvent = null;

// Läuft die App schon als Symbol? Dann hat der Streifen nichts mehr zu sagen.
function wkAlsAppOffen() {
  return window.matchMedia('(display-mode: standalone)').matches || navigator.standalone === true;
}
// iPadOS meldet sich seit 13 als Macintosh — ohne den Touch-Zähler hielte man
// jedes iPad für einen Rechner und zeigte den Hinweis nie an.
function wkIstApple(ua, touchPoints) {
  if (/iphone|ipad|ipod/i.test(ua)) return true;
  return /macintosh/i.test(ua) && touchPoints > 1;
}
function wkInstallRender() {
  const bar = document.getElementById('wk-install');
  if (!bar) return;
  const why = document.getElementById('wk-install-why');
  const apple = document.getElementById('wk-install-apple');
  const btn = document.getElementById('wk-install-btn');
  const apfel = !_installEvent && !wkAlsAppOffen() && wkIstApple(navigator.userAgent, navigator.maxTouchPoints);
  why.hidden = !_installEvent || wkAlsAppOffen();
  btn.hidden = why.hidden;
  apple.hidden = !apfel;
  bar.hidden = why.hidden && apple.hidden;
}
async function wkInstall() {
  if (!_installEvent) return;
  _installEvent.prompt();
  const wahl = await _installEvent.userChoice;
  // Das Ereignis ist verbraucht, wie die Antwort auch ausfiel — ein zweites
  // prompt() auf demselben wirft.
  _installEvent = null;
  wkInstallRender();
  if (wahl && wahl.outcome === 'accepted') setFb('ok', t('work.installDone'), { noModal: true });
}
window.addEventListener('beforeinstallprompt', (e) => {
  // Ohne preventDefault zeigt Chrome seinen eigenen Streifen — und der ist für
  // immer weg, sobald man ihn einmal wegwischt.
  e.preventDefault();
  _installEvent = e;
  wkInstallRender();
});
window.addEventListener('appinstalled', () => {
  _installEvent = null;
  wkInstallRender();
});

// Die Reihenfolge der Kacheln stellt jeder selbst ein. Wer jeden Tag erntet,
// will Ernte oben, wer im Labor steht, Labor. Gespeichert am Benutzer auf dem
// Server (/api/auth/me bringt sie mit, /api/me/tile-order schreibt sie), damit
// sie auf jedem Telefon gilt, auf dem man sich anmeldet; dazu eine Kopie auf
// dem Gerät für den Start ohne Netz. Umsortiert wird mit ↑/↓ in einer Liste statt mit
// Ziehen — Ziehen auf dem Telefon kämpft mit dem Scrollen, und ein Knopf in
// einer Kachel ginge nicht, die Kachel ist selbst einer.
const WK_TILES = {
  move: 'work.move',
  harvest: 'work.harvest',
  batch: 'work.tileBatch',
  lab: 'work.lab',
  grain: 'work.grain',
  sub: 'work.tileSubstrate',
  contam: 'work.contam'
};
const WK_TILE_DEFAULT = Object.keys(WK_TILES);
function _wkOrderKey() {
  return 'mp-tile-order:' + ((currentUser && currentUser.username) || '');
}
function _wkLocalOrder() {
  try {
    const v = JSON.parse(localStorage.getItem(_wkOrderKey()) || 'null');
    return Array.isArray(v) ? v : null;
  } catch (_) {
    return null;
  }
}
function wkTileOrder() {
  // Der Server zuerst; die Kopie auf dem Gerät nur, solange er nichts gesagt hat.
  const fromServer = currentUser && Array.isArray(currentUser.tileOrder) ? currentUser.tileOrder : null;
  const saved = fromServer || _wkLocalOrder() || [];
  // Eine gespeicherte Liste von gestern kennt eine neue Kachel nicht, und eine
  // gestrichene gibt es nicht mehr: die eine hinten anhängen, die andere weglassen.
  const order = saved.filter((id, i) => WK_TILES[id] && saved.indexOf(id) === i);
  for (const id of WK_TILE_DEFAULT) if (!order.includes(id)) order.push(id);
  return order;
}
let _wkOrderSendTimer = null;
function saveWkTileOrder(order) {
  try {
    localStorage.setItem(_wkOrderKey(), JSON.stringify(order));
  } catch (_) {
    /* dann gilt der Server */
  }
  if (!currentUser) return;
  currentUser.tileOrder = order.slice();
  // Mehrere ↑-Tipps hintereinander sind ein Umsortieren, nicht fünf: erst
  // senden, wenn eine Weile Ruhe ist, und dann nur den letzten Stand.
  clearTimeout(_wkOrderSendTimer);
  _wkOrderSendTimer = setTimeout(() => {
    apiPost('/api/me/tile-order', { order: currentUser.tileOrder });
  }, 600);
}
// Wer schon vor dem Server-Speicher sortiert hat, hat die Reihenfolge nur auf
// dem Telefon. Kennt der Server noch keine, geht die vom Gerät einmal hinauf.
function syncWkTileOrderUp() {
  if (!currentUser || currentUser.tileOrder !== null) return;
  const local = _wkLocalOrder();
  if (local && local.length) saveWkTileOrder(wkTileOrder());
}
function applyWkTileOrder() {
  const grid = document.getElementById('wk-tiles');
  if (!grid) return;
  const order = wkTileOrder();
  const now = [...grid.children].map((el) => el.id.replace('wk-t-', ''));
  if (now.join() === order.join()) return;
  for (const id of order) {
    const el = document.getElementById('wk-t-' + id);
    if (el) grid.appendChild(el);
  }
}
function renderWkOrderList() {
  const list = document.getElementById('wk-order-list');
  if (!list) return;
  const order = wkTileOrder();
  list.innerHTML = order
    .map(
      (id, i) =>
        '<li class="wk-order-row"><span class="wk-order-name">' +
        esc(t(WK_TILES[id])) +
        '</span><button type="button" class="btn btn-sm" data-wk-order="' +
        id +
        '" data-dir="-1" aria-label="' +
        esc(t('work.orderUp', { name: t(WK_TILES[id]) })) +
        '"' +
        (i === 0 ? ' disabled' : '') +
        '>↑</button><button type="button" class="btn btn-sm" data-wk-order="' +
        id +
        '" data-dir="1" aria-label="' +
        esc(t('work.orderDown', { name: t(WK_TILES[id]) })) +
        '"' +
        (i === order.length - 1 ? ' disabled' : '') +
        '>↓</button></li>'
    )
    .join('');
}
function setWkOrderOpen(open) {
  const panel = document.getElementById('wk-order');
  const btn = document.getElementById('wk-order-btn');
  if (!panel || !btn) return;
  panel.hidden = !open;
  btn.setAttribute('aria-expanded', open ? 'true' : 'false');
  if (open) renderWkOrderList();
}
function wireWkTileOrder() {
  const btn = document.getElementById('wk-order-btn');
  const list = document.getElementById('wk-order-list');
  if (!btn || !list) return;
  btn.addEventListener('click', () => setWkOrderOpen(document.getElementById('wk-order').hidden));
  list.addEventListener('click', (ev) => {
    const b = ev.target.closest('[data-wk-order]');
    if (!b || b.disabled) return;
    const order = wkTileOrder();
    const i = order.indexOf(b.dataset.wkOrder);
    const j = i + Number(b.dataset.dir);
    if (i < 0 || j < 0 || j >= order.length) return;
    [order[i], order[j]] = [order[j], order[i]];
    saveWkTileOrder(order);
    applyWkTileOrder();
    renderWkOrderList();
    // Den Fokus beim selben Pfeil der verschobenen Kachel lassen, damit man
    // mehrmals hintereinander tippen kann.
    const again = list.querySelector('[data-wk-order="' + order[j] + '"][data-dir="' + b.dataset.dir + '"]');
    if (again && !again.disabled) again.focus();
  });
  document.getElementById('wk-order-reset').addEventListener('click', () => {
    saveWkTileOrder(WK_TILE_DEFAULT.slice());
    applyWkTileOrder();
    renderWkOrderList();
  });
  document.getElementById('wk-order-done').addEventListener('click', () => setWkOrderOpen(false));
  applyWkTileOrder();
}

(function wireWorkSteps() {
  wireWkTileOrder();
  const tiles = [
    ['wk-t-lab', msQuickLaborNew],
    ['wk-t-grain', wkOpenGrain],
    ['wk-t-batch', wkbOpen],
    ['wk-t-sub', wkmOpen],
    ['wk-t-move', () => wkfOpen('move')],
    ['wk-t-harvest', () => wkfOpen('harvest')],
    ['wk-t-contam', () => wkfOpen('contam')]
  ];
  tiles.forEach(([id, fn]) => {
    const el = document.getElementById(id);
    if (el) el.addEventListener('click', fn);
  });
  const inst = document.getElementById('wk-install-btn');
  if (inst) inst.addEventListener('click', wkInstall);
  // Für den Apple-Weg und für den Fall, dass beforeinstallprompt schon durch
  // war, bevor diese Datei lief.
  wkInstallRender();
  const nav = document.getElementById('n-work');
  if (nav) nav.addEventListener('click', () => go('work', 'n-work'));
  const close = document.getElementById('wkf-close');
  if (close) close.addEventListener('click', wkfClose);
  const back = document.getElementById('wkf-back');
  if (back) back.addEventListener('click', wkfBackDispatch);
  const bg = document.getElementById('m-work-flow');
  if (bg) {
    bg.addEventListener('click', (e) => {
      if (e.target === bg) return wkfClose();
      // Delegated so the rendered bodies stay plain markup: an inline onclick on
      // generated HTML hides the call from every tool that reads this file.
      const act = e.target.closest('[data-wk]');
      if (!act) return;
      if (act.dataset.wk === 'back') wkfBackDispatch();
      else if (act.dataset.wk === 'book-harvest') wkfBookHarvest();
      else if (act.dataset.wk === 'book-move') wkfBookMove();
      else if (act.dataset.wk === 'receipt-next') wkfReceiptNext();
    });
    bg.addEventListener('input', (e) => {
      const g = e.target.closest('.wkf-g');
      if (g) wkfGramsInput(g);
    });
  }
})();
// ═══ CHARGE ANLEGEN ALS ARBEITSGANG ══════════════════════════════════════════
// Der geführte Weg aus dem Entwurf: drei Schritte, das Rezept sichtbar und
// änderbar, Notizen als eigenes Feld. Er ersetzt das lange Formular nicht — der
// bleibt unter Chargen → Neue Charge für alles, was hier nicht hineinpasst
// (ohne Ansatz, Körnerbrut, Produkte). Gebucht wird über dieselbe Funktion, die
// das Formular benutzt, samt ihrer Warnung bei Überzug.

const WKB = {
  step: 1,
  strainId: null,
  qty: 20,
  bagKg: NB_BAG_KG_DEFAULT,
  subId: '',
  // Hat jemand den Ansatz selbst gewählt? Dann schlägt wkbQuelleVorgabe nichts
  // mehr vor.
  subVonHand: false,
  notes: '',
  // Was im Feld steht, als Text: geprüft wird erst beim Anlegen (phLesen).
  ph: '',
  custom: false,
  hw: null,
  wb: null,
  rh: null,
  days: null
};

function wkbStrain() {
  return mushroomStrains.find((x) => x.id === WKB.strainId) || null;
}
// Die Werte, mit denen gerechnet wird: das Rezept der Sorte, sofern nicht von
// Hand überschrieben. Beides an einer Stelle, damit Anzeige und Buchung nicht
// auseinanderlaufen.
function wkbRecipe() {
  const ms = wkbStrain();
  return {
    hw: WKB.hw != null ? WKB.hw : (ms && ms.recHardwoodPct) || 0,
    wb: WKB.wb != null ? WKB.wb : (ms && ms.recWheatbranPct) || 0,
    rh: WKB.rh != null ? WKB.rh : (ms && ms.recRhPct) || 0,
    days: WKB.days != null ? WKB.days : (ms && ms.recIncDays) || 14
  };
}
function wkbMix() {
  return wkOpenMixes().find((x) => x.subId === WKB.subId) || null;
}
function wkbDraw() {
  return WKB.qty * WKB.bagKg;
}

// Woraus die Beutel wirklich bestehen. Ist ein Ansatz gewählt, ist das dessen
// Mischung — so, wie sie angesetzt wurde. Der Server bucht es genauso
// (createBagBatchFromSubstrate liest die Prozente aus substrate_batches), das
// Rezept der Sorte spielt dann keine Rolle mehr, auch wenn es sich seitdem
// geändert hat. Ohne Ansatz gilt das Rezept.
function wkbMischung() {
  const mix = wkbMix();
  if (mix && mix.composition) {
    return {
      hw: mix.composition.hardwoodPct || 0,
      wb: mix.composition.wheatbranPct || 0,
      rh: mix.composition.rhPct || 0,
      ausAnsatz: mix.subId
    };
  }
  const r = wkbRecipe();
  return { hw: r.hw, wb: r.wb, rh: r.rh, ausAnsatz: null };
}

// Woraus die Charge ist, schlägt der Ablauf vor: den ersten offenen Ansatz —
// außer bei einer Charge aus der Inventur. Die stand schon, bevor es den Ansatz
// von heute gab, und bucht ohnehin nichts ab; ein vorausgewählter Ansatz wäre
// dort eine erfundene Herkunft. Wer selbst gewählt hat, behält seine Wahl.
function wkbQuelleVorgabe() {
  if (WKB.subVonHand) return;
  const mixes = wkOpenMixes();
  WKB.subId = !anlageFrueher('wkb') && mixes.length ? mixes[0].subId : '';
}

function wkbOpen() {
  WKB.step = 1;
  WKB.notes = '';
  WKB.ph = '';
  WKB.custom = false;
  WKB.hw = WKB.wb = WKB.rh = WKB.days = null;
  // Jede Charge fängt bei "ohne Stamm" und heute an — auch "Noch eine Charge".
  // Und ohne Beimpfmaterial: das der letzten ist verbraucht.
  stammReset('wkb');
  anlageReset('wkb');
  _inoc = [];
  const first = mushroomStrains.filter((x) => x.recBatchType)[0] || mushroomStrains[0];
  WKB.strainId = first ? first.id : null;
  WKB.subVonHand = false;
  wkbQuelleVorgabe();
  WKF.kind = 'batch';
  WKF.step = 'detail';
  WKF.receipt = null;
  wkf('m-work-flow').classList.add('open');
  wkbRender();
}

function wkbBack() {
  // Erst lesen, dann zurück: der Fußknopf tut das seit jeher, der Kopfknopf
  // warf die Notiz und das geänderte Rezept weg.
  wkbReadStep();
  if (WKB.step > 1) {
    WKB.step--;
    wkbRender();
    return;
  }
  wkfClose();
}

function wkbRender() {
  // Der Renderer wird auch aus einem späten onDone gerufen. Landet der, während
  // schon ein anderer Ablauf offen ist, würde er dessen Bildschirm überschreiben.
  if (WKF.kind !== 'batch') return;
  const ms = wkbStrain();
  const r = wkbRecipe();
  const mix = wkbMix();
  const m = wkbMischung();
  wkf('wkf-title').textContent = t('work.batch');
  wkf('wkf-back').hidden = WKB.step === 1 || WKF.step === 'done';
  const labels = [t('work.bStep1'), t('work.bStep2'), t('work.bStep3')];
  wkf('wkf-steps').innerHTML =
    WKF.step === 'done'
      ? ''
      : '<div class="wkf-chips">' +
        labels
          .map((l, i) => {
            const n = i + 1;
            const cls = n < WKB.step ? 'wkf-chip done' : n === WKB.step ? 'wkf-chip now' : 'wkf-chip';
            return `<span class="${cls}">${n < WKB.step ? '&#10003; ' : ''}${esc(l)}</span>`;
          })
          .join('') +
        '</div>';

  if (WKF.step === 'done') {
    const d = WKF.receipt || {};
    wkf('wkf-body').innerHTML =
      `<div class="wkf-receipt">
         <div class="wkf-r-head"><span class="wkf-r-tick">&#10003;</span><b>${esc(d.headline || '')}</b></div>
         <div class="wkf-r-lines">` +
      (d.lines || []).map((l) => `<div><span class="wkf-r-k">${esc(l[0])}</span><span>${esc(l[1])}</span></div>`).join('') +
      '</div></div>';
    wkf('wkf-foot').innerHTML =
      `<button class="btn btn-p" data-wkb="again">${esc(t('work.bAnother'))}</button>` +
      `<button class="btn" onclick="wkfClose()">${esc(t('work.done'))}</button>`;
    return;
  }

  let body = '';
  if (WKB.step === 1) {
    const list = mushroomStrains
      .slice()
      .sort((a, b) => (a.name || '').localeCompare(b.name || ''))
      .map((x) => `<option value="${x.id}"${x.id === WKB.strainId ? ' selected' : ''}>${esc(x.name)}${x.kuerzel ? ' (' + esc(x.kuerzel) + ')' : ''}</option>`)
      .join('');
    // "Beimpft mit" steht zuoberst: die Körnerbrut hat man in der Hand, und
    // gescannt bringt sie Sorte und Stamm gleich mit (wkbInocAdd). Wählen geht
    // auch; die Liste zeigt nur, was zur Sorte passt.
    body =
      `<div class="wkf-q">${esc(t('work.bQ1'))}</div>
       <div class="wkf-field"><label for="wkb-inoc-pick">${esc(t('work.bInoc'))}</label>
         <div class="stamm-row"><button type="button" class="btn" data-wkb="inoc-scan">📷 ${esc(t('work.bInocScan'))}</button>
           <select id="wkb-inoc-pick"></select></div>
         <div id="wkb-inoc-chips" class="inoc-chips"></div></div>
       <div class="wkf-field"><label>${esc(t('strains.pilzsorte'))}</label>
         <select id="wkb-strain">${list}</select></div>
       <div id="wkb-stamm-wrap" class="wkf-field stamm-wrap"></div>
       <div class="wkf-two">
         <div class="wkf-field"><label>${esc(t('batch.qty'))}</label>
           <input type="text" inputmode="numeric" id="wkb-qty" value="${WKB.qty}" /></div>
         <div class="wkf-field"><label>${esc(t('batch.bagWeight'))}</label>
           <div class="wkf-chipsrow">` +
      [3.5, 3.8, 4.3, 5]
        .map((k) => `<button type="button" class="wkf-w${WKB.bagKg === k ? ' on' : ''}" data-wkb="kg" data-val="${k}">${String(k).replace('.', ',')} kg</button>`)
        .join('') +
      `</div></div>
       </div>
       <div id="wkb-anlage-wrap" class="anlage-wrap"></div>`;
  } else if (WKB.step === 2) {
    const mixes = wkOpenMixes();
    const rest = mix ? mix.remainingKg - wkbDraw() : null;
    // Eine Charge aus der Inventur bucht nichts ab. Die Zeilen, die sagen, was
    // aus dem Ansatz oder vom Lager ginge, wären hier falsch — an ihrer Stelle
    // steht, dass nichts geht.
    const frueher = anlageFrueher('wkb');
    const vomLager = frueher ? '' : `<div class="wkf-note">${esc(t('work.bFromShelf'))}</div>`;
    body =
      `<div class="wkf-q">${esc(t('work.bQ2'))}</div>` +
      (frueher ? `<div class="wkf-note">${esc(t('anlage.notBookedNote'))}</div>` : '') +
      (mixes.length
        ? `<div class="wkf-field"><label>${esc(t('sub.fromMix'))}</label><select id="wkb-mix">` +
          mixes
            .map((m) => `<option value="${esc(m.subId)}"${m.subId === WKB.subId ? ' selected' : ''}>${esc(m.subId)} &middot; ${t('work.bLeft', { kg: m.remainingKg.toFixed(0) })}</option>`)
            .join('') +
          // "vom Lager" stimmt bei Bestand aus der Inventur nicht — von dort geht nichts.
          `<option value=""${WKB.subId ? '' : ' selected'}>${esc(frueher ? t('anlage.noMix') : t('work.bNoMixOption'))}</option>` +
          '</select></div>' +
          (mix && !frueher
            ? `<div class="wkf-note${rest != null && rest < -1e-9 ? ' bad' : ''}">${esc(
                t('work.bDraw', { qty: WKB.qty, kg: WKB.bagKg, need: wkbDraw().toFixed(0) })
              )} &mdash; ${
                rest != null && rest < -1e-9
                  ? esc(t('work.bShort', { kg: (-rest).toFixed(0) }))
                  : esc(t('work.bRest', { kg: (rest || 0).toFixed(0) }))
              }</div>`
            : mix
              ? ''
              : vomLager)
        : vomLager +
          // Einen Ansatz anzulegen, damit eine Charge von vor drei Wochen daraus
          // ziehen kann, ergibt keinen Sinn — sie zieht ja nichts.
          (frueher ? '' : `<button class="btn" data-wkb="tosub">${esc(t('work.bMixFirst'))}</button>`)) +
      // Mit Ansatz steht dessen Mischung da, und zwar fest: sie lässt sich nicht
      // mehr ändern, also darf hier auch kein Feld so tun. Die Inkubationstage
      // gehen weiterhin vom Assistenten an den Server, die bleiben einstellbar.
      (mix
        ? `<div class="wkf-note">
             <b>${esc(t('work.bMixFrom', { id: mix.subId }))}</b>
             ${esc(t('work.bMixLine', { hw: m.hw, wb: m.wb, rh: m.rh }))}
             <div class="wkf-hint">${esc(t('work.bMixFixed'))}</div>
           </div>
           <div class="wkf-field"><label>${esc(t('batch.incDays'))}</label>
             <input type="text" inputmode="numeric" id="wkb-days" value="${r.days}" /></div>`
        : `<div class="wkf-note">
             <b>${esc(t('work.bRecipe', { name: ms ? ms.name : '' }))}${WKB.custom ? esc(t('work.bChanged')) : ''}</b>
             ${
               r.hw || r.wb || r.rh
                 ? esc(t('work.bRecipeLine', { hw: r.hw, wb: r.wb, rh: r.rh, days: r.days }))
                 : esc(t('work.bNoRecipe'))
             }
             <button type="button" class="wkf-link" data-wkb="custom">${esc(WKB.custom ? t('work.bCollapse') : t('work.bEditRecipe'))}</button>
           </div>` +
          (WKB.custom
            ? `<div class="wkf-two">
                 <div class="wkf-field"><label>${esc(t('batch.hardwood'))}</label><input type="text" inputmode="decimal" id="wkb-hw" value="${r.hw}" /></div>
                 <div class="wkf-field"><label>${esc(t('batch.wheatBran'))}</label><input type="text" inputmode="decimal" id="wkb-wb" value="${r.wb}" /></div>
               </div>
               <div class="wkf-two">
                 <div class="wkf-field"><label>${esc(t('batch.fieldCapacity'))}</label><input type="text" inputmode="decimal" id="wkb-rh" value="${r.rh}" /></div>
                 <div class="wkf-field"><label>${esc(t('batch.incDays'))}</label><input type="text" inputmode="numeric" id="wkb-days" value="${r.days}" /></div>
               </div>
               <div class="wkf-hint">${esc(t('work.bOnlyThis'))}</div>`
            : ''));
  } else {
    const frueher = anlageFrueher('wkb');
    // Was aus dem Ansatz oder vom Lager geht — bei einer Charge aus der Inventur
    // nichts, und das steht dann auch so da.
    const quelle = frueher
      ? (mix ? esc(mix.subId) + ' · ' : '') + esc(t('anlage.notBooked'))
      : mix
        ? esc(mix.subId) + ' · ' + wkbDraw().toFixed(0) + ' kg'
        : esc(t('work.bFromShelfShort'));
    body =
      `<div class="wkf-q">${esc(t('work.bQ3'))}</div>
       <div class="wkf-sum-card">
         <div><span class="wkf-r-k">${esc(t('strains.pilzsorte'))}</span><b>${esc(ms ? ms.name : '')}</b></div>
         <div><span class="wkf-r-k">${esc(t('stamm.label'))}</span>${stammAnzeige('wkb') ? esc(stammAnzeige('wkb')) : '&mdash;'}</div>
         ${wkbInocZeile()}
         <div><span class="wkf-r-k">${esc(t('anlage.label'))}</span>${frueher ? '<b>' + esc(fmtDt(anlageZeitpunkt(anlageState('wkb').datum))) + '</b>' : esc(t('anlage.today'))}</div>
         <div><span class="wkf-r-k">${esc(t('batch.qty'))}</span>${WKB.qty} &times; ${String(WKB.bagKg).replace('.', ',')} kg</div>
         <div><span class="wkf-r-k">${esc(t('work.stepSubstrate'))}</span>${quelle}</div>
         <div><span class="wkf-r-k">${esc(t('work.bMixLabel'))}</span>${m.hw}/${m.wb} @ ${m.rh} %${
           m.ausAnsatz ? '' : WKB.custom ? esc(t('work.bChanged')) : ''
         }
           <button type="button" class="wkf-link" data-wkb="step2">${esc(t('work.bEdit'))}</button></div>
         <div><span class="wkf-r-k">${esc(t('batch.incDays'))}</span>${r.days}</div>
       </div>
       <div class="wkf-field"><label>${esc(t('work.bNote'))}</label>
         <input type="text" id="wkb-notes" value="${esc(WKB.notes)}" placeholder="${esc(t('work.bNotePh'))}" /></div>
       <div class="wkf-two">
         <div class="wkf-field"><label>${esc(t('batch.ph'))}</label>
           <input type="text" inputmode="decimal" id="wkb-ph" value="${esc(WKB.ph)}" /></div>
       </div>`;
  }
  wkf('wkf-body').innerHTML = body;
  // Stamm und Datum zeichnen sich selbst in ihre Plätze; ihr Zustand überlebt
  // so jeden Schritt vor und zurück. Das Datum steht im ersten Schritt, weil es
  // den zweiten bestimmt: eine Charge aus der Inventur zieht aus keinem Ansatz.
  if (WKB.step === 1) {
    stammRender('wkb', WKB.strainId);
    anlageRender('wkb');
    inocRender('wkb');
  }

  const back = `<button class="btn" data-wkb="back">${esc(t('work.back'))}</button>`;
  wkf('wkf-foot').innerHTML =
    (WKB.step > 1 ? back : `<button class="btn" onclick="wkfClose()">${esc(t('work.cancel'))}</button>`) +
    (WKB.step < 3
      ? `<button class="btn btn-p" data-wkb="next">${esc(t('work.bNext'))}</button>`
      : `<button class="btn btn-p" data-wkb="create">${esc(t('work.bCreate', { n: WKB.qty }))}</button>`);
}

function wkbReadStep() {
  const g = (id) => document.getElementById(id);
  if (WKB.step === 1) {
    if (g('wkb-strain')) WKB.strainId = parseInt(g('wkb-strain').value, 10) || WKB.strainId;
    if (g('wkb-qty')) WKB.qty = Math.max(1, parseInt(g('wkb-qty').value, 10) || 1);
    if (g('wkb-stamm')) stammState('wkb').wert = g('wkb-stamm').value;
    if (g('wkb-anlage')) anlageState('wkb').datum = g('wkb-anlage').value;
  } else if (WKB.step === 2) {
    if (g('wkb-mix')) WKB.subId = g('wkb-mix').value;
    // Die Inkubationstage stehen auch beim Ansatz-Weg auf dem Bildschirm, wo es
    // kein „Rezept ändern" gibt — sie hängen nicht am Rezept, sondern gehen so
    // oder so an den Server.
    if (g('wkb-days')) WKB.days = parseInt(g('wkb-days').value, 10) || 14;
    if (WKB.custom) {
      if (g('wkb-hw')) WKB.hw = parseDecimal(g('wkb-hw').value) || 0;
      if (g('wkb-wb')) WKB.wb = parseDecimal(g('wkb-wb').value) || 0;
      if (g('wkb-rh')) WKB.rh = parseDecimal(g('wkb-rh').value) || 0;
    }
  } else if (WKB.step === 3) {
    if (g('wkb-notes')) WKB.notes = g('wkb-notes').value;
    if (g('wkb-ph')) WKB.ph = g('wkb-ph').value;
  }
}

// ── Beimpft mit, im geführten Ablauf ─────────────────────────
// Beim Anlegen die Körnerbrut scannen, damit man weiß, welche Brut in welchen
// Blöcken steckt. Das lange Formular und der Schnelldialog konnten das seit
// #449; seit die Kacheln der Weg zum Anlegen sind, öffnet die aber niemand
// mehr, und der Ablauf kannte es nicht.
//
// Der erste Körnerbeutel bringt Sorte und Stamm mit: gescannt ist schneller als
// gewählt, und die Brut sagt, was aus ihr wird. Danach nimmt die Liste nur Brut
// derselben Sorte, aus zwei Sorten wird keine Charge. Beim Anlegen gelten die
// Körnerbeutel als verbraucht — ein geöffneter Beutel geht ganz in die Blöcke,
// und die Zusammenfassung sagt es vorher. Eine Kultur wird nur verknüpft; sie
// hält meist für mehr als eine Charge.
function wkbInocAdd(id) {
  if (WKB.step === 1) wkbReadStep();
  const gesucht = String(id || '')
    .trim()
    .toUpperCase();
  const beutel = nbAvailableSpawnBags().find((x) => x.bag.toUpperCase() === gesucht);
  const hatBrut = _inoc.some((x) => x.kind === 'bag');
  if (beutel && hatBrut && beutel.strainId !== WKB.strainId) {
    const ms = wkbStrain();
    return t('work.bInocOtherSorte', { bag: beutel.bag, sorte: beutel.species, charge: ms ? ms.name : '' });
  }
  const err = inocAdd(id);
  if (err) return err;
  if (beutel && !hatBrut && beutel.strainId) {
    const sorteNeu = WKB.strainId !== beutel.strainId;
    WKB.strainId = beutel.strainId;
    // Der Stamm der Brut, wenn die Sorte ihn in ihrer Liste führt. Führt sie
    // ihn nicht, bleibt eine Wahl von Hand stehen — außer die Sorte hat eben
    // gewechselt, dann gehört die alte Wahl zu einer anderen Sorte.
    const stamm = staemmeFor(beutel.strainId).find((s) => stammGleich(s.name, beutel.strainText));
    if (stamm || sorteNeu) {
      const st = stammState('wkb');
      st.strainId = beutel.strainId;
      st.neu = false;
      st.getippt = '';
      st.wert = stamm ? stamm.name : '';
    }
  }
  wkbRender();
  return null;
}
// Die Sorte von Hand gewechselt, nachdem Brut gescannt war: Brut einer anderen
// Sorte gehört nicht zu dieser Charge und geht aus der Liste — mit Meldung.
function wkbInocSortePruefen() {
  const alle = nbAvailableSpawnBags();
  const fremd = _inoc.filter((x) => {
    if (x.kind !== 'bag') return false;
    const b = alle.find((y) => y.bag === x.id);
    return !!b && b.strainId !== WKB.strainId;
  });
  if (!fremd.length) return;
  _inoc = _inoc.filter((x) => !fremd.includes(x));
  toast(t('work.bInocDropped', { list: fremd.map((x) => x.id).join(', ') }));
}
// Die Zeile in der Zusammenfassung: womit beimpft wird, und dass die
// Körnerbeutel dabei ausgebucht werden — gesagt, bevor es geschieht.
function wkbInocZeile() {
  if (!_inoc.length) return '';
  const brut = _inoc.some((x) => x.kind === 'bag');
  return (
    `<div><span class="wkf-r-k">${esc(t('work.bInoc'))}</span>${esc(_inoc.map((x) => x.id).join(', '))}` +
    (brut ? `<div class="wkf-hint">${esc(t('work.bInocSpent'))}</div>` : '') +
    '</div>'
  );
}
// Die Liste fürs Anlegen, mit der Antwort auf "verbraucht?" schon darin.
function wkbInocListe() {
  return _inoc.map((x) => ({ kind: x.kind, id: x.id, spent: x.kind === 'bag' }));
}

// Ohne Ansatz läuft die Buchung über createBatch() des langen Formulars: es
// zieht Rohmaterial vom Lager, fragt danach die Zone ab und druckt Etiketten.
// Der Ablauf füllt dessen Felder und übergibt, statt denselben Weg noch einmal
// zu schreiben — eine zweite Fassung wäre die, die irgendwann abweicht.
// `stamm` und `angesetzt` kommen aus wkbCreate, schon geprüft: der Name aus der
// Liste der Sorte ('' für ohne), der Tag als JJJJ-MM-TT ('' für heute). `inoc`
// ist die Beimpf-Liste aus wkbInocListe(); createBatch() bucht die Brut nach dem
// Speichern aus (inocAskConsume) und nimmt die erste Kultur als Herkunft.
function wkbCreateFromShelf(stamm, angesetzt, inoc, ph) {
  const ms = wkbStrain();
  if (!ms) return;
  const r = wkbRecipe();
  wkfClose();
  // Erst bereitmachen, dann füllen: beim ersten Mal in einer Sitzung setzt
  // nbEnsureReady() die gemerkten Vorgaben, und die überschrieben sonst alles,
  // was hier gesetzt wird. Die Seite wechselt dafür nicht mehr — siehe
  // msQuickConfirm, derselbe Grund.
  nbEnsureReady();
  // Das Rezept des Assistenten überschreibt das der Sorte, wo es abweicht.
  nbFillFromStrain(ms, {
    qty: WKB.qty,
    bagKg: WKB.bagKg,
    days: r.days,
    hw: r.hw,
    wb: r.wb,
    rh: r.rh,
    notes: WKB.notes.trim(),
    ph,
    strainText: stamm || '',
    created: angesetzt || '',
    inoc: inoc || []
  });
  createBatch();
  // createBatch hat den pH schon gelesen, bevor es zum ersten Mal wartet. Bricht
  // es danach ab (Rückfrage verneint), stünde er sonst im versteckten Formular
  // und ginge mit der nächsten Charge von dort mit — gemessen an einer anderen.
  const phFeld = document.getElementById('nb-ph');
  if (phFeld) phFeld.value = '';
}

async function wkbCreate() {
  wkbReadStep();
  // Die Beimpf-Liste jetzt, solange der Ablauf offen ist: wkfClose() leert sie.
  const inoc = wkbInocListe();
  const ms = wkbStrain();
  const mix = wkbMix();
  if (!ms) return;
  // Vor allem anderen: ein vertippter pH soll nicht erst nach dem Stamm-Anlegen
  // auffallen. Leer ist erlaubt — gemessen wird nicht bei jeder Charge.
  const ph = phLesen(WKB.ph);
  if (ph === undefined) {
    toast(t('batch.phNaN'), 'err');
    return;
  }
  // Ein gewählter Ansatz, der inzwischen leer ist, ist kein "ohne Ansatz":
  // _sbList wird im Hintergrund aufgefrischt, und derselbe Tipp buchte sonst
  // klammheimlich Pellets und Kleie vom Lager statt aus dem Ansatz.
  if (!mix && WKB.subId) {
    toast(t('work.bMixGone', { id: WKB.subId }), 'err');
    WKB.subId = '';
    WKB.step = 2;
    wkbRender();
    return;
  }
  // Ein Tag in der Zukunft wird abgewiesen, solange der Ablauf noch offen ist.
  const angesetzt = anlageLesen('wkb');
  if (angesetzt === null) return;
  // Ein im ersten Schritt getippter, nicht hinzugefügter Stamm wird jetzt
  // angelegt; so lange nimmt der Knopf keinen zweiten Tipp an.
  const knopf = document.querySelector('#m-work-flow [data-wkb="create"]');
  if (knopf) knopf.disabled = true;
  const stamm = await stammFertig('wkb');
  if (knopf) knopf.disabled = false;
  // Fehlgeschlagen (gemeldet ist es), oder der Ablauf wurde währenddessen zu.
  if (stamm === null || WKF.kind !== 'batch') return;
  if (!mix) return wkbCreateFromShelf(stamm, angesetzt, inoc, ph);
  const r = wkbRecipe();
  const wann = anlageZeitpunkt(angesetzt);
  const batchId = genBatchId(ms.name, wann);
  const kultur = inoc.find((x) => x.kind === 'culture');
  // Wie das lange Formular: der Stamm steht in beiden Spalten, und ohne ihn steht
  // in `strain` 'XXX', nicht das Sorten-Kürzel. Sonst bedeutet dieselbe Spalte je
  // nach Eingabeweg etwas anderes.
  createBatchFromSubstrate(batchId, mix.subId, ms.id, WKB.qty, WKB.bagKg, r.days, stamm || 'XXX', stamm, {
    notes: WKB.notes.trim(),
    ph,
    created: angesetzt ? wann.toISOString() : undefined,
    sourceId: kultur ? kultur.id : undefined,
    onDone: (res) => {
      const neuId = res.batchId || batchId;
      const neu = batches.find((x) => x.batchId === neuId);
      // Die Körnerbrut geht jetzt aus dem Bestand, mit der neuen Charge als
      // Grund. Auch wenn der Ablauf inzwischen zu ist: angelegt ist angelegt.
      const brut = neu ? inocVerbrauchtBuchen(neu, inoc) : 0;
      // Was noch im Ansatz steht, ist die Zahl, gegen die die nächste Charge
      // geplant wird. Sie stand auf der Quittung, die dieser Weg jetzt nicht
      // mehr zeigt — also geht sie in die Meldung mit. Eine Charge aus der
      // Inventur hat nichts gezogen, und die Meldung sagt genau das.
      const gezogen = angesetzt
        ? t('anlage.notBooked')
        : t('work.bDrawn', {
            kg: (res.drawKg || wkbDraw()).toFixed(0),
            id: mix.subId,
            left: (res.remainingKg || 0).toFixed(0)
          });
      const meldung =
        t('work.bDone', { n: WKB.qty, name: ms.name }) +
        ' — ' +
        gezogen +
        (brut ? ' — ' + t('work.bInocDone', { n: brut }) : '');
      // Der Ablauf kann inzwischen verlassen oder ein anderer geöffnet worden
      // sein. Dann gehört WKF nicht mehr uns — die Bestätigung sagt es dem
      // Fenster, statt den fremden Bildschirm zu übernehmen.
      if (WKF.kind !== 'batch') {
        toast(meldung);
        return;
      }
      // Zuerst zu, dann einlagern: m-move-batch und m-batch-print lägen sonst
      // hinter diesem Fenster (siehe nbPlaceAndPrint). Die Quittung entfällt
      // dafür — der Zonenwähler ist ein Pflichtschritt, und ein Bildschirm, der
      // vorher "fertig" sagt, lädt dazu ein, ihn wegzutippen. Genau so können
      // Chargen ohne einen einzigen ADD-Scan entstehen.
      wkfClose();
      toast(meldung);
      if (neu) nbPlaceAndPrint(neu, neu.bags || []);
    }
  });
}

(function wireBatchWizard() {
  const flow = document.getElementById('m-work-flow');
  if (!flow) return;
  flow.addEventListener('click', (e) => {
    if (WKF.kind !== 'batch') return;
    // Das ✕ an einem Beimpf-Eintrag: raus aus der Liste, sonst bleibt alles.
    const weg = e.target.closest('[data-action="inoc-drop"]');
    if (weg) {
      wkbReadStep();
      inocRemove(weg.dataset.id);
      wkbRender();
      return;
    }
    const el = e.target.closest('[data-wkb]');
    if (!el || el.disabled) return;
    const a = el.dataset.wkb;
    if (a === 'inoc-scan') {
      // Die Kamera liegt über dem Ablauf (beide z-index 200, die Kamera steht in
      // index.html dahinter); der Scan landet über _inocScanPrefix in
      // wkbInocAdd(), und das Schließen der Kamera gibt den Ablauf wieder frei.
      wkbReadStep();
      msqOpenScan('wkb');
      return;
    }
    if (a === 'kg') {
      wkbReadStep();
      WKB.bagKg = parseDecimal(el.dataset.val) || NB_BAG_KG_DEFAULT;
    } else if (a === 'next') {
      wkbReadStep();
      // Ein Tag in der Zukunft hält den ersten Schritt fest, die Meldung steht am
      // Feld. Geht es in den zweiten, gilt die Vorgabe für den Ansatz neu: sie
      // hängt am Datum, das eben gewählt wurde.
      if (WKB.step === 1 && anlageLesen('wkb') === null) return;
      WKB.step++;
      if (WKB.step === 2) wkbQuelleVorgabe();
    } else if (a === 'back') {
      wkbReadStep();
      WKB.step--;
    } else if (a === 'step2') {
      wkbReadStep();
      WKB.step = 2;
    } else if (a === 'custom') {
      wkbReadStep();
      WKB.custom = !WKB.custom;
    } else if (a === 'again') {
      wkbOpen();
      return;
    } else if (a === 'tosub') {
      // Direkt in den Misch-Dialog, nicht auf die Chargenseite: das lange
      // Formular ließe den Arbeiter dort erst suchen. Die
      // Kachel auf der Arbeitsgang-Seite öffnet längst den Dialog; dieser Knopf
      // steht an genau der Stelle, an der man ihn am dringendsten braucht — es
      // gibt keinen Ansatz, also legen wir jetzt einen an.
      wkmOpen();
      return;
    } else if (a === 'create') {
      wkbCreate();
      return;
    }
    wkbRender();
  });
  // Menge und Sorte wirken auf die Zeile im zweiten Schritt, also sofort merken.
  flow.addEventListener('change', (e) => {
    if (WKF.kind !== 'batch') return;
    // Beimpfmaterial aus der Liste gewählt statt gescannt: derselbe Weg.
    if (e.target.closest('#wkb-inoc-pick')) {
      const wahl = e.target.value;
      if (!wahl) return;
      const err = wkbInocAdd(wahl);
      if (err) {
        toast(err, 'err');
        inocRender('wkb');
      }
      return;
    }
    if (e.target.closest('#wkb-mix')) WKB.subVonHand = true;
    if (e.target.closest('#wkb-strain,#wkb-qty,#wkb-mix')) {
      wkbReadStep();
      if (e.target.closest('#wkb-strain')) wkbInocSortePruefen();
      wkbRender();
    }
  });
  // Derselbe Weg aus der Karte heraus, wo das lange Formular steht: wer dort
  // landet, soll nicht erst auf die Startseite zurückmüssen, um geführt zu werden.
  const guided = document.getElementById('nb-guided');
  if (guided) {
    guided.addEventListener('click', wkbOpen);
  }
})();

// ═══ SUBSTRAT ANSETZEN ALS ARBEITSGANG ═══════════════════════════════════════
// Die Kachel schickte auf die Chargen-Seite und scrollte dort zu einem Formular.
// Sechs Kacheln öffnen einen Dialog, eine wechselte die Seite — das war der
// Ausreißer. Ein Bildschirm reicht: Rezept, Menge, was dabei herauskommt, und
// ob das Lager es trägt. Gebucht wird über denselben Aufruf wie im Formular.

// `previewKey` sagt, zu welchem Rezept und welcher Menge die Vorschau gehört —
// ohne das lässt sich nicht erkennen, ob sie noch gilt. `bucht` sperrt den
// Knopf für die Dauer der Buchung, nicht für die Dauer der Rechnerei.
// `mix` sind die Anteile dieses einen Ansatzes, aus dem Rezept vorbelegt und
// dann hier änderbar — dieselben Zahlen, die das Formular auf der Chargen-Seite
// schickt. Drei Rezepte zur Auswahl hießen sonst: wer 70/30 will, muss ins
// Formular oder das Rezept umschreiben, und damit jeden künftigen Ansatz mit.
// `steriMin` gehört nicht zur Mischung und nicht in den Vorschau-Schlüssel: es
// ändert keine Zahl der Rechnung, es wird nur mit dem Ansatz gespeichert.
const WKM = { recipeId: null, bags: 50, kg: 0, mix: null, steriMin: null, unlesbar: {}, notes: '', preview: null, previewKey: '', laedt: false, bucht: false, fehler: '' };
const WKM_MIX_KEYS = ['branPct', 'gypsumPct', 'calciumPct', 'moisturePct'];

function wkmKey() {
  // Mit den unlesbaren Feldern: eine getippte Nicht-Zahl ändert WKM.mix nicht,
  // muss die alte Vorschau aber trotzdem ungültig machen.
  return String(WKM.recipeId) + '|' + WKM.kg + '|' + JSON.stringify(WKM.mix) + '|' + Object.keys(WKM.unlesbar).sort();
}

function wkmMixFromRecipe() {
  const rec = sbRecipeOf(WKM.recipeId);
  WKM.mix = rec
    ? { branPct: rec.branPct, gypsumPct: rec.gypsumPct, calciumPct: rec.calciumPct, moisturePct: rec.moisturePct }
    : null;
}

// Ein leeres Feld fehlt im Objekt: dann gilt dafür das Rezept, so wie der
// Server ein fehlendes Feld liest.
function wkmMixAdjusted() {
  const rec = sbRecipeOf(WKM.recipeId);
  if (!rec || !WKM.mix) return false;
  return WKM_MIX_KEYS.some((k) => k in WKM.mix && Math.abs(WKM.mix[k] - rec[k]) > 1e-9);
}

// Dieselben Grenzen wie validateMixOverride() im Server. Hier geprüft, damit
// statt "branPct must be <= 95" ein Satz dasteht, mit dem man etwas anfangen kann.
function wkmMixOk() {
  const m = WKM.mix || {};
  const drin = (k, lo, hi) => !(k in m) || (m[k] >= lo && m[k] <= hi);
  return (
    !wkmUnlesbar('mix') &&
    drin('branPct', 0, 95) &&
    drin('gypsumPct', 0, 20) &&
    drin('calciumPct', 0, 20) &&
    drin('moisturePct', 20, 90)
  );
}
// Leer heißt: nicht eingetragen. Sonst ganze oder halbe Minuten bis zu einem Tag.
function wkmSteriOk() {
  return !WKM.unlesbar.steri && (WKM.steriMin == null || (WKM.steriMin >= 0 && WKM.steriMin <= 1440));
}

// Ein Feld, das etwas enthält, aber keine Zahl: das darf nicht still als "leer"
// gelten. Leer hieße beim Anteil "wie im Rezept" und bei der Zeit "nicht
// eingetragen" — der Ansatz würde mit einer anderen Zahl angelegt als der, die
// der Mischende getippt zu haben glaubt.
const WKM_FELD_NAME = {
  hw: 'sub.pellets',
  wb: 'sub.bran',
  gyp: 'sub.gypsum',
  ca: 'sub.calcium',
  rh: 'sub.moisture',
  steri: 'sub.steri'
};
function wkmFeldLesen(which) {
  const el = document.getElementById('wkm-' + which);
  const raw = el ? el.value.trim() : '';
  const v = raw === '' ? null : parseDecimal(raw);
  const lesbar = v == null || Number.isFinite(v);
  if (lesbar) delete WKM.unlesbar[which];
  else WKM.unlesbar[which] = true;
  return lesbar ? v : null;
}
// Das erste unlesbare Feld, für die Mischung oder für die Zeit.
function wkmUnlesbar(teil) {
  return Object.keys(WKM.unlesbar).find((k) => (teil === 'steri' ? k === 'steri' : k !== 'steri')) || null;
}
// Was über der Tabelle steht, wenn sich nicht rechnen lässt.
function wkmMixFehler() {
  const u = wkmUnlesbar('mix');
  return u ? t('work.mNotNumber', { feld: t(WKM_FELD_NAME[u]) }) : t('work.mMixRange');
}

// Pellets und Kleie sind eine Zahl in zwei Feldern, wie in sbBlendEdited():
// wer eines tippt, hat das andere mitgesagt.
let _wkmMixTimer = null;
function wkmBlendEdited(which) {
  if (!WKM.mix) WKM.mix = {};
  if (which === 'hw' || which === 'wb') {
    const v = wkmFeldLesen(which);
    // Das Gegenfeld ist jetzt wieder lesbar, weil es gleich überschrieben wird.
    delete WKM.unlesbar[which === 'hw' ? 'wb' : 'hw'];
    if (v == null) {
      delete WKM.mix.branPct;
    } else {
      const teil = Math.min(100, Math.max(0, v));
      WKM.mix.branPct = which === 'hw' ? 100 - teil : teil;
      _sbSet(which === 'hw' ? 'wkm-wb' : 'wkm-hw', 100 - teil);
    }
  } else {
    const k = { gyp: 'gypsumPct', ca: 'calciumPct', rh: 'moisturePct' }[which];
    const v = wkmFeldLesen(which);
    if (v == null) delete WKM.mix[k];
    else WKM.mix[k] = v;
  }
  const reset = document.querySelector('[data-wkm="mixreset"]');
  if (reset) reset.hidden = !wkmMixAdjusted();
  clearTimeout(_wkmMixTimer);
  _wkmMixTimer = setTimeout(wkmLoadPreview, 300);
}

// Die Beschriftung, die der Ansatz in der Liste bekommt. Gebaut vom Server
// (mixLabel), damit Dialog, Formular und Liste dasselbe sagen.
function wkmLabel() {
  const p = WKM.preview;
  return p ? p.label || p.recipeLabel || '' : '';
}

function wkmStock() {
  return (inventory && inventory.stock) || {};
}

// Was der Ansatz vom Lager nimmt, gegen das, was da ist. Der Server kappt eine
// Abbuchung auf den Bestand, also muss die Lücke vor dem Buchen dastehen.
function wkmShortfalls() {
  const m = WKM.preview && WKM.preview.mix;
  if (!m) return [];
  const s = wkmStock();
  const zeilen = [
    [t('sub.pellets'), m.pelletsKg, s.hardwood || 0],
    [t('sub.bran'), m.branKg, s.wheatbran || 0],
    [t('sub.gypsum'), m.gypsumKg, s.gypsum || 0]
  ];
  if (m.cornKg > 0.005) zeilen.push([t('sub.corn'), m.cornKg, s.corn || 0]);
  if (m.calciumKg > 0.005) zeilen.push([t('sub.calcium'), m.calciumKg, s.calcium || 0]);
  return zeilen.filter((z) => z[1] > z[2] + 1e-9).map((z) => ({ label: z[0], need: z[1], have: z[2] }));
}

// Jede Anfrage bekommt eine Nummer. Nur die jüngste darf schreiben — sonst
// überholt eine früher gestartete Antwort eine spätere und die Tabelle zeigt
// ein anderes Rezept als die Auswahl.
let _wkmSeq = 0;
async function wkmLoadPreview() {
  // Nichts geändert, Vorschau gilt noch: dann auch keine Anfrage. Das Feld
  // meldet ein change auch beim Verlassen ohne Änderung.
  if (WKM.preview && WKM.previewKey === wkmKey()) return;
  const seq = ++_wkmSeq;
  // Die alte Vorschau gilt ab jetzt nicht mehr: sie beschreibt eine andere
  // Menge. Sichtbar leeren, statt eine überholte Tabelle stehen zu lassen.
  WKM.preview = null;
  WKM.previewKey = '';
  WKM.fehler = '';
  if (!WKM.recipeId || !(WKM.kg > 0) || !wkmMixOk()) {
    WKM.laedt = false;
    if (!wkmMixOk()) WKM.fehler = wkmMixFehler();
    wkmRenderOut();
    wkmUpdateButton();
    return;
  }
  WKM.laedt = true;
  wkmRenderOut();
  wkmUpdateButton();
  const r = await apiPost('/api/substrate-batches/preview', {
    recipeId: WKM.recipeId,
    targetKg: WKM.kg,
    mix: WKM.mix || undefined
  });
  if (seq !== _wkmSeq) return;
  WKM.laedt = false;
  if (!r || r.error) {
    WKM.fehler = (r && r.error) || '?';
  } else if (!r.hasRecipe) {
    WKM.fehler = t('sub.noRecipe');
  } else {
    WKM.preview = r;
    WKM.previewKey = wkmKey();
  }
  wkmRenderOut();
  wkmUpdateButton();
}

async function wkmOpen() {
  await loadSubstrateRecipes();
  WKM.recipeId = _sbRecipes.length ? _sbRecipes[0].id : null;
  wkmMixFromRecipe();
  WKM.steriMin = null;
  WKM.unlesbar = {};
  WKM.bags = 50;
  WKM.kg = sbTargetKg(WKM.bags, sbBagKg());
  WKM.notes = '';
  WKM.preview = null;
  WKM.fehler = '';
  WKF.kind = 'mix';
  WKF.step = 'detail';
  WKF.receipt = null;
  wkf('m-work-flow').classList.add('open');
  wkmRender();
  wkmLoadPreview();
}

function wkmRead() {
  const g = (id) => document.getElementById(id);
  if (g('wkm-recipe')) WKM.recipeId = parseInt(g('wkm-recipe').value, 10) || null;
  if (g('wkm-bags')) WKM.bags = sbParseBags(g('wkm-bags').value);
  WKM.kg = sbTargetKg(WKM.bags, sbBagKg());
  if (g('wkm-steri')) WKM.steriMin = wkmFeldLesen('steri');
  if (g('wkm-notes')) WKM.notes = g('wkm-notes').value;
}

// Nur der Ergebnisbereich: Lagerwarnung, Fehlermeldung, Mischungstabelle.
function wkmRenderOut() {
  const out = document.getElementById('wkm-out');
  if (!out) return;
  const m = WKM.preview && WKM.preview.mix;
  const kurz = WKM.preview ? wkmShortfalls() : [];
  const zeile = (label, wert, einheit) =>
    `<div><span class="wkf-r-k">${esc(label)}</span><span>${fmtKg(wert, 1)} ${einheit}</span></div>`;
  out.innerHTML =
    (kurz.length
      ? '<div class="wkf-note bad"><b>' +
        esc(t('sub.shortTitle')) +
        '</b>' +
        kurz
          .map((x) => esc(t('sub.shortLine', { mat: x.label, need: fmtKg(x.need, 1), have: fmtKg(x.have, 1) })))
          .join('<br>') +
        '<br>' +
        esc(t('sub.shortHint')) +
        '</div>'
      : '') +
    (WKM.fehler ? `<div class="wkf-note bad">${esc(WKM.fehler)}</div>` : '') +
    (m
      ? '<div class="wkf-sum-card">' +
        zeile(t('sub.dryMix'), m.dryKg, 'kg') +
        zeile(t('sub.pellets'), m.pelletsKg, 'kg') +
        zeile(t('sub.bran'), m.branKg, 'kg') +
        (m.cornKg > 0.005 ? zeile(t('sub.corn'), m.cornKg, 'kg') : '') +
        zeile(t('sub.gypsum'), m.gypsumKg, 'kg') +
        (m.calciumKg > 0.005 ? zeile(t('sub.calcium'), m.calciumKg, 'kg') : '') +
        zeile(t('sub.waterNow'), sbWater(WKM.preview).nowL, 'L') +
        // Direkt unter die Literzahl: hier steht man am Hahn, und "107 L" sagt
        // nicht, wie lange er laufen soll. Die Vorschau im Formular zeigt es
        // seit jeher, der Arbeitsgang nicht — also ausgerechnet der Schirm
        // nicht, den man dabei in der Hand hat.
        `<div><span class="wkf-r-k">${esc(t('sub.waterTime'))}</span><span>${esc(waterTimeText(sbWater(WKM.preview).nowMinutes))}</span></div>` +
        zeile(t('sub.waterRest'), sbWater(WKM.preview).restL, 'L') +
        zeile(t('sub.moisture'), m.moisturePct, '%') +
        '</div>' +
        `<div class="wkf-hint">${esc(sbWaterHint(sbWater(WKM.preview)))}</div>`
      : WKM.laedt
        ? `<div class="wkf-hint">${esc(t('work.mCalc'))}</div>`
        : '');
}
// Anlegen erst, wenn eine Mischung berechnet ist.
function wkmUpdateButton() {
  const b = document.querySelector('[data-wkm="create"]');
  // Nicht während der Rechnerei sperren: ein Tipp auf den Knopf nimmt dem
  // Mengenfeld den Fokus, dessen change startet die Rechnerei — und die Sperre
  // schluckte dann genau den Tipp, der sie ausgelöst hatte. wkmCreate() wartet
  // die Vorschau selbst ab. Gesperrt wird, solange gebucht wird.
  if (b) b.disabled = WKM.bucht || !(WKM.preview && WKM.preview.mix);
}

function wkmRender() {
  // Siehe wkbRender(): ein spät zurückkommender Ansatz darf nicht in einen
  // inzwischen geöffneten anderen Ablauf schreiben.
  if (WKF.kind !== 'mix') return;
  wkf('wkf-title').textContent = t('work.substrate');
  // Die Felder werden gleich aus dem Zustand neu gezeichnet, also steht danach
  // in jedem eine lesbare Zahl.
  WKM.unlesbar = {};
  wkf('wkf-back').hidden = true;
  wkf('wkf-steps').innerHTML = '';

  if (WKF.step === 'done') {
    const d = WKF.receipt || {};
    wkf('wkf-body').innerHTML =
      `<div class="wkf-receipt">
         <div class="wkf-r-head"><span class="wkf-r-tick">&#10003;</span><b>${esc(d.headline || '')}</b></div>
         <div class="wkf-r-lines">` +
      (d.lines || []).map((l) => `<div><span class="wkf-r-k">${esc(l[0])}</span><span>${esc(l[1])}</span></div>`).join('') +
      '</div></div>';
    wkf('wkf-foot').innerHTML =
      // Gemessen wird nach dem Mischen; der Knopf steht hier, weil man in dem
      // Moment ohnehin am Ansatz ist.
      (d.subId
        ? `<button class="btn btn-p" data-wkm="rh" data-sub="${esc(d.subId)}">${esc(t('sub.rhAdd'))}</button>`
        : '') +
      `<button class="btn" data-wkm="again">${esc(t('work.mAnother'))}</button>` +
      `<button class="btn" onclick="wkfClose()">${esc(t('work.done'))}</button>`;
    return;
  }

  const list = sbRecipeOptions(WKM.recipeId);
  const mix = WKM.mix || {};
  // Mit Komma, wie getippt wird; parseDecimal liest beides.
  const zahl = (v) => (v == null ? '' : String(Math.round(v * 100) / 100).replace('.', ','));
  const feld = (id, label, wert, min, max, step, einheit) =>
    `<div><label class="fs-xs">${esc(label)} ${einheit || '%'}</label>
       <input type="text" id="${id}" inputmode="decimal" data-min="${min}" data-max="${max}" value="${zahl(wert)}" /></div>`;

  wkf('wkf-body').innerHTML =
    `<div class="wkf-q">${esc(t('work.mQ'))}</div>
     <div class="wkf-field"><label>${esc(t('sub.recipe'))}</label><select id="wkm-recipe">${list}</select></div>
     <div class="wkf-field">
       <div class="wkm-blend-head">
         <label>${esc(t('sub.blendTitle'))}</label>
         <button type="button" class="btn-xs" data-wkm="mixreset"${wkmMixAdjusted() ? '' : ' hidden'}>${esc(t('sub.blendReset'))}</button>
       </div>
       <div class="wkf-two wkm-blend">` +
    feld('wkm-hw', t('sub.pellets'), 'branPct' in mix ? 100 - mix.branPct : null, 0, 100, 1) +
    feld('wkm-wb', t('sub.bran'), mix.branPct, 0, 95, 1) +
    feld('wkm-gyp', t('sub.gypsum'), mix.gypsumPct, 0, 20, 0.5) +
    feld('wkm-ca', t('sub.calcium'), mix.calciumPct, 0, 20, 0.5) +
    feld('wkm-rh', t('sub.moisture'), mix.moisturePct, 20, 90, 0.5) +
    // Keine Zahl der Mischung, aber mit ihr gespeichert: neben dem pH der
    // Chargen zeigt sie, was die Sterilisierzeit mit dem Substrat macht.
    feld('wkm-steri', t('sub.steri'), WKM.steriMin, 0, 1440, 1, 'min') +
    `</div>
     </div>
     <div class="wkf-two">
       <div class="wkf-field"><label>${esc(t('sub.bags'))}</label>
         <input type="text" inputmode="numeric" id="wkm-bags" value="${WKM.bags || ''}" /></div>
       <div class="wkf-field"><label>${esc(t('batch.bagWeight'))}</label>
         <div class="wkf-chipsrow">${sbBagChips('data-wkm="bagkg" data-val')}</div></div>
     </div>` +
    '<div id="wkm-out"></div>' +
    `<div class="wkf-field"><label>${esc(t('work.bNote'))}</label>
       <input type="text" id="wkm-notes" value="${esc(WKM.notes)}" placeholder="${esc(t('work.mNotePh'))}" /></div>`;

  wkf('wkf-foot').innerHTML =
    `<button class="btn" onclick="wkfClose()">${esc(t('work.cancel'))}</button>` +
    `<button class="btn btn-p" data-wkm="create">${esc(t('sub.create'))}</button>`;
  wkmRenderOut();
  wkmUpdateButton();
}

async function wkmCreate() {
  if (WKM.bucht) return;
  wkmRead();
  // Gehört die Vorschau zu einer anderen Menge als der, die im Feld steht,
  // erst rechnen lassen — und dann weitermachen, statt den Tipp verfallen zu
  // lassen. Sonst muss der Arbeiter nach jeder Mengenänderung zweimal tippen.
  if (!WKM.preview || WKM.previewKey !== wkmKey()) await wkmLoadPreview();
  if (!WKM.preview) return;
  if (!wkmSteriOk()) {
    WKM.fehler = WKM.unlesbar.steri ? t('work.mNotNumber', { feld: t('sub.steri') }) : t('sub.steriNaN');
    wkmRenderOut();
    return;
  }
  const kurz = wkmShortfalls();
  const subId = sbGenId();
  const menge = { bags: WKM.bags, bagKg: sbBagKg(), kg: WKM.kg };
  const label = wkmLabel();
  // Die Anteile, die die Vorschau gerechnet hat, festhalten: wer tippt, während
  // die Bestätigung offen ist, soll nicht etwas anderes anlegen als bestätigt.
  const mix = WKM.mix ? Object.assign({}, WKM.mix) : undefined;
  const steriMin = WKM.steriMin;
  sbConfirmMix(subId, menge, label, kurz.length > 0, () => wkmSubmit(subId, menge, label, mix, steriMin));
}

function wkmSubmit(subId, menge, label, mix, steriMin) {
  // Der Knopf bleibt sonst die ganze Runde über anfassbar: POST, loadData und
  // refreshSubstrateBatches dauern, auf dem Bildschirm ändert sich nichts, und
  // ein zweiter Tipp legt einen zweiten Ansatz an.
  WKM.bucht = true;
  wkmUpdateButton();
  apiPost('/api/substrate-batches', {
    subId,
    recipeId: WKM.recipeId,
    targetKg: menge.kg,
    mix,
    steriMin,
    notes: WKM.notes.trim()
  })
    .then(async (r) => {
      if (!r || r.error) {
        const err = (r && r.error) || '?';
        // Auch der Fehlschlag braucht ein Zuhause: ist der Ablauf schon zu, malt
        // wkmRender() ins Leere und der Arbeiter hielte den Ansatz für angelegt.
        if (WKF.kind !== 'mix') {
          toast(t('common.error') + ': ' + err, 'err');
          return;
        }
        WKM.fehler = err;
        wkmRender();
        return;
      }
      await loadData();
      await refreshSubstrateBatches();
      // Der Ablauf kann inzwischen verlassen oder ein anderer geöffnet worden
      // sein. Dann gehört WKF nicht mehr uns: die Bestätigung geht ins Fenster,
      // statt den fremden Bildschirm zu überschreiben oder still zu verpuffen.
      if (WKF.kind !== 'mix') {
        toast(t('work.mDone', sbMengeParams(menge, { recipe: label })) + ' — ' + (r.subId || subId));
        return;
      }
      // Die Vorschau kann inzwischen ersetzt worden sein; die Quittung nennt dann
      // nur, was sicher stimmt, statt an einer leeren Referenz abzustürzen.
      const m = (WKM.preview && WKM.preview.mix) || null;
      WKF.receipt = {
        headline: t('work.mDone', sbMengeParams(menge, { recipe: label })),
        subId: r.subId || subId,
        lines: [
          [t('work.mId'), r.subId || subId],
          [t('sub.totalKg'), fmtKg(menge.kg, 1) + ' kg']
        ]
          .concat(
            m
              ? [
                  [t('sub.pellets'), fmtKg(m.pelletsKg, 1) + ' kg'],
                  [t('sub.bran'), fmtKg(m.branKg, 1) + ' kg'],
                  ...(m.calciumKg > 0.005 ? [[t('sub.calcium'), fmtKg(m.calciumKg, 1) + ' kg']] : []),
                  [t('sub.waterNow'), fmtKg(sbWater(r.water ? r : WKM.preview).nowL, 1) + ' L'],
                  [t('sub.waterRest'), fmtKg(sbWater(r.water ? r : WKM.preview).restL, 1) + ' L']
                ]
              : []
          )
          .concat(steriMin != null ? [[t('sub.steri'), fmtKg(steriMin, 0) + ' min']] : [])
          .concat(WKM.notes.trim() ? [[t('work.bNote'), WKM.notes.trim()]] : []),
        next: null
      };
      WKF.step = 'done';
      wkmRender();
    })
    .finally(() => {
      WKM.bucht = false;
      wkmUpdateButton();
    });
}

(function wireMixFlow() {
  const flow = document.getElementById('m-work-flow');
  if (!flow) return;
  flow.addEventListener('click', (e) => {
    if (WKF.kind !== 'mix') return;
    const el = e.target.closest('[data-wkm]');
    if (!el || el.disabled) return;
    if (el.dataset.wkm === 'create') wkmCreate();
    else if (el.dataset.wkm === 'again') wkmOpen();
    else if (el.dataset.wkm === 'mixreset') {
      wkmRead();
      wkmMixFromRecipe();
      wkmRender();
      wkmLoadPreview();
    } else if (el.dataset.wkm === 'bagkg') {
      wkmRead();
      sbSetBagKg(parseFloat(el.dataset.val));
      sbRenderBagChips();
      wkmRead();
      wkmRender();
      wkmLoadPreview();
    } else if (el.dataset.wkm === 'rh') {
      // Erst den Ablauf zu: der Prompt läge sonst dahinter (siehe measureSubstrateRh).
      const s = (_sbList || []).find((x) => x.subId === el.dataset.sub);
      wkfClose();
      if (s) measureSubstrateRh(s, { stay: true });
    }
  });
  // Rezept und Menge neu rechnen lassen; die Notiz nicht, sonst springt der Cursor.
  flow.addEventListener('change', (e) => {
    if (WKF.kind !== 'mix') return;
    if (e.target.closest('#wkm-recipe')) {
      // Andere Mischung: die Anteile kommen frisch aus deren Rezept, wie im
      // Formular (sbRecipeChanged). Eine Abweichung still mitzunehmen wäre die
      // unangenehmere Überraschung.
      wkmRead();
      wkmMixFromRecipe();
      wkmRender();
      wkmLoadPreview();
    } else if (e.target.closest('#wkm-bags')) {
      wkmRead();
      wkmLoadPreview();
    } else if (e.target.closest('#wkm-notes')) {
      wkmRead();
    }
  });
  // Die Anteile beim Tippen: das Gegenfeld sofort, die Rechnung kurz danach.
  flow.addEventListener('input', (e) => {
    if (WKF.kind !== 'mix') return;
    const f = e.target.closest('#wkm-hw,#wkm-wb,#wkm-gyp,#wkm-ca,#wkm-rh');
    if (f) wkmBlendEdited(f.id.slice(4));
    // Die Zeit ändert die Rechnung nicht, also nur merken.
    else if (e.target.closest('#wkm-steri')) WKM.steriMin = wkmFeldLesen('steri');
  });
})();