@vertesia/client 1.5.0-dev.20260910.052912Z → 1.5.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@vertesia/client",
-  "version": "1.5.0-dev.20260910.052912Z",
+  "version": "1.5.0",
   "type": "module",
   "main": "./lib/index.js",
   "types": "./lib/index.d.ts",
@@ -19,9 +19,9 @@
   },
   "dependencies": {
     "eventsource": "^5.0.0",
-    "@vertesia/api-fetch-client": "1.5.0-dev.20260910.052912Z",
-    "@vertesia/common": "1.5.0-dev.20260910.052912Z",
-    "@llumiverse/common": "1.5.0-dev.20260910.044936Z"
+    "@llumiverse/common": "1.5.0",
+    "@vertesia/api-fetch-client": "1.5.0",
+    "@vertesia/common": "1.5.0"
   },
   "exports": {
     ".": {
@@ -48,7 +48,7 @@
     "ai",
     "typescript"
   ],
-  "gitHead": "95d481ca856012cd67b501b901dc365afeb7cf81",
+  "gitHead": "3485742020066ab1fd3292487cf3a9577b5e4d91",
   "scripts": {
     "lint": "biome lint src",
     "clean:lib": "rimraf ./lib ./tsconfig.tsbuildinfo",

package/src/store/ObjectsApi.test.ts

@@ -0,0 +1,50 @@
+import { describe, expect, it, vi } from 'vitest';
+import { ZenoClient } from './client.js';
+
+describe('ObjectsApi revision labels', () => {
+    it.each(['v1.2', 'Review — 日本語', 'Révision – café', '100% complete & reviewed + approved'])(
+        'preserves the revision label %s through the query contract',
+        async (revisionLabel) => {
+            const requests: Request[] = [];
+            const client = new ZenoClient({
+                serverUrl: 'https://api.example.com',
+                fetch: vi.fn(async () => Response.json({ id: 'document-id' })),
+                onRequest: (request) => requests.push(request),
+            });
+
+            await client.objects.update(
+                'document-id',
+                { name: 'Updated document' },
+                {
+                    createRevision: true,
+                    revisionLabel,
+                    ifMatch: 'previous-etag',
+                },
+            );
+
+            expect(requests).toHaveLength(1);
+            const request = requests[0];
+            expect(request.method).toBe('PUT');
+            expect(new URL(request.url).searchParams.get('revision_label')).toBe(revisionLabel);
+            expect(request.headers.has('x-revision-label')).toBe(false);
+            expect(request.headers.get('x-create-revision')).toBe('true');
+            expect(request.headers.get('if-match')).toBe('previous-etag');
+            expect(await request.clone().json()).toEqual({ name: 'Updated document' });
+        },
+    );
+
+    it('does not send a label when updating in place', async () => {
+        const requests: Request[] = [];
+        const client = new ZenoClient({
+            serverUrl: 'https://api.example.com',
+            fetch: vi.fn(async () => Response.json({ id: 'document-id' })),
+            onRequest: (request) => requests.push(request),
+        });
+
+        await client.objects.update('document-id', {}, { revisionLabel: 'Unused — label' });
+
+        expect(new URL(requests[0].url).searchParams.has('revision_label')).toBe(false);
+        expect(requests[0].headers.has('x-create-revision')).toBe(false);
+        expect(requests[0].headers.has('x-revision-label')).toBe(false);
+    });
+});

package/src/store/ObjectsApi.ts

@@ -437,9 +437,6 @@ export class ObjectsApi extends ApiTopic {
         }
         if (options?.createRevision) {
             headers[ContentObjectApiHeaders.CREATE_REVISION] = 'true';
-            if (options.revisionLabel) {
-                headers[ContentObjectApiHeaders.REVISION_LABEL] = options.revisionLabel;
-            }
         }
         if (options?.suppressWorkflows) {
             headers[ContentObjectApiHeaders.SUPPRESS_WORKFLOWS] = 'true';
@@ -447,6 +444,11 @@ export class ObjectsApi extends ApiTopic {
 
         return this.put(`/${id}`, {
             payload: updatePayload,
+            // The existing query contract preserves Unicode labels; HTTP headers only accept ByteString values.
+            query:
+                options?.createRevision && options.revisionLabel
+                    ? { revision_label: options.revisionLabel }
+                    : undefined,
             headers,
         });
     }

package/src/store/signed-url.test.ts

@@ -173,10 +173,32 @@ describe('fetchSignedUrl', () => {
 
     it('honors a numeric Retry-After header when scheduling the retry', async () => {
         fetchMock
-            .mockResolvedValueOnce(response(503, 'slow down', { 'retry-after': '2' }))
+            .mockResolvedValueOnce(response(503, 'slow down', { 'retry-after': '30' }))
             .mockResolvedValueOnce(response(200, 'ok'));
-        const res = await runAllTimers(fetchSignedUrl('https://storage/x'));
+        const pending = fetchSignedUrl('https://storage/x');
+        await vi.advanceTimersByTimeAsync(29999);
+        expect(fetchMock).toHaveBeenCalledTimes(1);
+        await vi.advanceTimersByTimeAsync(1);
+        const res = await pending;
         expect(res.status).toBe(200);
         expect(fetchMock).toHaveBeenCalledTimes(2);
     });
 });
+
+describe('Retry-After request budget', () => {
+    it.each(['3600', '2147484', '1e308', new Date(Date.now() + 3600000).toUTCString()])(
+        'returns the intact response without an early retry for %s',
+        async (retryAfter) => {
+            const res = new Response('retry later', { status: 503, headers: { 'Retry-After': retryAfter } });
+            const fetch = vi.spyOn(globalThis, 'fetch').mockResolvedValueOnce(res);
+            try {
+                const result = await fetchSignedUrl('https://storage/x');
+                expect(result).toBe(res);
+                expect(await result.text()).toBe('retry later');
+                expect(fetch).toHaveBeenCalledTimes(1);
+            } finally {
+                fetch.mockRestore();
+            }
+        },
+    );
+});

package/src/store/signed-url.ts

@@ -20,6 +20,7 @@ const DEFAULT_RETRYABLE_STATUSES: ReadonlySet<number> = new Set([429, 500, 502,
 const DEFAULT_ATTEMPTS = 4;
 const DEFAULT_BASE_DELAY_MS = 500;
 const DEFAULT_MAX_DELAY_MS = 8_000;
+const MAX_RETRY_AFTER_MS = 60_000;
 
 export interface SignedUrlFetchOptions {
     method?: string;
@@ -29,7 +30,7 @@ export interface SignedUrlFetchOptions {
     attempts?: number;
     /** Base delay for exponential backoff, in milliseconds. Defaults to 500. */
     baseDelayMs?: number;
-    /** Upper bound for a single backoff delay, in milliseconds. Defaults to 8000. */
+    /** Upper bound for exponential backoff, in milliseconds. Defaults to 8000. Retry-After takes precedence. */
     maxDelayMs?: number;
     /** HTTP statuses to retry on. Defaults to 429, 500, 502, 503, 504. */
     retryableStatuses?: ReadonlySet<number>;
@@ -58,7 +59,7 @@ function retryAfterMs(res: Response): number | undefined {
 function backoffMs(attempt: number, baseDelayMs: number, maxDelayMs: number, res?: Response): number {
     const retryAfter = res ? retryAfterMs(res) : undefined;
     if (retryAfter !== undefined) {
-        return Math.min(maxDelayMs, retryAfter);
+        return retryAfter;
     }
     // Exponential backoff with full jitter.
     const capped = Math.min(maxDelayMs, baseDelayMs * 2 ** attempt);
@@ -141,7 +142,8 @@ async function toReplayableBody(body: BodyInit | null | undefined): Promise<Body
 /**
  * `fetch()` a cloud-storage signed URL, retrying transient failures (connection
  * errors and retryable HTTP statuses) with exponential backoff. Honors a
- * `Retry-After` response header when present.
+ * `Retry-After` response header up to 60 seconds. Longer delays return the response
+ * without retrying so the caller can schedule recovery outside this request.
  *
  * The returned `Response` is only guaranteed to be retried while it carries a
  * retryable status; a non-retryable error response (e.g. 403, 404) is returned
@@ -167,6 +169,9 @@ export async function fetchSignedUrl(url: string, options: SignedUrlFetchOptions
             if (res.ok || !retryableStatuses.has(res.status) || isLastAttempt) {
                 return res;
             }
+            // Do not retry earlier than requested or park the caller beyond the retry budget.
+            // Returning the response also avoids overflowing JavaScript's timer range.
+            if ((retryAfterMs(res) ?? 0) > MAX_RETRY_AFTER_MS) return res;
             // Retryable status: drain the body so the connection can be reused, then back off.
             await res.body?.cancel().catch(() => undefined);
             await sleep(backoffMs(attempt, baseDelayMs, maxDelayMs, res));