From 22dbe218fbc21ad277d7435e02c0afe439d546c1 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 28 Sep 2026 19:39:21 +0000
Subject: [PATCH 1/3] fix: make calculator, publish, profile and Excel import
 work

- Calculator: derive from/to states from bundled FISH_DATA_V3 keys so it
  works offline and when /api/fish-data fails; only replace bundled data
  with a usable API response. Reject yields outside (0, 100] instead of
  silently treating 0 as 100%, and clear stale results on input edits.
- Publish/unpublish: use getAuthHeaders from useAuth (user had no such
  method, so requests went out unauthenticated and failed silently);
  show an error in the preview modal on permanent failure.
- Contributor profile: call /api/contributor (the /me path only exists
  in Express) and accept Postgres booleans for show_on_page.
- Import: keep numeric XLSX cells so a "42%" cell imports as 42, not
  0.42; CSV "0.5" stays 0.5% in both backends.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PnPh61Aps5neY87hh1pu9T
---
 api/_lib/importRows.js                     | 22 ++++++--
 app/src/components/Calculator.jsx          | 25 +++++++--
 app/src/components/ContributorProfile.jsx  |  5 +-
 app/src/components/PreviewPublishModal.jsx |  9 +++-
 app/src/context/DataContext.jsx            | 19 +++++--
 app/src/lib/__tests__/importRows.test.js   | 29 ++++++++++
 app/src/lib/fishDataShape.js               | 63 ++++++++++++++++++++++
 app/src/lib/fishDataShape.test.js          | 51 ++++++++++++++++++
 server/importRows.js                       | 23 ++++++--
 9 files changed, 225 insertions(+), 21 deletions(-)
 create mode 100644 app/src/lib/fishDataShape.js
 create mode 100644 app/src/lib/fishDataShape.test.js

diff --git a/api/_lib/importRows.js b/api/_lib/importRows.js
index b206f03..509aaa0 100644
--- a/api/_lib/importRows.js
+++ b/api/_lib/importRows.js
@@ -65,7 +65,21 @@ function parseYieldPercent(value) {
   return Number.parseFloat(text);
 }
 
-function rowsFromWorksheet(worksheet) {
+// XLSX keeps numeric cells as numbers so normalizeYieldRows can recognize
+// percentage cells stored as fractions (a "42%" cell is stored as 0.42).
+// CSV cells stay strings: ExcelJS parses CSV numbers too, but "0.5" in a CSV
+// means 0.5%, not 50%.
+function cellValue(value, keepNumbers) {
+  if (keepNumbers) {
+    if (typeof value === 'number' && Number.isFinite(value)) return value;
+    if (value && typeof value === 'object' && typeof value.result === 'number' && Number.isFinite(value.result)) {
+      return value.result;
+    }
+  }
+  return normalizeCell(value);
+}
+
+function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
   const rows = [];
   const headerRow = worksheet.getRow(1);
   const headers = [];
@@ -83,9 +97,9 @@ function rowsFromWorksheet(worksheet) {
     const item = {};
     headers.forEach((header, colNumber) => {
       if (!header) return;
-      item[header] = normalizeCell(row.getCell(colNumber).value);
+      item[header] = cellValue(row.getCell(colNumber).value, keepNumbers);
     });
-    if (Object.values(item).some(Boolean)) rows.push(item);
+    if (Object.values(item).some((v) => v !== '' && v !== null && v !== undefined)) rows.push(item);
   });
 
   return rows;
@@ -104,7 +118,7 @@ export async function parseImportRows(buffer, extension) {
     await workbook.xlsx.load(buffer);
     const worksheet = workbook.worksheets[0];
     if (!worksheet) return [];
-    return rowsFromWorksheet(worksheet);
+    return rowsFromWorksheet(worksheet, { keepNumbers: true });
   }
 
   throw new Error('Unsupported file type. Please upload a .csv or .xlsx file.');
