@open-webapp/drive-sync 0.1.0

package/dist/testing/driveFake.d.ts

@@ -0,0 +1,50 @@
+/**
+ * An in-memory fake of the subset of the Google Drive v3 REST API that this
+ * library needs: files (list/get/create/update/delete, including multipart
+ * and media-upload variants) and permissions (list/create/update/delete).
+ *
+ * Intended use:
+ *
+ * ```ts
+ * const driveFake = createDriveFake()
+ * vi.stubGlobal('fetch', driveFake.fetch)
+ * // ... exercise code under test ...
+ * expect(driveFake.folderCreationLog).toEqual(['OpenWebApp', 'Planning'])
+ * ```
+ */
+export interface DriveFakeFile {
+    id: string;
+    name: string;
+    mimeType: string;
+    parents: string[];
+    content: string;
+    contentType?: string;
+    trashed?: boolean;
+}
+export interface DriveFakePermission {
+    id: string;
+    type: string;
+    role: string;
+    emailAddress?: string;
+    [key: string]: unknown;
+}
+export interface StatusOverrideOptions {
+    retryAfter?: number;
+    body?: string;
+    /** How many matching requests this override applies to. Defaults to 1. */
+    times?: number;
+}
+export interface DriveFake {
+    fetch: typeof fetch;
+    /** Every folder name involved in a folder lookup query or a folder create, in call order. */
+    folderCreationLog: string[];
+    /** Force a specific response for the next N (default 1) requests whose URL matches `pattern`. */
+    setStatusOverride(pattern: string | RegExp, status: number, opts?: StatusOverrideOptions): void;
+    /** Clear all in-memory state (files, permissions, overrides, logs). */
+    reset(): void;
+    /** Inspect current in-memory files, keyed by id. */
+    readonly files: Map<string, DriveFakeFile>;
+    /** Inspect current in-memory permissions, keyed by fileId then permission id. */
+    readonly permissions: Map<string, Map<string, DriveFakePermission>>;
+}
+export declare function createDriveFake(): DriveFake;

package/dist/testing/driveFake.js

