collabmd 0.1.49 → 0.1.52

package/src/server/domain/ripgrep-search-service.js

@@ -4,6 +4,7 @@ import { join } from 'node:path';
 import { promisify } from 'node:util';
 
 import { getVaultFileKind } from '../../domain/file-kind.js';
+import { isWholeWordMatch } from '../../domain/literal-text-search.js';
 import { logPerfEvent } from '../config/perf-logging.js';
 
 const execFile = promisify(execFileCallback);
@@ -108,6 +109,7 @@ function createSnippet(lineText = '', matchStart = 0, matchEnd = matchStart) {
 function createRipgrepArgs(query, {
   maxFileSize = DEFAULT_MAX_FILE_SIZE,
   maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+  wholeWord = false,
 } = {}) {
   const args = [
     '--json',
@@ -130,6 +132,7 @@ function createRipgrepArgs(query, {
     '--glob',
     '!.trash/**',
   ];
+  if (wholeWord) args.push('--word-regexp');
 
   TEXT_SEARCH_GLOBS.forEach((glob) => {
     args.push('--glob', glob);
@@ -140,10 +143,15 @@ function createRipgrepArgs(query, {
 }
 
 export function parseRipgrepJson(stdout, {
+  excludedPaths = [],
+  kinds = [],
   maxFiles = DEFAULT_MAX_FILES,
   maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+  prefix = '',
   query = '',
 } = {}) {
+  const excluded = new Set(excludedPaths);
+  const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
   const files = [];
   const filesByPath = new Map();
   let matchCount = 0;
@@ -167,7 +175,13 @@ export function parseRipgrepJson(stdout, {
     }
 
     const filePath = String(event?.data?.path?.text ?? '').replace(/^\.\//u, '');
-    if (!filePath) {
+    const kind = getVaultFileKind(filePath) ?? 'text';
+    if (
+      !filePath
+      || excluded.has(filePath)
+      || (prefix && filePath !== prefix && !filePath.startsWith(`${prefix}/`))
+      || (kindFilter.size > 0 && !kindFilter.has(kind))
+    ) {
       continue;
     }
 
@@ -180,7 +194,7 @@ export function parseRipgrepJson(stdout, {
 
       fileGroup = {
         file: filePath,
-        kind: getVaultFileKind(filePath) ?? 'text',
+        kind,
         matchCount: 0,
         snippets: [],
         truncated: false,
@@ -226,17 +240,65 @@ export function parseRipgrepJson(stdout, {
   };
 }
 
-async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile, query, signal, vaultDir }) {
+export function searchExcalidrawSceneText(scene, { query, maxSnippetsPerFile = 5, wholeWord = false }) {
+  const normalizedQuery = query.toLocaleLowerCase();
+  const snippets = [];
+  let matchCount = 0;
+  for (const element of Array.isArray(scene?.elements) ? scene.elements : []) {
+    if (element?.isDeleted || element?.type !== 'text' || typeof element.text !== 'string') continue;
+    const text = element.text;
+    const normalizedText = text.toLocaleLowerCase();
+    let matchStart = normalizedText.indexOf(normalizedQuery);
+    while (matchStart >= 0) {
+      if (!wholeWord || isWholeWordMatch(normalizedText, matchStart, matchStart + normalizedQuery.length)) {
+        matchCount += 1;
+        if (snippets.length < maxSnippetsPerFile) {
+          const snippet = createSnippet(text, matchStart, matchStart + query.length);
+          snippets.push({
+            column: matchStart + 1,
+            line: 1,
+            matchEnd: snippet.matchEnd,
+            matchStart: snippet.matchStart,
+            text: snippet.text,
+          });
+        }
+      }
+      matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
+    }
+  }
+
+  return { matchCount, snippets, truncated: matchCount > snippets.length };
+}
+
+async function searchExcalidrawText({
+  excludedPaths = [],
+  kinds = [],
+  maxFileSize,
+  maxFiles,
+  maxSnippetsPerFile,
+  prefix = '',
+  query,
+  wholeWord = false,
+  signal,
+  vaultDir,
+}) {
+  const excluded = new Set(excludedPaths);
+  const kindFilter = new Set(Array.isArray(kinds) ? kinds : []);
+  if (kindFilter.size > 0 && !kindFilter.has('excalidraw')) {
+    return { files: [], matchCount: 0, truncated: false };
+  }
   const files = [];
   let matchCount = 0;
   let truncated = false;
-  const normalizedQuery = query.toLocaleLowerCase();
   const paths = glob('**/*.excalidraw', {
     cwd: vaultDir,
     exclude: ['**/.*', '**/node_modules/**'],
   });
 
   for await (const filePath of paths) {
+    const normalizedPath = filePath.replaceAll('\\', '/');
+    if (excluded.has(normalizedPath)) continue;
+    if (prefix && normalizedPath !== prefix && !normalizedPath.startsWith(`${prefix}/`)) continue;
     signal?.throwIfAborted?.();
     const absolutePath = join(vaultDir, filePath);
     if ((await stat(absolutePath)).size > parseByteLimit(maxFileSize)) continue;
@@ -248,31 +310,10 @@ async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile,
       continue;
     }
 
-    const snippets = [];
-    let fileMatchCount = 0;
-    for (const element of Array.isArray(scene?.elements) ? scene.elements : []) {
-      if (element?.isDeleted || element?.type !== 'text' || typeof element.text !== 'string') continue;
-      const text = element.text;
-      const normalizedText = text.toLocaleLowerCase();
-      let matchStart = normalizedText.indexOf(normalizedQuery);
-      while (matchStart >= 0) {
-        fileMatchCount += 1;
-        matchCount += 1;
-        if (snippets.length < maxSnippetsPerFile) {
-          const snippet = createSnippet(text, matchStart, matchStart + query.length);
-          snippets.push({
-            column: matchStart + 1,
-            line: 1,
-            matchEnd: snippet.matchEnd,
-            matchStart: snippet.matchStart,
-            text: snippet.text,
-          });
-        } else {
-          truncated = true;
-        }
-        matchStart = normalizedText.indexOf(normalizedQuery, matchStart + Math.max(query.length, 1));
-      }
-    }
+    const result = searchExcalidrawSceneText(scene, { query, maxSnippetsPerFile, wholeWord });
+    const { matchCount: fileMatchCount, snippets } = result;
+    matchCount += fileMatchCount;
+    truncated ||= result.truncated;
 
     if (fileMatchCount > 0) {
       if (files.length >= maxFiles) {
@@ -280,7 +321,7 @@ async function searchExcalidrawText({ maxFileSize, maxFiles, maxSnippetsPerFile,
         continue;
       }
       files.push({
-        file: filePath.replaceAll('\\', '/'),
+        file: normalizedPath,
         kind: 'excalidraw',
         matchCount: fileMatchCount,
         snippets,
@@ -354,11 +395,20 @@ export class RipgrepSearchService {
   }
 
   async search({
+    excludedPaths = [],
+    kinds = [],
     limit = DEFAULT_MAX_FILES,
+    maxSnippetsPerFile = DEFAULT_MAX_SNIPPETS_PER_FILE,
+    prefix = '',
     query = '',
     signal = null,
+    wholeWord = false,
   } = {}) {
     const normalizedQuery = String(query ?? '').trim();
+    const snippetLimit = normalizePositiveInt(maxSnippetsPerFile, this.maxSnippetsPerFile, {
+      max: 10,
+      min: 1,
+    });
     const maxFiles = normalizePositiveInt(limit, this.maxFiles, {
       max: this.maxFiles,
       min: 1,
@@ -381,7 +431,8 @@ export class RipgrepSearchService {
     const startedAt = Date.now();
     const args = createRipgrepArgs(normalizedQuery, {
       maxFileSize: this.maxFileSize,
-      maxSnippetsPerFile: this.maxSnippetsPerFile,
+      maxSnippetsPerFile: snippetLimit,
+      wholeWord,
     });
     let parsed;
     try {
@@ -393,8 +444,11 @@ export class RipgrepSearchService {
         timeout: this.timeoutMs,
       });
       parsed = parseRipgrepJson(result.stdout, {
+        excludedPaths,
+        kinds,
         maxFiles,
-        maxSnippetsPerFile: this.maxSnippetsPerFile,
+        maxSnippetsPerFile: snippetLimit,
+        prefix,
         query: normalizedQuery,
       });
     } catch (error) {
@@ -406,8 +460,11 @@ export class RipgrepSearchService {
       } else {
         const isMaxBuffer = error?.code === 'ERR_CHILD_PROCESS_STDIO_MAXBUFFER';
         parsed = parseRipgrepJson(error?.stdout ?? '', {
+          excludedPaths,
+          kinds,
           maxFiles,
-          maxSnippetsPerFile: this.maxSnippetsPerFile,
+          maxSnippetsPerFile: snippetLimit,
+          prefix,
           query: normalizedQuery,
         });
         if (isMaxBuffer && parsed.files.length > 0) {
@@ -421,16 +478,22 @@ export class RipgrepSearchService {
 
     if (parsed.files.length < maxFiles) {
       const excalidraw = await searchExcalidrawText({
+        excludedPaths,
+        kinds,
         maxFileSize: this.maxFileSize,
         maxFiles: maxFiles - parsed.files.length,
-        maxSnippetsPerFile: this.maxSnippetsPerFile,
+        maxSnippetsPerFile: snippetLimit,
+        prefix,
         query: normalizedQuery,
+        wholeWord,
         signal,
         vaultDir: this.vaultDir,
       });
       parsed.files.push(...excalidraw.files);
       parsed.matchCount += excalidraw.matchCount;
       parsed.truncated ||= excalidraw.truncated;
+    } else if (kinds.length === 0 || kinds.includes('excalidraw')) {
+      parsed.truncated = true;
     }
     parsed.search = this.getClientConfig();
     logPerfEvent(this.perfLoggingEnabled, 'search-query', {

package/src/server/infrastructure/git/diff-service.js

@@ -142,20 +142,24 @@ export class GitDiffService {
     scope = 'working-tree',
   } = {}) {
     const trackedFiles = files.filter((entry) => entry.status !== 'untracked');
-    const trackedSummary = trackedFiles.length > 0
-      ? parseNumstatOutput(
-        await this.commandRunner.execGit(this.buildDiffCommandArgs({
-          hasHeadCommit,
-          numstat: true,
-          path,
-          scope,
-        })),
-      )
-      : createEmptyStats();
-    const untrackedAdditions = await this.untrackedFileService.countAdditions(
+    // The diff spawn and the untracked file scan are independent: overlap them.
+    const trackedSummaryPromise = trackedFiles.length > 0
+      ? this.commandRunner.execGit(this.buildDiffCommandArgs({
+        hasHeadCommit,
+        numstat: true,
+        path,
+        scope,
+      })).then((output) => parseNumstatOutput(output))
+      : Promise.resolve(createEmptyStats());
+    const untrackedAdditionsPromise = this.untrackedFileService.countAdditions(
       files.filter((entry) => entry.status === 'untracked'),
     );
 
+    const [trackedSummary, untrackedAdditions] = await Promise.all([
+      trackedSummaryPromise,
+      untrackedAdditionsPromise,
+    ]);
+
     return {
       additions: trackedSummary.additions + untrackedAdditions,
       deletions: trackedSummary.deletions,

package/src/server/infrastructure/git/git-service.js

@@ -127,6 +127,10 @@ export class GitService {
     return this.statusService.getStatus(options);
   }
 
+  async readPullBackupSummary(backupId) {
+    return this.pullBackupStore.readSummary(backupId);
+  }
+
   async listPullBackups() {
     if (!(await this.isGitRepo())) {
       return [];

package/src/server/infrastructure/git/image-mime.js

@@ -1,3 +1,5 @@
+import { extname } from 'node:path';
+
 const IMAGE_MIME_TYPES = Object.freeze({
   '.gif': 'image/gif',
   '.jpeg': 'image/jpeg',
@@ -8,7 +10,6 @@ const IMAGE_MIME_TYPES = Object.freeze({
 });
 
 export function getImageMimeType(filePath) {
-  const normalizedPath = String(filePath ?? '').toLowerCase();
-  const extension = Object.keys(IMAGE_MIME_TYPES).find((candidate) => normalizedPath.endsWith(candidate));
-  return extension ? IMAGE_MIME_TYPES[extension] : 'application/octet-stream';
+  const extension = extname(String(filePath ?? '').toLowerCase());
+  return IMAGE_MIME_TYPES[extension] ?? 'application/octet-stream';
 }

package/src/server/infrastructure/git/local-exclude.js

@@ -1,8 +1,20 @@
+import { execFile as execFileCallback } from 'node:child_process';
 import { readFile, writeFile } from 'node:fs/promises';
 import { resolve } from 'node:path';
+import { promisify } from 'node:util';
+
+const execFile = promisify(execFileCallback);
 
 export async function ensureCollabMetadataGitExclude(vaultDir) {
-  const excludePath = resolve(vaultDir, '.git/info/exclude');
+  let excludePath = resolve(vaultDir, '.git/info/exclude');
+  try {
+    const { stdout } = await execFile('git', ['rev-parse', '--git-path', 'info/exclude'], {
+      cwd: vaultDir,
+    });
+    excludePath = resolve(vaultDir, String(stdout).trim());
+  } catch {
+    // Preserve support for repositories represented by a local .git directory.
+  }
   let existingContent = '';
 
   try {

package/src/server/infrastructure/git/status-service.js

@@ -84,12 +84,16 @@ export class GitStatusService {
   }
 
   async getLocalChangeSummary({ hasHeadCommit = false, untrackedFiles = [] } = {}) {
-    const trackedSummary = parseNumstatOutput(
-      await this.commandRunner.execGit(hasHeadCommit
-        ? ['diff', '--numstat', 'HEAD']
-        : ['diff', '--cached', '--numstat']),
-    );
-    const untrackedAdditions = await this.untrackedFileService.countAdditions(untrackedFiles);
+    // The diff spawn and the untracked file scan are independent: overlap them.
+    const trackedSummaryPromise = this.commandRunner.execGit(hasHeadCommit
+      ? ['diff', '--numstat', 'HEAD']
+      : ['diff', '--cached', '--numstat']).then((output) => parseNumstatOutput(output));
+    const untrackedAdditionsPromise = this.untrackedFileService.countAdditions(untrackedFiles);
+
+    const [trackedSummary, untrackedAdditions] = await Promise.all([
+      trackedSummaryPromise,
+      untrackedAdditionsPromise,
+    ]);
 
     return {
       additions: trackedSummary.additions + untrackedAdditions,

package/src/server/infrastructure/http/create-agent-api-handler.js

@@ -63,7 +63,7 @@ async function createWebMcpActor({ agentConnectionService, authService, config,
 }
 
 async function mapWebMcpResult(definition, value) {
-  if (definition.resultKind === 'image' && value.svg) {
+  if (value.svg && ['image', 'optional-image'].includes(definition.resultKind)) {
     const { data, mimeType, structuredContent } = await encodeAgentToolImage(value);
     return {
       ...structuredContent,

package/src/server/infrastructure/http/create-git-api-query-handler.js

@@ -6,6 +6,7 @@ import {
   encodeContentDispositionFilename,
   jsonResponse,
   sendResponse,
+  SVG_ATTACHMENT_CSP,
 } from './http-response.js';
 
 function resolveDiffScope(requestUrl) {
@@ -127,6 +128,7 @@ export function createGitApiQueryHandler({ gitService }) {
             'Content-Disposition': `inline; filename="${createSafeAsciiFilename(fileName)}"; filename*=UTF-8''${encodeContentDispositionFilename(fileName)}`,
             'Content-Type': attachment.mimeType || 'application/octet-stream',
             'X-Content-Type-Options': 'nosniff',
+            ...(attachment.mimeType === 'image/svg+xml' ? { 'Content-Security-Policy': SVG_ATTACHMENT_CSP } : {}),
           },
           statusCode: 200,
         });
@@ -136,6 +138,29 @@ export function createGitApiQueryHandler({ gitService }) {
       return true;
     }
 
+    if (requestUrl.pathname === '/api/git/pull-backup-summary' && req.method === 'GET') {
+      try {
+        const content = await gitService.readPullBackupSummary(requestUrl.searchParams.get('id'));
+        if (content === null) {
+          jsonResponse(req, res, 404, { error: 'Pull backup summary not found' });
+        } else {
+          sendResponse(req, res, {
+            body: content,
+            headers: {
+              'Cache-Control': 'no-store',
+              'Content-Type': 'text/plain; charset=utf-8',
+              'Content-Security-Policy': "default-src 'none'; sandbox",
+              'X-Content-Type-Options': 'nosniff',
+            },
+            statusCode: 200,
+          });
+        }
+      } catch (error) {
+        handleApiError(req, res, error, '[api] Failed to read pull backup summary:', 'Failed to read pull backup summary');
+      }
+      return true;
+    }
+
     if (requestUrl.pathname === '/api/git/pull-backups' && req.method === 'GET') {
       try {
         jsonResponse(req, res, 200, {

package/src/server/infrastructure/http/create-hosted-api-handler.js

@@ -43,6 +43,11 @@ export function createHostedApiHandler({
         user,
       }));
     }],
+    ['POST /api/hosted/setup/complete', async ({ req, res, user }) => {
+      const admin = await hostedWorkspaceService.requireAdmin(user);
+      const team = await hostedWorkspaceService.completeWorkspaceSetup({ user: admin });
+      jsonResponse(req, res, 200, { ok: true, setupComplete: true, team });
+    }],
     ['GET /api/hosted/vault-source', async ({ req, res, user }) => {
       jsonResponse(req, res, 200, { vaultSource: await hostedWorkspaceService.getVaultSource(user) });
     }],

package/src/server/infrastructure/http/create-request-handler.js

@@ -42,6 +42,7 @@ export function createRequestHandler(
   githubSetupFlow = null,
   structurizrWorkspaceService = null,
   agentIntegration = null,
+  vaultRegistry = null,
 ) {
   const handleStaticRequest = createStaticHandler(config, authService, searchService);
   const handleAuthApi = createAuthApiHandler({ authService });
@@ -50,28 +51,43 @@ export function createRequestHandler(
     githubSetupFlow,
     hostedWorkspaceService,
   });
-  const handleGitApiQuery = createGitApiQueryHandler({ gitService });
-  const handleGitApiCommand = createGitApiCommandHandler({
-    authService,
-    gitService,
-    workspaceMutationCoordinator,
-  });
-  const handleVaultApiQuery = createVaultApiQueryHandler({
-    baseQueryService,
-    backlinkIndex,
-    config,
-    searchService,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
-  const handleVaultApiCommand = createVaultApiCommandHandler({
-    backlinkIndex,
-    maxPdfUploadBytes: config.maxPdfUploadBytes,
-    renderDocx,
-    roomRegistry,
-    vaultFileStore,
-    workspaceMutationCoordinator,
-  });
+  // ponytail: one builder for legacy primary paths and scoped vaults; only the parts differ
+  const vaultHandlerCache = new Map();
+  function getVaultHandlers(id, parts) {
+    let handlers = vaultHandlerCache.get(id);
+    if (!handlers) {
+      handlers = {
+        command: createVaultApiCommandHandler({
+          backlinkIndex: parts.backlinkIndex,
+          maxPdfUploadBytes: config.maxPdfUploadBytes,
+          renderDocx,
+          roomRegistry: parts.roomRegistry,
+          vaultFileStore: parts.vaultFileStore,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+        gitCommand: createGitApiCommandHandler({
+          authService,
+          gitService: parts.gitService,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+        gitQuery: createGitApiQueryHandler({ gitService: parts.gitService }),
+        query: createVaultApiQueryHandler({
+          baseQueryService: parts.baseQueryService,
+          backlinkIndex: parts.backlinkIndex,
+          config,
+          searchService: parts.searchService,
+          vaultFileStore: parts.vaultFileStore,
+          workspaceMutationCoordinator: parts.workspaceMutationCoordinator,
+        }),
+      };
+      vaultHandlerCache.set(id, handlers);
+    }
+    return handlers;
+  }
+  const primaryHandlers = getVaultHandlers(
+    vaultRegistry?.getPrimaryContext?.()?.def.id ?? '__primary__',
+    { backlinkIndex, baseQueryService, gitService, roomRegistry, searchService, vaultFileStore, workspaceMutationCoordinator },
+  );
   const handlePlantUmlApi = createPlantUmlApiHandler({ plantUmlRenderer });
   const handleStructurizrApi = createStructurizrApiHandler({
     basePath: config.basePath,
@@ -94,6 +110,56 @@ export function createRequestHandler(
       })
     : async () => false;
 
+  function parseVaultScope(pathname) {
+    if (!pathname.startsWith('/api/v/')) {
+      return null;
+    }
+    const rest = pathname.slice('/api/v/'.length);
+    const slashIndex = rest.indexOf('/');
+    if (slashIndex === -1) {
+      return null;
+    }
+    const vaultId = rest.slice(0, slashIndex);
+    if (!vaultId) {
+      return null;
+    }
+    return { subPath: `/api${rest.slice(slashIndex)}`, vaultId };
+  }
+
+  async function handleVaultScopedApi(req, res, requestUrl) {
+    const scope = parseVaultScope(requestUrl.pathname);
+    if (!scope || !vaultRegistry) {
+      return false;
+    }
+    let context;
+    try {
+      context = await vaultRegistry.getOrCreateContextAsync(scope.vaultId);
+    } catch (error) {
+      jsonResponse(req, res, error?.statusCode || 500, { error: error?.message || 'Vault unavailable' });
+      return true;
+    }
+    const subUrl = new URL(requestUrl.toString());
+    subUrl.pathname = scope.subPath;
+    const handlers = getVaultHandlers(context.def.id, context);
+    if (await handlers.query(req, res, subUrl)) {
+      return true;
+    }
+    if (await handlers.command(req, res, subUrl)) {
+      return true;
+    }
+    if (subUrl.pathname.startsWith('/api/git')) {
+      if (await handlers.gitQuery(req, res, subUrl)) {
+        return true;
+      }
+      if (await handlers.gitCommand(req, res, subUrl)) {
+        return true;
+      }
+      jsonResponse(req, res, 404, { error: 'Git API endpoint not found' });
+      return true;
+    }
+    return false;
+  }
+
   function handleBasePathRedirect(req, res, originalRequestUrl) {
     if (
       config.basePath
@@ -231,10 +297,13 @@ export function createRequestHandler(
     }
 
     if (requestUrl.pathname.startsWith('/api/')) {
-      if (await handleVaultApiQuery(req, res, requestUrl)) {
+      if (await handleVaultScopedApi(req, res, requestUrl)) {
+        return;
+      }
+      if (await primaryHandlers.query(req, res, requestUrl)) {
         return;
       }
-      if (await handleVaultApiCommand(req, res, requestUrl)) {
+      if (await primaryHandlers.command(req, res, requestUrl)) {
         return;
       }
       if (await handlePlantUmlApi(req, res, requestUrl)) {
@@ -247,10 +316,10 @@ export function createRequestHandler(
         jsonResponse(req, res, 503, { error: 'Git integration is not configured' });
         return;
       }
-      if (await handleGitApiQuery(req, res, requestUrl)) {
+      if (await primaryHandlers.gitQuery(req, res, requestUrl)) {
         return;
       }
-      if (await handleGitApiCommand(req, res, requestUrl)) {
+      if (await primaryHandlers.gitCommand(req, res, requestUrl)) {
         return;
       }
       jsonResponse(req, res, 404, { error: 'Git API endpoint not found' });

package/src/server/infrastructure/http/create-static-handler.js

@@ -58,8 +58,10 @@ function buildRuntimeConfig({
   structurizr,
   wikiLinkAutoCreate,
   wsBasePath,
+  vaults,
 }) {
   return `window.__COLLABMD_CONFIG__ = ${JSON.stringify({
+    activeVault: vaults?.[0]?.id ?? '',
     agentAccess: {
       enabled: Boolean(agentAccess?.enabled),
       endpoint: agentAccess?.endpoint || '',
@@ -79,6 +81,7 @@ function buildRuntimeConfig({
     structurizrEnabled: Boolean(structurizr?.enabled ?? structurizr?.serverUrl),
     wikiLinkAutoCreate,
     wsBasePath,
+    vaults: (vaults ?? []).map(({ id }) => ({ id })),
   })};\n`;
 }