diff --git a/CHANGELOG.md b/CHANGELOG.md
index 3bc13e6c5..289543a14 100644
--- a/CHANGELOG.md
+++ b/CHANGELOG.md
@@ -62,6 +62,14 @@
   on the phone to an account pending deletion now carries the date the
   account is erased, as the web sign-in already did, so the app can say
   until when an admin can still undo it. (#1341)
+- **A marker started from a text result keeps its range.** When a report
+  printed a text result such as "SEE NOTE" with a numeric range beside it,
+  the new marker was saved without that range, so its first number later
+  had nothing to be judged against. The range now goes onto the new marker,
+  from a document, a lab scan, a CSV import or a typed reading, and the
+  scan review shows it for such a row. A range that is text itself, like
+  "NEGATIVE", is not turned into bounds, and a marker that already exists
+  keeps its own. (#1313)
 
 ### Changed
 
diff --git a/src/__tests__/baselines/source-function-lines.json b/src/__tests__/baselines/source-function-lines.json
index 453a901c5..8490f21f6 100644
--- a/src/__tests__/baselines/source-function-lines.json
+++ b/src/__tests__/baselines/source-function-lines.json
@@ -1,7 +1,7 @@
 {
   "$comment": "Production functions over 200 lines, keyed \"file :: name\", and their length. Maintained by src/__tests__/source-size-ratchet.test.ts.",
   "count": 345,
-  "total": 111902,
+  "total": 111889,
   "entries": {
     "app/achievements/page.tsx :: AchievementsPage": 206,
     "app/api/admin/backups/upload/route.ts :: apiHandler(arg)": 275,
@@ -24,7 +24,7 @@
     "app/api/integrations/status/route.ts :: apiHandler(arg)": 476,
     "app/api/labs/[id]/route.ts :: apiHandler(arg) #2": 239,
     "app/api/labs/ocr/commit/route.ts :: commitOcrRows": 280,
-    "app/api/labs/route.ts :: postLabResult": 242,
+    "app/api/labs/route.ts :: postLabResult": 241,
     "app/api/mcp/oauth/token/route.ts :: POST": 250,
     "app/api/mcp/oauth/token/route.ts :: POST > withBackgroundEvent(arg)": 248,
     "app/api/measurement-reminders/[id]/route.ts :: apiHandler(arg) #2": 239,
@@ -139,7 +139,7 @@
     "components/labs/lab-history-list.tsx :: LabHistoryList": 534,
     "components/labs/lab-list.tsx :: LabList": 308,
     "components/labs/ocr-review-dialog.tsx :: OcrReviewDialog": 359,
-    "components/labs/ocr-row-editor.tsx :: OcrRowEditor": 386,
+    "components/labs/ocr-row-editor.tsx :: OcrRowEditor": 378,
     "components/layout/auth-shell.tsx :: AuthShell": 518,
     "components/layout/bottom-nav.tsx :: BottomNav": 262,
     "components/layout/capture-picker.tsx :: CapturePicker": 235,
@@ -286,8 +286,8 @@
     "lib/google-health/data-points.ts :: forEachDataPointPage > walk": 223,
     "lib/google-health/sync-core.ts :: upsertGoogleHealthMeasurements": 452,
     "lib/illness/correlation.ts :: computeIllnessCorrelation": 233,
-    "lib/import/labs-csv.ts :: importLabsCsv": 309,
-    "lib/import/labs-csv.ts :: importLabsCsv > flush": 231,
+    "lib/import/labs-csv.ts :: importLabsCsv": 307,
+    "lib/import/labs-csv.ts :: importLabsCsv > flush": 229,
     "lib/insights/comprehensive-aggregator.ts :: buildFromRollups": 217,
     "lib/insights/comprehensive-generate.ts :: generateComprehensiveInsight": 876,
     "lib/insights/features.ts :: extractFeatures": 796,
diff --git a/src/app/api/labs/ocr/commit/route.ts b/src/app/api/labs/ocr/commit/route.ts
index e3a2bce86..7a2891dab 100644
--- a/src/app/api/labs/ocr/commit/route.ts
+++ b/src/app/api/labs/ocr/commit/route.ts
@@ -249,10 +249,10 @@ async function commitOcrRows(request: NextRequest) {
           user.id,
           {
             analyte: row.analyte,
-            // A qualitative reading has no numeric unit / range.
+            // A text result has no unit; its printed window still seeds.
             unit: isQualitative ? (row.unit ?? "") : (row.unit as string),
-            referenceLow: isQualitative ? null : sourceLow,
-            referenceHigh: isQualitative ? null : sourceHigh,
+            referenceLow: sourceLow,
+            referenceHigh: sourceHigh,
             panel: row.panel ?? null,
           },
           { index: markerIndex },
diff --git a/src/app/api/labs/route.ts b/src/app/api/labs/route.ts
index 32fb3924e..2010c4281 100644
--- a/src/app/api/labs/route.ts
+++ b/src/app/api/labs/route.ts
@@ -234,12 +234,11 @@ async function postLabResult(request: NextRequest) {
   } else {
     biomarker = await resolveOrMintBiomarker(user.id, {
       analyte: analyte as string,
-      // A qualitative reading has no numeric unit / range — mint the catalog
-      // marker with an empty unit label and no bounds. A numeric reading
-      // supplies its unit (Zod requires it on the free-text numeric path).
+      // A qualitative reading mints with an empty unit but the printed range;
+      // a numeric one supplies its unit (Zod requires it on this path).
       unit: isQualitative ? (unit ?? "") : (unit as string),
-      referenceLow: isQualitative ? null : (referenceLow ?? null),
-      referenceHigh: isQualitative ? null : (referenceHigh ?? null),
+      referenceLow: referenceLow ?? null,
+      referenceHigh: referenceHigh ?? null,
       panel: panel ?? null,
     });
   }
diff --git a/src/components/labs/__tests__/ocr-review-validation.test.ts b/src/components/labs/__tests__/ocr-review-validation.test.ts
index 0919b24e3..65b9f4e6f 100644
--- a/src/components/labs/__tests__/ocr-review-validation.test.ts
+++ b/src/components/labs/__tests__/ocr-review-validation.test.ts
@@ -115,6 +115,27 @@ describe("toCommitRow agrees with validateReviewRow", () => {
   it("anchors the date at noon UTC", () => {
     expect(toCommitRow(row())?.takenAt).toBe("2026-06-10T12:00:00.000Z");
   });
+
+  it("sends the range printed beside a text result", () => {
+    expect(
+      toCommitRow(
+        row({
+          value: null,
+          valueText: "SEE NOTE",
+          unit: null,
+          referenceLow: 10,
+          referenceHigh: 20,
+          referenceText: "10 - 20",
+          biomarkerMatch: "new",
+        }),
+      ),
+    ).toMatchObject({
+      valueText: "SEE NOTE",
+      referenceLow: 10,
+      referenceHigh: 20,
+      referenceText: "10 - 20",
+    });
+  });
 });
 
 describe("collectRowErrors", () => {
diff --git a/src/components/labs/__tests__/ocr-row-editor.test.tsx b/src/components/labs/__tests__/ocr-row-editor.test.tsx
index 4c9544922..87d7b1260 100644
--- a/src/components/labs/__tests__/ocr-row-editor.test.tsx
+++ b/src/components/labs/__tests__/ocr-row-editor.test.tsx
@@ -125,6 +125,44 @@ describe("<OcrRowEditor> layout", () => {
   });
 });
 
+describe("<OcrRowEditor> range beside a text result", () => {
+  const text: OcrReviewRow = {
+    ...baseRow,
+    value: null,
+    valueText: "SEE NOTE",
+    unit: null,
+    referenceLow: 10,
+    referenceHigh: 20,
+    referenceText: "10 - 20",
+  };
+
+  it("offers the range for review when the row mints a new marker", () => {
+    const html = render(undefined, "en", { ...text, biomarkerMatch: "new" });
+    for (const id of ["-lo", "-hi", "-refText"]) {
+      expect(html, `field ${id}`).toContain(`${id}"`);
+    }
+    expect(html).toContain("Reference range taken from the scan");
+  });
+
+  it("does not ask to verify a range a new text marker never had", () => {
+    const html = render(undefined, "en", {
+      ...text,
+      biomarkerMatch: "new",
+      referenceLow: null,
+      referenceHigh: null,
+      referenceText: null,
+    });
+    expect(html).not.toContain("Verify the reference range");
+  });
+
+  it("leaves it out when the row goes to an existing marker", () => {
+    const html = render(undefined, "en", text);
+    for (const id of ["-lo", "-hi", "-refText"]) {
+      expect(html, `field ${id}`).not.toContain(`${id}"`);
+    }
+  });
+});
+
 describe("<OcrRowEditor> unit differs from the marker's", () => {
   const mismatched: OcrReviewRow = {
     ...baseRow,
diff --git a/src/components/labs/ocr-review-validation.ts b/src/components/labs/ocr-review-validation.ts
index 3d5eaa00a..3d7d5e1c7 100644
--- a/src/components/labs/ocr-review-validation.ts
+++ b/src/components/labs/ocr-review-validation.ts
@@ -157,6 +157,9 @@ export function toCommitRow(row: OcrReviewRow): OcrCommitRowInput | null {
       analyte,
       valueText,
       takenAt: takenAt.toISOString(),
+      // A text result has no window of its own, but a new marker minted from
+      // it takes the one printed beside it.
+      ...printedRange(row),
       ...chosen(row),
     };
   }
@@ -170,10 +173,19 @@ export function toCommitRow(row: OcrReviewRow): OcrCommitRowInput | null {
     value: row.value,
     unit,
     takenAt: takenAt.toISOString(),
+    ...printedRange(row),
+    ...chosen(row),
+  };
+}
+
+/** The reviewed window: the two bounds and the string they were read from. */
+function printedRange(
+  row: OcrReviewRow,
+): Pick<OcrCommitRowInput, "referenceLow" | "referenceHigh" | "referenceText"> {
+  return {
     ...(row.referenceLow !== null ? { referenceLow: row.referenceLow } : {}),
     ...(row.referenceHigh !== null ? { referenceHigh: row.referenceHigh } : {}),
     ...(row.referenceText ? { referenceText: row.referenceText } : {}),
-    ...chosen(row),
   };
 }
 
diff --git a/src/components/labs/ocr-row-editor.tsx b/src/components/labs/ocr-row-editor.tsx
index 942d93d90..8a50bb3af 100644
--- a/src/components/labs/ocr-row-editor.tsx
+++ b/src/components/labs/ocr-row-editor.tsx
@@ -75,6 +75,33 @@ function unitMismatchMessage(
     : ["labs.ocr.errorUnitMismatch", { markerUnit: row.markerUnit ?? "" }];
 }
 
+/**
+ * v1.18.10 (#5) — a NEW biomarker mints its catalog reference range from THIS
+ * extracted row, so the range is load-bearing and worth a second look. Surface
+ * the range confidence for a new numeric marker, and call it out when the
+ * model was unsure (or set no bounds at all) so the user verifies the range it
+ * will be judged against. A text result ("SEE NOTE") records no window of its
+ * own, but a new marker minted from it takes the one printed beside it, so the
+ * range is shown there too, and only called out when there is one: a text
+ * result often has no numeric range, and that is not a gap.
+ */
+function rangeReview(row: OcrReviewRow): {
+  showRange: boolean;
+  showRangeBadge: boolean;
+  flagRange: boolean;
+} {
+  const isQualitative = row.valueText !== null && row.valueText !== undefined;
+  const isNew = row.biomarkerMatch === "new";
+  const lowRangeConfidence = row.confidence.range < CONFIDENCE_THRESHOLD;
+  const hasBounds = row.referenceLow !== null || row.referenceHigh !== null;
+  const showRangeBadge = isNew && (!isQualitative || hasBounds);
+  return {
+    showRange: !isQualitative || isNew,
+    showRangeBadge,
+    flagRange: showRangeBadge && (lowRangeConfidence || !hasBounds),
+  };
+}
+
 export function OcrRowEditor({
   row,
   onChange,
@@ -138,15 +165,7 @@ export function OcrRowEditor({
       ? row.confidence.value < CONFIDENCE_THRESHOLD
       : lowValueConfidence);
 
-  // v1.18.10 (#5) — a NEW numeric biomarker mints its catalog reference range
-  // from THIS extracted row. The range is therefore load-bearing and worth a
-  // second look. Surface the range confidence prominently for new numeric
-  // markers, and call it out explicitly when the model was unsure (or set no
-  // bounds at all) so the user verifies the range it will be judged against.
-  const isNewNumericMarker = !isQualitative && row.biomarkerMatch === "new";
-  const lowRangeConfidence = row.confidence.range < CONFIDENCE_THRESHOLD;
-  const hasBounds = row.referenceLow !== null || row.referenceHigh !== null;
-  const flagRange = isNewNumericMarker && (lowRangeConfidence || !hasBounds);
+  const { showRange, showRangeBadge, flagRange } = rangeReview(row);
 
   return (
     // `@container` makes the row follow the width of the dialog, not the
@@ -353,11 +372,11 @@ export function OcrRowEditor({
             </div>
           </div>
 
-          {/* v1.18.10 (#5) — for a NEW numeric biomarker the reference range below
+          {/* v1.18.10 (#5) — for a NEW biomarker the reference range below
           becomes the marker's catalog range. Make that consequence visible, and
           flag low range-confidence / a missing range so the user verifies it
           before saving. A calm `secondary` badge, not an alarm. */}
-          {isNewNumericMarker ? (
+          {showRangeBadge ? (
             <div className="flex flex-wrap items-center gap-1.5">
               <Badge variant={flagRange ? "secondary" : "outline"}>
                 <Ruler aria-hidden />
@@ -368,7 +387,7 @@ export function OcrRowEditor({
             </div>
           ) : null}
 
-          {!isQualitative ? (
+          {showRange ? (
             <div className="grid grid-cols-2 gap-2">
               <div className="space-y-1">
                 <Label htmlFor={`${fieldId}-lo`} className="text-xs">
@@ -424,7 +443,7 @@ export function OcrRowEditor({
           reading of this string, and correcting the string is how a range the
           parser could not read ("bis 5,0", "negativ") still reaches the row
           instead of being dropped. */}
-          {!isQualitative ? (
+          {showRange ? (
             <div className="space-y-1">
               <Label htmlFor={`${fieldId}-refText`} className="text-xs">
                 {t("labs.ocr.refTextLabel")}
diff --git a/src/lib/documents/commit.ts b/src/lib/documents/commit.ts
index 97633752b..2332554a2 100644
--- a/src/lib/documents/commit.ts
+++ b/src/lib/documents/commit.ts
@@ -197,8 +197,10 @@ async function commitObservation(
     biomarker = await resolveOrMintBiomarker(userId, {
       analyte: data.label,
       unit: isQualitative ? (data.unit ?? "") : (data.unit as string),
-      referenceLow: isQualitative ? null : sourceLow,
-      referenceHigh: isQualitative ? null : sourceHigh,
+      // A text result mints with the window printed beside it as well: the
+      // marker's next number is judged against it.
+      referenceLow: sourceLow,
+      referenceHigh: sourceHigh,
       panel: null,
     });
   }
diff --git a/src/lib/import/__tests__/record-import-rows.test.ts b/src/lib/import/__tests__/record-import-rows.test.ts
index 606edce3b..be25ceb3e 100644
--- a/src/lib/import/__tests__/record-import-rows.test.ts
+++ b/src/lib/import/__tests__/record-import-rows.test.ts
@@ -106,6 +106,26 @@ describe("lab rows", () => {
     });
   });
 
+  it("keeps the numeric range beside a text result, and no text range", () => {
+    expect(
+      lab(["BUN/Creatinine ratio", "SEE NOTE", "", "2025-03-01", "10 - 20"]),
+    ).toMatchObject({
+      ok: true,
+      row: {
+        valueText: "SEE NOTE",
+        sourceReferenceLow: 10,
+        sourceReferenceHigh: 20,
+        sourceReferenceText: null,
+      },
+    });
+    expect(
+      lab(["Urine nitrite", "neg", "", "2025-03-01", "NEGATIVE"]),
+    ).toMatchObject({
+      ok: true,
+      row: { sourceReferenceLow: null, sourceReferenceHigh: null },
+    });
+  });
+
   it.each([
     [["", "5", "%", "2025-03-01", ""], "missing_value", "analyte"],
     [["HbA1c", "", "%", "2025-03-01", ""], "missing_value", "value"],
diff --git a/src/lib/import/labs-csv.ts b/src/lib/import/labs-csv.ts
index 92ec2e998..0a0bcecff 100644
--- a/src/lib/import/labs-csv.ts
+++ b/src/lib/import/labs-csv.ts
@@ -74,6 +74,8 @@ export interface LabCsvRow {
   valueText: string | null;
   unit: string | null;
   takenAt: Date;
+  /** The file's window. On a text result it only seeds a new marker: the
+   * reading itself records no window. */
   sourceReferenceLow: number | null;
   sourceReferenceHigh: number | null;
   sourceReferenceText: string | null;
@@ -200,8 +202,8 @@ export function normaliseLabRow(
       valueText,
       unit,
       takenAt: date.instant,
-      sourceReferenceLow: valueText === null ? low : null,
-      sourceReferenceHigh: valueText === null ? high : null,
+      sourceReferenceLow: low,
+      sourceReferenceHigh: high,
       sourceReferenceText: valueText === null ? rangeText : null,
       panel,
       note,
@@ -473,10 +475,8 @@ export async function importLabsCsv(args: {
           {
             analyte: row.analyte,
             unit: row.unit ?? "",
-            referenceLow:
-              row.valueText === null ? row.sourceReferenceLow : null,
-            referenceHigh:
-              row.valueText === null ? row.sourceReferenceHigh : null,
+            referenceLow: row.sourceReferenceLow,
+            referenceHigh: row.sourceReferenceHigh,
             panel: row.panel,
           },
           { index: working },
@@ -484,8 +484,8 @@ export async function importLabsCsv(args: {
       if (!marker) created.add(row.analyte);
 
       let storedValue = row.value;
-      let storedLow = row.sourceReferenceLow;
-      let storedHigh = row.sourceReferenceHigh;
+      let storedLow = row.valueText === null ? row.sourceReferenceLow : null;
+      let storedHigh = row.valueText === null ? row.sourceReferenceHigh : null;
       let convertedFrom: { sourceValue: number; sourceUnit: string } | null =
         null;
       if (row.value !== null) {
diff --git a/src/lib/labs/biomarker-store.ts b/src/lib/labs/biomarker-store.ts
index fb1db574b..560f628c5 100644
--- a/src/lib/labs/biomarker-store.ts
+++ b/src/lib/labs/biomarker-store.ts
@@ -86,6 +86,10 @@ export interface MintedBiomarker {
  * reused as-is: its unit / range are authoritative and the incoming free-text
  * unit / bounds are NOT allowed to silently rewrite it. When nothing resolves,
  * a marker is minted from the reading's own spelling / unit / bounds. The
+ * bounds are the report's printed window whether the reading is a number or a
+ * text result ("SEE NOTE" beside "10 - 20"): the marker outlives the reading,
+ * and its next number is judged against them. A window that cannot be true
+ * (low above high) is not minted; nothing says which of the two is wrong. The
  * `@@unique([userId, name])` index is the structural backstop; a concurrent
  * double-write converges via the catch-and-refetch.
  *
@@ -109,14 +113,18 @@ export async function resolveOrMintBiomarker(
   const hit = resolveInIndex(index, name, input.unit || null);
   if (hit) return toMinted(hit.marker);
 
+  const transposed =
+    input.referenceLow !== null &&
+    input.referenceHigh !== null &&
+    input.referenceLow > input.referenceHigh;
   try {
     const created = await prisma.biomarker.create({
       data: {
         userId,
         name,
         unit: input.unit,
-        lowerBound: input.referenceLow,
-        upperBound: input.referenceHigh,
+        lowerBound: transposed ? null : input.referenceLow,
+        upperBound: transposed ? null : input.referenceHigh,
         panel: input.panel,
         analyteKey: matchAnalyteKey({ name, unit: input.unit }),
       },
diff --git a/tests/integration/lab-text-marker-keeps-range.test.ts b/tests/integration/lab-text-marker-keeps-range.test.ts
new file mode 100644
index 000000000..123159d18
--- /dev/null
+++ b/tests/integration/lab-text-marker-keeps-range.test.ts
@@ -0,0 +1,354 @@
+/**
+ * A marker minted from a text result keeps the range the report printed.
+ *
+ * A report that prints "SEE NOTE" for a ratio, with "10 - 20" in the range
+ * column beside it, minted a marker with no bounds: every import path read the
+ * range only for a numeric reading. The next report's number then had nothing
+ * to be judged against. A numeric range now seeds the new marker the way a
+ * numeric first reading does; a range that is text itself ("NEGATIVE") is not
+ * a bound and stays out, and a marker that already exists keeps its own.
+ *
+ * Every path that mints markers from an import, against Postgres: a document's
+ * confirmed facts, the lab scan commit, a free-text reading through
+ * `POST /api/labs` (the on-device scan posts there), and the CSV import.
+ */
+import { NextRequest } from "next/server";
+import { beforeEach, describe, expect, it, vi } from "vitest";
+
+import { cookieJar } from "./mock-next-headers";
+import { getPrismaClient, truncateAllTables } from "./setup";
+import { textToStream } from "@/lib/import/csv-stream";
+import { importLabsCsv } from "@/lib/import/labs-csv";
+import { labsCsvQuerySchema } from "@/lib/validations/record-import";
+
+vi.mock("@/lib/jobs/boss-instance", () => ({
+  getGlobalBoss: vi.fn(() => null),
+}));
+
+vi.mock("next/headers", async () => {
+  const { cookieJar, headerJar } = await import("./mock-next-headers");
+  return {
+    headers: vi.fn(async () => ({
+      get: (name: string) => headerJar.get(name.toLowerCase()) ?? null,
+    })),
+    cookies: vi.fn(async () => ({
+      get: (name: string) => {
+        const value = cookieJar.get(name);
+        return value ? { name, value } : undefined;
+      },
+      set: (name: string, value: string) => cookieJar.set(name, value),
+      delete: (name: string) => cookieJar.delete(name),
+    })),
+  };
+});
+
+const prisma = getPrismaClient();
+const USER = "text-marker-range-user";
+const TAKEN_AT = "2026-09-01T12:00:00.000Z";
+
+beforeEach(async () => {
+  await truncateAllTables(prisma);
+  await prisma.user.create({
+    data: {
+      id: USER,
+      username: USER,
+      timezone: "UTC",
+      modulePreferencesJson: { inboundDocuments: true, labs: true },
+    },
+  });
+  const s = await prisma.session.create({
+    data: { userId: USER, expiresAt: new Date(Date.now() + 3_600_000) },
+  });
+  cookieJar.clear();
+  cookieJar.set("healthlog_session", s.id);
+});
+
+function jsonReq(path: string, body: unknown): NextRequest {
+  return new NextRequest(`http://localhost${path}`, {
+    method: "POST",
+    headers: { "content-type": "application/json" },
+    body: JSON.stringify(body),
+  });
+}
+
+async function bounds(name: string) {
+  const marker = await prisma.biomarker.findFirstOrThrow({
+    where: { userId: USER, name },
+  });
+  return { low: marker.lowerBound, high: marker.upperBound, id: marker.id };
+}
+
+async function seedMarker(name: string) {
+  return prisma.biomarker.create({
+    data: { userId: USER, name, unit: "", lowerBound: 1, upperBound: 2 },
+  });
+}
+
+// --- document facts ---------------------------------------------------------
+
+async function confirmTextFact(
+  label: string,
+  referenceText: string,
+  referenceLow: number | null,
+  referenceHigh: number | null,
+) {
+  const { encryptFactData, encryptFactProvenance } =
+    await import("@/lib/documents/store");
+  const doc = await prisma.inboundDocument.create({
+    data: {
+      userId: USER,
+      filename: "report.pdf",
+      mimeType: "application/pdf",
+      byteSize: 1024,
+      contentEncrypted: Buffer.from("stand-in for the stored bytes"),
+      status: "EXTRACTED",
+      reportDate: new Date(TAKEN_AT),
+    },
+  });
+  const fact = await prisma.extractedFact.create({
+    data: {
+      documentId: doc.id,
+      userId: USER,
+      factType: "OBSERVATION",
+      status: "PENDING",
+      confidence: 0.95,
+      needsReview: false,
+      dataEncrypted: encryptFactData({
+        label,
+        code: null,
+        codeSystem: null,
+        value: null,
+        valueText: "SEE NOTE",
+        unit: null,
+        referenceLow,
+        referenceHigh,
+        referenceText,
+        effectiveDate: null,
+      }),
+      provenanceEncrypted: encryptFactProvenance({
+        sourceText: `${label} SEE NOTE ${referenceText}`,
+        anchored: true,
+        sourceOffset: 0,
+        page: 0,
+        confidence: 0.95,
+      }),
+    },
+  });
+  const { POST } =
+    await import("@/app/api/documents/inbound/[id]/confirm/route");
+  const res = await POST(
+    jsonReq(`/api/documents/inbound/${doc.id}/confirm`, {
+      decisions: [{ factId: fact.id, action: "approve" }],
+    }),
+    { params: Promise.resolve({ id: doc.id }) },
+  );
+  expect(res.status).toBe(200);
+  const body = await res.json();
+  expect(body.data.failed).toEqual([]);
+}
+
+describe("a document's text result", () => {
+  it("gives a new marker the numeric range printed beside it", async () => {
+    await confirmTextFact("BUN/Creatinine ratio", "10 - 20", null, null);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 10,
+      high: 20,
+    });
+  });
+
+  it("does not turn a text range into bounds", async () => {
+    await confirmTextFact("Urine nitrite", "NEGATIVE", null, null);
+    expect(await bounds("Urine nitrite")).toMatchObject({
+      low: null,
+      high: null,
+    });
+  });
+
+  it("leaves an existing marker's range alone", async () => {
+    await seedMarker("BUN/Creatinine ratio");
+    await confirmTextFact("BUN/Creatinine ratio", "10 - 20", 10, 20);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 1,
+      high: 2,
+    });
+  });
+});
+
+// --- lab scan commit --------------------------------------------------------
+
+async function commitScanRows(rows: Record<string, unknown>[]) {
+  const { POST } = await import("@/app/api/labs/ocr/commit/route");
+  const res = await POST(
+    jsonReq("/api/labs/ocr/commit", {
+      rows: rows.map((row) => ({ takenAt: TAKEN_AT, ...row })),
+    }),
+  );
+  expect(res.status).toBe(200);
+}
+
+describe("a scanned text result", () => {
+  it("gives a new marker the confirmed bounds", async () => {
+    await commitScanRows([
+      {
+        analyte: "BUN/Creatinine ratio",
+        valueText: "SEE NOTE",
+        referenceLow: 10,
+        referenceHigh: 20,
+        referenceText: "10 - 20",
+      },
+    ]);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 10,
+      high: 20,
+    });
+  });
+
+  it("derives them from the printed range when no bounds were sent", async () => {
+    await commitScanRows([
+      {
+        analyte: "BUN/Creatinine ratio",
+        valueText: "SEE NOTE",
+        referenceText: "10 - 20",
+      },
+      { analyte: "Urine nitrite", valueText: "neg", referenceText: "NEGATIVE" },
+    ]);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 10,
+      high: 20,
+    });
+    expect(await bounds("Urine nitrite")).toMatchObject({
+      low: null,
+      high: null,
+    });
+  });
+
+  it("drops a transposed window instead of minting it", async () => {
+    await commitScanRows([
+      {
+        analyte: "BUN/Creatinine ratio",
+        valueText: "SEE NOTE",
+        referenceLow: 20,
+        referenceHigh: 10,
+      },
+    ]);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: null,
+      high: null,
+    });
+  });
+
+  it("leaves an existing marker's range alone", async () => {
+    await seedMarker("BUN/Creatinine ratio");
+    await commitScanRows([
+      {
+        analyte: "BUN/Creatinine ratio",
+        valueText: "SEE NOTE",
+        referenceLow: 10,
+        referenceHigh: 20,
+      },
+    ]);
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 1,
+      high: 2,
+    });
+  });
+});
+
+// --- POST /api/labs ---------------------------------------------------------
+
+async function postLab(body: Record<string, unknown>) {
+  const { POST } = await import("@/app/api/labs/route");
+  const res = await POST(jsonReq("/api/labs", { takenAt: TAKEN_AT, ...body }));
+  expect(res.status).toBe(201);
+  return (await res.json()).data;
+}
+
+describe("a free-text reading that is a text result", () => {
+  it("seeds the new marker, and the next number is judged against it", async () => {
+    await postLab({
+      analyte: "BUN/Creatinine ratio",
+      valueText: "SEE NOTE",
+      referenceLow: 10,
+      referenceHigh: 20,
+    });
+    const { id } = await bounds("BUN/Creatinine ratio");
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 10,
+      high: 20,
+    });
+    await postLab({
+      biomarkerId: id,
+      value: 18,
+      unit: "1",
+      takenAt: "2026-10-01T12:00:00.000Z",
+    });
+    const reading = await prisma.labResult.findFirstOrThrow({
+      where: { biomarkerId: id, value: { not: null } },
+    });
+    expect(reading).toMatchObject({ referenceLow: 10, referenceHigh: 20 });
+  });
+});
+
+// --- CSV import -------------------------------------------------------------
+
+describe("a CSV text result", () => {
+  const query = () =>
+    labsCsvQuerySchema.parse({
+      analyte: "0",
+      value: "1",
+      unit: "2",
+      date: "3",
+      referenceRange: "4",
+    });
+
+  it("gives a new marker a numeric range and leaves a text range out", async () => {
+    const result = await importLabsCsv({
+      userId: USER,
+      tz: "UTC",
+      stream: textToStream(
+        [
+          "Analyte;Value;Unit;Date;Range",
+          "BUN/Creatinine ratio;SEE NOTE;;2026-09-01;10 - 20",
+          "Urine nitrite;neg;;2026-09-01;NEGATIVE",
+        ].join("\n"),
+      ),
+      maxBytes: 1_000_000,
+      query: query(),
+    });
+    expect(result).toMatchObject({ inserted: 2 });
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 10,
+      high: 20,
+    });
+    expect(await bounds("Urine nitrite")).toMatchObject({
+      low: null,
+      high: null,
+    });
+    // The text reading itself still carries no window of its own.
+    const reading = await prisma.labResult.findFirstOrThrow({
+      where: { userId: USER, analyte: "BUN/Creatinine ratio" },
+    });
+    expect(reading).toMatchObject({
+      valueText: "SEE NOTE",
+      sourceReferenceLow: null,
+      sourceReferenceHigh: null,
+    });
+  });
+
+  it("leaves an existing marker's range alone", async () => {
+    await seedMarker("BUN/Creatinine ratio");
+    await importLabsCsv({
+      userId: USER,
+      tz: "UTC",
+      stream: textToStream(
+        "Analyte;Value;Unit;Date;Range\nBUN/Creatinine ratio;SEE NOTE;;2026-09-01;10 - 20\n",
+      ),
+      maxBytes: 1_000_000,
+      query: query(),
+    });
+    expect(await bounds("BUN/Creatinine ratio")).toMatchObject({
+      low: 1,
+      high: 2,
+    });
+  });
+});