docs-combiner 0.4.0 → 1.0.0

package/dist/integrations/driveApi.js

@@ -0,0 +1,420 @@
+"use strict";
+/**
+ * Google Drive REST + Google OAuth: низкоуровневые HTTP-примитивы.
+ * Без зависимостей от React и состояния приложения — токен передаётся параметром.
+ * Примитивы возвращают сырой Response: обработка ошибок/ретраи/refresh остаются у вызывающего кода.
+ * (Фаза 0 миграции на VPS: см. VPS_MIGRATION_DRAFT.md.)
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GOOGLE_TOKENINFO_URL = exports.GOOGLE_OAUTH_TOKEN_URL = exports.DRIVE_UPLOAD_FILES_URL = exports.DRIVE_FILES_URL = void 0;
+exports.setDriveServerProxyConfigProvider = setDriveServerProxyConfigProvider;
+exports.driveListFiles = driveListFiles;
+exports.driveGetFileMetadata = driveGetFileMetadata;
+exports.driveDownloadFile = driveDownloadFile;
+exports.driveCreateFolderRequest = driveCreateFolderRequest;
+exports.driveMultipartUploadRequest = driveMultipartUploadRequest;
+exports.driveMediaUpdateRequest = driveMediaUpdateRequest;
+exports.driveDeleteFileRequest = driveDeleteFileRequest;
+exports.driveCreatePermissionRequest = driveCreatePermissionRequest;
+exports.fetchDriveFilePermissions = fetchDriveFilePermissions;
+exports.permissionsIncludeAnyoneLink = permissionsIncludeAnyoneLink;
+exports.ensureOfferFolderAnyoneLinkReader = ensureOfferFolderAnyoneLinkReader;
+exports.googleOAuthTokenRequest = googleOAuthTokenRequest;
+exports.googleTokenInfoRequest = googleTokenInfoRequest;
+const httpTimeout_1 = require("./httpTimeout");
+exports.DRIVE_FILES_URL = 'https://www.googleapis.com/drive/v3/files';
+exports.DRIVE_UPLOAD_FILES_URL = 'https://www.googleapis.com/upload/drive/v3/files';
+exports.GOOGLE_OAUTH_TOKEN_URL = 'https://oauth2.googleapis.com/token';
+exports.GOOGLE_TOKENINFO_URL = 'https://www.googleapis.com/oauth2/v1/tokeninfo';
+let driveServerProxyConfigProvider = null;
+function setDriveServerProxyConfigProvider(provider) {
+    driveServerProxyConfigProvider = provider;
+}
+function getDriveServerProxyConfig() {
+    var _a, _b, _c, _d, _e;
+    const config = (_a = driveServerProxyConfigProvider === null || driveServerProxyConfigProvider === void 0 ? void 0 : driveServerProxyConfigProvider()) !== null && _a !== void 0 ? _a : null;
+    const baseUrl = (_c = (_b = config === null || config === void 0 ? void 0 : config.baseUrl) === null || _b === void 0 ? void 0 : _b.trim().replace(/\/+$/, '')) !== null && _c !== void 0 ? _c : '';
+    const token = (_e = (_d = config === null || config === void 0 ? void 0 : config.token) === null || _d === void 0 ? void 0 : _d.trim()) !== null && _e !== void 0 ? _e : '';
+    if (!baseUrl || !token)
+        return null;
+    return { baseUrl, token };
+}
+function buildServerApiUrl(baseUrl, path) {
+    return `${baseUrl}${path.startsWith('/') ? path : `/${path}`}`;
+}
+function serverAuthHeaders(config, extra) {
+    return Object.assign({ Authorization: `Bearer ${config.token}` }, extra);
+}
+function blobToBase64(blob) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const buffer = yield blob.arrayBuffer();
+        let binary = '';
+        const bytes = new Uint8Array(buffer);
+        const chunkSize = 0x8000;
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+        }
+        return btoa(binary);
+    });
+}
+function bodyInitToProxyPayload(body) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (typeof body === 'string')
+            return { text: body };
+        if (body instanceof Blob) {
+            return { base64: yield blobToBase64(body), contentType: body.type || undefined };
+        }
+        if (body instanceof ArrayBuffer) {
+            return { base64: yield blobToBase64(new Blob([body])) };
+        }
+        if (ArrayBuffer.isView(body)) {
+            return { base64: yield blobToBase64(new Blob([body.buffer.slice(body.byteOffset, body.byteOffset + body.byteLength)])) };
+        }
+        return { text: String(body) };
+    });
+}
+function formDataToProxyParts(form) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const parts = [];
+        const entries = form.entries();
+        for (const [name, value] of entries) {
+            if (typeof value === 'string') {
+                parts.push({ name, text: value });
+                continue;
+            }
+            const fileLike = value;
+            parts.push({
+                name,
+                filename: typeof fileLike.name === 'string' ? fileLike.name : undefined,
+                contentType: value.type || undefined,
+                base64: yield blobToBase64(value),
+            });
+        }
+        return parts;
+    });
+}
+function responseFromBase64Payload(payload, status) {
+    const binary = atob(payload.base64 || '');
+    const bytes = new Uint8Array(binary.length);
+    for (let i = 0; i < binary.length; i += 1)
+        bytes[i] = binary.charCodeAt(i);
+    return new Response(bytes, {
+        status,
+        headers: { 'Content-Type': payload.contentType || 'application/octet-stream' },
+    });
+}
+function rendererRequiresDriveProxyResponse() {
+    if (typeof window === 'undefined')
+        return null;
+    return new Response(JSON.stringify({
+        ok: false,
+        error: 'Drive operations require configured VPS Drive proxy.',
+    }), {
+        status: 400,
+        headers: { 'Content-Type': 'application/json' },
+    });
+}
+function authHeaders(token) {
+    return { Authorization: `Bearer ${token}` };
+}
+// ---------------------------------------------------------------------------
+// Files: list / metadata / download
+// ---------------------------------------------------------------------------
+/** `GET /files?q=...&fields=...` */
+function driveListFiles(token, q, fields, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, '/api/drive/files/list'), {
+                method: 'POST',
+                headers: serverAuthHeaders(proxy, { 'Content-Type': 'application/json' }),
+                body: JSON.stringify({
+                    q,
+                    fields,
+                    supportsAllDrives: (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) === true,
+                    pageSize: opts === null || opts === void 0 ? void 0 : opts.pageSize,
+                }),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        let url = `${exports.DRIVE_FILES_URL}?q=${encodeURIComponent(q)}&fields=${encodeURIComponent(fields)}`;
+        if (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives)
+            url += '&supportsAllDrives=true';
+        if (opts === null || opts === void 0 ? void 0 : opts.pageSize)
+            url += `&pageSize=${opts.pageSize}`;
+        return (0, httpTimeout_1.fetchWithTimeout)(url, { headers: authHeaders(token) });
+    });
+}
+/** `GET /files/{id}?fields=...` */
+function driveGetFileMetadata(token, fileId, fields, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            const params = new URLSearchParams({ fields });
+            if (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives)
+                params.set('supportsAllDrives', 'true');
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, `/api/drive/files/${encodeURIComponent(fileId)}/metadata?${params.toString()}`), {
+                headers: serverAuthHeaders(proxy),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        let url = `${exports.DRIVE_FILES_URL}/${encodeURIComponent(fileId)}?fields=${encodeURIComponent(fields)}`;
+        if (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives)
+            url += '&supportsAllDrives=true';
+        return (0, httpTimeout_1.fetchWithTimeout)(url, { headers: authHeaders(token) });
+    });
+}
+/** `GET /files/{id}?alt=media` — скачивание содержимого. */
+function driveDownloadFile(token, fileId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            const response = yield (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, `/api/drive/files/${encodeURIComponent(fileId)}/download`), {
+                headers: serverAuthHeaders(proxy),
+            });
+            if (!response.ok) {
+                return new Response(yield response.text(), { status: response.status, statusText: response.statusText });
+            }
+            const payload = yield response.json().catch(() => ({}));
+            return responseFromBase64Payload(payload, response.status);
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_FILES_URL}/${encodeURIComponent(fileId)}?alt=media`, {
+            headers: authHeaders(token),
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Files: create / upload / update / delete
+// ---------------------------------------------------------------------------
+/** `POST /files` — создание папки. */
+function driveCreateFolderRequest(token, folderName, parentFolderId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, '/api/drive/folders'), {
+                method: 'POST',
+                headers: serverAuthHeaders(proxy, { 'Content-Type': 'application/json' }),
+                body: JSON.stringify({ folderName, parentFolderId }),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_FILES_URL}?supportsAllDrives=true`, {
+            method: 'POST',
+            headers: Object.assign(Object.assign({}, authHeaders(token)), { 'Content-Type': 'application/json' }),
+            body: JSON.stringify({
+                name: folderName,
+                mimeType: 'application/vnd.google-apps.folder',
+                parents: [parentFolderId],
+            }),
+        });
+    });
+}
+/**
+ * Multipart upload: `POST /upload/files?uploadType=multipart` (создание)
+ * или `PATCH /upload/files/{id}?uploadType=multipart` (обновление, если передан existingFileId).
+ * FormData с metadata/file собирает вызывающий код.
+ */
+function driveMultipartUploadRequest(token, form, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            const parts = yield formDataToProxyParts(form);
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, '/api/drive/files/multipart'), {
+                method: 'POST',
+                headers: serverAuthHeaders(proxy, { 'Content-Type': 'application/json' }),
+                body: JSON.stringify({
+                    parts,
+                    existingFileId: (opts === null || opts === void 0 ? void 0 : opts.existingFileId) || undefined,
+                    supportsAllDrives: (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) === true,
+                }),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        const suffix = (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) ? '&supportsAllDrives=true' : '';
+        if (opts === null || opts === void 0 ? void 0 : opts.existingFileId) {
+            return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_UPLOAD_FILES_URL}/${encodeURIComponent(opts.existingFileId)}?uploadType=multipart${suffix}`, {
+                method: 'PATCH',
+                headers: authHeaders(token),
+                body: form,
+            });
+        }
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_UPLOAD_FILES_URL}?uploadType=multipart${suffix}`, {
+            method: 'POST',
+            headers: authHeaders(token),
+            body: form,
+        });
+    });
+}
+/** `PATCH /upload/files/{id}?uploadType=media` — замена содержимого файла. */
+function driveMediaUpdateRequest(token, fileId, body, contentType, fields) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            const payload = yield bodyInitToProxyPayload(body);
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, `/api/drive/files/${encodeURIComponent(fileId)}/media`), {
+                method: 'PATCH',
+                headers: serverAuthHeaders(proxy, { 'Content-Type': 'application/json' }),
+                body: JSON.stringify(Object.assign(Object.assign({}, payload), { contentType: payload.contentType || contentType, fields })),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        const fieldsSuffix = fields ? `&fields=${fields}` : '';
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_UPLOAD_FILES_URL}/${encodeURIComponent(fileId)}?uploadType=media${fieldsSuffix}`, {
+            method: 'PATCH',
+            headers: Object.assign(Object.assign({}, authHeaders(token)), { 'Content-Type': contentType }),
+            body,
+        });
+    });
+}
+/** `DELETE /files/{id}` */
+function driveDeleteFileRequest(token, fileId, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            const params = new URLSearchParams();
+            if (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives)
+                params.set('supportsAllDrives', 'true');
+            const suffix = params.toString() ? `?${params.toString()}` : '';
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, `/api/drive/files/${encodeURIComponent(fileId)}${suffix}`), {
+                method: 'DELETE',
+                headers: serverAuthHeaders(proxy),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        const suffix = (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) ? '?supportsAllDrives=true' : '';
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_FILES_URL}/${encodeURIComponent(fileId)}${suffix}`, {
+            method: 'DELETE',
+            headers: authHeaders(token),
+        });
+    });
+}
+// ---------------------------------------------------------------------------
+// Permissions
+// ---------------------------------------------------------------------------
+/** `POST /files/{id}/permissions` */
+function driveCreatePermissionRequest(token, fileId, permission, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const proxy = getDriveServerProxyConfig();
+        if (proxy) {
+            return (0, httpTimeout_1.fetchWithTimeout)(buildServerApiUrl(proxy.baseUrl, `/api/drive/files/${encodeURIComponent(fileId)}/permissions`), {
+                method: 'POST',
+                headers: serverAuthHeaders(proxy, { 'Content-Type': 'application/json' }),
+                body: JSON.stringify(Object.assign(Object.assign({}, permission), { supportsAllDrives: (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) === true })),
+            });
+        }
+        const proxyRequired = rendererRequiresDriveProxyResponse();
+        if (proxyRequired)
+            return proxyRequired;
+        const suffix = (opts === null || opts === void 0 ? void 0 : opts.supportsAllDrives) ? '?supportsAllDrives=true' : '';
+        return (0, httpTimeout_1.fetchWithTimeout)(`${exports.DRIVE_FILES_URL}/${encodeURIComponent(fileId)}/permissions${suffix}`, {
+            method: 'POST',
+            headers: Object.assign(Object.assign({}, authHeaders(token)), { 'Content-Type': 'application/json' }),
+            body: JSON.stringify(permission),
+        });
+    });
+}
+function fetchDriveFilePermissions(token, fileId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const permissionsResponse = yield driveGetFileMetadata(token, fileId, 'permissions(id,type,role)', {
+            supportsAllDrives: true,
+        });
+        if (!permissionsResponse.ok) {
+            return { ok: false, errorText: yield permissionsResponse.text() };
+        }
+        const permissionsData = yield permissionsResponse.json();
+        return { ok: true, permissions: permissionsData.permissions || [] };
+    });
+}
+/** Доступ «любой по ссылке» / публичный читатель — нужен для скачивания референса по URL без OAuth. */
+function permissionsIncludeAnyoneLink(permissions) {
+    return permissions.some(p => p.type === 'anyone');
+}
+/**
+ * Гарантирует право anyone/reader на папке оффера (нужен публичный URL для OpenRouter).
+ * Если доступа не было — создаёт через Drive API.
+ */
+function ensureOfferFolderAnyoneLinkReader(token, folderId) {
+    return __awaiter(this, void 0, void 0, function* () {
+        const initial = yield fetchDriveFilePermissions(token, folderId);
+        if (!initial.ok) {
+            return {
+                ok: false,
+                message: 'Не удалось проверить доступ к папке оффера в Google Диске.\n\n' +
+                    'Генерация изображений с референсом может не работать без доступа по ссылке.\n\n' +
+                    (initial.errorText.trim().slice(0, 280) || 'Ошибка API')
+            };
+        }
+        if (permissionsIncludeAnyoneLink(initial.permissions)) {
+            return { ok: true, alreadyHadLink: true };
+        }
+        const createPermissionResponse = yield driveCreatePermissionRequest(token, folderId, { type: 'anyone', role: 'reader' }, { supportsAllDrives: true });
+        if (!createPermissionResponse.ok) {
+            const errorText = yield createPermissionResponse.text();
+            const recheck = yield fetchDriveFilePermissions(token, folderId);
+            if (recheck.ok && permissionsIncludeAnyoneLink(recheck.permissions)) {
+                return { ok: true, alreadyHadLink: true };
+            }
+            return {
+                ok: false,
+                message: 'Не удалось включить доступ по ссылке для папки оффера.\n\n' +
+                    (errorText.trim().slice(0, 280) || 'Ошибка API') +
+                    '\n\nВключите вручную в Google Диске: «Все, у кого есть ссылка» → Читатель.'
+            };
+        }
+        const verify = yield fetchDriveFilePermissions(token, folderId);
+        if (!verify.ok) {
+            return {
+                ok: false,
+                message: 'Не удалось повторно проверить доступ к папке после запроса на общий доступ.\n\n' +
+                    (verify.errorText.trim().slice(0, 280) || 'Ошибка API')
+            };
+        }
+        if (!permissionsIncludeAnyoneLink(verify.permissions)) {
+            return {
+                ok: false,
+                message: 'Запрос на доступ отправлен, но проверка не подтвердила «Все, у кого есть ссылка».\n\n' +
+                    'Проверьте папку в Google Диске вручную (роль «Читатель»).'
+            };
+        }
+        return { ok: true, alreadyHadLink: false };
+    });
+}
+// ---------------------------------------------------------------------------
+// Google OAuth
+// ---------------------------------------------------------------------------
+/** `POST oauth2/token` (authorization_code / refresh_token). */
+function googleOAuthTokenRequest(params) {
+    return (0, httpTimeout_1.fetchWithTimeout)(exports.GOOGLE_OAUTH_TOKEN_URL, {
+        method: 'POST',
+        headers: { 'Content-Type': 'application/x-www-form-urlencoded' },
+        body: new URLSearchParams(params),
+    });
+}
+/** `GET tokeninfo?access_token=...` — проверка валидности access token. */
+function googleTokenInfoRequest(accessToken) {
+    return (0, httpTimeout_1.fetchWithTimeout)(`${exports.GOOGLE_TOKENINFO_URL}?access_token=${encodeURIComponent(accessToken)}`);
+}

