@bleedingdev/modern-js-app-tools 3.8.3-ultramodern.1 → 3.8.3-ultramodern.2

package/dist/esm/plugins/deploy/platforms/cloudflare-output-verifier/worker-bundles.mjs

@@ -1,313 +0,0 @@
-import promises from "node:fs/promises";
-import node_path from "node:path";
-import { pathToFileURL } from "node:url";
-import { isDeepStrictEqual } from "node:util";
-import { parse } from "@babel/parser";
-import traverse from "@babel/traverse";
-import { CLOUDFLARE_WORKER_BUNDLE_DIRECTORY, CLOUDFLARE_WORKER_NODE_BUILTINS } from "../cloudflare-output-contract.mjs";
-import { addIssue } from "./issues.mjs";
-const getReferencedRouteWorkers = (manifest)=>Array.isArray(manifest?.routeSpec?.routes) ? manifest.routeSpec.routes.map((route)=>'string' == typeof route?.worker && route.worker.length > 0 ? route.worker : void 0).filter((worker)=>'string' == typeof worker) : [];
-const getEffectBffWorker = (manifest)=>manifest?.bff?.runtimeFramework === 'effect' && 'string' == typeof manifest.bff.worker ? manifest.bff.worker : void 0;
-const getWorkerBundleReferences = (manifest)=>{
-    const effectBffWorker = getEffectBffWorker(manifest);
-    return [
-        ...effectBffWorker ? [
-            {
-                dispatcherExport: 'string' == typeof manifest.bff?.dispatcherExport ? manifest.bff.dispatcherExport : void 0,
-                kind: 'effect-bff',
-                reference: effectBffWorker
-            }
-        ] : [],
-        ...getReferencedRouteWorkers(manifest).map((reference)=>({
-                kind: 'route',
-                reference
-            }))
-    ];
-};
-const resolveWorkerBundleReference = (issues, outputDirectory, reference, manifestPath)=>{
-    const workerRoot = node_path.resolve(outputDirectory, CLOUDFLARE_WORKER_BUNDLE_DIRECTORY);
-    const workerPath = node_path.resolve(outputDirectory, reference.reference);
-    const relativeToWorkerRoot = node_path.relative(workerRoot, workerPath);
-    if (node_path.isAbsolute(reference.reference) || relativeToWorkerRoot.startsWith('..') || node_path.isAbsolute(relativeToWorkerRoot)) {
-        addIssue(issues, {
-            code: 'invalid-manifest',
-            message: 'Cloudflare output manifest worker bundle references must stay under worker/.',
-            path: manifestPath
-        });
-        return null;
-    }
-    return {
-        ...reference,
-        path: workerPath
-    };
-};
-const missingWorkerBundleMessage = (reference)=>'effect-bff' === reference.kind ? 'Cloudflare Effect BFF manifest points to a missing worker bundle.' : 'Cloudflare route worker manifest points to a missing worker bundle.';
-const isAstNode = (value)=>null !== value && 'object' == typeof value && 'type' in value && 'string' == typeof value.type;
-const getNodeName = (node)=>{
-    if (!isAstNode(node)) return;
-    return 'Identifier' === node.type && 'string' == typeof node.name ? node.name : 'StringLiteral' === node.type && 'string' == typeof node.value ? node.value : void 0;
-};
-const getStringLiteralValue = (node)=>isAstNode(node) && 'StringLiteral' === node.type && 'string' == typeof node.value ? node.value : void 0;
-const collectBindingNames = (node, names)=>{
-    if (!isAstNode(node)) return;
-    const name = getNodeName(node);
-    if (name) return void names.add(name);
-    if ('ObjectPattern' === node.type && Array.isArray(node.properties)) {
-        for (const property of node.properties)if (isAstNode(property)) collectBindingNames('RestElement' === property.type ? property.argument : property.value, names);
-    } else if ('ArrayPattern' === node.type && Array.isArray(node.elements)) for (const element of node.elements)collectBindingNames(element, names);
-    else if ('AssignmentPattern' === node.type || 'RestElement' === node.type) collectBindingNames('AssignmentPattern' === node.type ? node.left : node.argument, names);
-};
-const getMemberPropertyName = (node)=>{
-    if ('MemberExpression' !== node.type) return;
-    return true === node.computed ? getStringLiteralValue(node.property) : getNodeName(node.property);
-};
-const isAmbientModuleRequire = (node, modulePath)=>isAstNode(node) && 'MemberExpression' === node.type && isAstNode(node.object) && 'Identifier' === node.object.type && 'module' === node.object.name && void 0 === modulePath.scope.getBinding('module') && 'require' === getMemberPropertyName(node);
-const isModuleExports = (node)=>isAstNode(node) && 'MemberExpression' === node.type && isAstNode(node.object) && 'Identifier' === node.object.type && 'module' === node.object.name && 'exports' === getMemberPropertyName(node);
-const collectCommonJsExports = (statement, exports)=>{
-    if ('ExpressionStatement' !== statement.type || !isAstNode(statement.expression) || 'AssignmentExpression' !== statement.expression.type) return;
-    const { left, right } = statement.expression;
-    if (isAstNode(left) && 'MemberExpression' === left.type && (isAstNode(left.object) && 'Identifier' === left.object.type && 'exports' === left.object.name || isModuleExports(left.object))) {
-        const exportName = getMemberPropertyName(left);
-        if (exportName) exports.add(exportName);
-        return;
-    }
-    if (isModuleExports(left) && isAstNode(right) && 'ObjectExpression' === right.type && Array.isArray(right.properties)) {
-        for (const property of right.properties)if (isAstNode(property)) {
-            const exportName = getNodeName(property.key);
-            if (exportName) exports.add(exportName);
-        }
-    }
-};
-const collectEsmExports = (statement, exports)=>{
-    if ('ExportDefaultDeclaration' === statement.type) return void exports.add('default');
-    if ('ExportNamedDeclaration' !== statement.type) return;
-    if (isAstNode(statement.declaration)) {
-        const declaration = statement.declaration;
-        const declarationName = getNodeName(declaration.id);
-        if (declarationName) exports.add(declarationName);
-        if ('VariableDeclaration' === declaration.type && Array.isArray(declaration.declarations)) {
-            for (const declarator of declaration.declarations)if (isAstNode(declarator)) collectBindingNames(declarator.id, exports);
-        }
-    }
-    if (Array.isArray(statement.specifiers)) {
-        for (const specifier of statement.specifiers)if (isAstNode(specifier)) {
-            const exportName = getNodeName(specifier.exported);
-            if (exportName) exports.add(exportName);
-        }
-    }
-};
-const getStaticImport = (modulePath)=>{
-    const node = modulePath.node;
-    if (('ImportDeclaration' === node.type || 'ExportNamedDeclaration' === node.type || 'ExportAllDeclaration' === node.type) && isAstNode(node.source)) return getStringLiteralValue(node.source);
-    if ('ImportExpression' === node.type && isAstNode(node.source)) return getStringLiteralValue(node.source);
-    if ('CallExpression' === node.type && Array.isArray(node.arguments) && 1 === node.arguments.length && isAstNode(node.callee) && ('Identifier' === node.callee.type && 'require' === node.callee.name && void 0 === modulePath.scope.getBinding('require') || isAmbientModuleRequire(node.callee, modulePath) || 'Import' === node.callee.type)) return getStringLiteralValue(node.arguments[0]);
-};
-const isAmbientLoaderWrite = (modulePath)=>{
-    let targetPath = modulePath;
-    while(targetPath.parentPath){
-        const parentPath = targetPath.parentPath;
-        if (parentPath.isAssignmentExpression()) return 'left' === targetPath.key;
-        if (parentPath.isUpdateExpression()) return 'argument' === targetPath.key;
-        if (parentPath.isForInStatement() || parentPath.isForOfStatement()) return 'left' === targetPath.key;
-        if (parentPath.isObjectProperty()) {
-            if ('value' !== targetPath.key) return false;
-            targetPath = parentPath;
-            continue;
-        }
-        if (parentPath.isObjectPattern() || parentPath.isArrayPattern() || parentPath.isRestElement() || parentPath.isAssignmentPattern()) {
-            targetPath = parentPath;
-            continue;
-        }
-        break;
-    }
-    return false;
-};
-const analyzeWorkerModule = (source)=>{
-    const ast = parse(source, {
-        sourceType: 'unambiguous'
-    });
-    const exports = new Set();
-    const imports = new Set();
-    let unsafeCommonJsLoaderUsage = false;
-    let unsafeDynamicImport = false;
-    for (const statement of ast.program.body){
-        collectEsmExports(statement, exports);
-        collectCommonJsExports(statement, exports);
-    }
-    traverse(ast, {
-        enter (modulePath) {
-            const node = modulePath.node;
-            if (('ImportExpression' === node.type || 'CallExpression' === node.type && isAstNode(node.callee) && 'Import' === node.callee.type) && void 0 === getStaticImport(modulePath)) unsafeDynamicImport = true;
-            if (modulePath.isReferencedIdentifier({
-                name: 'require'
-            }) && void 0 === modulePath.scope.getBinding('require')) {
-                const parentPath = modulePath.parentPath;
-                const isStaticRequireCall = parentPath?.isCallExpression() && 'callee' === modulePath.key && void 0 !== getStaticImport(parentPath);
-                const isAvailabilityCheck = parentPath?.isUnaryExpression({
-                    operator: 'typeof'
-                });
-                if (!isStaticRequireCall && !isAvailabilityCheck) unsafeCommonJsLoaderUsage = true;
-            }
-            if ('Identifier' === node.type && isAmbientLoaderWrite(modulePath) && ('require' === node.name || 'module' === node.name) && void 0 === modulePath.scope.getBinding(node.name)) unsafeCommonJsLoaderUsage = true;
-            if (modulePath.isReferencedIdentifier({
-                name: 'module'
-            }) && void 0 === modulePath.scope.getBinding('module')) {
-                const parentPath = modulePath.parentPath;
-                const isExportsAccess = null !== parentPath && isModuleExports(parentPath.node);
-                const isStaticModuleRequireCall = null !== parentPath && isAmbientModuleRequire(parentPath.node, parentPath) && parentPath.parentPath?.isCallExpression() === true && 'callee' === parentPath.key && void 0 !== getStaticImport(parentPath.parentPath);
-                if (!isExportsAccess && !isStaticModuleRequireCall) unsafeCommonJsLoaderUsage = true;
-            }
-            if (isAmbientModuleRequire(node, modulePath)) {
-                const parentPath = modulePath.parentPath;
-                const isStaticRequireCall = parentPath?.isCallExpression() && 'callee' === modulePath.key && void 0 !== getStaticImport(parentPath);
-                if (!isStaticRequireCall) unsafeCommonJsLoaderUsage = true;
-            }
-            const specifier = getStaticImport(modulePath);
-            if (void 0 !== specifier) imports.add(specifier);
-        }
-    });
-    return {
-        exports,
-        imports,
-        unsafeCommonJsLoaderUsage,
-        unsafeDynamicImport
-    };
-};
-const getPackageName = (specifier)=>specifier.startsWith('@') ? specifier.split('/').slice(0, 2).join('/') : specifier.split('/')[0];
-const CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS = new Set(CLOUDFLARE_WORKER_NODE_BUILTINS.map((builtin)=>`node:${builtin}`));
-const isInsideDirectory = (directory, filePath)=>{
-    const relative = node_path.relative(directory, filePath);
-    return 0 === relative.length || !relative.startsWith('..') && !node_path.isAbsolute(relative);
-};
-const resolveWorkerModule = async (importer, specifier)=>{
-    const unresolvedPath = node_path.resolve(node_path.dirname(importer), specifier);
-    const candidates = [
-        unresolvedPath,
-        `${unresolvedPath}.js`,
-        `${unresolvedPath}.mjs`,
-        `${unresolvedPath}.cjs`,
-        node_path.join(unresolvedPath, 'index.js'),
-        node_path.join(unresolvedPath, 'index.mjs'),
-        node_path.join(unresolvedPath, 'index.cjs')
-    ];
-    for (const candidate of candidates)try {
-        if ((await promises.stat(candidate)).isFile()) return await promises.realpath(candidate);
-    } catch  {}
-};
-const verifyWorkerModuleClosure = async (issues, entryPath, entrySource, contract)=>{
-    const visited = new Set();
-    let entryAnalysis;
-    const [realWorkerRoot, realEntryPath] = await Promise.all([
-        promises.realpath(contract.workerRoot),
-        promises.realpath(entryPath)
-    ]);
-    if (!isInsideDirectory(realWorkerRoot, realEntryPath)) return void addIssue(issues, {
-        code: 'invalid-worker-bundle',
-        message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
-        path: entryPath
-    });
-    const visitModule = async (modulePath, source, isEntry = false)=>{
-        if (visited.has(modulePath)) return;
-        visited.add(modulePath);
-        let analysis;
-        try {
-            analysis = analyzeWorkerModule(source ?? await promises.readFile(modulePath, 'utf-8'));
-        } catch (error) {
-            addIssue(issues, {
-                code: 'invalid-worker-bundle',
-                message: `Cloudflare worker bundle module could not be parsed: ${error instanceof Error ? error.message : String(error)}`,
-                path: modulePath
-            });
-            return;
-        }
-        if (isEntry) entryAnalysis = analysis;
-        if (analysis.unsafeCommonJsLoaderUsage) addIssue(issues, {
-            code: 'invalid-worker-bundle',
-            message: 'Cloudflare worker bundles must use exactly one string-literal specifier in ambient CommonJS loader calls and must not pass or alias the loader.',
-            path: modulePath
-        });
-        if (analysis.unsafeDynamicImport) addIssue(issues, {
-            code: 'invalid-worker-bundle',
-            message: 'Cloudflare worker bundles must not contain non-static dynamic module imports.',
-            path: modulePath
-        });
-        for (const specifier of analysis.imports){
-            if (0 === specifier.length) {
-                addIssue(issues, {
-                    code: 'invalid-worker-bundle',
-                    message: 'Cloudflare worker bundle module specifiers must not be empty.',
-                    path: modulePath
-                });
-                continue;
-            }
-            if (!specifier.startsWith('.') && !node_path.isAbsolute(specifier)) {
-                if (CLOUDFLARE_WORKER_NODE_BUILTIN_SPECIFIERS.has(specifier)) continue;
-                if (specifier.startsWith('node:')) {
-                    addIssue(issues, {
-                        code: 'invalid-worker-bundle',
-                        message: `Cloudflare worker bundle import "${specifier}" is not a supported Worker node: builtin.`,
-                        path: modulePath
-                    });
-                    continue;
-                }
-                if (!contract.providedPackages.has(getPackageName(specifier))) addIssue(issues, {
-                    code: 'invalid-worker-bundle',
-                    message: `Cloudflare worker bundle import "${specifier}" is not provided by worker/package.json dependencies.`,
-                    path: modulePath
-                });
-                continue;
-            }
-            const resolved = await resolveWorkerModule(modulePath, specifier);
-            if (resolved && !isInsideDirectory(realWorkerRoot, resolved)) {
-                addIssue(issues, {
-                    code: 'invalid-worker-bundle',
-                    message: 'Cloudflare worker bundles must not resolve outside the staged worker directory.',
-                    path: modulePath
-                });
-                continue;
-            }
-            if (!resolved) {
-                addIssue(issues, {
-                    code: 'invalid-worker-bundle',
-                    message: `Cloudflare worker bundle import "${specifier}" does not resolve inside worker/.`,
-                    path: modulePath
-                });
-                continue;
-            }
-            await visitModule(resolved);
-        }
-    };
-    await visitModule(realEntryPath, entrySource, true);
-    return entryAnalysis;
-};
-const verifyWorkerBundleReferences = async (issues, worker, source, contract)=>{
-    const entryAnalysis = await verifyWorkerModuleClosure(issues, worker.path, source, contract);
-    if ('effect-bff' === worker.kind && 'string' == typeof worker.dispatcherExport && !entryAnalysis?.exports.has(worker.dispatcherExport)) addIssue(issues, {
-        code: 'invalid-worker-bundle',
-        message: 'Cloudflare Effect BFF worker bundle must expose its manifest dispatcherExport.',
-        path: worker.path
-    });
-};
-const verifyWorkerImport = async (issues, entryPath, expectedManifest)=>{
-    try {
-        const workerModule = await import(`${pathToFileURL(entryPath).href}?t=${Date.now()}`);
-        const worker = workerModule.default;
-        if (!worker || 'function' != typeof worker.fetch) addIssue(issues, {
-            code: 'worker-import-failed',
-            message: 'Cloudflare server entry must default-export a Worker with fetch.',
-            path: entryPath
-        });
-        if (void 0 !== expectedManifest && !isDeepStrictEqual(workerModule.modernWorkerManifest, expectedManifest)) addIssue(issues, {
-            code: 'worker-import-failed',
-            message: 'Cloudflare server entry runtime manifest must exactly match modern-worker-manifest.json.',
-            path: entryPath
-        });
-    } catch (error) {
-        addIssue(issues, {
-            code: 'worker-import-failed',
-            message: `Cloudflare server entry could not be imported: ${error instanceof Error ? error.message : String(error)}`,
-            path: entryPath
-        });
-    }
-};
-export { getEffectBffWorker, getWorkerBundleReferences, missingWorkerBundleMessage, resolveWorkerBundleReference, verifyWorkerBundleReferences, verifyWorkerImport };

