@ethlete/query 6.0.0-next.45 → 6.0.0-next.48

package/generators/migrate-to-query-v3/query-client-migration.js

@@ -115,17 +115,25 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     const sourceFile = createSourceFile(content, filePath);
     const replacements = [];
     const variableRenames = new Map();
+    let hasUnmigratedClient = false;
     const visit = (node) => {
-        if (ts.isNewExpression(node) &&
-            ts.isIdentifier(node.expression) &&
-            node.expression.text === 'V2QueryClient' &&
-            node.arguments &&
-            node.arguments.length > 0) {
-            const configArgument = node.arguments[0];
-            if (ts.isObjectLiteralExpression(configArgument)) {
+        if (ts.isNewExpression(node) && ts.isIdentifier(node.expression) && node.expression.text === 'V2QueryClient') {
+            const configArgument = node.arguments?.[0];
+            if (!configArgument || !ts.isObjectLiteralExpression(configArgument)) {
+                hasUnmigratedClient = true;
+                report.addManualReview({
+                    title: 'Migrate a V2QueryClient whose config is not an object literal',
+                    summary: `\`${node.getText(sourceFile)}\` passes its config indirectly, so the migration cannot read it and left the client on v2.`,
+                    action: 'Inline the config object and re-run the migration, or rewrite the client by hand as `createQueryClient({ baseUrl, name })` with provider aliases and creators.',
+                    locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(node.getStart(sourceFile)).line + 1 }],
+                    source: 'query-client-migration',
+                    dedupeKey: `unmigrated-client:${filePath}:${node.getStart(sourceFile)}`,
+                });
+            }
+            else {
                 const oldVariableName = getVariableNameForQueryClient(node);
-                const newVariableName = ensureConfigSuffix(oldVariableName);
-                if (oldVariableName !== newVariableName) {
+                const newVariableName = oldVariableName && ensureConfigSuffix(oldVariableName);
+                if (oldVariableName && newVariableName && oldVariableName !== newVariableName) {
                     const collisionRegex = new RegExp(`\\b(?:const|let|var)\\s+${newVariableName}\\b`);
                     if (collisionRegex.test(content)) {
                         report.addWarning({
@@ -158,16 +166,20 @@ const migrateQueryClientToConfig = ({ content, filePath, renamesOut, report }) =
     replacements.forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
     });
-    result = removeQueryClientImport(result);
+    result = removeQueryClientImport(result, hasUnmigratedClient);
     return renameVariables(result, variableRenames);
 };
-const removeQueryClientImport = (content) => {
+const removeQueryClientImport = (content, keepLegacyClient) => {
     const sourceFile = createSourceFile(content);
     let queryImportNode;
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
+        if (!queryImportNode &&
+            ts.isImportDeclaration(node) &&
             ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === '@ethlete/query') {
+            node.moduleSpecifier.text === '@ethlete/query' &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings) &&
+            node.importClause.namedBindings.elements.some((element) => element.name.text === 'V2QueryClient')) {
             queryImportNode = node;
         }
     });
@@ -183,10 +195,10 @@ const removeQueryClientImport = (content) => {
         return ensureImportFromQuery(content, requiredImports);
     }
     const existingElements = queryImportNode.importClause.namedBindings.elements.filter((element) => {
-        return element.name.text !== 'V2QueryClient';
+        return keepLegacyClient || element.name.text !== 'V2QueryClient';
     });
     const nextImports = new Set(requiredImports);
-    existingElements.forEach((element) => nextImports.add(element.name.text));
+    existingElements.forEach((element) => nextImports.add(element.getText(sourceFile)));
     const nextImportStatement = `import { ${Array.from(nextImports).sort().join(', ')} } from '@ethlete/query';`;
     return (content.slice(0, queryImportNode.getStart(sourceFile)) +
         nextImportStatement +
@@ -267,14 +279,37 @@ const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, repo
             dedupeKey: `dropped-client-option:${filePath}:${optionPath}`,
         });
     };
+    const raiseSpread = (spread) => {
+        const text = spread.getText(sourceFile);
+        report.addWarning({
+            title: `Reconfigure spread query client options "${text}"`,
+            summary: `The v2 client config spreads \`${text}\`. The migration cannot see which options it holds, so none of them were carried over to \`createQueryClient\`.`,
+            action: 'Inline the spread options that are still needed (`baseRoute` becomes `baseUrl`) and re-check the result.',
+            locations: [{ filePath, line: sourceFile.getLineAndCharacterOfPosition(spread.getStart(sourceFile)).line + 1 }],
+            source: 'query-client-migration',
+            dedupeKey: `dropped-client-spread:${filePath}:${spread.getStart(sourceFile)}`,
+        });
+    };
     configArgument.properties.forEach((property) => {
-        if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
+        if (ts.isSpreadAssignment(property)) {
+            raiseSpread(property);
+            return;
+        }
+        if ((!ts.isPropertyAssignment(property) && !ts.isShorthandPropertyAssignment(property)) ||
+            !ts.isIdentifier(property.name)) {
             return;
         }
         const name = property.name.text;
-        if ((name === 'request' || name === 'logging') && ts.isObjectLiteralExpression(property.initializer)) {
+        if ((name === 'request' || name === 'logging') &&
+            ts.isPropertyAssignment(property) &&
+            ts.isObjectLiteralExpression(property.initializer)) {
             property.initializer.properties.forEach((nested) => {
-                if (!ts.isPropertyAssignment(nested) || !ts.isIdentifier(nested.name)) {
+                if (ts.isSpreadAssignment(nested)) {
+                    raiseSpread(nested);
+                    return;
+                }
+                if ((!ts.isPropertyAssignment(nested) && !ts.isShorthandPropertyAssignment(nested)) ||
+                    !ts.isIdentifier(nested.name)) {
                     return;
                 }
                 if (name === 'request' && ['queryParams', 'cacheAdapter', 'retryFn'].includes(nested.name.text)) {
@@ -289,40 +324,42 @@ const reportDroppedClientOptions = ({ configArgument, sourceFile, filePath, repo
         }
     });
 };
+const getPropertyValueText = (property, sourceFile) => {
+    if (ts.isShorthandPropertyAssignment(property)) {
+        return property.name.text;
+    }
+    return ts.isPropertyAssignment(property) ? property.initializer.getText(sourceFile) : undefined;
+};
+const findProperty = (objectLiteral, name) => objectLiteral.properties.find((property) => {
+    return ((ts.isPropertyAssignment(property) || ts.isShorthandPropertyAssignment(property)) &&
+        ts.isIdentifier(property.name) &&
+        property.name.text === name);
+});
 const migrateConfigObject = (configArgument, node, sourceFile) => {
-    const variableName = getVariableNameForQueryClient(node);
+    const variableName = getVariableNameForQueryClient(node) ?? 'client';
     const nextConfig = [];
-    const baseRouteProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'baseRoute';
-    });
-    if (baseRouteProperty && ts.isPropertyAssignment(baseRouteProperty)) {
-        const baseRouteValue = baseRouteProperty.initializer
-            .getText(sourceFile)
-            .replace('as `https://${string}`', '')
-            .trim();
-        nextConfig.push(`baseUrl: ${baseRouteValue}`);
+    const baseRouteProperty = findProperty(configArgument, 'baseRoute');
+    const baseRouteText = baseRouteProperty && getPropertyValueText(baseRouteProperty, sourceFile);
+    if (baseRouteText) {
+        nextConfig.push(`baseUrl: ${baseRouteText.replace('as `https://${string}`', '').trim()}`);
     }
     nextConfig.push(`name: '${variableName}'`);
-    const requestProperty = configArgument.properties.find((property) => {
-        return ts.isPropertyAssignment(property) && ts.isIdentifier(property.name) && property.name.text === 'request';
-    });
+    const requestProperty = findProperty(configArgument, 'request');
     if (requestProperty &&
         ts.isPropertyAssignment(requestProperty) &&
         ts.isObjectLiteralExpression(requestProperty.initializer)) {
-        requestProperty.initializer.properties.forEach((property) => {
-            if (!ts.isPropertyAssignment(property) || !ts.isIdentifier(property.name)) {
-                return;
-            }
-            if (property.name.text === 'queryParams') {
-                nextConfig.push(`queryString: ${property.initializer.getText(sourceFile)}`);
-            }
-            if (property.name.text === 'cacheAdapter') {
-                nextConfig.push(`cacheAdapter: ${property.initializer.getText(sourceFile)}`);
+        const requestConfig = requestProperty.initializer;
+        for (const [from, to] of [
+            ['queryParams', 'queryString'],
+            ['cacheAdapter', 'cacheAdapter'],
+            ['retryFn', 'retryFn'],
+        ]) {
+            const property = findProperty(requestConfig, from);
+            const valueText = property && getPropertyValueText(property, sourceFile);
+            if (valueText) {
+                nextConfig.push(`${to}: ${valueText}`);
             }
-            if (property.name.text === 'retryFn') {
-                nextConfig.push(`retryFn: ${property.initializer.getText(sourceFile)}`);
-            }
-        });
+        }
     }
     return `createQueryClient({\n  ${nextConfig.join(',\n  ')}\n})`;
 };
@@ -334,7 +371,7 @@ const getVariableNameForQueryClient = (node) => {
         }
         parent = parent.parent;
     }
-    return 'client';
+    return undefined;
 };
 const extractClientConfigNames = (content) => {
     const sourceFile = createSourceFile(content);
@@ -433,6 +470,19 @@ const generateCreatorsForConfig = (configName) => {
         `export const ${creatorBaseName}Delete = createDeleteQuery(${configVariableName});`,
     ].join('\n');
 };
+const declaresName = (declarations, name) => declarations.some((declaration) => declaration.name && ts.isIdentifier(declaration.name) && declaration.name.text === name);
+const isShadowedByLocalDeclaration = (identifier) => {
+    for (let scope = identifier.parent; scope && !ts.isSourceFile(scope); scope = scope.parent) {
+        if (ts.isFunctionLike(scope) && declaresName(scope.parameters, identifier.text)) {
+            return true;
+        }
+        if (ts.isBlock(scope) &&
+            scope.statements.some((statement) => ts.isVariableStatement(statement) && declaresName(statement.declarationList.declarations, identifier.text))) {
+            return true;
+        }
+    }
+    return false;
+};
 const updateImportsInFile = (content, renames) => {
     const sourceFile = createSourceFile(content);
     const replacements = [];
@@ -443,7 +493,7 @@ const updateImportsInFile = (content, renames) => {
             const nextElements = [];
             let hasChanges = false;
             node.importClause.namedBindings.elements.forEach((element) => {
-                const nextName = renames.get(element.name.text);
+                const nextName = renames.get(element.propertyName?.text ?? element.name.text);
                 if (!nextName) {
                     nextElements.push(element.getText(sourceFile));
                     return;
@@ -494,7 +544,7 @@ const updateImportsInFile = (content, renames) => {
                 ts.forEachChild(node, visit);
                 return;
             }
-            if (ts.isPropertyAssignment(parent) && parent.name === node) {
+            if ((ts.isPropertyAssignment(parent) && parent.name === node) || isShadowedByLocalDeclaration(node)) {
                 ts.forEachChild(node, visit);
                 return;
             }

package/generators/migrate-to-query-v3/rename-symbols.js

@@ -17,8 +17,6 @@ const isNamePosition = (node) => {
     // Object literal / type member keys, enum members, JSX-ish attribute names.
     if (ts.isPropertyAssignment(parent) && parent.name === node)
         return true;
-    if (ts.isShorthandPropertyAssignment(parent) && parent.name === node)
-        return true;
     if (ts.isPropertySignature(parent) && parent.name === node)
         return true;
     if (ts.isMethodSignature(parent) && parent.name === node)
@@ -57,12 +55,24 @@ const isNamePosition = (node) => {
     if (ts.isLabeledStatement(parent) && parent.label === node)
         return true;
     // Import / export clauses are rewritten by the caller, never by the reference pass.
-    if (ts.isImportSpecifier(parent) || ts.isExportSpecifier(parent))
+    if (ts.isImportSpecifier(parent))
+        return true;
+    if (ts.isExportSpecifier(parent) &&
+        (parent.parent.parent.moduleSpecifier || (parent.propertyName && parent.name === node))) {
         return true;
+    }
     if (ts.isImportClause(parent) || ts.isNamespaceImport(parent))
         return true;
     return false;
 };
+const renamedReference = (node, nextName) => {
+    const parent = node.parent;
+    if (ts.isShorthandPropertyAssignment(parent))
+        return `${node.text}: ${nextName}`;
+    if (ts.isExportSpecifier(parent) && !parent.propertyName)
+        return `${nextName} as ${node.text}`;
+    return nextName;
+};
 /** Every name the file declares itself - a local by the same name means the import is shadowed. */
 const collectLocalDeclarations = (sourceFile) => {
     const declared = new Set();
@@ -115,7 +125,11 @@ export const renameImportedReferences = (content, renames) => {
         if (ts.isIdentifier(node)) {
             const nextName = applicable.get(node.text);
             if (nextName && !isNamePosition(node)) {
-                replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement: nextName });
+                replacements.push({
+                    start: node.getStart(sourceFile),
+                    end: node.getEnd(),
+                    replacement: renamedReference(node, nextName),
+                });
             }
         }
         ts.forEachChild(node, visit);
@@ -136,7 +150,7 @@ export const renameImportedReferences = (content, renames) => {
  * the same generator invocation so they land that way. Identifiers inside template strings count as
  * usage too - a component referenced only from an inline template must not be pruned.
  */
-export const pruneUnusedNamedImports = (content, moduleSpecifiers) => {
+export const pruneUnusedNamedImports = (content) => {
     const sourceFile = createSourceFile(content);
     const used = new Set();
     const addWordsFrom = (text) => {
@@ -162,7 +176,6 @@ export const pruneUnusedNamedImports = (content, moduleSpecifiers) => {
     for (const node of sourceFile.statements) {
         if (!ts.isImportDeclaration(node) ||
             !ts.isStringLiteral(node.moduleSpecifier) ||
-            (moduleSpecifiers !== 'all' && !moduleSpecifiers.includes(node.moduleSpecifier.text)) ||
             !node.importClause?.namedBindings ||
             !ts.isNamedImports(node.importClause.namedBindings)) {
             continue;

package/generators/migrate-to-query-v3/shared.js

@@ -17,9 +17,13 @@ export const ensureNamedImports = ({ content, importsNeeded, moduleSpecifier })
     const sourceFile = createSourceFile(content);
     let importNode;
     ts.forEachChild(sourceFile, (node) => {
-        if (ts.isImportDeclaration(node) &&
+        if (!importNode &&
+            ts.isImportDeclaration(node) &&
             ts.isStringLiteral(node.moduleSpecifier) &&
-            node.moduleSpecifier.text === moduleSpecifier) {
+            node.moduleSpecifier.text === moduleSpecifier &&
+            !node.importClause?.isTypeOnly &&
+            node.importClause?.namedBindings &&
+            ts.isNamedImports(node.importClause.namedBindings)) {
             importNode = node;
         }
     });

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

@@ -76,7 +76,18 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     const replacements = [];
     // Track which symbols are imported from @ethlete/query
     const importedSymbols = new Set();
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
     function visit(node) {
+        const namespaceMember = getNamespaceMember(node, namespaceAliases)?.member;
+        const renamedMember = namespaceMember && (TYPE_RENAMES.get(namespaceMember.text) || FUNCTION_RENAMES.get(namespaceMember.text));
+        if (namespaceMember && renamedMember) {
+            replacements.push({
+                start: namespaceMember.getStart(sourceFile),
+                end: namespaceMember.getEnd(),
+                replacement: renamedMember,
+                oldName: namespaceMember.text,
+            });
+        }
         // Track imports from @ethlete/query
         if (ts.isImportDeclaration(node)) {
             const moduleSpecifier = node.moduleSpecifier;
@@ -107,7 +118,9 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
                 return;
             }
             // 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)) {
+            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;
             }
@@ -138,6 +151,33 @@ function renameSymbolsInFile(content, filePath, symbolUsageCounts) {
     }
     return result;
 }
+function collectQueryNamespaceAliases(sourceFile) {
+    const aliases = new Set();
+    sourceFile.statements.forEach((statement) => {
+        if (!ts.isImportDeclaration(statement)) {
+            return;
+        }
+        const namedBindings = statement.importClause?.namedBindings;
+        if (namedBindings &&
+            ts.isNamespaceImport(namedBindings) &&
+            ts.isStringLiteral(statement.moduleSpecifier) &&
+            statement.moduleSpecifier.text === '@ethlete/query') {
+            aliases.add(namedBindings.name.text);
+        }
+    });
+    return aliases;
+}
+function getNamespaceMember(node, namespaceAliases) {
+    const [namespace, member] = ts.isPropertyAccessExpression(node)
+        ? [node.expression, node.name]
+        : ts.isQualifiedName(node)
+            ? [node.left, node.right]
+            : [];
+    if (!namespace || !member || !ts.isIdentifier(namespace) || !ts.isIdentifier(member)) {
+        return undefined;
+    }
+    return namespaceAliases.has(namespace.text) ? { namespace, member } : undefined;
+}
 function updateImports(sourceFile) {
     const replacements = [];
     function visit(node) {
@@ -232,9 +272,11 @@ function replaceNamespaceInFile(content, filePath) {
         ts.forEachChild(node, collectImport);
     }
     collectImport(sourceFile);
+    const namespaceAliases = collectQueryNamespaceAliases(sourceFile);
+    const namespaceReplacements = collectNamespacedExperimentalQueryReplacements(sourceFile, namespaceAliases);
     // If no ExperimentalQuery import found, return unchanged
     if (!hasExperimentalQueryImport || !experimentalQueryAlias) {
-        return { content, modified: false, replacementCount: 0 };
+        return applyReplacements(content, namespaceReplacements, namespaceReplacements.length);
     }
     // Second pass: collect used symbols
     function findUsages(node) {
@@ -313,17 +355,32 @@ function replaceNamespaceInFile(content, filePath) {
         ts.forEachChild(node, createReplacements);
     }
     createReplacements(sourceFile);
-    // Apply replacements in reverse order
+    // Subtract 1 for the import replacement
+    return applyReplacements(content, [...replacements, ...namespaceReplacements], replacements.length - 1 + namespaceReplacements.length);
+}
+function collectNamespacedExperimentalQueryReplacements(sourceFile, namespaceAliases) {
+    const replacements = [];
+    if (namespaceAliases.size === 0) {
+        return replacements;
+    }
+    function visit(node) {
+        const access = getNamespaceMember(node, namespaceAliases);
+        if (access?.member.text === 'ExperimentalQuery') {
+            replacements.push({ start: node.getStart(sourceFile), end: node.getEnd(), replacement: access.namespace.text });
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return replacements;
+}
+function applyReplacements(content, replacements, replacementCount) {
     let result = content;
-    replacements.sort((a, b) => b.start - a.start);
-    for (const { start, end, replacement } of replacements) {
+    [...replacements]
+        .sort((a, b) => b.start - a.start)
+        .forEach(({ start, end, replacement }) => {
         result = result.slice(0, start) + replacement + result.slice(end);
-    }
-    return {
-        content: result,
-        modified: replacements.length > 0,
-        replacementCount: replacements.length - 1, // Subtract 1 for the import replacement
-    };
+    });
+    return { content: result, modified: replacements.length > 0, replacementCount };
 }
 //#endregion
 //# sourceMappingURL=migration.js.map

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@ethlete/query",
-  "version": "6.0.0-next.45",
+  "version": "6.0.0-next.48",
   "license": "MIT",
   "sideEffects": false,
   "peerDependencies": {
     "@analogjs/vite-plugin-angular": "2.6.3",
-    "@angular/common": "22.0.7",
-    "@angular/core": "22.0.7",
-    "@angular/forms": "22.0.7",
-    "@angular/router": "22.0.7",
+    "@angular/common": "22.1.6",
+    "@angular/core": "22.1.6",
+    "@angular/forms": "22.1.6",
+    "@angular/router": "22.1.6",
     "@ethlete/core": "^5.0.0-beta.11",
     "@ethlete/types": "^2.0.0-beta.4",
     "@nx/devkit": "23.1.0",

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

@@ -15,6 +15,11 @@ type QueryTestSetup = {
     createPut: ReturnType<typeof createPutQuery>;
     createPatch: ReturnType<typeof createPatchQuery>;
     createDelete: ReturnType<typeof createDeleteQuery>;
+    /**
+     * Puts back the `console.warn` / `console.error` that were installed before the first
+     * {@link setupQueryTest} call. Idempotent, and safe to call from any of the setups a file created.
+     */
+    restoreConsole: () => void;
 };
 type QueryTestSetupConfig = {
     baseUrl?: string;
@@ -235,6 +240,8 @@ type FakeQueryPersistenceStoreHandle = {
     calls: () => Record<'loadIndex' | 'read' | 'write' | 'remove' | 'clear', number>;
     /** Makes the next `count` writes reject - a full disk, by default. */
     failNextWrites: (count: number, error?: unknown) => void;
+    /** Makes the next `count` removals reject. */
+    failNextRemoves: (count: number, error?: unknown) => void;
     /** Makes the next `loadIndex` reject. */
     failNextLoadIndex: (error?: unknown) => void;
     /**
@@ -245,6 +252,14 @@ type FakeQueryPersistenceStoreHandle = {
     deferReads: () => void;
     /** Settles the reads held by {@link deferReads} and stops deferring. */
     flushReads: () => Promise<void>;
+    /**
+     * Holds every subsequent `loadIndex` pending until {@link flushLoadIndex} is called, for testing
+     * what happens to the store while a client's startup is still reading its index (a real disk takes
+     * milliseconds). The snapshot each held load returns is the one it would have read when it started.
+     */
+    deferLoadIndex: () => void;
+    /** Settles the index loads held by {@link deferLoadIndex} and stops deferring. */
+    flushLoadIndex: () => Promise<void>;
 };
 declare const createFakeQueryPersistenceStore: () => FakeQueryPersistenceStoreHandle;
 
@@ -266,20 +281,37 @@ type WebSocketTestDouble = {
         url: string;
         transports: string[] | undefined;
     } | null;
-    /** Every message the client sent, newest last - room joins and leaves included. */
+    /** The `withCredentials` the client asked the factory for, or `null` until it called it. */
+    withCredentials: () => boolean | null;
+    /** Every message the client emitted, newest last - room joins and leaves included, buffered ones too. */
     sent: () => {
         event: string;
         data: unknown;
     }[];
+    /** Every message that reached the server, newest last. An emit buffered while offline lands here on the next connect. */
+    delivered: () => {
+        event: string;
+        data: unknown;
+    }[];
     /** Whether the client asked the socket to connect, and whether it has since disconnected it. */
     state: () => {
         connectRequested: boolean;
         disconnected: boolean;
     };
-    /** Complete the handshake, so the client's `isConnected` turns true and queued rooms re-join. */
-    serverConnect: () => void;
+    /**
+     * Complete the handshake: flush every buffered emit, then turn the client's `isConnected` true. Pass
+     * `recovered: true` for a connection-state-recovered reconnect, in which the server kept the rooms.
+     */
+    serverConnect: (options?: {
+        recovered?: boolean;
+    }) => void;
     /** Drop the connection, so `isConnected` turns false. */
     serverDisconnect: () => 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}.
+     */
+    serverPingExpire: () => void;
     /** Deliver a message the way the server would. */
     serverSend: (message: SocketMessageView) => void;
     /** Deliver a raw frame, for the malformed-payload path. */
@@ -291,8 +323,8 @@ type WebSocketTestDouble = {
  *
  * Nothing here connects on its own: the client's own `connect()` only flips
  * {@link WebSocketTestDouble.state}, and it is {@link WebSocketTestDouble.serverConnect} that fires
- * the `connect` listener. That split is what makes "joined a room while disconnected, and the join
- * was re-sent on connect" testable.
+ * the `connect` listener. That split is what makes "joined a room while disconnected, and it was
+ * re-joined after a reconnect" testable.
  */
 declare const createWebSocketTestDouble: () => WebSocketTestDouble;