@bxb1337/windsurf-fast-context 1.0.0

package/dist/cjs/provider.test.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const provider_js_1 = require("./provider.js");
+const devstral_language_model_js_1 = require("./model/devstral-language-model.js");
+// Helper to narrow the returned model in tests without using `any`.
+function providerShape(m) {
+    return m;
+}
+(0, vitest_1.describe)('provider factory', () => {
+    (0, vitest_1.it)('with-api-key: constructs model when apiKey passed explicitly', () => {
+        const factory = (0, provider_js_1.createWindsurfProvider)({ apiKey: 'explicit-key' });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        (0, vitest_1.expect)(model).toBeInstanceOf(devstral_language_model_js_1.DevstralLanguageModel);
+        (0, vitest_1.expect)(providerShape(model).apiKey).toBe('explicit-key');
+    });
+    (0, vitest_1.it)('env-var: uses WINDSURF_API_KEY when apiKey not provided', () => {
+        const old = process.env.WINDSURF_API_KEY;
+        try {
+            process.env.WINDSURF_API_KEY = 'env-key';
+            const factory = (0, provider_js_1.createWindsurfProvider)();
+            const model = factory('MODEL_SWE_1_6_FAST');
+            (0, vitest_1.expect)(providerShape(model).apiKey).toBe('env-key');
+        }
+        finally {
+            if (old === undefined)
+                delete process.env.WINDSURF_API_KEY;
+            else
+                process.env.WINDSURF_API_KEY = old;
+        }
+    });
+    (0, vitest_1.it)('no-key: throws when no api key available', () => {
+        const old = process.env.WINDSURF_API_KEY;
+        try {
+            delete process.env.WINDSURF_API_KEY;
+            const factory = (0, provider_js_1.createWindsurfProvider)();
+            (0, vitest_1.expect)(() => factory('MODEL_SWE_1_6_FAST')).toThrow('WINDSURF_API_KEY is required');
+        }
+        finally {
+            if (old === undefined)
+                delete process.env.WINDSURF_API_KEY;
+            else
+                process.env.WINDSURF_API_KEY = old;
+        }
+    });
+    (0, vitest_1.it)('custom-baseurl: passes baseURL and trims trailing slash', () => {
+        const factory = (0, provider_js_1.createWindsurfProvider)({ apiKey: 'k', baseURL: 'https://example.com/' });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        (0, vitest_1.expect)(providerShape(model).baseURL).toBe('https://example.com');
+    });
+    (0, vitest_1.it)('custom-headers: passes headers through to model', () => {
+        const headers = { 'x-foo': 'bar' };
+        const factory = (0, provider_js_1.createWindsurfProvider)({ apiKey: 'k', headers });
+        const model = factory('MODEL_SWE_1_6_FAST');
+        (0, vitest_1.expect)(providerShape(model).headers['x-foo']).toBe('bar');
+    });
+    (0, vitest_1.it)('exports: named factory and default windsurf', () => {
+        (0, vitest_1.expect)(typeof provider_js_1.createWindsurfProvider).toBe('function');
+        (0, vitest_1.expect)(provider_js_1.windsurf).toBeDefined();
+    });
+});

package/dist/cjs/transport/http.js

