@@ -0,0 +1,12 @@
+---
+'@object-ui/data-objectstack': patch
+---
+
+Clause-②: no
+Metadata-protocol: none
+
+A request that got no answer (a dropped connection, an unreachable host) no longer reads as a server that answered with a 500 (#29885).
+
+- `createErrorFromResponse` now leaves `statusCode` undefined when its input carries no status. Before, it stamped `500`, and `ObjectStackAdapter.getObjectSchema` rewraps through it, so every reader of a schema-read failure took the browser's "Failed to fetch" for the server's own answer. The error is still an `ObjectStackError` with code `UNKNOWN_ERROR`. `classifyLoadError` reads it as `network`, and `answeredLoadFailure` returns `null`, so a failed-read state keeps its "check your connection" sentence.
+- An input that is an `Error` is kept as `details.originalError`, whatever its status.
+- Answered statuses map as before: 400, 401, 403, 404, 503, 504 and any other status keep their class, code and `statusCode`.
@@ -353,7 +353,57 @@ describe('Error Helpers', () => {
       const error = createErrorFromResponse(response);
 
       expect(error).toBeInstanceOf(ObjectStackError);
-      expect(error.statusCode).toBe(500);
+      expect(error.code).toBe('UNKNOWN_ERROR');
+      // objectstack#29885 — no status in, no status out: an invented 500
+      // reads as an answer from the server.
+      expect(error.statusCode).toBeUndefined();
+      expect((error.details as any).response.status).toBeUndefined();
+    });
+
+    // objectstack#29885 — a request that got no answer (fetch rejects with a
+    // bare TypeError) is not an answered server error.
+    describe('an error that got no answer (objectstack#29885)', () => {
+      it('a fetch TypeError keeps no status, and is kept as the cause', () => {
+        const drop = new TypeError('Failed to fetch');
+
+        const error = createErrorFromResponse(drop as unknown as Record<string, unknown>, 'getObjectSchema(account)');
+
+        expect(error).toBeInstanceOf(ObjectStackError);
+        expect(error).not.toBeInstanceOf(ConnectionError);
+        expect(error.code).toBe('UNKNOWN_ERROR');
+        expect(error.statusCode).toBeUndefined();
+        expect(error.message).toBe('Failed to fetch');
+        expect(error.details?.originalError).toBe(drop);
+        expect(error.toJSON().statusCode).toBeUndefined();
+      });
+
+      it('CONTROL: an answered 500 keeps its status, and its cause', () => {
+        const answered = Object.assign(new Error('Database connection refused.'), { status: 500, code: 'INTERNAL_ERROR' });
+
+        const error = createErrorFromResponse(answered as unknown as Record<string, unknown>);
+
+        expect(error.code).toBe('UNKNOWN_ERROR');
+        expect(error.statusCode).toBe(500);
+        expect(error.details?.originalError).toBe(answered);
+      });
+
+      it('CONTROL: an answered 503 is the ConnectionError it was, with its status', () => {
+        const answered = Object.assign(new Error('The metadata store is down.'), { status: 503 });
+
+        const error = createErrorFromResponse(answered as unknown as Record<string, unknown>);
+
+        expect(error).toBeInstanceOf(ConnectionError);
+        expect(error.code).toBe('CONNECTION_ERROR');
+        expect(error.statusCode).toBe(503);
+        expect(error.details?.originalError).toBe(answered);
+      });
+
+      it('CONTROL: a plain response object (not an Error) carries no cause', () => {
+        const error = createErrorFromResponse({ status: 500, message: 'Server error' });
+
+        expect(error.statusCode).toBe(500);
+        expect(error.details).not.toHaveProperty('originalError');
+      });
     });
 
     it('should include context in error details', () => {
 
@@ -217,13 +217,21 @@ export class DataApiValidationError extends ObjectStackError {
 
 /**
  * Helper function to create an error from an HTTP response
- * 
+ *
+ * An input that carries no status got no answer (a dropped connection, an
+ * unreachable host: `fetch` rejects with a bare `TypeError`). It comes back as
+ * an `UNKNOWN_ERROR` with `statusCode` left undefined, never with an invented
+ * status: a reader that sees a numeric status takes it for the server's answer
+ * (`answeredLoadFailure`), and would show the browser's "Failed to fetch" as
+ * if the server had said it (objectstack#29885). An input that is an `Error`
+ * is kept as `details.originalError`, whatever its status.
+ *
  * @param response - Response object or error from fetch/axios
  * @param context - Additional context for debugging
  * @returns Appropriate error instance
  */
 export function createErrorFromResponse(response: Record<string, unknown>, context?: string): ObjectStackError {
-  const status = (response?.status as number) || (response?.statusCode as number) || 500;
+  const status = (response?.status as number) || (response?.statusCode as number) || undefined;
   const message = (response?.message as string) || (response?.statusText as string) || 'Unknown error';
   const details = {
     context,
@@ -232,6 +240,9 @@ export function createErrorFromResponse(response: Record<string, unknown>, conte
       data: response?.data,
       headers: response?.headers,
     },
+    // The transport's own error, when the input is one: what the server said
+    // (its status, ADR-0112 code and sentence), or the bare fetch failure.
+    ...(response instanceof Error ? { originalError: response } : {}),
   };
 
   switch (status) {
 
@@ -150,11 +150,10 @@ describe('ObjectStackAdapter.getObjectSchema', () => {
 /**
  * objectstack#29728 — a failed by-name read that is not a 404 is rewrapped by
  * `createErrorFromResponse`, which replaces the server's ADR-0112 code with its
- * own taxonomy and stamps `500` on a request that got no answer. The rewrap
- * keeps the transport's own error as `details.originalError` (as the 404 arm's
- * `MetadataNotFoundError` does), so a reader can tell whether, and what, the
- * server answered. The wrapper's class, code, statusCode and message are
- * unchanged.
+ * own taxonomy. The rewrap keeps the transport's own error as
+ * `details.originalError` (as the 404 arm's `MetadataNotFoundError` does), so
+ * a reader can tell what the server answered. Since objectstack#29885 a
+ * request that got no answer carries no `statusCode` on the wrapper either.
  */
 describe('ObjectStackAdapter.getObjectSchema keeps the server answer as the cause of a non-404 failure (objectstack#29728)', () => {
   beforeEach(() => clearSharedDiscoveryCache());
@@ -196,15 +195,15 @@ describe('ObjectStackAdapter.getObjectSchema keeps the server answer as the caus
     expect(err.details.originalError).toMatchObject({ status: 500, code: 'INTERNAL_ERROR', message: 'Database connection refused.' });
   });
 
-  it('no answer: the wrapper still reads 500, and its cause is the bare fetch failure, with no status', async () => {
+  it('no answer: the wrapper carries no status (objectstack#29885), and its cause is the bare fetch failure', async () => {
     const drop = new TypeError('Failed to fetch');
     const adapter = adapterAnswering(() => {
       throw drop;
     });
     const err: any = await adapter.getObjectSchema('account').catch((e: unknown) => e);
     expect(err).toBeInstanceOf(ObjectStackError);
     expect(err.code).toBe('UNKNOWN_ERROR');
-    expect(err.statusCode).toBe(500);
+    expect(err.statusCode).toBeUndefined();
     expect(err.message).toBe('Failed to fetch');
     expect(err.details.originalError).toBe(drop);
   });
 
@@ -5717,9 +5717,9 @@ export class ObjectStackAdapter<T = unknown> implements DataSource<T> {
       // objectstack#29728 — the rewrap keeps the transport's own error as its
       // cause, as the 404 arm above does. `createErrorFromResponse` replaces
       // the server's ADR-0112 code with its own taxonomy (`CONNECTION_ERROR`,
-      // `UNKNOWN_ERROR`), and it stamps `500` on an error that carries no
-      // status at all (a dropped connection), so the wrapper alone cannot say
-      // whether the server answered or in what words. The cause can: the
+      // `UNKNOWN_ERROR`) and its sentence with its own ("Connection error:
+      // ..."), so the wrapper alone cannot say what the server answered (a
+      // dropped connection carries no status, objectstack#29885). The cause can: the
       // by-name route read throws `status` + the server's `code` and sentence
       // for an answer, and the bare fetch failure for none.
       const wrapped = createErrorFromResponse(errorObj, `getObjectSchema(${objectName})`);
 
@@ -0,0 +1,76 @@
+/**
+ * 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 { ObjectStackAdapter, clearSharedDiscoveryCache } from '@object-ui/data-objectstack';
+import { answeredLoadFailure, classifyLoadError } from './error-message';
+
+/**
+ * objectstack#29885 — what the adapter throws for a request that got no
+ * answer, read by the shared load-failure rule, pinned where the two meet.
+ *
+ * `ObjectStackAdapter.getObjectSchema` rewraps a non-404 failure through
+ * `createErrorFromResponse`, which used to stamp `statusCode: 500` on an error
+ * that carried no status (a dropped connection: `fetch` rejects with a bare
+ * `TypeError`). `answeredLoadFailure` reads any numeric status as the server's
+ * answer, so every reader of that wrapper showed the browser's "Failed to
+ * fetch" as if the server had said it, instead of its "check your connection"
+ * sentence. The adapter cannot import this reader (this package depends on
+ * that one), so neither side's unit tests can pin the pair alone.
+ */
+describe('a getObjectSchema read that got no answer reads as no answer (objectstack#29885)', () => {
+  beforeEach(() => clearSharedDiscoveryCache());
+
+  function adapterAnswering(byName: () => unknown) {
+    const fetchImpl = vi.fn(async (url: unknown) => {
+      const u = String(url);
+      if (u.includes('/api/v1/discovery')) {
+        return { ok: true, status: 200, statusText: 'OK', json: async () => ({ success: true, data: { version: 'v1', routes: {} } }) };
+      }
+      if (u.includes('/api/v1/meta/object/')) return byName();
+      return { ok: true, status: 200, statusText: 'OK', json: async () => ({}) };
+    });
+    return new ObjectStackAdapter({ baseUrl: 'http://unanswered-29885.test', autoReconnect: false, fetch: fetchImpl as any });
+  }
+
+  const answered = (status: number, body: unknown) => () => ({ ok: false, status, statusText: 'Error', json: async () => body });
+
+  it('a fetch that rejects with a TypeError: no answered failure, and a network kind', async () => {
+    const adapter = adapterAnswering(() => {
+      throw new TypeError('Failed to fetch');
+    });
+
+    const err: any = await adapter.getObjectSchema('account').catch((e: unknown) => e);
+
+    expect(err).toBeInstanceOf(Error);
+    expect(err.statusCode).toBeUndefined();
+    expect(answeredLoadFailure(err)).toBeNull();
+    expect(classifyLoadError(err)).toBe('network');
+  });
+
+  it('CONTROL: an answered 500 keeps its status and reads as answered', async () => {
+    const adapter = adapterAnswering(answered(500, { error: 'Database connection refused.', code: 'INTERNAL_ERROR' }));
+
+    const err: any = await adapter.getObjectSchema('account').catch((e: unknown) => e);
+
+    expect(err.statusCode).toBe(500);
+    expect(answeredLoadFailure(err)).toMatchObject({ message: 'Database connection refused.' });
+  });
+
+  it('CONTROL: an answered 503 keeps its status and reads as answered', async () => {
+    const adapter = adapterAnswering(
+      answered(503, { success: false, error: { code: 'SERVICE_UNAVAILABLE', message: 'The metadata store is down.' } }),
+    );
+
+    const err: any = await adapter.getObjectSchema('account').catch((e: unknown) => e);
+
+    expect(err.statusCode).toBe(503);
+    expect(answeredLoadFailure(err)).not.toBeNull();
+  });
+});