From bae962ed551b98e8e4e729b986d50d85a2d774f8 Mon Sep 17 00:00:00 2001
From: Jesse Dijkstra <mail@jessedijkstra.nl>
Date: Tue, 14 Jul 2026 15:27:05 +0200
Subject: [PATCH 1/2] fix(helpers): preserve tuple response types

Keep tuple arity and element positions through Readable and Writable transformations so generated clients retain fixed-length schema contracts.
---
 .changeset/bright-helpers-smile.md                        | 5 +++++
 .../test/read-write-visibility/read-write.test.ts         | 8 ++++++++
 packages/openapi-typescript-helpers/src/index.ts          | 8 ++++----
 3 files changed, 17 insertions(+), 4 deletions(-)
 create mode 100644 .changeset/bright-helpers-smile.md

diff --git a/.changeset/bright-helpers-smile.md b/.changeset/bright-helpers-smile.md
new file mode 100644
index 000000000..a62fa8e47
--- /dev/null
+++ b/.changeset/bright-helpers-smile.md
@@ -0,0 +1,5 @@
+---
+"openapi-typescript-helpers": patch
+---
+
+Preserve tuple arity when deriving readable and writable types.
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..a2f5af1ee 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,8 +1,16 @@
+import type { Readable, Writable } from "openapi-typescript-helpers";
 import { describe, expect, expectTypeOf, test } from "vitest";
 import { createObservedClient } from "../helpers.js";
 import type { paths } from "./schemas/read-write.js";
 
 describe("readOnly/writeOnly", () => {
+  test("preserves tuple arity in readable and writable types", () => {
+    type Availability = ["digital", "print"] | ["digital", "print", "presentation"];
+
+    expectTypeOf<Readable<Availability>>().toEqualTypeOf<Availability>();
+    expectTypeOf<Writable<Availability>>().toEqualTypeOf<Availability>();
+  });
+
   describe("deeply nested $Read unwrapping through $Read<Object>", () => {
     test("$Read should continue recursion when unwrapping $Read<ObjectWithReadProperties>", async () => {
       // This tests the fix for a bug where Readable<$Read<U>> returned U directly
diff --git a/packages/openapi-typescript-helpers/src/index.ts b/packages/openapi-typescript-helpers/src/index.ts
index 391e0a694..f5fe76cff 100644
--- a/packages/openapi-typescript-helpers/src/index.ts
+++ b/packages/openapi-typescript-helpers/src/index.ts
@@ -221,8 +221,8 @@ export type Readable<T> =
     ? never
     : T extends $Read<infer U>
       ? Readable<U>
-      : T extends (infer E)[]
-        ? Readable<E>[]
+      : T extends readonly unknown[]
+        ? { [K in keyof T]: Readable<T[K]> }
         : T extends object
           ? { [K in keyof T as NonNullable<T[K]> extends $Write<any> ? never : K]: Readable<T[K]> }
           : T;
@@ -238,8 +238,8 @@ export type Writable<T> =
     ? never
     : T extends $Write<infer U>
       ? Writable<U>
-      : T extends (infer E)[]
-        ? Writable<E>[]
+      : T extends readonly unknown[]
+        ? { [K in keyof T]: Writable<T[K]> }
         : 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;

From abf73b85703bf78c174855c354026ef81610f735 Mon Sep 17 00:00:00 2001
From: Jesse Dijkstra <mail@jessedijkstra.nl>
Date: Tue, 14 Jul 2026 15:34:55 +0200
Subject: [PATCH 2/2] test(fetch): use neutral tuple fixture

---
 .../test/read-write-visibility/read-write.test.ts           | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

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 a2f5af1ee..5e89bfae8 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
@@ -5,10 +5,10 @@ import type { paths } from "./schemas/read-write.js";
 
 describe("readOnly/writeOnly", () => {
   test("preserves tuple arity in readable and writable types", () => {
-    type Availability = ["digital", "print"] | ["digital", "print", "presentation"];
+    type Tuple = ["a", "b"] | ["a", "b", "c"];
 
-    expectTypeOf<Readable<Availability>>().toEqualTypeOf<Availability>();
-    expectTypeOf<Writable<Availability>>().toEqualTypeOf<Availability>();
+    expectTypeOf<Readable<Tuple>>().toEqualTypeOf<Tuple>();
+    expectTypeOf<Writable<Tuple>>().toEqualTypeOf<Tuple>();
   });
 
   describe("deeply nested $Read unwrapping through $Read<Object>", () => {