@@ -0,0 +1,83 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DevstralTransport = exports.DevstralTransportError = void 0;
+class DevstralTransportError extends Error {
+    code;
+    status;
+    constructor(code, message, status, options) {
+        super(message, options);
+        this.name = 'DevstralTransportError';
+        this.code = code;
+        this.status = status;
+    }
+}
+exports.DevstralTransportError = DevstralTransportError;
+class DevstralTransport {
+    fetchFn;
+    maxAttempts;
+    constructor(options = {}) {
+        this.fetchFn = options.fetch ?? fetch;
+        this.maxAttempts = Math.max(1, options.maxAttempts ?? 3);
+    }
+    postUnary(url, body, headers) {
+        return this.postUnaryRequest(url, body, headers);
+    }
+    postStreaming(url, body, headers, signal) {
+        return this.postStreamingRequest(url, body, headers, signal);
+    }
+    async postUnaryRequest(url, body, headers) {
+        const response = await this.post(url, body, headers);
+        return Buffer.from(await response.arrayBuffer());
+    }
+    async postStreamingRequest(url, body, headers, signal) {
+        const response = await this.post(url, body, headers, signal);
+        if (response.body == null) {
+            throw new DevstralTransportError('NETWORK_ERROR', 'Streaming response body is unavailable', response.status);
+        }
+        return response.body;
+    }
+    async post(url, body, headers, signal) {
+        for (let attempt = 1; attempt <= this.maxAttempts; attempt += 1) {
+            try {
+                const response = await this.fetchFn(url, {
+                    method: 'POST',
+                    headers,
+                    body,
+                    signal,
+                });
+                if (response.ok) {
+                    return response;
+                }
+                if (response.status === 403) {
+                    throw new DevstralTransportError('AUTH_ERROR', 'HTTP 403', response.status);
+                }
+                if (response.status === 429) {
+                    throw new DevstralTransportError('RATE_LIMITED', 'HTTP 429', response.status);
+                }
+                if (response.status >= 500 && response.status < 600) {
+                    if (attempt < this.maxAttempts) {
+                        continue;
+                    }
+                    throw new DevstralTransportError('NETWORK_ERROR', `HTTP ${response.status}`, response.status);
+                }
+                throw new DevstralTransportError('NETWORK_ERROR', `HTTP ${response.status}`, response.status);
+            }
+            catch (error) {
+                if (isAbortError(error)) {
+                    throw error;
+                }
+                if (error instanceof DevstralTransportError) {
+                    throw error;
+                }
+                throw new DevstralTransportError('NETWORK_ERROR', 'Network request failed', undefined, {
+                    cause: error,
+                });
+            }
+        }
+        throw new DevstralTransportError('NETWORK_ERROR', 'Network request failed');
+    }
+}
+exports.DevstralTransport = DevstralTransport;
+function isAbortError(error) {
+    return error instanceof Error && error.name === 'AbortError';
+}

package/dist/cjs/transport/http.test.js

