diff --git a/.changeset/fix-readable-markers.md b/.changeset/fix-readable-markers.md
new file mode 100644
index 000000000..842ad5342
--- /dev/null
+++ b/.changeset/fix-readable-markers.md
@@ -0,0 +1,25 @@
+---
+"openapi-typescript-helpers": patch
+"openapi-fetch": minor
+"openapi-typescript": patch
+---
+
+Fix `Readable` and `Writable` types to correctly handle readonly arrays, and make marker resolution opt-in via `Markers` type parameter (default: `false`). This fixes issues where `Readable<readonly string[]>` would destructure the array into an object type (#2615), and where applying `Readable`/`Writable` unconditionally broke discriminated union narrowing (#2620).
+
+### Breaking change for `--read-write-markers` users
+
+`Readable`/`Writable` are no longer applied unconditionally to all responses and request bodies. If you use `--read-write-markers` with `openapi-fetch`, you now need to pass `true` as the third type parameter to opt in to marker resolution:
+
+```ts
+// Before (0.17.x): markers resolved automatically
+const client = createClient<paths>();
+
+// After: opt in explicitly
+import type { MediaType } from "openapi-typescript-helpers";
+//                          ↓ MediaType is required as a positional placeholder
+const client = createClient<paths, MediaType, true>();
+```
+
+The second type parameter (`MediaType`) is the media type filter — it defaults to `MediaType` which accepts all content types. You must specify it explicitly to reach the third `Markers` parameter, since TypeScript does not support skipping positional type arguments.
+
+Without `Markers = true`, `$Read`/`$Write` markers will be treated as raw wrapper types and not resolved. This is the intended default for users who do not use `--read-write-markers`.
diff --git a/packages/openapi-fetch/src/index.d.ts b/packages/openapi-fetch/src/index.d.ts
index 5bca81075..7a0f43eac 100644
--- a/packages/openapi-fetch/src/index.d.ts
+++ b/packages/openapi-fetch/src/index.d.ts
@@ -3,14 +3,14 @@ import type {
   FilterKeys,
   HttpMethod,
   IsOperationRequestBodyOptional,
+  MaybeReadable,
+  MaybeWritable,
   MediaType,
   OperationRequestBodyContent,
   PathsWithMethod,
-  Readable,
   RequiredKeysOf,
   ResponseObjectMap,
   SuccessResponse,
-  Writable,
 } from "openapi-typescript-helpers";
 
 /** Options for each client instance */
@@ -98,31 +98,37 @@ export type ParamsOption<T> = T extends {
     : { params: T["parameters"] }
   : DefaultParamsOption;
 
-// Writable<T> strips $Read markers (readOnly properties excluded from request body)
-export type RequestBodyOption<T> =
-  Writable<OperationRequestBodyContent<T>> extends never
+// MaybeWritable<T> strips $Read markers when Markers is true (readOnly properties excluded from request body)
+export type RequestBodyOption<T, Markers extends boolean = false> =
+  MaybeWritable<OperationRequestBodyContent<T>, Markers> extends never
     ? { body?: never }
     : IsOperationRequestBodyOptional<T> extends true
-      ? { body?: Writable<OperationRequestBodyContent<T>> }
-      : { body: Writable<OperationRequestBodyContent<T>> };
+      ? { body?: MaybeWritable<OperationRequestBodyContent<T>, Markers> }
+      : { body: MaybeWritable<OperationRequestBodyContent<T>, Markers> };
 
-export type FetchOptions<T> = RequestOptions<T> & Omit<RequestInit, "body" | "headers">;
+export type FetchOptions<T, Markers extends boolean = false> = RequestOptions<T, Markers> &
+  Omit<RequestInit, "body" | "headers">;
 
-// Readable<T> strips $Write markers (writeOnly properties excluded from response)
-export type FetchResponse<T extends Record<string | number, any>, Options, Media extends MediaType> =
+// MaybeReadable<T> strips $Write markers when Markers is true (writeOnly properties excluded from response)
+export type FetchResponse<
+  T extends Record<string | number, any>,
+  Options,
+  Media extends MediaType,
+  Markers extends boolean = false,
+> =
   | {
-      data: ParseAsResponse<Readable<SuccessResponse<ResponseObjectMap<T>, Media>>, Options>;
+      data: ParseAsResponse<MaybeReadable<SuccessResponse<ResponseObjectMap<T>, Media>, Markers>, Options>;
       error?: never;
       response: Response;
     }
   | {
       data?: never;
-      error: Readable<ErrorResponse<ResponseObjectMap<T>, Media>>;
+      error: MaybeReadable<ErrorResponse<ResponseObjectMap<T>, Media>, Markers>;
       response: Response;
     };
 
-export type RequestOptions<T> = ParamsOption<T> &
-  RequestBodyOption<T> & {
+export type RequestOptions<T, Markers extends boolean = false> = ParamsOption<T> &
+  RequestBodyOption<T, Markers> & {
     baseUrl?: string;
     querySerializer?: QuerySerializer<T> | QuerySerializerOptions;
     bodySerializer?: BodySerializer<T>;
@@ -190,10 +196,10 @@ export type Middleware =
     };
 
 /** This type helper makes the 2nd function param required if params/requestBody are required; otherwise, optional */
-export type MaybeOptionalInit<Params, Location extends keyof Params> =
-  RequiredKeysOf<FetchOptions<FilterKeys<Params, Location>>> extends never
-    ? FetchOptions<FilterKeys<Params, Location>> | undefined
-    : FetchOptions<FilterKeys<Params, Location>>;
+export type MaybeOptionalInit<Params, Location extends keyof Params, Markers extends boolean = false> =
+  RequiredKeysOf<FetchOptions<FilterKeys<Params, Location>, Markers>> extends never
+    ? FetchOptions<FilterKeys<Params, Location>, Markers> | undefined
+    : FetchOptions<FilterKeys<Params, Location>, Markers>;
 
 // The final init param to accept.
 // - Determines if the param is optional or not.
@@ -206,79 +212,102 @@ export type ClientMethod<
   Paths extends Record<string, Record<HttpMethod, {}>>,
   Method extends HttpMethod,
   Media extends MediaType,
-> = <Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<Paths[Path], Method>>(
+  Markers extends boolean = false,
+> = <Path extends PathsWithMethod<Paths, Method>, Init extends MaybeOptionalInit<Paths[Path], Method, Markers>>(
   url: Path,
   ...init: InitParam<Init>
-) => Promise<FetchResponse<Paths[Path][Method], Init, Media>>;
+) => Promise<FetchResponse<Paths[Path][Method], Init, Media, Markers>>;
 
-export type ClientRequestMethod<Paths extends Record<string, Record<HttpMethod, {}>>, Media extends MediaType> = <
+export type ClientRequestMethod<
+  Paths extends Record<string, Record<HttpMethod, {}>>,
+  Media extends MediaType,
+  Markers extends boolean = false,
+> = <
   Method extends HttpMethod,
   Path extends PathsWithMethod<Paths, Method>,
-  Init extends MaybeOptionalInit<Paths[Path], Method>,
+  Init extends MaybeOptionalInit<Paths[Path], Method, Markers>,
 >(
   method: Method,
   url: Path,
   ...init: InitParam<Init>
-) => Promise<FetchResponse<Paths[Path][Method], Init, Media>>;
+) => Promise<FetchResponse<Paths[Path][Method], Init, Media, Markers>>;
 
-export type ClientForPath<PathInfo extends Record<string | number, any>, Media extends MediaType> = {
-  [Method in keyof PathInfo as Uppercase<string & Method>]: <Init extends MaybeOptionalInit<PathInfo, Method>>(
+export type ClientForPath<
+  PathInfo extends Record<string | number, any>,
+  Media extends MediaType,
+  Markers extends boolean = false,
+> = {
+  [Method in keyof PathInfo as Uppercase<string & Method>]: <Init extends MaybeOptionalInit<PathInfo, Method, Markers>>(
     ...init: InitParam<Init>
-  ) => Promise<FetchResponse<PathInfo[Method], Init, Media>>;
+  ) => Promise<FetchResponse<PathInfo[Method], Init, Media, Markers>>;
 };
 
-export interface Client<Paths extends {}, Media extends MediaType = MediaType> {
-  request: ClientRequestMethod<Paths, Media>;
+export interface Client<Paths extends {}, Media extends MediaType = MediaType, Markers extends boolean = false> {
+  request: ClientRequestMethod<Paths, Media, Markers>;
   /** Call a GET endpoint */
-  GET: ClientMethod<Paths, "get", Media>;
+  GET: ClientMethod<Paths, "get", Media, Markers>;
   /** Call a PUT endpoint */
-  PUT: ClientMethod<Paths, "put", Media>;
+  PUT: ClientMethod<Paths, "put", Media, Markers>;
   /** Call a POST endpoint */
-  POST: ClientMethod<Paths, "post", Media>;
+  POST: ClientMethod<Paths, "post", Media, Markers>;
   /** Call a DELETE endpoint */
-  DELETE: ClientMethod<Paths, "delete", Media>;
+  DELETE: ClientMethod<Paths, "delete", Media, Markers>;
   /** Call a OPTIONS endpoint */
-  OPTIONS: ClientMethod<Paths, "options", Media>;
+  OPTIONS: ClientMethod<Paths, "options", Media, Markers>;
   /** Call a HEAD endpoint */
-  HEAD: ClientMethod<Paths, "head", Media>;
+  HEAD: ClientMethod<Paths, "head", Media, Markers>;
   /** Call a PATCH endpoint */
-  PATCH: ClientMethod<Paths, "patch", Media>;
+  PATCH: ClientMethod<Paths, "patch", Media, Markers>;
   /** Call a TRACE endpoint */
-  TRACE: ClientMethod<Paths, "trace", Media>;
+  TRACE: ClientMethod<Paths, "trace", Media, Markers>;
   /** Register middleware */
   use(...middleware: Middleware[]): void;
   /** Unregister middleware */
   eject(...middleware: Middleware[]): void;
 }
 
-export type ClientPathsWithMethod<CreatedClient extends Client<any, any>, Method extends HttpMethod> =
-  CreatedClient extends Client<infer Paths, infer _Media> ? PathsWithMethod<Paths, Method> : never;
+export type ClientPathsWithMethod<CreatedClient extends Client<any, any, any>, Method extends HttpMethod> =
+  CreatedClient extends Client<infer Paths, infer _Media, infer _Markers> ? PathsWithMethod<Paths, Method> : never;
 
 export type MethodResponse<
-  CreatedClient extends Client<any, any>,
+  CreatedClient extends Client<any, any, any>,
   Method extends HttpMethod,
   Path extends ClientPathsWithMethod<CreatedClient, Method>,
   Options = {},
 > =
-  CreatedClient extends Client<infer Paths extends { [key: string]: any }, infer Media extends MediaType>
-    ? NonNullable<FetchResponse<Paths[Path][Method], Options, Media>["data"]>
+  CreatedClient extends Client<
+    infer Paths extends { [key: string]: any },
+    infer Media extends MediaType,
+    infer Markers extends boolean
+  >
+    ? NonNullable<FetchResponse<Paths[Path][Method], Options, Media, Markers>["data"]>
     : never;
 
-export default function createClient<Paths extends {}, Media extends MediaType = MediaType>(
-  clientOptions?: ClientOptions,
-): Client<Paths, Media>;
-
-export type PathBasedClient<Paths extends Record<string | number, any>, Media extends MediaType = MediaType> = {
-  [Path in keyof Paths]: ClientForPath<Paths[Path], Media>;
+export default function createClient<
+  Paths extends {},
+  Media extends MediaType = MediaType,
+  Markers extends boolean = false,
+>(clientOptions?: ClientOptions): Client<Paths, Media, Markers>;
+
+export type PathBasedClient<
+  Paths extends Record<string | number, any>,
+  Media extends MediaType = MediaType,
+  Markers extends boolean = false,
+> = {
+  [Path in keyof Paths]: ClientForPath<Paths[Path], Media, Markers>;
 };
 
-export declare function wrapAsPathBasedClient<Paths extends {}, Media extends MediaType = MediaType>(
-  client: Client<Paths, Media>,
-): PathBasedClient<Paths, Media>;
-
-export declare function createPathBasedClient<Paths extends {}, Media extends MediaType = MediaType>(
-  clientOptions?: ClientOptions,
-): PathBasedClient<Paths, Media>;
+export declare function wrapAsPathBasedClient<
+  Paths extends {},
+  Media extends MediaType = MediaType,
+  Markers extends boolean = false,
+>(client: Client<Paths, Media, Markers>): PathBasedClient<Paths, Media, Markers>;
+
+export declare function createPathBasedClient<
+  Paths extends {},
+  Media extends MediaType = MediaType,
+  Markers extends boolean = false,
+>(clientOptions?: ClientOptions): PathBasedClient<Paths, Media, Markers>;
 
 /** Serialize primitive params to string */
 export declare function serializePrimitiveParam(
diff --git a/packages/openapi-fetch/test/helpers.ts b/packages/openapi-fetch/test/helpers.ts
index bece1b17a..e9bbd8b0b 100644
--- a/packages/openapi-fetch/test/helpers.ts
+++ b/packages/openapi-fetch/test/helpers.ts
@@ -1,5 +1,5 @@
 import type { MediaType } from "openapi-typescript-helpers";
-import createClient from "../src/index.js";
+import createClient, { type ClientOptions } from "../src/index.js";
 
 /**
  * Create a client instance where all requests use a custom fetch implementation.
@@ -12,11 +12,11 @@ import createClient from "../src/index.js";
  * If you have too much going on in one handler, just make another instance. These are cheap.
  */
 // Note: this isn’t called “createMockedClient” because ✨ nothing is mocked 🌈! It’s only calling the handler you pass in.
-export function createObservedClient<T extends {}, M extends MediaType = MediaType>(
-  options?: Parameters<typeof createClient<T>>[0],
+export function createObservedClient<T extends {}, M extends MediaType = MediaType, Markers extends boolean = false>(
+  options?: ClientOptions,
   onRequest: (input: Request) => Promise<Response> = async () => Response.json({ status: 200, message: "OK" }),
 ) {
-  return createClient<T, M>({
+  return createClient<T, M, Markers>({
     ...options,
     baseUrl: options?.baseUrl || "https://fake-api.example", // Node.js requires a domain for Request(). This restriction doesn’t exist in browsers, but we are using `e2e.test.ts` for that..
     fetch: (input) => onRequest(input),
diff --git a/packages/openapi-fetch/test/read-write-visibility/read-write.test.ts b/packages/openapi-fetch/test/read-write-visibility/read-write.test.ts
index b699887af..3beb64d76 100644
--- a/packages/openapi-fetch/test/read-write-visibility/read-write.test.ts
+++ b/packages/openapi-fetch/test/read-write-visibility/read-write.test.ts
@@ -1,6 +1,9 @@
+import type { $Read, Readable } from "openapi-typescript-helpers";
 import { describe, expect, expectTypeOf, test } from "vitest";
+import type { Client, MethodResponse } from "../../src/index.js";
 import { createObservedClient } from "../helpers.js";
 import type { paths } from "./schemas/read-write.js";
+import type { paths as noMarkerPaths } from "./schemas/read-write-no-markers.js";
 
 describe("readOnly/writeOnly", () => {
   describe("deeply nested $Read unwrapping through $Read<Object>", () => {
@@ -9,7 +12,7 @@ describe("readOnly/writeOnly", () => {
       // instead of Readable<U>, causing nested $Read markers to not be unwrapped.
       // Example: nested: $Read<NestedObject> where NestedObject contains
       // entries: $Read<Entry[]> - the inner $Read was not stripped.
-      const client = createObservedClient<paths>({}, async () =>
+      const client = createObservedClient<paths, `${string}/${string}`, true>({}, async () =>
         Response.json({
           id: 1,
           items: [
@@ -48,7 +51,7 @@ describe("readOnly/writeOnly", () => {
 
   describe("request body (POST)", () => {
     test("CANNOT include readOnly properties", async () => {
-      const client = createObservedClient<paths>({});
+      const client = createObservedClient<paths, `${string}/${string}`, true>({});
 
       await client.POST("/users", {
         body: {
@@ -61,7 +64,7 @@ describe("readOnly/writeOnly", () => {
     });
 
     test("CAN include writeOnly properties", async () => {
-      const client = createObservedClient<paths>({});
+      const client = createObservedClient<paths, `${string}/${string}`, true>({});
 
       // No error - password (writeOnly) is allowed in request
       await client.POST("/users", {
@@ -73,7 +76,7 @@ describe("readOnly/writeOnly", () => {
     });
 
     test("CAN include normal properties", async () => {
-      const client = createObservedClient<paths>({});
+      const client = createObservedClient<paths, `${string}/${string}`, true>({});
 
       // No error - name (normal) is allowed everywhere
       await client.POST("/users", {
@@ -84,7 +87,9 @@ describe("readOnly/writeOnly", () => {
 
   describe("response body (GET/POST response)", () => {
     test("CAN access readOnly properties", async () => {
-      const client = createObservedClient<paths>({}, async () => Response.json({ id: 1, name: "Alice" }));
+      const client = createObservedClient<paths, `${string}/${string}`, true>({}, async () =>
+        Response.json({ id: 1, name: "Alice" }),
+      );
 
       const { data } = await client.GET("/users");
       // No error - id (readOnly) is available in response
@@ -93,7 +98,9 @@ describe("readOnly/writeOnly", () => {
     });
 
     test("CANNOT access writeOnly properties", async () => {
-      const client = createObservedClient<paths>({}, async () => Response.json({ id: 1, name: "Alice" }));
+      const client = createObservedClient<paths, `${string}/${string}`, true>({}, async () =>
+        Response.json({ id: 1, name: "Alice" }),
+      );
 
       const { data } = await client.GET("/users");
       // @ts-expect-error - password is writeOnly, should NOT be in response
@@ -102,7 +109,9 @@ describe("readOnly/writeOnly", () => {
     });
 
     test("CAN access normal properties", async () => {
-      const client = createObservedClient<paths>({}, async () => Response.json({ id: 1, name: "Alice" }));
+      const client = createObservedClient<paths, `${string}/${string}`, true>({}, async () =>
+        Response.json({ id: 1, name: "Alice" }),
+      );
 
       const { data } = await client.GET("/users");
       // No error - name (normal) is available everywhere
@@ -110,4 +119,139 @@ describe("readOnly/writeOnly", () => {
       expect(name).toBe("Alice");
     });
   });
+
+  describe("markers opt-in (default: off)", () => {
+    test("without Markers, $Read/$Write markers are NOT resolved", async () => {
+      // Default createClient — Markers = false
+      const client = createObservedClient<paths>({}, async () =>
+        Response.json({ id: 1, name: "Alice", password: "secret" }),
+      );
+
+      const { data } = await client.GET("/users");
+      // Without markers, $Write<string> is NOT stripped — password is accessible
+      // (it's treated as a raw type, not resolved)
+      const password = data?.password;
+      expect(password).toBe("secret");
+    });
+  });
+
+  describe("MethodResponse with Markers", () => {
+    test("MethodResponse infers Markers from Client type", () => {
+      // Verify that MethodResponse correctly infers Markers from a Client<..., true>
+      type MarkerClient = Client<paths, `${string}/${string}`, true>;
+      type Resp = MethodResponse<MarkerClient, "get", "/users">;
+      // With Markers=true, id ($Read<number>) should be unwrapped to number
+      expectTypeOf<Resp>().toHaveProperty("id");
+      expectTypeOf<Resp>().toHaveProperty("name");
+    });
+
+    test("MethodResponse works with default (no Markers) client", () => {
+      type DefaultClient = Client<paths>;
+      type Resp = MethodResponse<DefaultClient, "get", "/users">;
+      // Without markers, $Read/$Write are raw types — all properties present
+      expectTypeOf<Resp>().toHaveProperty("name");
+    });
+  });
+
+  describe("#2615: Readable preserves array types", () => {
+    test("readonly arrays are not destructured into object types", () => {
+      // Before fix: Readable<readonly string[]> fell through to `T extends object`,
+      // producing { readonly [x: number]: string; length: number; ... } instead of an array
+      expectTypeOf<Readable<readonly string[]>>().toEqualTypeOf<readonly string[]>();
+    });
+
+    test("mutable arrays remain mutable", () => {
+      expectTypeOf<Readable<string[]>>().toEqualTypeOf<string[]>();
+    });
+
+    test("nested readonly arrays are preserved", () => {
+      expectTypeOf<Readable<readonly { id: number }[]>>().toEqualTypeOf<readonly { id: number }[]>();
+    });
+  });
+
+  describe("flag OFF: no markers (read-write-no-markers fixture)", () => {
+    test("readOnly properties use readonly modifier instead of $Read", () => {
+      // In the no-markers fixture, readOnly fields are plain `readonly` modifiers
+      type User = noMarkerPaths["/users"]["get"]["responses"]["200"]["content"]["application/json"];
+      // id is `readonly id?: number` — accessible without $Read unwrapping
+      expectTypeOf<User["id"]>().toEqualTypeOf<number | undefined>();
+    });
+
+    test("writeOnly properties remain as normal types without $Write", () => {
+      type User = noMarkerPaths["/users"]["get"]["responses"]["200"]["content"]["application/json"];
+      // password is `password?: string` — no $Write wrapper
+      expectTypeOf<User["password"]>().toEqualTypeOf<string | undefined>();
+    });
+
+    test("default client can access all properties without marker resolution", async () => {
+      const client = createObservedClient<noMarkerPaths>({}, async () =>
+        Response.json({ id: 1, name: "Alice", password: "secret" }),
+      );
+
+      const { data } = await client.GET("/users");
+      expect(data?.id).toBe(1);
+      expect(data?.name).toBe("Alice");
+      // Without markers, password is a normal property — accessible in response
+      expect(data?.password).toBe("secret");
+    });
+
+    test("nested readonly properties use readonly modifier", () => {
+      type Entry =
+        noMarkerPaths["/resources/{id}"]["get"]["responses"]["200"]["content"]["application/json"]["items"][number]["nested"]["entries"][number];
+      // label is `readonly label: string` — accessible as plain string
+      expectTypeOf<Entry["label"]>().toEqualTypeOf<string>();
+    });
+  });
+
+  describe("#2620: discriminated union narrowing", () => {
+    test("narrowing preserved when markers disabled (default)", async () => {
+      // The core fix: Readable<T> is no longer applied when Markers=false,
+      // so the original discriminated union type identity is preserved and
+      // TypeScript's control-flow narrowing works as expected.
+      const client = createObservedClient<paths>({}, async () => Response.json({ type: "success", payload: "ok" }));
+
+      const { data } = await client.GET("/events");
+      if (data) {
+        if (data.type === "success") {
+          // Without Readable wrapping, narrowing works: 'payload' exists on SuccessEvent
+          expectTypeOf(data.payload).toEqualTypeOf<string>();
+          expect(data.payload).toBe("ok");
+        }
+      }
+    });
+
+    test("narrowing preserved with markers on non-marker union members", async () => {
+      // When Markers=true but union members have no $Read/$Write markers,
+      // Readable<T> recurses into the object branch but produces a structurally
+      // identical type, preserving narrowing for simple discriminated unions.
+      const client = createObservedClient<paths, `${string}/${string}`, true>({}, async () =>
+        Response.json({ type: "error", message: "not found" }),
+      );
+
+      const { data } = await client.GET("/events");
+      if (data) {
+        if (data.type === "error") {
+          expectTypeOf(data.message).toEqualTypeOf<string>();
+          expect(data.message).toBe("not found");
+        }
+      }
+    });
+
+    test("narrowing preserved when union members contain $Read markers", () => {
+      // Verify that Readable distributes over the union and unwraps $Read
+      // while preserving the discriminant for control-flow narrowing.
+      type MarkedUnion = { type: "success"; data: string; audit: $Read<string> } | { type: "error"; message: string };
+
+      type Result = Readable<MarkedUnion>;
+
+      // Use control-flow narrowing on the resolved type
+      const value = {} as Result;
+      if (value.type === "success") {
+        expectTypeOf(value.data).toEqualTypeOf<string>();
+        expectTypeOf(value.audit).toEqualTypeOf<string>();
+      } else {
+        expectTypeOf(value.message).toEqualTypeOf<string>();
+      }
+    });
+  });
 });
diff --git a/packages/openapi-fetch/test/read-write-visibility/schemas/read-write-no-markers.d.ts b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write-no-markers.d.ts
new file mode 100644
index 000000000..4951dae70
--- /dev/null
+++ b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write-no-markers.d.ts
@@ -0,0 +1,185 @@
+/**
+ * This file was auto-generated by openapi-typescript.
+ * Do not make direct changes to the file.
+ */
+
+export interface paths {
+    "/users": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["User"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody: {
+                content: {
+                    "application/json": components["schemas"]["User"];
+                };
+            };
+            responses: {
+                /** @description Created */
+                201: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["User"];
+                    };
+                };
+            };
+        };
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["SuccessEvent"] | components["schemas"]["ErrorEvent"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+    "/resources/{id}": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path: {
+                    id: number;
+                };
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["Resource"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
+}
+export type webhooks = Record<string, never>;
+export interface components {
+    schemas: {
+        User: {
+            readonly id?: number;
+            name: string;
+            password?: string;
+        };
+        Resource: {
+            id: number;
+            items: components["schemas"]["ResourceItem"][];
+        };
+        ResourceItem: {
+            id: number;
+            readonly nested: components["schemas"]["NestedObject"];
+        };
+        NestedObject: {
+            readonly entries: components["schemas"]["Entry"][];
+        };
+        Entry: {
+            code: string;
+            readonly label: string;
+        };
+        SuccessEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "success";
+            payload: string;
+        };
+        ErrorEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "error";
+            message: string;
+        };
+    };
+    responses: never;
+    parameters: never;
+    requestBodies: never;
+    headers: never;
+    pathItems: never;
+}
+export type $defs = Record<string, never>;
+export type operations = Record<string, never>;
diff --git a/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.d.ts b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.d.ts
index 2154b1e38..bd4edcbcb 100644
--- a/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.d.ts
+++ b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.d.ts
@@ -9,10 +9,10 @@ export type $Read<T> = {
 export type $Write<T> = {
     readonly $write: T;
 };
-export type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends (infer E)[] ? Readable<E>[] : T extends object ? {
+export type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends (infer E)[] ? Readable<E>[] : T extends readonly (infer E)[] ? readonly Readable<E>[] : T extends object ? {
     [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]>;
 } : T;
-export type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends (infer E)[] ? Writable<E>[] : T extends object ? {
+export type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends (infer E)[] ? Writable<E>[] : T extends readonly (infer E)[] ? readonly Writable<E>[] : T extends object ? {
     [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]>;
 } & {
     [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never;
@@ -76,6 +76,41 @@ export interface paths {
         patch?: never;
         trace?: never;
     };
+    "/events": {
+        parameters: {
+            query?: never;
+            header?: never;
+            path?: never;
+            cookie?: never;
+        };
+        get: {
+            parameters: {
+                query?: never;
+                header?: never;
+                path?: never;
+                cookie?: never;
+            };
+            requestBody?: never;
+            responses: {
+                /** @description OK */
+                200: {
+                    headers: {
+                        [name: string]: unknown;
+                    };
+                    content: {
+                        "application/json": components["schemas"]["SuccessEvent"] | components["schemas"]["ErrorEvent"];
+                    };
+                };
+            };
+        };
+        put?: never;
+        post?: never;
+        delete?: never;
+        options?: never;
+        head?: never;
+        patch?: never;
+        trace?: never;
+    };
     "/resources/{id}": {
         parameters: {
             query?: never;
@@ -137,6 +172,22 @@ export interface components {
             code: string;
             label: $Read<string>;
         };
+        SuccessEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "success";
+            payload: string;
+        };
+        ErrorEvent: {
+            /**
+             * @description discriminator enum property added by openapi-typescript
+             * @enum {string}
+             */
+            type: "error";
+            message: string;
+        };
     };
     responses: never;
     parameters: never;
diff --git a/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.yaml b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.yaml
index 77a1a3d63..701171346 100644
--- a/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.yaml
+++ b/packages/openapi-fetch/test/read-write-visibility/schemas/read-write.yaml
@@ -26,6 +26,22 @@ paths:
             application/json:
               schema:
                 $ref: "#/components/schemas/User"
+  /events:
+    get:
+      responses:
+        200:
+          description: OK
+          content:
+            application/json:
+              schema:
+                oneOf:
+                  - $ref: "#/components/schemas/SuccessEvent"
+                  - $ref: "#/components/schemas/ErrorEvent"
+                discriminator:
+                  propertyName: type
+                  mapping:
+                    success: "#/components/schemas/SuccessEvent"
+                    error: "#/components/schemas/ErrorEvent"
   /resources/{id}:
     get:
       parameters:
@@ -102,3 +118,28 @@ components:
         label:
           type: string
           readOnly: true
+    # Discriminated union for narrowing regression test (#2620)
+    SuccessEvent:
+      type: object
+      required:
+        - type
+        - payload
+      properties:
+        type:
+          type: string
+          enum:
+            - success
+        payload:
+          type: string
+    ErrorEvent:
+      type: object
+      required:
+        - type
+        - message
+      properties:
+        type:
+          type: string
+          enum:
+            - error
+        message:
+          type: string
diff --git a/packages/openapi-fetch/test/redocly.yaml b/packages/openapi-fetch/test/redocly.yaml
index 1f211f405..84d46f18f 100644
--- a/packages/openapi-fetch/test/redocly.yaml
+++ b/packages/openapi-fetch/test/redocly.yaml
@@ -58,3 +58,7 @@ apis:
     x-openapi-ts:
       output: ./read-write-visibility/schemas/read-write.d.ts
       read-write-markers: true
+  read-write-no-markers:
+    root: ./read-write-visibility/schemas/read-write.yaml
+    x-openapi-ts:
+      output: ./read-write-visibility/schemas/read-write-no-markers.d.ts
diff --git a/packages/openapi-typescript-helpers/src/index.ts b/packages/openapi-typescript-helpers/src/index.ts
index 391e0a694..535dde644 100644
--- a/packages/openapi-typescript-helpers/src/index.ts
+++ b/packages/openapi-typescript-helpers/src/index.ts
@@ -214,6 +214,7 @@ export type $Write<T> = { readonly $write: T };
  * Resolve type for reading (responses): strips $Write properties, unwraps $Read
  * - $Read<T> → T (readable), continues recursion
  * - $Write<T> → never (excluded from response)
+ * - readonly T[] / T[] → recursively resolve elements
  * - object → recursively resolve
  */
 export type Readable<T> =
@@ -223,14 +224,17 @@ export type Readable<T> =
       ? Readable<U>
       : T extends (infer E)[]
         ? Readable<E>[]
-        : T extends object
-          ? { [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]> }
-          : T;
+        : T extends readonly (infer E)[]
+          ? readonly Readable<E>[]
+          : T extends object
+            ? { [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]> }
+            : T;
 
 /**
  * Resolve type for writing (requests): strips $Read properties, unwraps $Write
  * - $Write<T> → T (writable), continues recursion
  * - $Read<T> → never (excluded from request)
+ * - readonly T[] / T[] → recursively resolve elements
  * - object → recursively resolve
  */
 export type Writable<T> =
@@ -240,8 +244,16 @@ export type Writable<T> =
       ? Writable<U>
       : T extends (infer E)[]
         ? Writable<E>[]
-        : T extends object
-          ? { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]> } & {
-              [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never;
-            }
-          : T;
+        : T extends readonly (infer E)[]
+          ? readonly Writable<E>[]
+          : T extends object
+            ? { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]> } & {
+                [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never;
+              }
+            : T;
+
+/** Apply Readable only when read/write markers are enabled */
+export type MaybeReadable<T, Markers extends boolean> = Markers extends true ? Readable<T> : T;
+
+/** Apply Writable only when read/write markers are enabled */
+export type MaybeWritable<T, Markers extends boolean> = Markers extends true ? Writable<T> : T;
diff --git a/packages/openapi-typescript/src/transform/index.ts b/packages/openapi-typescript/src/transform/index.ts
index ad4af119a..260fc4df0 100644
--- a/packages/openapi-typescript/src/transform/index.ts
+++ b/packages/openapi-typescript/src/transform/index.ts
@@ -22,8 +22,8 @@ const transformers: Record<SchemaTransforms, (node: any, options: GlobalContext)
 const READ_WRITE_HELPER_TYPES = `
 export type $Read<T> = { readonly $read: T };
 export type $Write<T> = { readonly $write: T };
-export type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends (infer E)[] ? Readable<E>[] : T extends object ? { [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]> } : T;
-export type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends (infer E)[] ? Writable<E>[] : T extends object ? { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]> } & { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never } : T;
+export type Readable<T> = T extends $Write<any> ? never : T extends $Read<infer U> ? Readable<U> : T extends (infer E)[] ? Readable<E>[] : T extends readonly (infer E)[] ? readonly Readable<E>[] : T extends object ? { [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]> } : T;
+export type Writable<T> = T extends $Read<any> ? never : T extends $Write<infer U> ? Writable<U> : T extends (infer E)[] ? Writable<E>[] : T extends readonly (infer E)[] ? readonly Writable<E>[] : T extends object ? { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? never : K]: Writable<T[K]> } & { [K in keyof T as NonNullable<T[K]> extends $Read<any> ? K : never]?: never } : T;
 `;
 
 export default function transformSchema(schema: OpenAPI3, ctx: GlobalContext) {