@@ -0,0 +1,10 @@
+---
+'@objectstack/client': patch
+---
+
+fix(client): `storage.upload` sends `application/octet-stream` for a file of unknown type instead of an empty `mimeType` the presigned door refuses
+
+Clause-②: no
+Metadata-protocol: none
+
+A browser `File` whose type the browser does not know carries `type === ''`. `storage.upload(file)` sent that empty string as the presigned request's `mimeType`, and `POST /storage/upload/presigned` refuses an empty `mimeType` with `400 INVALID_REQUEST`, so such a file could not be attached at all. The helper now sends `application/octet-stream` when the file has no type; a typed file keeps its own type. The door is unchanged.
@@ -163,7 +163,9 @@ other adapter.
 | GET | `/storage/files/:fileId` | — | Stable browser URL; 302s to the same signed URL (what file fields carry) |
 
 `storage.upload(file)` runs steps 1–3 for you, including the direct-to-storage
-`PUT` in step 2.
+`PUT` in step 2. Step 1 refuses an empty `mimeType` with `400 INVALID_REQUEST`,
+so for a file whose type the browser does not know (`file.type === ''`) the
+helper sends `application/octet-stream`; a typed file keeps its own type.
 
 A file field takes the `fileId` only after step 3. A signed-in record write
 that names a file whose upload was never completed is refused with `400
 
@@ -5366,9 +5366,14 @@ export class ObjectStackClient {
   storage = {
     upload: async (file: any, scope: UploadScope = 'user'): Promise<FileUploadResponse> => {
         // 1. Get Presigned URL
+        // A browser `File` of unknown type carries `type === ''`, and the
+        // presigned door refuses an empty `mimeType` (its published contract,
+        // `GetPresignedUrlRequestSchema.mimeType` is `min(1)`). An unknown type
+        // is therefore sent as `application/octet-stream`; a typed file keeps
+        // its own type.
         const presignedReq: GetPresignedUrlRequest = {
             filename: file.name,
-            mimeType: file.type,
+            mimeType: file.type || 'application/octet-stream',
             size: file.size,
             scope
         };
 
@@ -246,3 +246,64 @@ describe('storage.resumeUpload exits on an expired session before uploading (#78
     ).resolves.toBeDefined();
   });
 });
+
+/**
+ * `storage.upload` names a type for a file the browser could not type.
+ *
+ * A browser `File` whose type the browser does not know carries
+ * `type === ''`. The presigned door refuses an empty `mimeType` with
+ * `400 INVALID_REQUEST` — that refusal is the published contract
+ * (`GetPresignedUrlRequestSchema.mimeType` is `min(1)`), so the helper is the
+ * one that must name a type: an unknown type is sent as
+ * `application/octet-stream`. The control pins the other half — a typed file
+ * keeps its own type, so the fallback cannot widen into overwriting one.
+ */
+describe('storage.upload sends application/octet-stream for a file of unknown type', () => {
+  function uploadHarness() {
+    const fetchMock = vi.fn(async (url: string) => {
+      const body = url.includes('/upload/presigned')
+        ? {
+            success: true,
+            data: {
+              uploadUrl: 'http://localhost:3000/api/v1/storage/_local/raw/tok',
+              method: 'PUT',
+              fileId: 'f1',
+              expiresIn: 3600,
+            },
+          }
+        : { success: true, data: { fileId: 'f1' } };
+      return { ok: true, status: 200, statusText: 'OK', json: async () => body, headers: new Headers() };
+    });
+    const client = new ObjectStackClient({ baseUrl: 'http://localhost:3000', fetch: fetchMock as any });
+    const presignedBody = () => {
+      const call = fetchMock.mock.calls.find(([url]) => String(url).includes('/upload/presigned'));
+      expect(call, 'storage.upload never asked the presigned door').toBeDefined();
+      return JSON.parse((call as any)[1].body as string);
+    };
+    return { client, presignedBody };
+  }
+
+  it('a File with type "" asks the door for application/octet-stream', async () => {
+    const { client, presignedBody } = uploadHarness();
+    const file = new File(['payload'], 'notes.weird-ext', { type: '' });
+    expect(file.type).toBe('');
+
+    await client.storage.upload(file);
+
+    expect(presignedBody()).toMatchObject({
+      filename: 'notes.weird-ext',
+      mimeType: 'application/octet-stream',
+      size: 7,
+      scope: 'user',
+    });
+  });
+
+  it('control: a typed File keeps its own type', async () => {
+    const { client, presignedBody } = uploadHarness();
+    const file = new File(['payload'], 'photo.png', { type: 'image/png' });
+
+    await client.storage.upload(file);
+
+    expect(presignedBody().mimeType).toBe('image/png');
+  });
+});