@@ -0,0 +1,196 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const vitest_1 = require("vitest");
+const http_js_1 = require("./http.js");
+const requestBytes = Buffer.from([1, 2, 3, 4]);
+const responseBytes = Buffer.from([9, 8, 7, 6]);
+function bufferFromBody(body) {
+    if (body == null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new Error(`Unsupported request body type: ${typeof body}`);
+}
+function makeResponse(status, body) {
+    return new Response(Uint8Array.from(body), { status });
+}
+function makeChunkStream(chunks) {
+    let index = 0;
+    return new ReadableStream({
+        pull(controller) {
+            const chunk = chunks[index];
+            if (!chunk) {
+                controller.close();
+                return;
+            }
+            controller.enqueue(chunk);
+            index += 1;
+        },
+    });
+}
+async function readStreamBytes(stream) {
+    const reader = stream.getReader();
+    const chunks = [];
+    while (true) {
+        const next = await reader.read();
+        if (next.done) {
+            break;
+        }
+        chunks.push(Buffer.from(next.value));
+    }
+    return Buffer.concat(chunks);
+}
+function makeFakeFetch(sequence) {
+    const calls = [];
+    const queue = [...sequence];
+    const fakeFetch = async (input, init) => {
+        calls.push({ input, init });
+        const next = queue.shift();
+        if (!next) {
+            throw new Error('No fake fetch result configured');
+        }
+        if (next instanceof Error) {
+            throw next;
+        }
+        return next;
+    };
+    return { fakeFetch, calls };
+}
+(0, vitest_1.describe)('unary transport', () => {
+    (0, vitest_1.it)('unary posts bytes and returns response bytes', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(200, responseBytes)]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        const headers = new Headers({ 'content-type': 'application/grpc+proto' });
+        const output = await transport.postUnary('https://api.test/unary', requestBytes, headers);
+        (0, vitest_1.expect)(output).toEqual(responseBytes);
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        (0, vitest_1.expect)(calls[0]?.input).toBe('https://api.test/unary');
+        (0, vitest_1.expect)(calls[0]?.init?.method).toBe('POST');
+        (0, vitest_1.expect)(calls[0]?.init?.headers).toBe(headers);
+        (0, vitest_1.expect)(bufferFromBody(calls[0]?.init?.body)).toEqual(requestBytes);
+    });
+    (0, vitest_1.it)('unary retries 5xx responses and eventually succeeds', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([
+            makeResponse(500, Buffer.from('first-failure')),
+            makeResponse(502, Buffer.from('second-failure')),
+            makeResponse(200, responseBytes),
+        ]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        const output = await transport.postUnary('https://api.test/unary', requestBytes, new Headers());
+        (0, vitest_1.expect)(output).toEqual(responseBytes);
+        (0, vitest_1.expect)(calls).toHaveLength(3);
+    });
+});
+(0, vitest_1.describe)('streaming transport', () => {
+    (0, vitest_1.it)('streaming posts bytes and returns response stream without pre-buffering', async () => {
+        let arrayBufferCalled = false;
+        const streamingBody = makeChunkStream([
+            Uint8Array.from([9, 8]),
+            Uint8Array.from([7, 6]),
+        ]);
+        const streamingResponse = {
+            ok: true,
+            status: 200,
+            body: streamingBody,
+            arrayBuffer: async () => {
+                arrayBufferCalled = true;
+                throw new Error('arrayBuffer should not be called for streaming responses');
+            },
+        };
+        const { fakeFetch, calls } = makeFakeFetch([streamingResponse]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        const headers = new Headers({ accept: 'application/connect+proto' });
+        const output = await transport.postStreaming('https://api.test/stream', requestBytes, headers);
+        (0, vitest_1.expect)(output).toBe(streamingBody);
+        (0, vitest_1.expect)(await readStreamBytes(output)).toEqual(responseBytes);
+        (0, vitest_1.expect)(arrayBufferCalled).toBe(false);
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        (0, vitest_1.expect)(calls[0]?.input).toBe('https://api.test/stream');
+        (0, vitest_1.expect)(calls[0]?.init?.method).toBe('POST');
+        (0, vitest_1.expect)(calls[0]?.init?.headers).toBe(headers);
+        (0, vitest_1.expect)(bufferFromBody(calls[0]?.init?.body)).toEqual(requestBytes);
+    });
+    (0, vitest_1.it)('streaming throws NETWORK_ERROR when response body stream is missing', async () => {
+        const responseWithoutBody = {
+            ok: true,
+            status: 200,
+            body: null,
+            arrayBuffer: async () => Buffer.alloc(0),
+        };
+        const { fakeFetch } = makeFakeFetch([responseWithoutBody]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        await (0, vitest_1.expect)(transport.postStreaming('https://api.test/stream', requestBytes, new Headers())).rejects.toMatchObject({
+            code: 'NETWORK_ERROR',
+            message: 'Streaming response body is unavailable',
+        });
+    });
+    (0, vitest_1.it)('streaming uses AbortSignal to cancel request', async () => {
+        const controller = new AbortController();
+        const abortedError = new Error('Request aborted');
+        abortedError.name = 'AbortError';
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            calls.push({ input, init });
+            if (init?.signal?.aborted) {
+                throw abortedError;
+            }
+            return makeResponse(200, responseBytes);
+        };
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        controller.abort();
+        await (0, vitest_1.expect)(transport.postStreaming('https://api.test/stream', requestBytes, new Headers(), controller.signal)).rejects.toMatchObject({ name: 'AbortError' });
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        (0, vitest_1.expect)(calls[0]?.init?.signal).toBe(controller.signal);
+    });
+});
+(0, vitest_1.describe)('error classification', () => {
+    (0, vitest_1.it)('error maps 403 to AUTH_ERROR without retrying', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(403, Buffer.from('forbidden'))]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        await (0, vitest_1.expect)(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'AUTH_ERROR' });
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+    });
+    (0, vitest_1.it)('error maps 429 to RATE_LIMITED without retrying', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([makeResponse(429, Buffer.from('limited'))]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        await (0, vitest_1.expect)(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'RATE_LIMITED' });
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+    });
+    (0, vitest_1.it)('error maps network failures to NETWORK_ERROR', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([new Error('socket hang up')]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        await (0, vitest_1.expect)(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+    });
+    (0, vitest_1.it)('error does not downgrade https requests on TLS failures', async () => {
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            calls.push({ input, init });
+            throw new Error('TLS certificate verify failed');
+        };
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        const request = transport.postUnary('https://api.test/unary', requestBytes, new Headers());
+        await (0, vitest_1.expect)(request).rejects.toBeInstanceOf(http_js_1.DevstralTransportError);
+        await (0, vitest_1.expect)(request).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        (0, vitest_1.expect)(calls).toHaveLength(1);
+        (0, vitest_1.expect)(calls[0]?.input).toBe('https://api.test/unary');
+    });
+    (0, vitest_1.it)('error retries 5xx responses before throwing NETWORK_ERROR', async () => {
+        const { fakeFetch, calls } = makeFakeFetch([
+            makeResponse(500, Buffer.from('fail-1')),
+            makeResponse(500, Buffer.from('fail-2')),
+            makeResponse(503, Buffer.from('fail-3')),
+        ]);
+        const transport = new http_js_1.DevstralTransport({ fetch: fakeFetch });
+        await (0, vitest_1.expect)(transport.postUnary('https://api.test/unary', requestBytes, new Headers())).rejects.toMatchObject({ code: 'NETWORK_ERROR' });
+        (0, vitest_1.expect)(calls).toHaveLength(3);
+    });
+});