package/dist/integrations/httpTimeout.js

@@ -0,0 +1,116 @@
+"use strict";
+/**
+ * Общий помощник для устойчивых сетевых запросов: любой fetch получает жёсткий дедлайн
+ * через AbortController, чтобы при пропаже интернета запрос не висел бесконечно.
+ * Используется и в рендерере, и в VPS-сервере (fetch/AbortController глобальны в обоих).
+ */
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NetworkTimeoutError = exports.UPLOAD_NETWORK_TIMEOUT_MS = exports.DEFAULT_NETWORK_TIMEOUT_MS = void 0;
+exports.isTransientNetworkError = isTransientNetworkError;
+exports.fetchWithTimeout = fetchWithTimeout;
+/** Дефолтный таймаут для обычных API-запросов (JSON, метаданные, поллинг). */
+exports.DEFAULT_NETWORK_TIMEOUT_MS = 60000;
+/** Таймаут для тяжёлых операций (загрузка/скачивание файлов в Drive). */
+exports.UPLOAD_NETWORK_TIMEOUT_MS = 120000;
+/** Ошибка превышения сетевого таймаута — отличима от «честного» AbortError вызывающего кода. */
+class NetworkTimeoutError extends Error {
+    constructor(timeoutMs, url) {
+        super(`Сеть недоступна: запрос не ответил за ${Math.round(timeoutMs / 1000)}с${url ? ` (${url})` : ''}`);
+        this.isNetworkTimeout = true;
+        this.name = 'NetworkTimeoutError';
+        this.timeoutMs = timeoutMs;
+    }
+}
+exports.NetworkTimeoutError = NetworkTimeoutError;
+/**
+ * Признак «временной» сетевой ошибки (пропал интернет, DNS, таймаут, обрыв соединения).
+ * Такие ошибки безопасно ретраить — они не означают логической проблемы запроса.
+ */
+function isTransientNetworkError(err) {
+    if (!err)
+        return false;
+    if (err instanceof NetworkTimeoutError)
+        return true;
+    if ((err === null || err === void 0 ? void 0 : err.isNetworkTimeout) === true)
+        return true;
+    const name = (err === null || err === void 0 ? void 0 : err.name) || '';
+    if (name === 'AbortError' || name === 'TimeoutError')
+        return true;
+    const message = String((err === null || err === void 0 ? void 0 : err.message) || err).toLowerCase();
+    return (message.includes('failed to fetch') ||
+        message.includes('load failed') ||
+        message.includes('networkerror') ||
+        message.includes('network error') ||
+        message.includes('network request failed') ||
+        message.includes('timeout') ||
+        message.includes('timed out') ||
+        message.includes('econnreset') ||
+        message.includes('econnrefused') ||
+        message.includes('enotfound') ||
+        message.includes('eai_again') ||
+        message.includes('etimedout') ||
+        message.includes('socket hang up') ||
+        message.includes('dns'));
+}
+/**
+ * fetch с жёстким таймаутом. Если передан внешний signal — он комбинируется с внутренним
+ * таймаут-контроллером (сработает любой из них). При срабатывании таймаута бросается
+ * {@link NetworkTimeoutError}; при внешнем abort пробрасывается исходная ошибка.
+ */
+function fetchWithTimeout(input_1) {
+    return __awaiter(this, arguments, void 0, function* (input, init = {}, opts = {}) {
+        var _a, _b, _c;
+        const timeoutMs = (_a = opts.timeoutMs) !== null && _a !== void 0 ? _a : exports.DEFAULT_NETWORK_TIMEOUT_MS;
+        const externalSignal = (_c = (_b = opts.signal) !== null && _b !== void 0 ? _b : init.signal) !== null && _c !== void 0 ? _c : undefined;
+        const controller = new AbortController();
+        let timedOut = false;
+        const onExternalAbort = () => {
+            try {
+                controller.abort(externalSignal === null || externalSignal === void 0 ? void 0 : externalSignal.reason);
+            }
+            catch (_a) {
+                controller.abort();
+            }
+        };
+        if (externalSignal) {
+            if (externalSignal.aborted) {
+                onExternalAbort();
+            }
+            else {
+                externalSignal.addEventListener('abort', onExternalAbort, { once: true });
+            }
+        }
+        const timer = setTimeout(() => {
+            timedOut = true;
+            controller.abort();
+        }, timeoutMs);
+        try {
+            return yield fetch(input, Object.assign(Object.assign({}, init), { signal: controller.signal }));
+        }
+        catch (err) {
+            if (timedOut) {
+                let url;
+                if (typeof input === 'string')
+                    url = input;
+                else if (input instanceof URL)
+                    url = input.toString();
+                throw new NetworkTimeoutError(timeoutMs, url);
+            }
+            throw err;
+        }
+        finally {
+            clearTimeout(timer);
+            if (externalSignal)
+                externalSignal.removeEventListener('abort', onExternalAbort);
+        }
+    });
+}