@@ -0,0 +1,423 @@
+/**
+ * An in-memory fake of the subset of the Google Drive v3 REST API that this
+ * library needs: files (list/get/create/update/delete, including multipart
+ * and media-upload variants) and permissions (list/create/update/delete).
+ *
+ * Intended use:
+ *
+ * ```ts
+ * const driveFake = createDriveFake()
+ * vi.stubGlobal('fetch', driveFake.fetch)
+ * // ... exercise code under test ...
+ * expect(driveFake.folderCreationLog).toEqual(['OpenWebApp', 'Planning'])
+ * ```
+ */
+const DRIVE_BASE = 'https://www.googleapis.com/drive/v3';
+const UPLOAD_BASE = 'https://www.googleapis.com/upload/drive/v3';
+const FOLDER_MIME_TYPE = 'application/vnd.google-apps.folder';
+function matchesPattern(pattern, url) {
+    return typeof pattern === 'string' ? url.includes(pattern) : pattern.test(url);
+}
+function jsonResponse(body, status = 200, headers) {
+    return new Response(JSON.stringify(body), {
+        status,
+        headers: { 'Content-Type': 'application/json', ...(headers ?? {}) },
+    });
+}
+function errorResponse(status, message, retryAfter, bodyOverride) {
+    const headers = {};
+    if (retryAfter !== undefined)
+        headers['Retry-After'] = String(retryAfter);
+    const body = bodyOverride ??
+        JSON.stringify({
+            error: {
+                code: status,
+                message,
+                errors: [{ reason: statusToReason(status), message }],
+            },
+        });
+    return new Response(body, {
+        status,
+        headers: { 'Content-Type': 'application/json', ...headers },
+    });
+}
+function statusToReason(status) {
+    switch (status) {
+        case 401:
+            return 'authError';
+        case 403:
+            return 'forbidden';
+        case 404:
+            return 'notFound';
+        case 429:
+            return 'rateLimitExceeded';
+        default:
+            return status >= 500 ? 'internalError' : 'invalid';
+    }
+}
+let idSeq = 0;
+function nextId() {
+    idSeq += 1;
+    return `fake-id-${idSeq}`;
+}
+/** Extract a quoted-string argument from a Drive `q=` query, e.g. name='X' -> X. */
+function extractQuotedField(q, field) {
+    const re = new RegExp(`${field}\\s*=\\s*'((?:[^'\\\\]|\\\\.)*)'`);
+    const m = re.exec(q);
+    return m ? m[1].replace(/\\'/g, "'") : undefined;
+}
+/** Extract the parent id from a `'parentId' in parents` clause. */
+function extractParentInParents(q) {
+    const m = /'((?:[^'\\]|\\.)*)'\s+in\s+parents/.exec(q);
+    return m ? m[1].replace(/\\'/g, "'") : undefined;
+}
+function parseMultipartBody(body, boundary) {
+    const parts = body.split(`--${boundary}`).filter((p) => p.trim() && p.trim() !== '--');
+    let metadata = {};
+    let mediaContent = '';
+    let mediaType;
+    for (const rawPart of parts) {
+        const part = rawPart.replace(/^\r\n/, '').replace(/\r\n--$/, '');
+        const headerEnd = part.indexOf('\r\n\r\n');
+        const headerBlock = headerEnd >= 0 ? part.slice(0, headerEnd) : '';
+        const content = headerEnd >= 0 ? part.slice(headerEnd + 4) : part;
+        const contentTypeMatch = /Content-Type:\s*([^\r\n]+)/i.exec(headerBlock);
+        const contentType = contentTypeMatch?.[1]?.trim();
+        const trimmedContent = content.replace(/\r\n$/, '');
+        if (contentType?.includes('application/json')) {
+            try {
+                metadata = JSON.parse(trimmedContent);
+            }
+            catch {
+                metadata = {};
+            }
+        }
+        else {
+            mediaContent = trimmedContent;
+            mediaType = contentType;
+        }
+    }
+    return { metadata, mediaContent, mediaType };
+}
+async function readBodyText(init) {
+    const body = init?.body;
+    if (body === undefined || body === null)
+        return '';
+    if (typeof body === 'string')
+        return body;
+    if (body instanceof Uint8Array)
+        return new TextDecoder().decode(body);
+    if (typeof body.text === 'function')
+        return await body.text();
+    return String(body);
+}
+function getHeader(init, name) {
+    const headers = init?.headers;
+    if (!headers)
+        return undefined;
+    if (headers instanceof Headers)
+        return headers.get(name) ?? undefined;
+    if (Array.isArray(headers)) {
+        const found = headers.find(([k]) => k.toLowerCase() === name.toLowerCase());
+        return found?.[1];
+    }
+    const rec = headers;
+    const key = Object.keys(rec).find((k) => k.toLowerCase() === name.toLowerCase());
+    return key ? rec[key] : undefined;
+}
+export function createDriveFake() {
+    const files = new Map();
+    const permissions = new Map();
+    const folderCreationLog = [];
+    const statusOverrides = [];
+    function takeOverride(url) {
+        const idx = statusOverrides.findIndex((o) => o.remaining > 0 && matchesPattern(o.pattern, url));
+        if (idx === -1)
+            return undefined;
+        const override = statusOverrides[idx];
+        override.remaining -= 1;
+        if (override.remaining <= 0) {
+            statusOverrides.splice(idx, 1);
+        }
+        return override;
+    }
+    function fileToMetadata(f) {
+        return { id: f.id, name: f.name, mimeType: f.mimeType, parents: f.parents };
+    }
+    async function handleFilesList(url) {
+        const q = url.searchParams.get('q') ?? '';
+        const name = extractQuotedField(q, 'name');
+        const mimeType = extractQuotedField(q, 'mimeType');
+        const parentId = extractParentInParents(q);
+        const trashedMatch = /trashed\s*=\s*(true|false)/.exec(q);
+        const wantTrashed = trashedMatch ? trashedMatch[1] === 'true' : undefined;
+        if (mimeType === FOLDER_MIME_TYPE && name !== undefined) {
+            folderCreationLog.push(name);
+        }
+        const results = [...files.values()].filter((f) => {
+            if (name !== undefined && f.name !== name)
+                return false;
+            if (mimeType !== undefined && f.mimeType !== mimeType)
+                return false;
+            if (parentId !== undefined && !f.parents.includes(parentId))
+                return false;
+            if (wantTrashed !== undefined && Boolean(f.trashed) !== wantTrashed)
+                return false;
+            return true;
+        });
+        return jsonResponse({ files: results.map(fileToMetadata) });
+    }
+    async function handleFileGet(url, id) {
+        const file = files.get(id);
+        if (!file || file.trashed) {
+            return errorResponse(404, `File not found: ${id}.`);
+        }
+        if (url.searchParams.get('alt') === 'media') {
+            return new Response(file.content, {
+                status: 200,
+                headers: { 'Content-Type': file.contentType ?? 'application/octet-stream' },
+            });
+        }
+        return jsonResponse(fileToMetadata(file));
+    }
+    async function handleFilesCreate(url, init) {
+        const uploadType = url.searchParams.get('uploadType');
+        const contentType = getHeader(init, 'Content-Type') ?? '';
+        const bodyText = await readBodyText(init);
+        let metadata = {};
+        let content = '';
+        let mediaType;
+        if (uploadType === 'multipart' || contentType.includes('multipart/related')) {
+            const boundaryMatch = /boundary=(?:"([^"]+)"|([^\s;]+))/i.exec(contentType);
+            const boundary = boundaryMatch?.[1] ?? boundaryMatch?.[2];
+            if (boundary) {
+                const parsed = parseMultipartBody(bodyText, boundary);
+                metadata = parsed.metadata;
+                content = parsed.mediaContent;
+                mediaType = parsed.mediaType;
+            }
+        }
+        else if (uploadType === 'media') {
+            content = bodyText;
+            mediaType = contentType || undefined;
+        }
+        else {
+            try {
+                metadata = bodyText ? JSON.parse(bodyText) : {};
+            }
+            catch {
+                metadata = {};
+            }
+        }
+        const id = nextId();
+        const mimeType = metadata.mimeType ?? mediaType ?? 'application/octet-stream';
+        const file = {
+            id,
+            name: metadata.name ?? '',
+            mimeType,
+            parents: Array.isArray(metadata.parents) ? metadata.parents : [],
+            content,
+            contentType: mediaType,
+        };
+        files.set(id, file);
+        if (mimeType === FOLDER_MIME_TYPE) {
+            folderCreationLog.push(file.name);
+        }
+        return jsonResponse(fileToMetadata(file), 200);
+    }
+    async function handleFileUpdate(url, id, init) {
+        const file = files.get(id);
+        if (!file) {
+            return errorResponse(404, `File not found: ${id}.`);
+        }
+        const uploadType = url.searchParams.get('uploadType');
+        const bodyText = await readBodyText(init);
+        if (uploadType === 'media') {
+            file.content = bodyText;
+            const contentType = getHeader(init, 'Content-Type');
+            if (contentType)
+                file.contentType = contentType;
+            return jsonResponse(fileToMetadata(file));
+        }
+        if (uploadType === 'multipart') {
+            const contentType = getHeader(init, 'Content-Type') ?? '';
+            const boundaryMatch = /boundary=(?:"([^"]+)"|([^\s;]+))/i.exec(contentType);
+            const boundary = boundaryMatch?.[1] ?? boundaryMatch?.[2];
+            if (boundary) {
+                const parsed = parseMultipartBody(bodyText, boundary);
+                if (parsed.metadata.name !== undefined)
+                    file.name = parsed.metadata.name;
+                if (parsed.metadata.mimeType !== undefined)
+                    file.mimeType = parsed.metadata.mimeType;
+                if (Array.isArray(parsed.metadata.parents))
+                    file.parents = parsed.metadata.parents;
+                file.content = parsed.mediaContent;
+                if (parsed.mediaType)
+                    file.contentType = parsed.mediaType;
+            }
+            return jsonResponse(fileToMetadata(file));
+        }
+        // Plain metadata PATCH (JSON body).
+        try {
+            const metadata = bodyText ? JSON.parse(bodyText) : {};
+            if (metadata.name !== undefined)
+                file.name = metadata.name;
+            if (metadata.mimeType !== undefined)
+                file.mimeType = metadata.mimeType;
+            if (Array.isArray(metadata.parents))
+                file.parents = metadata.parents;
+            if (metadata.trashed !== undefined)
+                file.trashed = metadata.trashed;
+        }
+        catch {
+            // ignore malformed body
+        }
+        // Support addParents / removeParents query params used by the real API.
+        const addParents = url.searchParams.get('addParents');
+        const removeParents = url.searchParams.get('removeParents');
+        if (addParents) {
+            for (const p of addParents.split(',')) {
+                if (!file.parents.includes(p))
+                    file.parents.push(p);
+            }
+        }
+        if (removeParents) {
+            const removeSet = new Set(removeParents.split(','));
+            file.parents = file.parents.filter((p) => !removeSet.has(p));
+        }
+        return jsonResponse(fileToMetadata(file));
+    }
+    async function handleFileDelete(id) {
+        if (!files.has(id)) {
+            return errorResponse(404, `File not found: ${id}.`);
+        }
+        files.delete(id);
+        permissions.delete(id);
+        return new Response(null, { status: 204 });
+    }
+    async function handlePermissionsList(fileId) {
+        const perms = permissions.get(fileId);
+        return jsonResponse({ permissions: perms ? [...perms.values()] : [] });
+    }
+    async function handlePermissionsCreate(fileId, init) {
+        const bodyText = await readBodyText(init);
+        let body = {};
+        try {
+            body = bodyText ? JSON.parse(bodyText) : {};
+        }
+        catch {
+            body = {};
+        }
+        const id = nextId();
+        const permission = {
+            id,
+            type: body.type ?? 'user',
+            role: body.role ?? 'reader',
+            emailAddress: body.emailAddress,
+        };
+        if (!permissions.has(fileId))
+            permissions.set(fileId, new Map());
+        permissions.get(fileId).set(id, permission);
+        return jsonResponse(permission);
+    }
+    async function handlePermissionUpdate(fileId, permId, init) {
+        const perms = permissions.get(fileId);
+        const permission = perms?.get(permId);
+        if (!permission) {
+            return errorResponse(404, `Permission not found: ${permId}.`);
+        }
+        const bodyText = await readBodyText(init);
+        try {
+            const body = bodyText ? JSON.parse(bodyText) : {};
+            if (body.role !== undefined)
+                permission.role = body.role;
+        }
+        catch {
+            // ignore malformed body
+        }
+        return jsonResponse(permission);
+    }
+    async function handlePermissionDelete(fileId, permId) {
+        const perms = permissions.get(fileId);
+        if (!perms?.has(permId)) {
+            return errorResponse(404, `Permission not found: ${permId}.`);
+        }
+        perms.delete(permId);
+        return new Response(null, { status: 204 });
+    }
+    const fakeFetch = async (input, init) => {
+        const url = typeof input === 'string' ? input : input?.url ?? String(input);
+        if (!url.startsWith(DRIVE_BASE) && !url.startsWith(UPLOAD_BASE)) {
+            throw new Error(`driveFake: unhandled URL (not a Drive API endpoint): ${url}`);
+        }
+        const override = takeOverride(url);
+        if (override) {
+            return errorResponse(override.status, 'Forced error (test override).', override.retryAfter, override.body);
+        }
+        const parsedUrl = new URL(url);
+        const method = (init?.method ?? 'GET').toUpperCase();
+        const base = url.startsWith(UPLOAD_BASE) ? UPLOAD_BASE : DRIVE_BASE;
+        const path = parsedUrl.pathname.slice(new URL(base).pathname.length).replace(/^\/+/, '');
+        const segments = path.split('/').filter(Boolean);
+        try {
+            // files collection: files, files/{id}, files/{id}/permissions, files/{id}/permissions/{permId}
+            if (segments[0] === 'files') {
+                if (segments.length === 1) {
+                    if (method === 'GET')
+                        return await handleFilesList(parsedUrl);
+                    if (method === 'POST')
+                        return await handleFilesCreate(parsedUrl, init);
+                }
+                else if (segments.length === 2) {
+                    const id = segments[1];
+                    if (method === 'GET')
+                        return await handleFileGet(parsedUrl, id);
+                    if (method === 'PATCH' || method === 'PUT')
+                        return await handleFileUpdate(parsedUrl, id, init);
+                    if (method === 'DELETE')
+                        return await handleFileDelete(id);
+                }
+                else if (segments.length === 3 && segments[2] === 'permissions') {
+                    const id = segments[1];
+                    if (method === 'GET')
+                        return await handlePermissionsList(id);
+                    if (method === 'POST')
+                        return await handlePermissionsCreate(id, init);
+                }
+                else if (segments.length === 4 && segments[2] === 'permissions') {
+                    const id = segments[1];
+                    const permId = segments[3];
+                    if (method === 'PATCH' || method === 'PUT')
+                        return await handlePermissionUpdate(id, permId, init);
+                    if (method === 'DELETE')
+                        return await handlePermissionDelete(id, permId);
+                }
+            }
+        }
+        catch (err) {
+            return errorResponse(500, err instanceof Error ? err.message : String(err));
+        }
+        return errorResponse(404, `driveFake: unhandled request ${method} ${url}`);
+    };
+    return {
+        fetch: fakeFetch,
+        folderCreationLog,
+        setStatusOverride(pattern, status, opts) {
+            statusOverrides.push({
+                pattern,
+                status,
+                retryAfter: opts?.retryAfter,
+                body: opts?.body,
+                remaining: opts?.times ?? 1,
+            });
+        },
+        reset() {
+            files.clear();
+            permissions.clear();
+            folderCreationLog.length = 0;
+            statusOverrides.length = 0;
+        },
+        files,
+        permissions,
+    };
+}