package/dist/cjs/types/index.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/conversion/prompt-converter.d.ts

@@ -0,0 +1,49 @@
+import type { DevstralMessage } from '../types/index.js';
+export type LanguageModelV3Prompt = Array<{
+    role: 'system';
+    content: string;
+} | {
+    role: 'user';
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'file';
+        data: string;
+        mediaType: string;
+    } | {
+        type: 'image';
+        image: string;
+    }>;
+} | {
+    role: 'assistant';
+    content: Array<{
+        type: 'text';
+        text: string;
+    } | {
+        type: 'tool-call';
+        toolCallId: string;
+        toolName: string;
+        args: unknown;
+    } | {
+        type: 'file';
+        data: string;
+        mediaType: string;
+    } | {
+        type: 'image';
+        image: string;
+    } | {
+        type: 'reasoning';
+        text: string;
+    }>;
+} | {
+    role: 'tool';
+    content: Array<{
+        type: 'tool-result';
+        toolCallId: string;
+        toolName: string;
+        result: unknown;
+        isError?: boolean;
+    }>;
+}>;
+export declare function convertPrompt(prompt: LanguageModelV3Prompt): DevstralMessage[];

package/dist/conversion/prompt-converter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/conversion/response-converter.d.ts

@@ -0,0 +1,12 @@
+export interface TextPart {
+    type: 'text';
+    text: string;
+}
+export interface ToolCallPart {
+    type: 'tool-call';
+    toolCallId: string;
+    toolName: string;
+    args: unknown;
+}
+export type LanguageModelV3Content = TextPart | ToolCallPart;
+export declare function convertResponse(buffer: Buffer): LanguageModelV3Content[];

package/dist/conversion/response-converter.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/esm/auth/api-key.js

@@ -0,0 +1,7 @@
+export function resolveApiKey(options) {
+    if (options?.apiKey)
+        return options.apiKey;
+    if (process.env.WINDSURF_API_KEY)
+        return process.env.WINDSURF_API_KEY;
+    throw new Error('WINDSURF_API_KEY is required');
+}

package/dist/esm/auth/api-key.test.js

@@ -0,0 +1,27 @@
+import { describe, it, expect, afterEach } from 'vitest';
+import { resolveApiKey } from './api-key';
+describe('api key resolver', () => {
+    const ORIGINAL = process.env.WINDSURF_API_KEY;
+    afterEach(() => {
+        // restore original env to avoid leakage
+        if (ORIGINAL === undefined) {
+            delete process.env.WINDSURF_API_KEY;
+        }
+        else {
+            process.env.WINDSURF_API_KEY = ORIGINAL;
+        }
+    });
+    it('constructor', () => {
+        const key = resolveApiKey({ apiKey: 'ctor-key' });
+        expect(key).toBe('ctor-key');
+    });
+    it('env', () => {
+        process.env.WINDSURF_API_KEY = 'test-key';
+        const key = resolveApiKey();
+        expect(key).toBe('test-key');
+    });
+    it('missing', () => {
+        delete process.env.WINDSURF_API_KEY;
+        expect(() => resolveApiKey()).toThrowError(new Error('WINDSURF_API_KEY is required'));
+    });
+});

