@ethlete/query 6.0.0-next.52 → 6.0.0-next.54

package/generators/prep-for-query-v3/migration.js

@@ -5,6 +5,8 @@ export default async function migrate(tree, schema) {
     console.log('\n🔄 Starting Query v3 symbol conflict migration...');
     renameConflictingSymbols(tree);
     replaceExperimentalQueryNamespace(tree);
+    reportWithArgsNullReturns(tree);
+    replaceClearQueryArgs(tree);
     reportPrebuiltPackagesImportingRenamedSymbols(tree);
     if (!schema.skipFormat) {
         await formatFiles(tree);
@@ -75,10 +77,19 @@ function renameConflictingSymbols(tree) {
 }
 function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     const sourceFile = ts.createSourceFile(filePath, content, ts.ScriptTarget.Latest, true);
+    const checker = createBindingChecker(sourceFile);
     const replacements = [];
-    // Track which symbols are imported from @ethlete/query
-    const importedSymbols = new Set();
     const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
+    const renamedImports = new Map();
+    sourceFile.statements.forEach((statement) => {
+        getQueryNamedImports(statement)?.elements.forEach((element) => {
+            const newName = TYPE_RENAMES.get(element.name.text) || FUNCTION_RENAMES.get(element.name.text);
+            const symbol = checker.getSymbolAtLocation(element.name);
+            if (!element.propertyName && newName && symbol) {
+                renamedImports.set(symbol, { oldName: element.name.text, newName });
+            }
+        });
+    });
     function visit(node) {
         const namespaceMember = getNamespaceMember(node, namespaceAliases)?.member;
         const renamedMember = namespaceMember && (TYPE_RENAMES.get(namespaceMember.text) || FUNCTION_RENAMES.get(namespaceMember.text));
@@ -90,62 +101,29 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
                 oldName: namespaceMember.text,
             });
         }
-        // Track imports from @ethlete/query
-        if (ts.isImportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (ts.isStringLiteral(moduleSpecifier) && moduleSpecifier.text === '@ethlete/query') {
-                const namedBindings = node.importClause?.namedBindings;
-                if (namedBindings && ts.isNamedImports(namedBindings)) {
-                    namedBindings.elements.forEach((element) => {
-                        const importedName = element.propertyName?.text || element.name.text;
-                        if (TYPE_RENAMES.has(importedName) || FUNCTION_RENAMES.has(importedName)) {
-                            importedSymbols.add(importedName);
-                        }
-                    });
-                }
-            }
-        }
-        // Rename identifiers that match our rename maps
-        if (ts.isIdentifier(node)) {
-            const name = node.text;
-            const parent = node.parent;
-            // Only rename if this symbol was imported from @ethlete/query
-            if (!importedSymbols.has(name)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            const newName = TYPE_RENAMES.get(name) || FUNCTION_RENAMES.get(name);
-            if (!newName) {
-                ts.forEachChild(node, visit);
-                return;
+        if (ts.isIdentifier(node) && !ts.isImportSpecifier(node.parent)) {
+            const symbol = resolveReferenceSymbol(checker, node);
+            const rename = symbol && renamedImports.get(symbol);
+            if (rename) {
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: ts.isShorthandPropertyAssignment(node.parent)
+                        ? `${rename.oldName}: ${rename.newName}`
+                        : rename.newName,
+                    oldName: rename.oldName,
+                });
             }
-            // Skip if it's the imported name in an import specifier (we'll handle that separately)
-            if ((ts.isImportSpecifier(parent) && (parent.propertyName === node || parent.name === node)) ||
-                (ts.isPropertyAccessExpression(parent) && parent.name === node) ||
-                (ts.isQualifiedName(parent) && parent.right === node)) {
-                ts.forEachChild(node, visit);
-                return;
-            }
-            // Rename the identifier
-            replacements.push({
-                start: node.getStart(sourceFile),
-                end: node.getEnd(),
-                replacement: newName,
-                oldName: name,
-            });
         }
         ts.forEachChild(node, visit);
     }
     visit(sourceFile);