package/dist/testing/gisFake.d.ts

@@ -0,0 +1,60 @@
+/**
+ * A scriptable double for Google Identity Services (GIS) token client,
+ * for use in tests of code that calls
+ * `window.google.accounts.oauth2.initTokenClient(...)`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const gisFake = createGisFake()
+ * gisFake.install()
+ * gisFake.queueResponse({ access_token: 'tok', expires_in: 3600, scope: 'a b' })
+ * // ... exercise code under test ...
+ * expect(gisFake.calls).toEqual([{ prompt: 'consent', hint: undefined, scope: 'a b' }])
+ * ```
+ */
+export interface GisTokenResponse {
+    access_token?: string;
+    expires_in?: number;
+    scope?: string;
+    error?: string;
+}
+export interface GisRecordedCall {
+    prompt: string;
+    hint?: string;
+    scope: string;
+}
+export interface GisTokenClientConfig {
+    client_id?: string;
+    scope?: string;
+    prompt?: string;
+    hint?: string;
+    callback?: (response: GisTokenResponse) => void;
+    error_callback?: (error: {
+        type?: string;
+        message?: string;
+    }) => void;
+    [key: string]: unknown;
+}
+export interface GisRequestAccessTokenOverride {
+    prompt?: string;
+    hint?: string;
+    scope?: string;
+    [key: string]: unknown;
+}
+export interface GisTokenClient {
+    requestAccessToken(overrideConfig?: GisRequestAccessTokenOverride): void;
+}
+export interface GisFake {
+    /** All calls made via `requestAccessToken`, in order. */
+    calls: GisRecordedCall[];
+    /** Queue a response to be delivered to the next `requestAccessToken` call. */
+    queueResponse(response: GisTokenResponse): void;
+    /** Stub `window.google.accounts.oauth2.initTokenClient` with this fake. */
+    install(): void;
+    /** Remove the stub installed by `install()`, restoring prior state. */
+    uninstall(): void;
+    /** Clear queued responses and call history. */
+    reset(): void;
+}
+export declare function createGisFake(): GisFake;