diff --git a/app/src/components/Calculator.jsx b/app/src/components/Calculator.jsx
index e2dc05e..8c8a0fb 100644
--- a/app/src/components/Calculator.jsx
+++ b/app/src/components/Calculator.jsx
@@ -3,6 +3,7 @@ import { ACRONYMS, FISH_DATA_V3, PROFILES_DATA } from '../data/fish_data_v3';
 import { Info, Calculator as CalcIcon, Save, HelpCircle, Download, ChevronRight } from 'lucide-react';
 import { useAuth } from '../context/AuthContext';
 import { apiUrl } from '../config/api';
+import { withConversionStates, hasUsableConversions, parseYieldPercent } from '../lib/fishDataShape';
 
 const Tooltip = ({ text, children }) => {
   const [show, setShow] = useState(false);
@@ -93,7 +94,7 @@ const Calculator = () => {
   const [_history, setHistory] = useState([]);
   const [publicHistory, setPublicHistory] = useState([]);
 
-  const [fishData, setFishData] = useState(FISH_DATA_V3);
+  const [fishData, setFishData] = useState(() => withConversionStates(FISH_DATA_V3));
   const [profilesData, setProfilesData] = useState(PROFILES_DATA);
   const [dataLoading, _setDataLoading] = useState(false);
 
@@ -101,7 +102,9 @@ const Calculator = () => {
     fetch(apiUrl('/api/fish-data'))
       .then(res => res.json())
       .then(data => {
-        if (data.fishData && Object.keys(data.fishData).length > 0) setFishData(data.fishData);
+        // Keep the bundled data unless the API returns something usable.
+        const apiData = withConversionStates(data.fishData);
+        if (hasUsableConversions(apiData)) setFishData(apiData);
         if (data.profiles && Object.keys(data.profiles).length > 0) setProfilesData(data.profiles);
       })
       .catch(() => {});
@@ -218,7 +221,9 @@ const Calculator = () => {
   }, [useRangeMin, useRangeMax, yieldRange, currentConversion]);
 
   const calculate = () => {
-    const y = (parseFloat(yieldPercent) || 100) / 100;
+    const yieldValue = parseYieldPercent(yieldPercent);
+    if (yieldValue === null) return;
+    const y = yieldValue / 100;
 
     if (mode === 'weight') {
       const target = parseFloat(targetWeight) || 0;
@@ -300,7 +305,14 @@ const Calculator = () => {
     }
   };
 
-  const canCalculate = species && toState;
+  const yieldIsValid = parseYieldPercent(yieldPercent) !== null;
+  const canCalculate = species && toState && yieldIsValid;
+
+  // A result computed from different inputs is misleading; clear it on edit.
+  useEffect(() => {
+    // eslint-disable-next-line react-hooks/set-state-in-effect
+    setResult(null);
+  }, [mode, cost, targetWeight, yieldPercent, processingCost, weightType]);
 
   return (
     <div className="max-w-2xl mx-auto space-y-5">
@@ -514,6 +526,11 @@ const Calculator = () => {
                 />
                 <span className="absolute right-3 top-1/2 -translate-y-1/2 text-text-muted text-xs">%</span>
               </div>
+              {yieldPercent !== '' && !yieldIsValid && (
+                <p className="mt-1 text-xs text-red-600 dark:text-red-400" role="alert">
+                  Enter a yield between 0 and 100%.
+                </p>
+              )}
               {yieldRange && (
                 <p className="mt-1 text-xs text-text-muted">
                   Reported range: {yieldRange[0]}–{yieldRange[1]}%
diff --git a/app/src/components/ContributorProfile.jsx b/app/src/components/ContributorProfile.jsx
index 80d13db..e35160d 100644
--- a/app/src/components/ContributorProfile.jsx
+++ b/app/src/components/ContributorProfile.jsx
@@ -21,7 +21,7 @@ const ContributorProfile = () => {
         const loadProfile = async () => {
             try {
                 const headers = await getAuthHeaders();
-                const res = await fetch(apiUrl('/api/contributor/me'), { headers });
+                const res = await fetch(apiUrl('/api/contributor'), { headers });
 
                 if (res.status === 404) return;
 
@@ -51,7 +51,8 @@ const ContributorProfile = () => {
                         display_name: data.display_name || '',
                         organization: data.organization || '',
                         bio: data.bio || '',
-                        show_on_page: data.show_on_page === 1
+                        // Postgres returns a boolean, SQLite returns 0/1.
+                        show_on_page: data.show_on_page === true || data.show_on_page === 1
                     });
                 }
             } catch (err) {
diff --git a/app/src/components/PreviewPublishModal.jsx b/app/src/components/PreviewPublishModal.jsx
index 1801d65..f95dc99 100644
--- a/app/src/components/PreviewPublishModal.jsx
+++ b/app/src/components/PreviewPublishModal.jsx
@@ -10,10 +10,11 @@ const FOCUSABLE = 'button, [href], input, select, textarea, [tabindex]:not([tabi
  * Props:
  *   calc    — the local calc record { species, product, cost, yield, result, createdAt, name }
  *   loading — true while the publish API call is in flight
+ *   error   — message shown when publishing failed permanently
  *   onConfirm — called when the user clicks "Publish"
  *   onCancel  — called when the user cancels
  */
-export default function PreviewPublishModal({ calc, loading, onConfirm, onCancel }) {
+export default function PreviewPublishModal({ calc, loading, error, onConfirm, onCancel }) {
   const dialogRef = useRef(null);
   const triggerRef = useRef(null);
 
@@ -87,6 +88,12 @@ export default function PreviewPublishModal({ calc, loading, onConfirm, onCancel
           <Row label="Date" value={date} />
         </div>
 
+        {error && (
+          <p role="alert" className="mb-3 text-sm text-red-600 dark:text-red-400">
+            {error}
+          </p>
+        )}
+
         <div className="flex gap-2">
           <button
             onClick={onCancel}
diff --git a/app/src/context/DataContext.jsx b/app/src/context/DataContext.jsx
index 866d36f..0010ffb 100644
--- a/app/src/context/DataContext.jsx
+++ b/app/src/context/DataContext.jsx
@@ -17,7 +17,7 @@ import { trackGuestAdoption, trackPendingAge } from '../lib/lifecycleTelemetry';
 const DataContext = createContext(null);
 
 export function DataProvider({ children }) {
-  const { user, logout } = useAuth();
+  const { user, logout, getAuthHeaders } = useAuth();
   const [savedCalcs, setSavedCalcs] = useState([]);
   const [customYields, setCustomYields] = useState([]);
   const [customSpecies, setCustomSpeciesState] = useState({});
@@ -37,6 +37,7 @@ export function DataProvider({ children }) {
   // null | calc record — non-null while publish preview modal is shown
   const [publishPreviewCalc, setPublishPreviewCalc] = useState(null);
   const [publishLoading, setPublishLoading] = useState(false);
+  const [publishError, setPublishError] = useState(null);
   // null | { calcs: number, yields: number } — non-null while recovery modal is shown
   const [recoveryCounts, setRecoveryCounts] = useState(null);
   const [recoveryAssigning, setRecoveryAssigning] = useState(false);
@@ -384,6 +385,7 @@ export function DataProvider({ children }) {
 
   // Open the preview modal — no API call yet.
   const requestPublish = useCallback((calc) => {
+    setPublishError(null);
     setPublishPreviewCalc(calc);
   }, []);
 
@@ -392,7 +394,7 @@ export function DataProvider({ children }) {
     if (!publishPreviewCalc?.serverId) return;
     setPublishLoading(true);
     try {
-      const authHeaders = await (user?.getAuthHeaders?.() ?? Promise.resolve({}));
+      const authHeaders = await getAuthHeaders();
       let succeeded = false;
       let transientFailure = false;
       try {
@@ -418,13 +420,19 @@ export function DataProvider({ children }) {
         );
         debouncedSync();
       }
+      if (!succeeded && !transientFailure) {
+        // Permanent failure (e.g. 401/404): keep the modal open and say so.
+        setPublishError('Could not publish this calculation. Sign in again and retry.');
+        return;
+      }
       setPublishPreviewCalc(null);
     } finally {
       setPublishLoading(false);
     }
-  }, [publishPreviewCalc, user, repo, debouncedSync]);
+  }, [publishPreviewCalc, getAuthHeaders, repo, debouncedSync]);
 
   const cancelPublish = useCallback(() => {
+    setPublishError(null);
     setPublishPreviewCalc(null);
   }, []);
 
@@ -434,7 +442,7 @@ export function DataProvider({ children }) {
     let succeeded = false;
     let transientFailure = false;
     try {
-      const authHeaders = await (user?.getAuthHeaders?.() ?? Promise.resolve({}));
+      const authHeaders = await getAuthHeaders();
       const res = await apiClient.unpublishCalcRaw(calc.serverId, authHeaders);
       if (res.ok) {
         await repo.updateCalcPublicationState(calc.id, true);
@@ -456,7 +464,7 @@ export function DataProvider({ children }) {
       );
       debouncedSync();
     }
-  }, [user, repo, debouncedSync]);
+  }, [getAuthHeaders, repo, debouncedSync]);
 
   // ---- Saved Calculations ----
 
@@ -582,6 +590,7 @@ export function DataProvider({ children }) {
         <PreviewPublishModal
           calc={publishPreviewCalc}
           loading={publishLoading}
+          error={publishError}
           onConfirm={confirmPublish}
           onCancel={cancelPublish}
         />
diff --git a/app/src/lib/__tests__/importRows.test.js b/app/src/lib/__tests__/importRows.test.js
index e2c86bc..004b15e 100644
--- a/app/src/lib/__tests__/importRows.test.js
+++ b/app/src/lib/__tests__/importRows.test.js
@@ -1,6 +1,8 @@
 import { describe, expect, it } from 'vitest';
+import { Buffer } from 'node:buffer';
 import {
   normalizeYieldRows,
+  parseImportRows,
   upsertImportedYieldRows,
 } from '../../../../api/_lib/importRows.js';
 
@@ -63,3 +65,30 @@ describe('upsertImportedYieldRows — transaction behavior', () => {
     expect(calls).not.toContain('COMMIT');
   });
 });
+
+describe('parseImportRows — real files end to end', () => {
+  it('imports an Excel "42%" percent cell as a 42% yield', async () => {
+    const ExcelJS = (await import('exceljs')).default;
+    const workbook = new ExcelJS.Workbook();
+    const sheet = workbook.addWorksheet('Yields');
+    sheet.addRow(['Species', '% Yield', 'Product', 'Source']);
+    const row = sheet.addRow(['Coho Salmon', 0.42, 'Skinless Fillet', 'Test']);
+    row.getCell(2).numFmt = '0%';
+    const buffer = Buffer.from(await workbook.xlsx.writeBuffer());
+
+    const parsed = await parseImportRows(buffer, '.xlsx');
+    const { rows, skippedRows } = normalizeYieldRows(parsed, 'test.xlsx');
+
+    expect(skippedRows).toEqual([]);
+    expect(rows).toHaveLength(1);
+    expect(rows[0].yield).toBe(42);
+  });
+
+  it('keeps a CSV "0.5" yield as 0.5%, not 50%', async () => {
+    const csv = 'Species,% Yield,Product,Source\nAnchovy,0.5,Fillet,Test\nPink Salmon,42%,Fillet,Test\n';
+    const parsed = await parseImportRows(Buffer.from(csv), '.csv');
+    const { rows } = normalizeYieldRows(parsed, 'test.csv');
+
+    expect(rows.map((r) => r.yield)).toEqual([0.5, 42]);
+  });
+});
diff --git a/app/src/lib/fishDataShape.js b/app/src/lib/fishDataShape.js
new file mode 100644
index 0000000..0e2c85e
--- /dev/null
+++ b/app/src/lib/fishDataShape.js
@@ -0,0 +1,63 @@
+// Normalizes fish yield data into the shape the Calculator reads:
+// conversions[key] = { from, to, yield: number, range: [min, max] | null }.
+//
+// The bundled FISH_DATA_V3 keys conversions as "From → To" and omits the
+// from/to fields; the Neon-backed /api/fish-data response includes them.
+// Normalizing both lets the calculator work offline and when the API fails.
+
+const ARROW = ' → ';
+
+function toNumber(value) {
+  const n = typeof value === 'number' ? value : Number.parseFloat(value);
+  return Number.isFinite(n) ? n : null;
+}
+
+function toRange(range) {
+  if (Array.isArray(range) && range.length === 2) {
+    const min = toNumber(range[0]);
+    const max = toNumber(range[1]);
+    return min !== null && max !== null ? [min, max] : null;
+  }
+  if (typeof range === 'string') {
+    const [min, max] = range.split('-').map(toNumber);
+    return min != null && max != null ? [min, max] : null;
+  }
+  return null;
+}
+
+export function normalizeConversion(key, conv) {
+  let { from, to } = conv;
+  if ((!from || !to) && key.includes(ARROW)) {
+    const [keyFrom, ...rest] = key.split(ARROW);
+    from = from || keyFrom.trim();
+    to = to || rest.join(ARROW).trim();
+  }
+  return { ...conv, from, to, yield: toNumber(conv.yield), range: toRange(conv.range) };
+}
+
+export function withConversionStates(fishData) {
+  const out = {};
+  for (const [species, data] of Object.entries(fishData || {})) {
+    const conversions = {};
+    for (const [key, conv] of Object.entries(data?.conversions || {})) {
+      conversions[key] = normalizeConversion(key, conv || {});
+    }
+    out[species] = { ...data, conversions };
+  }
+  return out;
+}
+
+// True when at least one conversion has a usable from/to pair and yield.
+export function hasUsableConversions(fishData) {
+  return Object.values(fishData || {}).some((data) =>
+    Object.values(data?.conversions || {}).some(
+      (conv) => conv.from && conv.to && conv.yield !== null && conv.yield > 0
+    )
+  );
+}
+
+// A yield percentage is usable when it is a finite number in (0, 100].
+export function parseYieldPercent(value) {
+  const n = toNumber(value);
+  return n !== null && n > 0 && n <= 100 ? n : null;
+}
diff --git a/app/src/lib/fishDataShape.test.js b/app/src/lib/fishDataShape.test.js
new file mode 100644
index 0000000..0fd5618
--- /dev/null
+++ b/app/src/lib/fishDataShape.test.js
@@ -0,0 +1,51 @@
+import { describe, expect, it } from 'vitest';
+import { FISH_DATA_V3 } from '../data/fish_data_v3';
+import {
+  hasUsableConversions,
+  normalizeConversion,
+  parseYieldPercent,
+  withConversionStates,
+} from './fishDataShape';
+
+describe('withConversionStates', () => {
+  const data = withConversionStates(FISH_DATA_V3);
+
+  it('gives every bundled conversion a from and to state', () => {
+    const conversions = Object.values(data).flatMap((sp) => Object.values(sp.conversions));
+    expect(conversions.length).toBeGreaterThan(600);
+    expect(conversions.every((c) => c.from && c.to)).toBe(true);
+    expect(hasUsableConversions(data)).toBe(true);
+  });
+
+  it('lets the calculator offer Round → Skinless Fillet for Pink Salmon', () => {
+    const conversions = Object.values(data['Pink Salmon'].conversions);
+    const fromStates = new Set(conversions.map((c) => c.from));
+    expect(fromStates.has('Round')).toBe(true);
+    const fillet = conversions.find((c) => c.from === 'Round' && c.to === 'Skinless Fillet');
+    expect(fillet).toMatchObject({ yield: 42, range: [41, 46] });
+  });
+
+  it('keeps API-shaped conversions and coerces numeric fields', () => {
+    const conv = normalizeConversion('whatever', { from: 'Round', to: 'Fillet', yield: '45.5', range: '40-50' });
+    expect(conv).toMatchObject({ from: 'Round', to: 'Fillet', yield: 45.5, range: [40, 50] });
+  });
+
+  it('treats data without usable conversions as unusable', () => {
+    expect(hasUsableConversions({})).toBe(false);
+    expect(hasUsableConversions({ Cod: { conversions: { Fillet: { yield: 40 } } } })).toBe(false);
+  });
+});
+
+describe('parseYieldPercent', () => {
+  it('accepts yields in (0, 100]', () => {
+    expect(parseYieldPercent('42')).toBe(42);
+    expect(parseYieldPercent(100)).toBe(100);
+  });
+
+  it('rejects zero, negative, over-100 and blank yields', () => {
+    expect(parseYieldPercent('0')).toBeNull();
+    expect(parseYieldPercent('-42')).toBeNull();
+    expect(parseYieldPercent('420')).toBeNull();
+    expect(parseYieldPercent('')).toBeNull();
+  });
+});
diff --git a/server/importRows.js b/server/importRows.js
index f09fdcd..f0f3946 100644
--- a/server/importRows.js
+++ b/server/importRows.js
@@ -65,7 +65,19 @@ function parseYieldPercent(value) {
     return Number.parseFloat(text);
 }
 
-function rowsFromWorksheet(worksheet) {
+// Mirrors api/_lib/importRows.js: XLSX keeps numeric cells as numbers so a
+// "42%" cell (stored as 0.42) can be scaled; CSV cells stay strings.
+function cellValue(value, keepNumbers) {
+    if (keepNumbers) {
+        if (typeof value === 'number' && Number.isFinite(value)) return value;
+        if (value && typeof value === 'object' && typeof value.result === 'number' && Number.isFinite(value.result)) {
+            return value.result;
+        }
+    }
+    return normalizeCell(value);
+}
+
+function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
     const rows = [];
     const headerRow = worksheet.getRow(1);
     const headers = [];
@@ -81,9 +93,9 @@ function rowsFromWorksheet(worksheet) {
         const item = {};
         headers.forEach((header, colNumber) => {
             if (!header) return;
-            item[header] = normalizeCell(row.getCell(colNumber).value);
+            item[header] = cellValue(row.getCell(colNumber).value, keepNumbers);
         });
-        if (Object.values(item).some(Boolean)) rows.push(item);
+        if (Object.values(item).some((v) => v !== '' && v !== null && v !== undefined)) rows.push(item);
     });
 
     return rows;
@@ -102,7 +114,7 @@ async function parseImportRows(buffer, extension) {
         await workbook.xlsx.load(buffer);
         const worksheet = workbook.worksheets[0];
         if (!worksheet) return [];
-        return rowsFromWorksheet(worksheet);
+        return rowsFromWorksheet(worksheet, { keepNumbers: true });
     }
 
     throw new Error('Unsupported file type. Please upload a .csv or .xlsx file.');
@@ -129,7 +141,8 @@ function normalizeYieldRows(data, sourceName) {
             return;
         }
 
-        if (finalYield > 0 && finalYield <= 1) {
+        // Only numeric (XLSX) fractions are percentages; CSV "0.5" means 0.5%.
+        if (typeof yieldRaw === 'number' && finalYield > 0 && finalYield <= 1) {
             finalYield *= 100;
         }
 

From a5d3c6f3efa782a673badd65246f9ec68e249c02 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Mon, 28 Sep 2026 19:45:40 +0000
Subject: [PATCH 2/3] fix: close publish preview when auth token refresh fails

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PnPh61Aps5neY87hh1pu9T
---
 app/src/context/DataContext.jsx | 11 ++++++++++-
 1 file changed, 10 insertions(+), 1 deletion(-)

diff --git a/app/src/context/DataContext.jsx b/app/src/context/DataContext.jsx
index 0010ffb..bab52ef 100644
--- a/app/src/context/DataContext.jsx
+++ b/app/src/context/DataContext.jsx
@@ -394,7 +394,16 @@ export function DataProvider({ children }) {
     if (!publishPreviewCalc?.serverId) return;
     setPublishLoading(true);
     try {
-      const authHeaders = await getAuthHeaders();
+      let authHeaders;
+      try {
+        authHeaders = await getAuthHeaders();
+      } catch {
+        // Token refresh failed: the session is ending, so close this
+        // account-scoped preview rather than leave it open.
+        setPublishError(null);
+        setPublishPreviewCalc(null);
+        return;
+      }
       let succeeded = false;
       let transientFailure = false;
       try {

From bdc940156c7d020053c3bf730b9c649264498522 Mon Sep 17 00:00:00 2001
From: Claude <noreply@anthropic.com>
Date: Tue, 29 Sep 2026 04:35:04 +0000
Subject: [PATCH 3/3] fix: scale only percent-formatted XLSX yield cells

A plain numeric 0.5 in an XLSX, including the app's own export, is 0.5%,
not 50%. Keep a cell as a number (for fraction scaling) only when its
number format contains '%'. Same change in the local server parser.

Co-Authored-By: Claude Opus 5.5 <noreply@anthropic.com>
Claude-Session: https://claude.ai/code/session_01PnPh61Aps5neY87hh1pu9T
---
 api/_lib/importRows.js                   | 19 ++++++++++---------
 app/src/lib/__tests__/importRows.test.js | 15 +++++++++++++++
 server/importRows.js                     | 15 ++++++++-------
 3 files changed, 33 insertions(+), 16 deletions(-)

diff --git a/api/_lib/importRows.js b/api/_lib/importRows.js
index 509aaa0..1f14294 100644
--- a/api/_lib/importRows.js
+++ b/api/_lib/importRows.js
@@ -65,12 +65,13 @@ function parseYieldPercent(value) {
   return Number.parseFloat(text);
 }
 
-// XLSX keeps numeric cells as numbers so normalizeYieldRows can recognize
-// percentage cells stored as fractions (a "42%" cell is stored as 0.42).
-// CSV cells stay strings: ExcelJS parses CSV numbers too, but "0.5" in a CSV
-// means 0.5%, not 50%.
-function cellValue(value, keepNumbers) {
-  if (keepNumbers) {
+// Only XLSX cells formatted as a percentage stay numbers, so normalizeYieldRows
+// can scale them (a "42%" cell is stored as 0.42). Every other cell becomes a
+// string: a plain 0.5 in an XLSX (including the app's own export) or "0.5" in
+// a CSV means 0.5%, not 50%.
+function cellValue(cell, keepPercentCells) {
+  const { value } = cell;
+  if (keepPercentCells && String(cell.numFmt ?? '').includes('%')) {
     if (typeof value === 'number' && Number.isFinite(value)) return value;
     if (value && typeof value === 'object' && typeof value.result === 'number' && Number.isFinite(value.result)) {
       return value.result;
@@ -79,7 +80,7 @@ function cellValue(value, keepNumbers) {
   return normalizeCell(value);
 }
 
-function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
+function rowsFromWorksheet(worksheet, { keepPercentCells = false } = {}) {
   const rows = [];
   const headerRow = worksheet.getRow(1);
   const headers = [];
@@ -97,7 +98,7 @@ function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
     const item = {};
     headers.forEach((header, colNumber) => {
       if (!header) return;
-      item[header] = cellValue(row.getCell(colNumber).value, keepNumbers);
+      item[header] = cellValue(row.getCell(colNumber), keepPercentCells);
     });
     if (Object.values(item).some((v) => v !== '' && v !== null && v !== undefined)) rows.push(item);
   });
@@ -118,7 +119,7 @@ export async function parseImportRows(buffer, extension) {
     await workbook.xlsx.load(buffer);
     const worksheet = workbook.worksheets[0];
     if (!worksheet) return [];
-    return rowsFromWorksheet(worksheet, { keepNumbers: true });
+    return rowsFromWorksheet(worksheet, { keepPercentCells: true });
   }
 
   throw new Error('Unsupported file type. Please upload a .csv or .xlsx file.');
diff --git a/app/src/lib/__tests__/importRows.test.js b/app/src/lib/__tests__/importRows.test.js
index 004b15e..91c4b2b 100644
--- a/app/src/lib/__tests__/importRows.test.js
+++ b/app/src/lib/__tests__/importRows.test.js
@@ -84,6 +84,21 @@ describe('parseImportRows — real files end to end', () => {
     expect(rows[0].yield).toBe(42);
   });
 
+  it('keeps a plain (not percent-formatted) Excel 0.5 as 0.5%, as the app exports it', async () => {
+    const ExcelJS = (await import('exceljs')).default;
+    const workbook = new ExcelJS.Workbook();
+    const sheet = workbook.addWorksheet('Yields');
+    sheet.addRow(['Species', '% Yield', 'Product', 'Source']);
+    sheet.addRow(['Anchovy', 0.5, 'Fillet', 'Test']);
+    sheet.addRow(['Pink Salmon', 42, 'Fillet', 'Test']);
+    const buffer = Buffer.from(await workbook.xlsx.writeBuffer());
+
+    const parsed = await parseImportRows(buffer, '.xlsx');
+    const { rows } = normalizeYieldRows(parsed, 'test.xlsx');
+
+    expect(rows.map((r) => r.yield)).toEqual([0.5, 42]);
+  });
+
   it('keeps a CSV "0.5" yield as 0.5%, not 50%', async () => {
     const csv = 'Species,% Yield,Product,Source\nAnchovy,0.5,Fillet,Test\nPink Salmon,42%,Fillet,Test\n';
     const parsed = await parseImportRows(Buffer.from(csv), '.csv');
diff --git a/server/importRows.js b/server/importRows.js
index f0f3946..84129a6 100644
--- a/server/importRows.js
+++ b/server/importRows.js
@@ -65,10 +65,11 @@ function parseYieldPercent(value) {
     return Number.parseFloat(text);
 }
 
-// Mirrors api/_lib/importRows.js: XLSX keeps numeric cells as numbers so a
-// "42%" cell (stored as 0.42) can be scaled; CSV cells stay strings.
-function cellValue(value, keepNumbers) {
-    if (keepNumbers) {
+// Mirrors api/_lib/importRows.js: only percent-formatted XLSX cells stay
+// numbers, so a "42%" cell (stored as 0.42) is scaled but a plain 0.5 is not.
+function cellValue(cell, keepPercentCells) {
+    const { value } = cell;
+    if (keepPercentCells && String(cell.numFmt ?? '').includes('%')) {
         if (typeof value === 'number' && Number.isFinite(value)) return value;
         if (value && typeof value === 'object' && typeof value.result === 'number' && Number.isFinite(value.result)) {
             return value.result;
@@ -77,7 +78,7 @@ function cellValue(value, keepNumbers) {
     return normalizeCell(value);
 }
 
-function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
+function rowsFromWorksheet(worksheet, { keepPercentCells = false } = {}) {
     const rows = [];
     const headerRow = worksheet.getRow(1);
     const headers = [];
@@ -93,7 +94,7 @@ function rowsFromWorksheet(worksheet, { keepNumbers = false } = {}) {
         const item = {};
         headers.forEach((header, colNumber) => {
             if (!header) return;
-            item[header] = cellValue(row.getCell(colNumber).value, keepNumbers);
+            item[header] = cellValue(row.getCell(colNumber), keepPercentCells);
         });
         if (Object.values(item).some((v) => v !== '' && v !== null && v !== undefined)) rows.push(item);
     });
@@ -114,7 +115,7 @@ async function parseImportRows(buffer, extension) {
         await workbook.xlsx.load(buffer);
         const worksheet = workbook.worksheets[0];
         if (!worksheet) return [];
-        return rowsFromWorksheet(worksheet, { keepNumbers: true });
+        return rowsFromWorksheet(worksheet, { keepPercentCells: true });
     }
 
     throw new Error('Unsupported file type. Please upload a .csv or .xlsx file.');