-    // Update imports in @ethlete/query import declarations
     const importReplacements = updateImports(sourceFile);
     replacements.push(...importReplacements);
-    // Count usages
     replacements.forEach((r) => {
         const count = symbolUsageCounts.get(r.oldName) || 0;
         symbolUsageCounts.set(r.oldName, count + 1);
     });
-    // Apply replacements in reverse order
     let result = content;
     replacements.sort((a, b) => b.start - a.start);
     for (const { start, end, replacement } of replacements) {
@@ -153,6 +131,26 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     }
     return result;
 }
+function createBindingChecker(sourceFile) {
+    const options = { noLib: true, noResolve: true, types: [] };
+    const host = ts.createCompilerHost(options);
+    host.getSourceFile = (fileName) => (fileName === sourceFile.fileName ? sourceFile : undefined);
+    host.fileExists = (fileName) => fileName === sourceFile.fileName;
+    host.readFile = (fileName) => (fileName === sourceFile.fileName ? sourceFile.text : undefined);
+    return ts.createProgram([sourceFile.fileName], options, host).getTypeChecker();
+}
+function resolveReferenceSymbol(checker, identifier) {
+    const parent = identifier.parent;
+    if (ts.isShorthandPropertyAssignment(parent) && parent.name === identifier) {
+        return checker.getShorthandAssignmentValueSymbol(parent);
+    }
+    if (ts.isExportSpecifier(parent)) {
+        return (parent.propertyName ?? parent.name) === identifier && !parent.parent.parent.moduleSpecifier
+            ? checker.getExportSpecifierLocalTargetSymbol(parent)
+            : undefined;
+    }
+    return checker.getSymbolAtLocation(identifier);
+}
 function collectQueryNamespaceAliases(sourceFile) {
     const aliases = new Set();
     sourceFile.statements.forEach((statement) => {
@@ -287,14 +285,13 @@ function replaceNamespaceInFile(content, filePath) {
     if (!hasExperimentalQueryImport || !experimentalQueryAlias) {
         return applyReplacements(content, namespaceReplacements, namespaceReplacements.length);
     }
+    const getAliasMember = (node) => getNamespaceMember(node, new Set([experimentalQueryAlias]))?.member;
     // Second pass: collect used symbols
     function findUsages(node) {
         // Find usages: ExperimentalQuery.someSymbol or E.someSymbol (if aliased)
-        if (ts.isPropertyAccessExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === experimentalQueryAlias) {
-            const symbolName = node.name.text;
-            usedSymbols.add(symbolName);
+        const member = getAliasMember(node);
+        if (member) {
+            usedSymbols.add(member.text);
         }
         ts.forEachChild(node, findUsages);
     }
@@ -352,13 +349,12 @@ function replaceNamespaceInFile(content, filePath) {
             }
         }
         // Replace usages: ExperimentalQuery.someSymbol → someSymbol
-        if (ts.isPropertyAccessExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === experimentalQueryAlias) {
+        const member = getAliasMember(node);
+        if (member) {
             replacements.push({
                 start: node.getStart(sourceFile),
                 end: node.getEnd(),
-                replacement: node.name.text,
+                replacement: member.text,
             });
         }
         ts.forEachChild(node, createReplacements);
@@ -391,6 +387,271 @@ function applyReplacements(content, replacements, replacementCount) {
     });
     return { content: result, modified: replacements.length > 0, replacementCount };
 }
+//#endregion
+//#region withArgs null returns
+function reportWithArgsNullReturns(tree) {
+    const sites = [];
+    const uncheckedSites = [];
+    visitQueryFiles(tree, ['withArgs'], (filePath, content) => {
+        const { nullLines, uncheckedLines } = findWithArgsNullReturns(createSourceFile(content, filePath));
+        nullLines.forEach((line) => sites.push(`   - ${filePath}:${line}`));
+        uncheckedLines.forEach((line) => uncheckedSites.push(`   - ${filePath}:${line}`));
+    });
+    if (sites.length > 0) {
+        console.warn(`\n⚠️ These withArgs callbacks return null. Before v3, null kept the previous args; v3 parks the query instead (args, response and executionState become null, and polling pauses). Check each one: a null that should park the query is fine, one that relied on keeping the previous args must now return those args itself:\n${sites.join('\n')}`);
+    }
+    if (uncheckedSites.length > 0) {
+        console.warn(`\n⚠️ TODO: These withArgs callbacks are passed by reference from somewhere this file does not declare, so they could not be checked for a null return. Check each one by hand - v3 parks the query on null, where earlier versions kept the previous args:\n${uncheckedSites.join('\n')}`);
+    }
+}
+const isCheckableFunction = (node) => !!node &&
+    (ts.isArrowFunction(node) ||
+        ts.isFunctionExpression(node) ||
+        ts.isFunctionDeclaration(node) ||
+        ts.isMethodDeclaration(node)) &&
+    !!node.body;
+function resolveCallbackReference(checker, source) {
+    const name = ts.isPropertyAccessExpression(source) ? source.name : source;
+    if (!ts.isIdentifier(name))
+        return undefined;
+    const declaration = checker.getSymbolAtLocation(name)?.valueDeclaration;
+    if (isCheckableFunction(declaration))
+        return declaration;
+    if (!declaration || !(ts.isVariableDeclaration(declaration) || ts.isPropertyDeclaration(declaration))) {
+        return undefined;
+    }
+    const initializer = declaration.initializer && skipOuterExpressions(declaration.initializer);
+    if (isCheckableFunction(initializer))
+        return initializer;
+    if (initializer &&
+        ts.isCallExpression(initializer) &&
+        ts.isIdentifier(initializer.expression) &&
+        initializer.expression.text === 'computed') {
+        const [computation] = initializer.arguments;
+        return isCheckableFunction(computation) ? computation : undefined;
+    }
+    return undefined;
+}
+function skipOuterExpressions(expression) {
+    return ts.isParenthesizedExpression(expression) ||
+        ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression)
+        ? skipOuterExpressions(expression.expression)
+        : expression;
+}
+function findWithArgsNullReturns(sourceFile) {
+    const checker = createBindingChecker(sourceFile);
+    const withArgsImports = new Set();
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
+    const nullLines = [];
+    const uncheckedLines = [];
+    const lineOf = (node) => sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1;
+    sourceFile.statements.forEach((statement) => {
+        getQueryNamedImports(statement)?.elements.forEach((element) => {
+            const symbol = checker.getSymbolAtLocation(element.name);
+            if ((element.propertyName ?? element.name).text === 'withArgs' && symbol)
+                withArgsImports.add(symbol);
+        });
+    });
+    const isWithArgsCallee = (callee) => {
+        if (ts.isIdentifier(callee)) {
+            const symbol = checker.getSymbolAtLocation(callee);
+            return !!symbol && withArgsImports.has(symbol);
+        }
+        return getNamespaceMember(callee, namespaceAliases)?.member.text === 'withArgs';
+    };
+    function visit(node) {
+        if (ts.isCallExpression(node) && isWithArgsCallee(node.expression)) {
+            const [source] = node.arguments;
+            const callback = source && (isCheckableFunction(source) ? source : resolveCallbackReference(checker, source));
+            if (callback) {
+                collectNullReturns(callback).forEach((nullNode) => nullLines.push(lineOf(nullNode)));
+            }
+            else if (source) {
+                uncheckedLines.push(lineOf(source));
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return { nullLines: [...new Set(nullLines)].sort((a, b) => a - b), uncheckedLines };
+}
+function collectNullReturns(fn) {
+    if (!ts.isBlock(fn.body)) {
+        return findNullResults(fn.body);
+    }
+    const found = [];
+    function visit(node) {
+        if (ts.isFunctionLike(node))
+            return;
+        if (ts.isReturnStatement(node) && node.expression) {
+            found.push(...findNullResults(node.expression));
+        }
+        ts.forEachChild(node, visit);
+    }
+    ts.forEachChild(fn.body, visit);
+    return found;
+}
+function findNullResults(expression) {
+    if (expression.kind === ts.SyntaxKind.NullKeyword)
+        return [expression];
+    if (ts.isParenthesizedExpression(expression) ||
+        ts.isAsExpression(expression) ||
+        ts.isSatisfiesExpression(expression) ||
+        ts.isTypeAssertionExpression(expression)) {
+        return findNullResults(expression.expression);
+    }
+    if (ts.isConditionalExpression(expression)) {
+        return [...findNullResults(expression.whenTrue), ...findNullResults(expression.whenFalse)];
+    }
+    if (ts.isBinaryExpression(expression) &&
+        [ts.SyntaxKind.QuestionQuestionToken, ts.SyntaxKind.BarBarToken, ts.SyntaxKind.AmpersandAmpersandToken].includes(expression.operatorToken.kind)) {
+        return findNullResults(expression.right);
+    }
+    return [];
+}
+//#endregion
+//#region CLEAR_QUERY_ARGS replacement
+const CLEAR_QUERY_ARGS_NAMES = new Set(['CLEAR_QUERY_ARGS', 'ClearQueryArgs']);
+function replaceClearQueryArgs(tree) {
+    const updatedFiles = [];
+    const reExports = [];
+    visitQueryFiles(tree, [...CLEAR_QUERY_ARGS_NAMES], (filePath, content) => {
+        const result = replaceClearQueryArgsInFile(content, filePath);
+        if (result.content !== content) {
+            tree.write(filePath, result.content);
+            updatedFiles.push(filePath);
+        }
+        result.reExportLines.forEach((line) => reExports.push(`   - ${filePath}:${line}`));
+    });
+    if (updatedFiles.length > 0) {
+        console.log(`\n🅿️ Replaced CLEAR_QUERY_ARGS with null (the v3 park value) in ${updatedFiles.length} files: ${updatedFiles.join(', ')}`);
+    }
+    if (reExports.length > 0) {
+        console.warn(`\n⚠️ These files re-exported CLEAR_QUERY_ARGS or ClearQueryArgs. They now export a local \`null\` under the same name, so their importers keep compiling. Replace each import of it with \`null\`, then delete the export:\n${reExports.join('\n')}`);
+    }
+}
+function replaceClearQueryArgsInFile(content, filePath) {
+    const sourceFile = createSourceFile(content, filePath);
+    const checker = createBindingChecker(sourceFile);
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
+    const clearImports = new Map();
+    const replacements = [];
+    const reExportLines = [];
+    const statementEnd = (statement) => content[statement.getEnd()] === '\n' ? statement.getEnd() + 1 : statement.getEnd();
+    sourceFile.statements.forEach((statement) => {
+        const namedBindings = getQueryNamedImports(statement);
+        if (!namedBindings)
+            return;
+        const kept = namedBindings.elements.filter((element) => {
+            const importedName = (element.propertyName ?? element.name).text;
+            if (!CLEAR_QUERY_ARGS_NAMES.has(importedName))
+                return true;
+            const symbol = checker.getSymbolAtLocation(element.name);
+            if (symbol)
+                clearImports.set(symbol, importedName);
+            return false;
+        });
+        if (kept.length === namedBindings.elements.length)
+            return;
+        const importClause = statement.importClause;
+        if (kept.length === 0 && !importClause?.name) {
+            replacements.push({ start: statement.getStart(sourceFile), end: statementEnd(statement), replacement: '' });
+            return;
+        }
+        replacements.push({
+            start: namedBindings.getStart(sourceFile),
+            end: namedBindings.getEnd(),
+            replacement: `{ ${kept.map((element) => element.getText(sourceFile)).join(', ')} }`,
+        });
+    });
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isExportDeclaration(statement) || !statement.exportClause || !ts.isNamedExports(statement.exportClause)) {
+            return;
+        }
+        const fromQuery = isQueryModuleSpecifier(statement.moduleSpecifier);
+        if (statement.moduleSpecifier && !fromQuery)
+            return;
+        const clearedName = (element) => {
+            if (fromQuery) {
+                const exportedName = (element.propertyName ?? element.name).text;
+                return CLEAR_QUERY_ARGS_NAMES.has(exportedName) ? exportedName : undefined;
+            }
+            const symbol = checker.getExportSpecifierLocalTargetSymbol(element);
+            return symbol && clearImports.get(symbol);
+        };
+        const elements = statement.exportClause.elements;
+        const nullExports = elements.flatMap((element) => {
+            const name = clearedName(element);
+            if (!name)
+                return [];
+            return [`export ${name === 'ClearQueryArgs' ? 'type' : 'const'} ${element.name.text} = null;`];
+        });
+        if (nullExports.length === 0)
+            return;
+        reExportLines.push(sourceFile.getLineAndCharacterOfPosition(statement.getStart(sourceFile)).line + 1);
+        const kept = elements.filter((element) => !clearedName(element));
+        if (kept.length === 0) {
+            replacements.push({
+                start: statement.getStart(sourceFile),
+                end: statement.getEnd(),
+                replacement: nullExports.join('\n'),
+            });
+            return;
+        }
+        replacements.push({
+            start: statement.exportClause.getStart(sourceFile),
+            end: statement.exportClause.getEnd(),
+            replacement: `{ ${kept.map((element) => element.getText(sourceFile)).join(', ')} }`,
+        });
+        replacements.push({
+            start: statement.getEnd(),
+            end: statement.getEnd(),
+            replacement: `\n${nullExports.join('\n')}`,
+        });
+    });
+    function visit(node) {
+        const namespaceMember = getNamespaceMember(node, namespaceAliases)?.member;
+        const referencesImport = () => {
+            const symbol = ts.isIdentifier(node) ? resolveReferenceSymbol(checker, node) : undefined;
+            return !!symbol && clearImports.has(symbol);
+        };
+        if ((namespaceMember && CLEAR_QUERY_ARGS_NAMES.has(namespaceMember.text)) || referencesImport()) {
+            const target = ts.isTypeQueryNode(node.parent) ? node.parent : node;
+            const replacement = ts.isShorthandPropertyAssignment(node.parent) ? `${node.getText(sourceFile)}: null` : 'null';
+            replacements.push({ start: target.getStart(sourceFile), end: target.getEnd(), replacement });
+            return;
+        }
+        ts.forEachChild(node, visit);
+    }
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement) && !ts.isExportDeclaration(statement))
+            visit(statement);
+    });
+    return { content: applyReplacements(content, replacements, replacements.length).content, reExportLines };
+}
+function isQueryModuleSpecifier(node) {
+    return !!node && ts.isStringLiteral(node) && node.text === '@ethlete/query';
+}
+function visitQueryFiles(tree, markers, visitor) {
+    visitNotIgnoredFiles(tree, '', (filePath) => {
+        if (!filePath.endsWith('.ts') || filePath.endsWith('.spec.ts'))
+            return;
+        const content = tree.read(filePath, 'utf-8');
+        if (!content?.includes('@ethlete/query') || !markers.some((marker) => content.includes(marker)))
+            return;
+        visitor(filePath, content);
+    });
+}
+function getQueryNamedImports(statement) {
+    if (!ts.isImportDeclaration(statement) ||
+        !ts.isStringLiteral(statement.moduleSpecifier) ||
+        statement.moduleSpecifier.text !== '@ethlete/query') {
+        return undefined;
+    }
+    const namedBindings = statement.importClause?.namedBindings;
+    return namedBindings && ts.isNamedImports(namedBindings) ? namedBindings : undefined;
+}
 const isRenamedSymbol = (name) => TYPE_RENAMES.has(name) || FUNCTION_RENAMES.has(name);
 function reportPrebuiltPackagesImportingRenamedSymbols(tree) {
     if (!tree.exists('package.json'))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.52",
+  "version": "6.0.0-next.54",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {

package/types/ethlete-query-testing.d.ts

@@ -124,7 +124,7 @@ type AuthTestSetup<TLoginArgs extends {
     ], TFeatures, TBearerData>;
     /** Helper to login a user and flush the HTTP request */
     login: (credentials: TLoginArgs['body'], response: TLoginArgs['response']) => void;
-    /** Helper to trigger a refresh and flush the HTTP request */
+    /** Helper to trigger a refresh and flush the HTTP request. Sends `buildRefreshArgs(token)` when configured, else `{ body: { token } }` */
     refresh: (token: string, response: TRefreshArgs['response']) => void;
     /** Helper to make a secure request that requires authentication */
     makeSecureRequest: (route: string) => void;
@@ -184,9 +184,9 @@ type FakeBroadcastChannelHandle = {
  * Replaces `globalThis.BroadcastChannel` with an in-memory bus.
  *
  * Messages are structured-cloned at post time (so a non-cloneable payload throws exactly like the
- * real API does), delivered on a microtask (never synchronously), and never delivered back to the
- * channel that posted them - all three matching browser behavior. `await Promise.resolve()` in a
- * spec is enough to flush delivery.
+ * real API does), delivered as a task (never synchronously, and after every pending microtask), and
+ * never delivered back to the channel that posted them - all three matching browser behavior. Delivery
+ * does not depend on fake timers; `await flushMultiTabSync()` in a spec flushes it.
  */
 declare const installFakeBroadcastChannel: () => FakeBroadcastChannelHandle;
 type FakeWebLocksHandle = {
@@ -211,9 +211,9 @@ type FakeWebLocksHandle = {
  */
 declare const installFakeWebLocks: () => FakeWebLocksHandle;
 /**
- * Flushes the microtask queue, which is where both fakes schedule their work - message delivery and
- * lock grants. Awaiting it once is enough for a single hop; a grant that has to wait for another
- * tab's release needs one await per hop.
+ * Waits for the fakes' pending work - message delivery (a task) and lock grants (a microtask) - even
+ * under fake timers. Awaiting it once is enough for a single hop; a grant that has to wait for another
+ * tab's release, or a reply to a delivered message, needs one await per hop.
  */
 declare const flushMultiTabSync: () => Promise<void>;
 
@@ -247,7 +247,7 @@ type FakeQueryPersistenceStoreHandle = {
     /**
      * Holds every subsequent `read` pending until {@link flushReads} is called, for testing the window
      * between a cold mount and its hydration (a slow disk, or a mount that happened before startup
-     * finished).
+     * finished). Each held read returns what the store held when it started, as `loadIndex` does.
      */
     deferReads: () => void;
     /** Settles the reads held by {@link deferReads} and stops deferring. */
@@ -295,10 +295,16 @@ type WebSocketTestDouble = {
         event: string;
         data: unknown;
     }[];
-    /** Whether the client asked the socket to connect, and whether it has since disconnected it. */
+    /**
+     * Whether the client asked the socket to connect, and whether it has since disconnected it. `active` is
+     * socket.io's own flag - `false` after a server disconnect or a rejected handshake, until the next
+     * `connect()`; `connectCalls` counts every `connect()`.
+     */
     state: () => {
         connectRequested: boolean;
         disconnected: boolean;
+        active: boolean;
+        connectCalls: number;
     };
     /**
      * Complete the handshake: flush every buffered emit, then turn the client's `isConnected` true. Pass
@@ -307,8 +313,19 @@ type WebSocketTestDouble = {
     serverConnect: (options?: {
         recovered?: boolean;
     }) => void;
-    /** Drop the connection, so `isConnected` turns false. */
-    serverDisconnect: () => void;
+    /**
+     * Drop the connection, so `isConnected` turns false. The default reason, `'transport close'`, is one
+     * socket.io recovers from itself; `'io server disconnect'` is the server kicking the socket, after which
+     * socket.io only reconnects when `connect()` is called again.
+     */
+    serverDisconnect: (options?: {
+        reason?: 'transport close' | 'io server disconnect';
+    }) => void;
+    /**
+     * Reject the handshake the way a server middleware does: the `auth` payload is recorded in
+     * {@link handshakes}, `connect_error` fires and the socket stops reconnecting on its own.
+     */
+    serverRejectHandshake: (message?: string) => void;
     /**
      * Let the ping expire: the socket still reports itself connected, but buffers every emit like socket.io
      * does until it notices and closes. Follow it with {@link serverDisconnect}.