package/dist/testing/gisFake.js

@@ -0,0 +1,86 @@
+/**
+ * A scriptable double for Google Identity Services (GIS) token client,
+ * for use in tests of code that calls
+ * `window.google.accounts.oauth2.initTokenClient(...)`.
+ *
+ * Usage:
+ *
+ * ```ts
+ * const gisFake = createGisFake()
+ * gisFake.install()
+ * gisFake.queueResponse({ access_token: 'tok', expires_in: 3600, scope: 'a b' })
+ * // ... exercise code under test ...
+ * expect(gisFake.calls).toEqual([{ prompt: 'consent', hint: undefined, scope: 'a b' }])
+ * ```
+ */
+export function createGisFake() {
+    const responseQueue = [];
+    const calls = [];
+    let previousGoogle;
+    let hadGoogle = false;
+    function nextResponse() {
+        const next = responseQueue.shift();
+        if (next)
+            return next;
+        // Default: a generic successful token response.
+        return { access_token: 'fake-access-token', expires_in: 3600, scope: '' };
+    }
+    function initTokenClient(config) {
+        return {
+            requestAccessToken(overrideConfig) {
+                const prompt = overrideConfig?.prompt ?? config.prompt ?? 'consent';
+                const hint = overrideConfig?.hint ?? config.hint;
+                const scope = overrideConfig?.scope ?? config.scope ?? '';
+                calls.push({ prompt, hint, scope });
+                const response = nextResponse();
+                const callback = config.callback;
+                // Deliver asynchronously (microtask), matching the real GIS client's
+                // callback-based, non-synchronous delivery.
+                queueMicrotask(() => {
+                    if (response.error) {
+                        // The real GIS client invokes the token callback with an object
+                        // containing an `error` field (e.g. `{ error: 'access_denied' }`)
+                        // rather than throwing or rejecting a promise.
+                        callback?.({ error: response.error });
+                        return;
+                    }
+                    callback?.(response);
+                });
+            },
+        };
+    }
+    return {
+        calls,
+        queueResponse(response) {
+            responseQueue.push(response);
+        },
+        install() {
+            const w = globalThis;
+            hadGoogle = Object.prototype.hasOwnProperty.call(w, 'google');
+            previousGoogle = w.google;
+            if (!w.google) {
+                w.google = {};
+            }
+            if (!w.google.accounts) {
+                w.google.accounts = {};
+            }
+            if (!w.google.accounts.oauth2) {
+                w.google.accounts.oauth2 = {};
+            }
+            w.google.accounts.oauth2.initTokenClient = initTokenClient;
+        },
+        uninstall() {
+            const w = globalThis;
+            if (hadGoogle) {
+                w.google = previousGoogle;
+            }
+            else {
+                delete w.google;
+            }
+        },
+        reset() {
+            responseQueue.length = 0;
+            calls.length = 0;
+        },
+    };
+}