package/dist/esm/plugins/deploy/platforms/templates/cloudflare-entry.001-bootstrap-security.mjs

@@ -1,251 +0,0 @@
-const ASSETS_BINDING = 'ASSETS';
-const MODERN_WORKER_MANIFEST = p_workerManifest;
-export const modernWorkerManifest = MODERN_WORKER_MANIFEST;
-const WORKER_MODULE_LOADERS = p_workerModuleLoaders;
-const workerModulePromises = new Map();
-const effectBffDispatcherPromises = new Map();
-const remoteJsonPromises = new Map();
-const CORS_POLICY = MODERN_WORKER_MANIFEST.security?.cors || {};
-const ASSET_CORS_ENABLED = CORS_POLICY.assets !== false;
-const APP_CORS_ALLOWED_ORIGINS = (CORS_POLICY.allowedOrigins || []).map(
-  origin => String(origin).toLowerCase(),
-);
-const APP_CORS_ALLOWED_METHODS = (
-  CORS_POLICY.allowedMethods?.length
-    ? CORS_POLICY.allowedMethods
-    : ['GET', 'HEAD', 'POST', 'PUT', 'PATCH', 'DELETE', 'OPTIONS']
-).join(', ');
-const APP_CORS_ALLOWED_HEADERS = (
-  CORS_POLICY.allowedHeaders?.length ? CORS_POLICY.allowedHeaders : ['*']
-).join(', ');
-const ASSET_CORS_HEADERS = {
-  'access-control-allow-headers': '*',
-  'access-control-allow-methods': 'GET, HEAD, OPTIONS',
-  'access-control-allow-origin': '*',
-};
-
-globalThis.__dirname ??= '/';
-globalThis.__filename ??= '/index.js';
-
-function getAllowedAppCorsOrigin(request) {
-  if (APP_CORS_ALLOWED_ORIGINS.length === 0) {
-    return null;
-  }
-
-  const origin = request.headers.get('origin');
-
-  if (!origin) {
-    return null;
-  }
-
-  if (APP_CORS_ALLOWED_ORIGINS.includes('*')) {
-    return '*';
-  }
-
-  return APP_CORS_ALLOWED_ORIGINS.includes(origin.toLowerCase())
-    ? origin
-    : null;
-}
-
-function appendVaryOrigin(headers) {
-  const vary = headers.get('vary');
-
-  if (!vary) {
-    headers.set('vary', 'origin');
-    return;
-  }
-
-  const varyValues = vary.split(',').map(value => value.trim().toLowerCase());
-
-  if (!varyValues.includes('origin')) {
-    headers.set('vary', `${vary}, origin`);
-  }
-}
-
-function withAppCorsHeaders(response, request) {
-  const allowedOrigin = getAllowedAppCorsOrigin(request);
-
-  if (!allowedOrigin) {
-    return response;
-  }
-
-  const headers = new Headers(response.headers);
-
-  if (!headers.has('access-control-allow-origin')) {
-    headers.set('access-control-allow-origin', allowedOrigin);
-  }
-
-  if (allowedOrigin !== '*') {
-    appendVaryOrigin(headers);
-  }
-
-  return new Response(response.body, {
-    headers,
-    status: response.status,
-    statusText: response.statusText,
-  });
-}
-
-function withAssetCorsHeaders(response) {
-  if (!ASSET_CORS_ENABLED) {
-    return response;
-  }
-
-  const headers = new Headers(response.headers);
-
-  for (const [name, value] of Object.entries(ASSET_CORS_HEADERS)) {
-    if (!headers.has(name)) {
-      headers.set(name, value);
-    }
-  }
-
-  return new Response(response.body, {
-    headers,
-    status: response.status,
-    statusText: response.statusText,
-  });
-}
-
-function setHeaderIfEnabled(headers, name, value) {
-  if (value === false || typeof value !== 'string' || value.trim() === '') {
-    return;
-  }
-
-  if (!headers.has(name)) {
-    headers.set(name, value);
-  }
-}
-
-function renderContentSecurityPolicy(directives) {
-  return Object.entries(directives || {})
-    .filter(([, values]) => Array.isArray(values) && values.length > 0)
-    .sort(([left], [right]) => left.localeCompare(right))
-    .map(([name, values]) => `${name} ${values.join(' ')}`)
-    .join('; ');
-}
-
-function isHtmlResponse(response) {
-  return (response.headers.get('content-type') || '').includes('text/html');
-}
-
-function matchesPreviewHostname(hostname, pattern) {
-  const normalizedHostname = hostname.toLowerCase();
-  const normalizedPattern = String(pattern || '').toLowerCase();
-
-  if (!normalizedPattern) {
-    return false;
-  }
-
-  if (normalizedPattern.startsWith('*.')) {
-    return normalizedHostname.endsWith(normalizedPattern.slice(1));
-  }
-
-  return normalizedHostname === normalizedPattern;
-}
-
-function shouldNoindex(request, noindex) {
-  if (!noindex || noindex === false) {
-    return false;
-  }
-
-  const { hostname } = new URL(request.url);
-  const normalizedHostname = hostname.toLowerCase();
-
-  if (
-    noindex.localhost !== false &&
-    (normalizedHostname === 'localhost' ||
-      normalizedHostname === '127.0.0.1' ||
-      normalizedHostname === '[::1]')
-  ) {
-    return true;
-  }
-
-  if (
-    noindex.workersDev !== false &&
-    normalizedHostname.endsWith('.workers.dev')
-  ) {
-    return true;
-  }
-
-  return (noindex.previewHostnames || []).some(pattern =>
-    matchesPreviewHostname(normalizedHostname, pattern),
-  );
-}
-
-function withCloudflareSecurityHeaders(response, request) {
-  const security = MODERN_WORKER_MANIFEST.security;
-
-  if (!security || security.enabled === false) {
-    return response;
-  }
-
-  const headers = new Headers(response.headers);
-  const configuredHeaders = security.headers || {};
-
-  setHeaderIfEnabled(
-    headers,
-    'referrer-policy',
-    configuredHeaders.referrerPolicy,
-  );
-  setHeaderIfEnabled(
-    headers,
-    'x-content-type-options',
-    configuredHeaders.contentTypeOptions,
-  );
-  setHeaderIfEnabled(
-    headers,
-    'permissions-policy',
-    configuredHeaders.permissionsPolicy,
-  );
-
-  const csp = security.contentSecurityPolicy;
-  const cspHeader =
-    csp?.mode === 'enforce'
-      ? 'content-security-policy'
-      : 'content-security-policy-report-only';
-  const cspValue = renderContentSecurityPolicy(csp?.directives);
-
-  if (
-    isHtmlResponse(response) &&
-    csp?.mode !== 'off' &&
-    cspValue &&
-    !headers.has(cspHeader)
-  ) {
-    headers.set(cspHeader, cspValue);
-  }
-
-  if (shouldNoindex(request, security.noindex)) {
-    headers.set('x-robots-tag', 'noindex, nofollow');
-  }
-
-  return new Response(response.body, {
-    headers,
-    status: response.status,
-    statusText: response.statusText,
-  });
-}
-
-function createRenderableRequest(request) {
-  if (request.method !== 'HEAD') {
-    return request;
-  }
-
-  return new Request(request, { method: 'GET' });
-}
-
-function finalizeResponseForRequest(response, request) {
-  const securedResponse = withCloudflareSecurityHeaders(response, request);
-
-  if (request.method !== 'HEAD') {
-    return securedResponse;
-  }
-
-  const headers = new Headers(securedResponse.headers);
-  headers.delete('content-length');
-
-  return new Response(null, {
-    headers,
-    status: securedResponse.status,
-    statusText: securedResponse.statusText,
-  });
-}