package/dist/esm/auth/jwt-manager.js

@@ -0,0 +1,90 @@
+import { ProtobufEncoder } from '../protocol/protobuf.js';
+export const AUTH_BASE = 'https://server.self-serve.windsurf.com/exa.auth_pb.AuthService';
+const WS_APP = 'windsurf';
+const WS_APP_VER = process.env.WS_APP_VER ?? '1.48.2';
+const WS_LS_VER = process.env.WS_LS_VER ?? '1.9544.35';
+const JWT_PATTERN = /eyJ[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*\.[A-Za-z0-9_-]*/;
+export class JwtManager {
+    fetchFn;
+    authBase;
+    now;
+    cache = new Map();
+    inFlight = new Map();
+    constructor(options = {}) {
+        this.fetchFn = options.fetch ?? fetch;
+        this.authBase = options.authBase ?? AUTH_BASE;
+        this.now = options.now ?? Date.now;
+    }
+    async getJwt(apiKey) {
+        if (!apiKey) {
+            throw new Error('API key is required');
+        }
+        const nowSeconds = Math.floor(this.now() / 1000);
+        const cached = this.cache.get(apiKey);
+        if (cached && cached.expiresAt > nowSeconds + 60) {
+            return cached.token;
+        }
+        const inFlight = this.inFlight.get(apiKey);
+        if (inFlight) {
+            return inFlight;
+        }
+        const pending = this.fetchJwt(apiKey)
+            .then((token) => {
+            const expiresAt = getJwtExp(token) || Math.floor(this.now() / 1000) + 3600;
+            this.cache.set(apiKey, { token, expiresAt });
+            return token;
+        })
+            .finally(() => {
+            this.inFlight.delete(apiKey);
+        });
+        this.inFlight.set(apiKey, pending);
+        return pending;
+    }
+    async fetchJwt(apiKey) {
+        const metadata = new ProtobufEncoder();
+        metadata.writeString(1, WS_APP);
+        metadata.writeString(2, WS_APP_VER);
+        metadata.writeString(3, apiKey);
+        metadata.writeString(4, 'zh-cn');
+        metadata.writeString(7, WS_LS_VER);
+        metadata.writeString(12, WS_APP);
+        metadata.writeBytes(30, Buffer.from([0x00, 0x01]));
+        const requestBody = new ProtobufEncoder();
+        requestBody.writeMessage(1, metadata);
+        const response = await this.fetchFn(`${this.authBase}/GetUserJwt`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/proto',
+                'Connect-Protocol-Version': '1',
+                'User-Agent': 'connect-go/1.18.1 (go1.25.5)',
+            },
+            body: requestBody.toBuffer(),
+        });
+        if (!response.ok) {
+            throw new Error(`HTTP ${response.status}`);
+        }
+        const bytes = Buffer.from(await response.arrayBuffer());
+        const token = extractJwt(bytes);
+        if (!token) {
+            throw new Error('Failed to extract JWT from GetUserJwt response');
+        }
+        return token;
+    }
+}
+function extractJwt(value) {
+    const match = value.toString('utf8').match(JWT_PATTERN);
+    return match?.[0] ?? null;
+}
+function getJwtExp(jwt) {
+    try {
+        const payloadPart = jwt.split('.')[1];
+        if (!payloadPart) {
+            return 0;
+        }
+        const payload = JSON.parse(Buffer.from(payloadPart, 'base64url').toString('utf8'));
+        return typeof payload.exp === 'number' ? payload.exp : 0;
+    }
+    catch {
+        return 0;
+    }
+}

package/dist/esm/auth/jwt-manager.test.js