package/dist/testing/index.d.ts

@@ -0,0 +1,4 @@
+export { createGisFake } from './gisFake.js';
+export type { GisFake, GisTokenResponse, GisRecordedCall } from './gisFake.js';
+export { createDriveFake } from './driveFake.js';
+export type { DriveFake, DriveFakeFile, DriveFakePermission, StatusOverrideOptions } from './driveFake.js';

package/dist/testing/index.js

@@ -0,0 +1,2 @@
+export { createGisFake } from './gisFake.js';
+export { createDriveFake } from './driveFake.js';

package/dist/token.d.ts

@@ -0,0 +1,54 @@
+import type { Logger } from './logger.js';
+import type { StoredToken } from './types.js';
+/** Minimal shape of the GIS token response passed to a token client's callback. */
+interface GisTokenResponse {
+    access_token?: string;
+    expires_in?: number;
+    scope?: string;
+    error?: string;
+}
+/**
+ * Persists a freshly-acquired GIS token response as a StoredToken, deriving
+ * expiresAt from the response's own expires_in (never hardcoded) and
+ * grantedScopes from the response's space-delimited scope string.
+ */
+export declare function persistTokenResponse(appId: string, projectId: string, response: GisTokenResponse): Promise<StoredToken>;
+export interface AcquireTokenOptions {
+    appId: string;
+    projectId: string;
+    clientId: string;
+    scopes: string[];
+    interactive: boolean;
+    hint?: string;
+    logger?: Logger;
+}
+/**
+ * Records that another tab just persisted a fresh token for `projectId` (via
+ * a cross-tab `token` broadcast). The NEXT non-interactive `acquireToken`
+ * call for this project will, instead of unconditionally starting a new GIS
+ * round-trip, first re-read the token this tab already shares via
+ * IndexedDB — skipping the redundant network request when that stored token
+ * turns out to already be usable.
+ */
+export declare function notifyExternalTokenRefresh(projectId: string): void;
+/**
+ * Single entry point for acquiring a Drive access token, used by BOTH the
+ * interactive "connect" path (interactive: true -> prompt: 'consent', no
+ * hint) and the silent "refresh" path (interactive: false -> prompt: 'none',
+ * hint: the connection's known email).
+ *
+ * Design contract (see report): if `interactive` is false and GIS reports an
+ * error on the silent attempt, this function throws a NeedsReauthError
+ * itself (rather than pushing that decision to the caller). Callers that
+ * want to surface a different error type on the interactive path may catch
+ * and rethrow.
+ *
+ * Every call creates a FRESH `initTokenClient` — there is no module-level
+ * client, no module-level resolve/reject, and no module-level in-flight
+ * promise. Concurrent calls for different (projectId, scopes) pairs cannot
+ * collide; concurrent calls for the SAME (projectId, scopes) pair are
+ * coalesced onto a single in-flight promise (removed from the map in a
+ * `finally` once it settles).
+ */
+export declare function acquireToken(opts: AcquireTokenOptions): Promise<StoredToken>;
+export {};