@@ -0,0 +1,36 @@
+---
+'@object-ui/fields': patch
+---
+
+`GeolocationField` renders a `0` coordinate as the place it is, and stops leaking a literal
+`0` into the DOM (objectui#8055).
+
+Two independent defects were live in the widget's **display/read** path, and fixing either
+one alone left the other:
+
+1. **A valid location displayed as empty.** Every presence test in the widget asked the
+   parsed NUMBER whether it was falsy — `if (!loc.latitude || !loc.longitude)` — and `0` is
+   falsy. So the equator (`latitude: 0`), the prime meridian (`longitude: 0`) and a perfect
+   `accuracy: 0` all took the "no value" branch: the coordinates row showed the `EmptyValue`
+   em dash, the accuracy row vanished, and "View on map" was withheld — including its
+   `openInMaps` handler, which refused the same value a second time. The stored data was
+   intact and unreachable.
+
+2. **A literal `0` reached the DOM.** Three of those guards were JSX render expressions
+   (`{location.latitude && location.longitude && (…)}`). With `latitude === 0` such an
+   expression evaluates to `0`, and React renders the NUMBER as a text node. Measured on
+   `main`, `{ latitude: 0, longitude: 120.1551 }` rendered `"—0"`: the em dash from defect 1,
+   and a stray `0` beside it from defect 2.
+
+Both are closed by one predicate that is nullish **and** boolean-valued — nullish so `0`
+counts as present, boolean so no numeric operand can ever reach the DOM through `&&`.
+
+**The delta is exactly `0` and `-0`.** The predicate excludes `NaN` just as the old falsy
+guard did; a bare `!= null` would have started rendering `"NaN, NaN"` at a surface that has
+always shown the placeholder for an unreadable coordinate. `Infinity`, `null`, `undefined`, a
+missing half of the pair and a non-number all answer exactly as they did before.
+
+**If you depended on the old rendering**, you were depending on a zero coordinate displaying
+as no coordinate; nothing in this repo did (the sibling `LocationField` already pins the
+opposite — a stored `{ lat: 0, lng: 0 }` renders `0, 0`). A `type: 'geolocation'` record
+holding a zero now shows its coordinates, its accuracy row and its map link.
@@ -0,0 +1,212 @@
+/**
+ * ObjectUI
+ * Copyright (c) 2024-present ObjectStack Inc.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ */
+
+/**
+ * objectui#8055 — `GeolocationField`'s DISPLAY path reads a valid `0`
+ * coordinate as "no location", and leaks the literal `0` into the DOM.
+ *
+ * ## TWO defects, and this file keeps them apart
+ *
+ * The card measured one reading and correctly separated two independent
+ * defects inside it. They are pinned by DIFFERENT assertions here, because
+ * fixing either one alone leaves the other live:
+ *
+ *  1. **Falsy used as a presence test.** `if (!loc.latitude || !loc.longitude)`
+ *     asks the parsed NUMBER whether it is falsy, and `0` is falsy — so the
+ *     equator (`latitude: 0`), the prime meridian (`longitude: 0`) and a
+ *     perfect `accuracy: 0` all took the "no value" branch. Measured on `main`:
+ *     `{ latitude: 0, longitude: 120.1551 }` rendered `"—0"` where the control
+ *     `{ latitude: 30.2741, longitude: 120.1551 }` rendered
+ *     `"30.274100, 120.155100View on map"`.
+ *     ⇒ pinned by the "renders the coordinates" assertions.
+ *
+ *  2. **A numeric operand in a JSX conditional.** The same guard was also
+ *     written as `{location.latitude && location.longitude && (…)}`. With
+ *     `latitude === 0` that expression evaluates to `0`, and React renders the
+ *     NUMBER as a text node — the trailing `0` of `"—0"`.
+ *     ⇒ pinned by {@link directTextNodes}, which reads exactly the place such
+ *     an operand lands: a text node that is a DIRECT child of the container
+ *     holding the guard.
+ *
+ * ⚠️ The two are pinned separately on purpose. `directTextNodes` stays EMPTY
+ * when only defect 1 is live (a boolean guard renders nothing either way), and
+ * the coordinate string is still rendered when only defect 2 is live — so
+ * neither assertion can stand in for the other. The "View on map" assertions
+ * answer to BOTH, because that one site carried both defects; they are the
+ * user-facing consequence, not the separator.
+ *
+ * ## The two live CONTROLS this card came with
+ *
+ * `value={location.latitude ?? ''}` was ALREADY correct on `main` — it uses
+ * `??`, and the box showed `"0"`. It is pinned below as a control: it proves
+ * the probe can see this widget and read a `0` out of it, and it must not have
+ * been "fixed" into consistency with the broken guards. The non-zero render
+ * string is the second control and must be byte-identical to the card's
+ * reading.
+ */
+
+import { describe, it, expect, vi, afterEach } from 'vitest';
+import React from 'react';
+import { render, cleanup, fireEvent } from '@testing-library/react';
+import type { FieldMetadata } from '@object-ui/types';
+import { GeolocationField, type GeolocationValue } from '../widgets/GeolocationField';
+
+/** U+2014, the glyph `EmptyValue` draws — asserting on it is asserting "no value". */
+const EM_DASH = '—';
+
+const field = (name: string, type: string): FieldMetadata =>
+  ({ name, label: name, type } as unknown as FieldMetadata);
+
+const noop = () => undefined;
+
+/** The readonly composite collapses to one row; that row is the container. */
+function renderReadonly(value: GeolocationValue): HTMLElement {
+  const { container } = render(
+    <GeolocationField value={value} onChange={noop} field={field('geo', 'location')} readonly />,
+  );
+  return container.firstElementChild as HTMLElement;
+}
+
+/** The editable composite's outer container (`space-y-3`). */
+function renderEditable(value: GeolocationValue): HTMLElement {
+  const { container } = render(
+    <GeolocationField value={value} onChange={noop} field={field('geo', 'location')} />,
+  );
+  return container.firstElementChild as HTMLElement;
+}
+
+/**
+ * The non-blank text nodes that are DIRECT children of `el`.
+ *
+ * ⭐ This is defect 2's oracle, and it is written as a DOM shape rather than as
+ * a string diff on purpose: `{0 && <Button/>}` puts the number where React puts
+ * any other child — a text node parented by the element holding the guard. A
+ * text node nested deeper is somebody's legitimate content (the accuracy row
+ * really does render `"Accuracy: ±"`, `"0"`, `"m"` as three nodes), so the
+ * scan is deliberately NOT recursive.
+ */
+function directTextNodes(el: Element): string[] {
+  return Array.from(el.childNodes)
+    .filter((n) => n.nodeType === 3 /* Node.TEXT_NODE */)
+    .map((n) => n.textContent ?? '')
+    .filter((t) => t.trim() !== '');
+}
+
+afterEach(cleanup);
+
+describe('objectui#8055 defect 1 — a `0` coordinate is a PLACE, not an absence', () => {
+  it('⭐ readonly: a zero LATITUDE renders the coordinates, not the empty placeholder', () => {
+    const row = renderReadonly({ latitude: 0, longitude: 120.1551 });
+
+    // ⛔ Not `not.toContain('—')` alone: that assertion is satisfied by the
+    // stray `0` of defect 2 and would call a still-broken widget fixed. The
+    // positive half is `toFixed(6)`'s own product, which nothing but a real
+    // formatted coordinate can produce.
+    expect(row.textContent).toContain('0.000000, 120.155100');
+    expect(row.textContent).not.toContain(EM_DASH);
+  });
+
+  it('readonly: a zero LONGITUDE is the same rule, not a second one', () => {
+    const row = renderReadonly({ latitude: 30.2741, longitude: 0 });
+    expect(row.textContent).toContain('30.274100, 0.000000');
+    expect(row.textContent).not.toContain(EM_DASH);
+  });
+
+  it('readonly: `{ latitude: 0, longitude: 0 }` renders both zeros', () => {
+    const row = renderReadonly({ latitude: 0, longitude: 0 });
+    expect(row.textContent).toContain('0.000000, 0.000000');
+    expect(row.textContent).not.toContain(EM_DASH);
+  });
+
+  it('editable: an `accuracy` of 0 renders its row instead of hiding it', () => {
+    const outer = renderEditable({ latitude: 30.2741, longitude: 120.1551, accuracy: 0 });
+    expect(outer.textContent).toContain('Accuracy: ±0m');
+  });
+});
+
+describe('objectui#8055 defect 2 — no numeric operand reaches the DOM as a text node', () => {
+  it('⭐ readonly: the coordinates row has no bare text-node children', () => {
+    const row = renderReadonly({ latitude: 0, longitude: 120.1551 });
+
+    // On `main` this is `['0']` — the trailing `0` of the card's `"—0"`.
+    expect(directTextNodes(row)).toEqual([]);
+  });
+
+  it('⭐ editable: the button row has no bare text-node children', () => {
+    const outer = renderEditable({ latitude: 0, longitude: 120.1551 });
+    const buttonRow = outer.firstElementChild as HTMLElement;
+    expect(directTextNodes(buttonRow)).toEqual([]);
+  });
+
+  it('⭐ editable: the accuracy guard leaks nothing into the outer container', () => {
+    const outer = renderEditable({ latitude: 30.2741, longitude: 120.1551, accuracy: 0 });
+    expect(directTextNodes(outer)).toEqual([]);
+  });
+});
+
+describe('objectui#8055 — the affordance the two defects withheld', () => {
+  it('readonly: "View on map" is offered for a zero coordinate', () => {
+    const row = renderReadonly({ latitude: 0, longitude: 120.1551 });
+    expect(row.querySelector('button')?.textContent).toBe('View on map');
+  });
+
+  it('editable: both buttons are offered, matching the non-zero control', () => {
+    const outer = renderEditable({ latitude: 0, longitude: 120.1551 });
+    const labels = Array.from(outer.querySelectorAll('button')).map((b) => b.textContent);
+    expect(labels).toEqual(['Use Current Location', 'View on map']);
+  });
+
+  it('the map opens on the real zero coordinate — `openInMaps` refused it too', () => {
+    const opened = vi.spyOn(window, 'open').mockImplementation(() => null);
+    const row = renderReadonly({ latitude: 0, longitude: 120.1551 });
+
+    fireEvent.click(row.querySelector('button') as HTMLButtonElement);
+
+    expect(opened).toHaveBeenCalledWith('https://www.google.com/maps?q=0,120.1551', '_blank');
+    opened.mockRestore();
+  });
+});
+
+describe('objectui#8055 CONTROLS — what must NOT have moved', () => {
+  it('⭐ CONTROL: the coordinate boxes already showed `0` and still do (`?? \'\'`)', () => {
+    // The card measured this site as ALREADY CORRECT on `main`. A control that
+    // goes red with the subject is not a control: this one proves the probe
+    // reads a `0` out of this widget, and that the one guard that was right was
+    // not "fixed" into consistency with the broken ones.
+    const outer = renderEditable({ latitude: 0, longitude: 0 });
+    const boxes = Array.from(outer.querySelectorAll('input[type="number"]'));
+    expect(boxes.map((b) => (b as HTMLInputElement).value)).toEqual(['0', '0']);
+  });
+
+  it('⭐ CONTROL: the non-zero render string is byte-identical to the card`s reading', () => {
+    const row = renderReadonly({ latitude: 30.2741, longitude: 120.1551 });
+    expect(row.textContent).toBe('30.274100, 120.155100View on map');
+  });
+
+  it('CONTROL: a genuinely ABSENT coordinate still renders the empty placeholder', () => {
+    const row = renderReadonly({});
+    expect(row.textContent).toContain(EM_DASH);
+    expect(row.querySelector('button')).toBeNull();
+  });
+
+  it('CONTROL: one absent half is still no location — a half pair invents nothing', () => {
+    const row = renderReadonly({ latitude: 0 });
+    expect(row.textContent).toContain(EM_DASH);
+    expect(row.querySelector('button')).toBeNull();
+  });
+
+  it('CONTROL: `NaN` stays empty — the delta of this fix is exactly `0`', () => {
+    // The presence predicate is nullish AND NaN-excluding, deliberately: a bare
+    // `!= null` would have started rendering `"NaN, NaN"` at a surface that has
+    // always shown the placeholder for an unreadable coordinate. Every input
+    // other than `0` / `-0` answers exactly as it did before this card.
+    const row = renderReadonly({ latitude: NaN, longitude: 120.1551 });
+    expect(row.textContent).toContain(EM_DASH);
+    expect(row.querySelector('button')).toBeNull();
+  });
+});
@@ -21,6 +21,65 @@ export interface GeolocationValue {
   accuracy?: number | null;
 }
 
+/**
+ * A `GeolocationValue` whose two coordinates are both readable numbers — what
+ * {@link hasCoordinates} narrows to, so `formatLocation` can call `.toFixed`
+ * without a second null check of its own.
+ */
+type LocatedGeolocation = GeolocationValue & { latitude: number; longitude: number };
+
+/**
+ * Is this numeric slot FILLED? (objectui#8055)
+ *
+ * ⛔ Deliberately NOT `!n`. Every guard in this widget used to ask the parsed
+ * NUMBER whether it was falsy, and `0` is falsy — so `latitude: 0` (the
+ * equator), `longitude: 0` (the prime meridian) and `accuracy: 0` were all read
+ * as "no value". A record holding a real place displayed as the `EmptyValue`
+ * em dash and its "View on map" affordance was withheld from it; the data was
+ * intact and unreachable. Presence is a NULLISH question, never a falsy one.
+ *
+ * ⚠️ The delta this predicate deliberately keeps to EXACTLY `0` and `-0`:
+ * `NaN` answers `false` here just as it answered falsy before. A bare
+ * `n != null` would have been the card's wording taken literally, and it would
+ * have started rendering `"NaN, NaN"` at a surface that has always shown the
+ * empty placeholder for an unreadable coordinate — a second display defect
+ * wearing the first one's fix. `Infinity` was admitted by the old guard and is
+ * still admitted, for the same reason in the other direction: it is not this
+ * card's value. Every input other than `0` / `-0` answers exactly as it did
+ * before.
+ *
+ * ⭐ It returns a BOOLEAN, and that is the SECOND defect's fix, not a style
+ * choice — see {@link hasCoordinates}.
+ */
+const isPresentNumber = (n: number | null | undefined): n is number =>
+  typeof n === 'number' && !Number.isNaN(n);
+
+/**
+ * Does this value carry a coordinate PAIR? Both halves, both readable.
+ *
+ * ⭐ Boolean-valued on purpose, because three of its call sites are JSX render
+ * expressions. The guard used to be written inline as
+ * `{location.latitude && location.longitude && (…)}`, and with
+ * `location.latitude === 0` that expression EVALUATES TO `0` — which React
+ * renders as a text node. The user saw a stray `0` next to the em dash
+ * (`"—0"`), the `&&`-with-a-numeric-operand hazard.
+ *
+ * ⛔ That is a genuinely different defect from the falsy presence test above,
+ * and the fix is genuinely different too: making the presence test nullish
+ * would still have left a numeric operand in front of `&&`, and making the
+ * operand boolean would still have called the equator "no location". A
+ * predicate that is nullish AND boolean is what closes both, and the class
+ * criterion it answers to is: in this file no "has a value" test whose operand
+ * may legitimately be `0` uses falsy semantics, and no JSX conditional carries
+ * a numeric operand.
+ *
+ * ⛔ Not a tolerant fallback (AGENTS.md #0.1): it accepts nothing this widget
+ * did not already accept in its `value` contract, it only stops MISREADING a
+ * value that contract has always admitted.
+ */
+const hasCoordinates = (loc: GeolocationValue): loc is LocatedGeolocation =>
+  isPresentNumber(loc.latitude) && isPresentNumber(loc.longitude);
+
 /**
  * Geolocation field widget - provides a location picker with coordinates
  * Supports manual entry and browser geolocation API
@@ -150,12 +209,12 @@ export function GeolocationField({ value, onChange, field, readonly, error, ...p
   };
 
   const formatLocation = (loc: GeolocationValue): string => {
-    if (!loc.latitude || !loc.longitude) return '';
+    if (!hasCoordinates(loc)) return '';
     return `${loc.latitude.toFixed(6)}, ${loc.longitude.toFixed(6)}`;
   };
 
   const openInMaps = () => {
-    if (!location.latitude || !location.longitude) return;
+    if (!hasCoordinates(location)) return;
     const url = `https://www.google.com/maps?q=${location.latitude},${location.longitude}`;
     window.open(url, '_blank');
   };
@@ -171,7 +230,7 @@ export function GeolocationField({ value, onChange, field, readonly, error, ...p
       <div {...readonlyHostGroupProps} className="flex items-center gap-2">
         <MapPin className="w-4 h-4 text-muted-foreground" />
         {formatted ? <span className="text-sm">{formatted}</span> : <EmptyValue />}
-        {location.latitude && location.longitude && (
+        {hasCoordinates(location) && (
           <Button
             type="button"
             variant="link"
@@ -207,7 +266,7 @@ export function GeolocationField({ value, onChange, field, readonly, error, ...p
           <Crosshair className="w-4 h-4 mr-2" />
           {isLoading ? 'Getting location...' : 'Use Current Location'}
         </Button>
-        {location.latitude && location.longitude && (
+        {hasCoordinates(location) && (
           <Button
             type="button"
             variant="link"
@@ -265,7 +324,7 @@ export function GeolocationField({ value, onChange, field, readonly, error, ...p
         </div>
       </div>
 
-      {location.accuracy && (
+      {isPresentNumber(location.accuracy) && (
         <p className="text-xs text-muted-foreground">
           Accuracy: ±{location.accuracy.toFixed(0)}m
         </p>