@@ -0,0 +1,12 @@
+---
+'@object-ui/data-objectstack': patch
+---
+
+Clause-②: no
+Metadata-protocol: none
+
+A `ConnectionError` for a request nothing answered (an unreachable host, a rejected `fetch`) no longer reads as a server that answered with a 503 (#29916).
+
+- The `ConnectionError` constructor leaves `statusCode` undefined when the caller passes none. Before, it stamped `503`. `connect()` builds it that way when discovery's `fetch` rejects, every data method opens with `await this.connect()`, and the post-connect `error` connection state builds it the same way, so a read against a down backend was taken for the server's own answer. `answeredLoadFailure` now returns `null` for it and `classifyLoadError` reads `network`, so a failed-read state keeps its "check your connection" sentence.
+- A discovery read the server answered with an error status (`!res.ok`) now carries that status (a 401 reads as `unauthorized`), instead of the invented 503.
+- An answered 503 or 504 through `createErrorFromResponse` keeps its status, as before.
@@ -156,7 +156,10 @@ describe('a failed first connect() retries discovery as a new attempt (objectui#
     expect(fetch).toHaveBeenCalledTimes(3);
     expect(outcome.settled).toBe('rejected');
     expect(outcome.error).toBeInstanceOf(ConnectionError);
-    expect(outcome.error).toMatchObject({ code: 'CONNECTION_ERROR', statusCode: 503 });
+    expect(outcome.error).toMatchObject({ code: 'CONNECTION_ERROR' });
+    // Discovery was refused, never answered: the error carries no status
+    // (objectstack#29916; it used to carry an invented 503).
+    expect((outcome.error as ConnectionError).statusCode).toBeUndefined();
     expect(adapter.getConnectionState()).toBe('error');
     expect(adapter.isConnected()).toBe(false);
     expect(states).toEqual([
 
@@ -149,7 +149,9 @@ describe('Error Classes', () => {
 
       expect(error.message).toBe('Connection error: Network timeout');
       expect(error.code).toBe('CONNECTION_ERROR');
-      expect(error.statusCode).toBe(503);
+      // Built without a status, nothing answered: no invented 503
+      // (objectstack#29916).
+      expect(error.statusCode).toBeUndefined();
       expect(error.name).toBe('ConnectionError');
       expect(error.url).toBe('https://api.example.com');
       expect(error).toBeInstanceOf(ObjectStackError);
@@ -162,6 +164,11 @@ describe('Error Classes', () => {
       expect(error.url).toBeUndefined();
       expect(error.message).toBe('Connection error: Network timeout');
     });
+
+    it('CONTROL: a status the caller passes is kept', () => {
+      expect(new ConnectionError('down', undefined, undefined, 503).statusCode).toBe(503);
+      expect(new ConnectionError('timeout', undefined, undefined, 504).statusCode).toBe(504);
+    });
   });
 
   describe('AuthenticationError', () => {
 
@@ -121,6 +121,16 @@ export class BulkOperationError extends ObjectStackError {
 
 /**
  * Error thrown when connection to ObjectStack server fails
+ *
+ * `statusCode` is the server's answer and nothing else: a 503 / 504 the server
+ * sent (`createErrorFromResponse`), or the status a refused discovery read
+ * came back with (`connect()`). Built without one, the error stands for a
+ * request nothing answered (the host unreachable, `fetch` rejected), and
+ * `statusCode` stays undefined rather than an invented 503: a reader that sees
+ * a numeric status takes it for the server's answer (`answeredLoadFailure`)
+ * and would show "Failed to fetch" as the server's own words
+ * (objectstack#29916, the same rule objectstack#29885 set for
+ * `createErrorFromResponse`).
  */
 export class ConnectionError extends ObjectStackError {
   constructor(
@@ -132,7 +142,7 @@ export class ConnectionError extends ObjectStackError {
     super(
       `Connection error: ${message}`,
       'CONNECTION_ERROR',
-      statusCode || 503,
+      statusCode,
       { url, ...details }
     );
     this.name = 'ConnectionError';
 
@@ -3613,7 +3613,12 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
             : undefined,
         });
         if (!res.ok) {
-          throw new Error(`discovery ${res.status} ${res.statusText}`);
+          // The server answered: its status rides on the error, so the
+          // ConnectionError below carries the server's status rather than
+          // none (objectstack#29916).
+          throw Object.assign(new Error(`discovery ${res.status} ${res.statusText}`), {
+            status: res.status,
+          });
         }
         const body = await res.json();
         return body && typeof body.success === 'boolean' && 'data' in body
@@ -3635,10 +3640,15 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       this.setConnectionState('connected');
     } catch (error: unknown) {
       const errorMessage = error instanceof Error ? error.message : 'Failed to connect to ObjectStack server';
+      // A status only when discovery was answered (the `!res.ok` throw above);
+      // a rejected `fetch` got no answer and the error carries no status
+      // (objectstack#29916).
+      const answeredStatus = (error as { status?: unknown } | null)?.status;
       const connectionError = new ConnectionError(
         errorMessage,
         undefined,
-        { originalError: error }
+        { originalError: error },
+        typeof answeredStatus === 'number' ? answeredStatus : undefined,
       );
 
       this.setConnectionState('error', connectionError);
@@ -3788,6 +3798,7 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       if (this.connectionState !== 'reconnecting') this.setConnectionState('reconnecting');
       return;
     }
+    // No status: nothing answered this request (objectstack#29916).
     this.setConnectionState(
       'error',
       new ConnectionError(
 
@@ -0,0 +1,125 @@
+/**
+ * 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.
+ */
+
+import { beforeEach, describe, expect, it, vi } from 'vitest';
+
+import {
+  ConnectionError,
+  ObjectStackAdapter,
+  clearSharedDiscoveryCache,
+  createErrorFromResponse,
+  type ConnectionStateEvent,
+} from '@object-ui/data-objectstack';
+import { answeredLoadFailure, classifyLoadError } from './error-message';
+
+/**
+ * objectstack#29916 — a `ConnectionError` for a request nothing answered,
+ * read by the shared load-failure rule, pinned where the two meet.
+ *
+ * The `ConnectionError` constructor used to stamp `statusCode: 503` on every
+ * error built without a status. `connect()`'s catch (a discovery `fetch` that
+ * rejected) and the post-connect "the server did not answer" state both build
+ * it that way, and every data method opens with `await this.connect()`, so a
+ * list read against a down backend rejected with an error that looked
+ * answered: `answeredLoadFailure` takes any numeric status for the server's
+ * answer and showed "Connection error: Failed to fetch" as the server's own
+ * words. Same defect as objectstack#29885 for `createErrorFromResponse`.
+ */
+describe('a ConnectionError that nothing answered reads as no answer (objectstack#29916)', () => {
+  beforeEach(() => clearSharedDiscoveryCache());
+
+  const discoveryOk = () => ({
+    ok: true,
+    status: 200,
+    statusText: 'OK',
+    json: async () => ({ success: true, data: { version: 'v1', routes: {} } }),
+  });
+
+  function adapterWith(discovery: () => unknown, data: () => unknown = () => { throw new TypeError('Failed to fetch'); }) {
+    const fetchImpl = vi.fn(async (url: unknown) => {
+      if (String(url).includes('/api/v1/discovery')) return discovery();
+      return data();
+    });
+    return new ObjectStackAdapter({
+      baseUrl: 'http://connection-unanswered-29916.test',
+      autoReconnect: false,
+      fetch: fetchImpl as any,
+    });
+  }
+
+  it('connect() over a fetch that rejects: a ConnectionError with no status, no answered failure, a network kind', async () => {
+    const adapter = adapterWith(() => {
+      throw new TypeError('Failed to fetch');
+    });
+
+    const err: any = await adapter.connect().catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.code).toBe('CONNECTION_ERROR');
+    expect(err.statusCode).toBeUndefined();
+    expect(answeredLoadFailure(err)).toBeNull();
+    expect(classifyLoadError(err)).toBe('network');
+  });
+
+  it('a data read before connect, discovery unreachable: the read rejects as no answer', async () => {
+    const adapter = adapterWith(() => {
+      throw new TypeError('Failed to fetch');
+    });
+
+    const err: any = await adapter.find('account').catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.statusCode).toBeUndefined();
+    expect(answeredLoadFailure(err)).toBeNull();
+    expect(classifyLoadError(err)).toBe('network');
+  });
+
+  it('an unanswered request after connect: the error-state ConnectionError carries no status', async () => {
+    const adapter = adapterWith(discoveryOk);
+    await adapter.connect();
+    const events: ConnectionStateEvent[] = [];
+    adapter.onConnectionStateChange((event) => events.push(event));
+
+    await expect(adapter.find('account')).rejects.toBeInstanceOf(TypeError);
+
+    expect(events.map((e) => e.state)).toEqual(['error']);
+    const err: any = events[0].error;
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.statusCode).toBeUndefined();
+    expect(answeredLoadFailure(err)).toBeNull();
+    expect(classifyLoadError(err)).toBe('network');
+  });
+
+  it('CONTROL: an answered 503 through createErrorFromResponse keeps its status and reads as answered', () => {
+    const err: any = createErrorFromResponse({ status: 503, message: 'The metadata store is down.' }, 'find(account)');
+
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.statusCode).toBe(503);
+    expect(answeredLoadFailure(err)).not.toBeNull();
+  });
+
+  it('CONTROL: a discovery the server answered with 503 keeps that status and reads as answered', async () => {
+    const adapter = adapterWith(() => ({ ok: false, status: 503, statusText: 'Service Unavailable', json: async () => ({}) }));
+
+    const err: any = await adapter.connect().catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.statusCode).toBe(503);
+    expect(answeredLoadFailure(err)).not.toBeNull();
+  });
+
+  it('a discovery the server answered with 401 carries 401, not an invented 503', async () => {
+    const adapter = adapterWith(() => ({ ok: false, status: 401, statusText: 'Unauthorized', json: async () => ({}) }));
+
+    const err: any = await adapter.connect().catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(ConnectionError);
+    expect(err.statusCode).toBe(401);
+    expect(classifyLoadError(err)).toBe('unauthorized');
+  });
+});