@@ -0,0 +1,97 @@
+import { describe, expect, it } from 'vitest';
+import { ProtobufEncoder } from '../protocol/protobuf.js';
+import { AUTH_BASE, JwtManager } from './jwt-manager.js';
+function makeJwt(exp, tag) {
+    const header = Buffer.from(JSON.stringify({ alg: 'HS256', typ: 'JWT' })).toString('base64url');
+    const payload = Buffer.from(JSON.stringify({ exp, tag })).toString('base64url');
+    return `${header}.${payload}.signature`;
+}
+function makeJwtResponse(token) {
+    const encoder = new ProtobufEncoder();
+    encoder.writeString(1, `prefix:${token}:suffix`);
+    return new Response(Uint8Array.from(encoder.toBuffer()), { status: 200 });
+}
+function bufferFromBody(body) {
+    if (body == null) {
+        return Buffer.alloc(0);
+    }
+    if (typeof body === 'string') {
+        return Buffer.from(body, 'utf8');
+    }
+    if (body instanceof ArrayBuffer) {
+        return Buffer.from(body);
+    }
+    if (ArrayBuffer.isView(body)) {
+        return Buffer.from(body.buffer, body.byteOffset, body.byteLength);
+    }
+    throw new Error(`Unsupported request body type: ${typeof body}`);
+}
+describe('jwt manager fetch', () => {
+    it('fetch exchanges api key to jwt and caches result', async () => {
+        const exp = 4_000_000_000;
+        const token = makeJwt(exp, 'first');
+        const calls = [];
+        const fakeFetch = async (input, init) => {
+            calls.push({ input, init });
+            return makeJwtResponse(token);
+        };
+        const manager = new JwtManager({ fetch: fakeFetch, now: () => (exp - 3_600) * 1000 });
+        const jwt1 = await manager.getJwt('test-api-key');
+        const jwt2 = await manager.getJwt('test-api-key');
+        expect(jwt1).toBe(token);
+        expect(jwt2).toBe(token);
+        expect(calls).toHaveLength(1);
+        expect(calls[0]?.input).toBe(`${AUTH_BASE}/GetUserJwt`);
+        expect(calls[0]?.init?.method).toBe('POST');
+        expect(new Headers(calls[0]?.init?.headers).get('content-type')).toBe('application/proto');
+        const requestBody = bufferFromBody(calls[0]?.init?.body);
+        expect(requestBody.length).toBeGreaterThan(0);
+        expect(requestBody.toString('utf8')).toContain('test-api-key');
+    });
+});
+describe('jwt manager expiry', () => {
+    it('expiry refreshes token when less than sixty seconds remain', async () => {
+        let nowMs = 0;
+        const token1 = makeJwt(10_000, 'first');
+        const token2 = makeJwt(20_000, 'second');
+        const queue = [makeJwtResponse(token1), makeJwtResponse(token2)];
+        let callCount = 0;
+        const fakeFetch = async () => {
+            callCount += 1;
+            const next = queue.shift();
+            if (!next) {
+                throw new Error('No fake fetch response queued');
+            }
+            return next;
+        };
+        const manager = new JwtManager({ fetch: fakeFetch, now: () => nowMs });
+        const first = await manager.getJwt('exp-api-key');
+        nowMs = (10_000 - 59) * 1000;
+        const second = await manager.getJwt('exp-api-key');
+        expect(first).toBe(token1);
+        expect(second).toBe(token2);
+        expect(callCount).toBe(2);
+    });
+});
+describe('jwt manager concurrent', () => {
+    it('concurrent getJwt calls share one in-flight fetch', async () => {
+        const token = makeJwt(50_000, 'concurrent');
+        let fetchCalls = 0;
+        let resolveFetch;
+        const pending = new Promise((resolve) => {
+            resolveFetch = resolve;
+        });
+        const fakeFetch = async () => {
+            fetchCalls += 1;
+            return pending;
+        };
+        const manager = new JwtManager({ fetch: fakeFetch, now: () => 0 });
+        const p1 = manager.getJwt('same-key');
+        const p2 = manager.getJwt('same-key');
+        resolveFetch(makeJwtResponse(token));
+        const [jwt1, jwt2] = await Promise.all([p1, p2]);
+        expect(fetchCalls).toBe(1);
+        expect(jwt1).toBe(token);
+        expect(jwt2).toBe(token);
+    });
+});