bluera-knowledge 0.9.32 → 0.9.36

package/src/workers/pid-file.test.ts

@@ -0,0 +1,167 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import { mkdtempSync, rmSync, existsSync, chmodSync, writeFileSync, readFileSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import { writePidFile, deletePidFile, buildPidFilePath } from './pid-file.js';
+
+/**
+ * PID File Operations Tests
+ *
+ * SAFETY: All tests use fake PID 999999999 - never real PIDs.
+ * This prevents accidentally killing VSCode, terminals, or other processes.
+ */
+describe('PID File Operations', () => {
+  let tempDir: string;
+  let pidFile: string;
+
+  // Fake PID - guaranteed not to be a real process
+  const FAKE_PID = 999999999;
+
+  beforeEach(() => {
+    tempDir = mkdtempSync(join(tmpdir(), 'pid-file-test-'));
+    pidFile = join(tempDir, 'test_job.pid');
+  });
+
+  afterEach(() => {
+    if (existsSync(tempDir)) {
+      // Restore permissions before cleanup (in case test made it read-only)
+      try {
+        chmodSync(tempDir, 0o755);
+      } catch {
+        // Ignore - might not exist
+      }
+      rmSync(tempDir, { recursive: true, force: true });
+    }
+  });
+
+  describe('writePidFile', () => {
+    it('should write PID to file successfully', () => {
+      writePidFile(pidFile, FAKE_PID);
+
+      expect(existsSync(pidFile)).toBe(true);
+      const content = readFileSync(pidFile, 'utf-8');
+      expect(content).toBe('999999999');
+    });
+
+    it('should overwrite existing PID file', () => {
+      writeFileSync(pidFile, '123456', 'utf-8');
+
+      writePidFile(pidFile, FAKE_PID);
+
+      const content = readFileSync(pidFile, 'utf-8');
+      expect(content).toBe('999999999');
+    });
+
+    it('should throw with CRITICAL message when write fails (permission denied)', () => {
+      // Make directory read-only to prevent file creation
+      chmodSync(tempDir, 0o444);
+
+      expect(() => writePidFile(pidFile, FAKE_PID)).toThrow(/CRITICAL/);
+      expect(() => writePidFile(pidFile, FAKE_PID)).toThrow(/Failed to write PID file/);
+      expect(() => writePidFile(pidFile, FAKE_PID)).toThrow(/Job cannot be cancelled/);
+    });
+
+    it('should include file path in error message', () => {
+      chmodSync(tempDir, 0o444);
+
+      try {
+        writePidFile(pidFile, FAKE_PID);
+        expect.fail('Should have thrown');
+      } catch (error) {
+        expect(error).toBeInstanceOf(Error);
+        expect((error as Error).message).toContain(pidFile);
+      }
+    });
+
+    it('should throw when path directory does not exist', () => {
+      const invalidPath = '/nonexistent/directory/test.pid';
+
+      expect(() => writePidFile(invalidPath, FAKE_PID)).toThrow(/CRITICAL/);
+    });
+  });
+
+  describe('deletePidFile', () => {
+    it('should delete PID file successfully', () => {
+      writeFileSync(pidFile, FAKE_PID.toString(), 'utf-8');
+
+      const result = deletePidFile(pidFile, 'success');
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+      expect(existsSync(pidFile)).toBe(false);
+    });
+
+    it('should return success when PID file does not exist', () => {
+      // File doesn't exist
+      expect(existsSync(pidFile)).toBe(false);
+
+      const result = deletePidFile(pidFile, 'success');
+
+      expect(result.success).toBe(true);
+      expect(result.error).toBeUndefined();
+    });
+
+    it('should return failure (NOT throw) when delete fails', () => {
+      writeFileSync(pidFile, FAKE_PID.toString(), 'utf-8');
+      // Make directory read-only to prevent deletion
+      chmodSync(tempDir, 0o444);
+
+      // Should NOT throw
+      const result = deletePidFile(pidFile, 'success');
+
+      expect(result.success).toBe(false);
+      expect(result.error).toBeInstanceOf(Error);
+    });
+
+    it('should never throw on delete failure - returns result instead', () => {
+      writeFileSync(pidFile, FAKE_PID.toString(), 'utf-8');
+      chmodSync(tempDir, 0o444);
+
+      // Must not throw - this is best-effort cleanup
+      expect(() => deletePidFile(pidFile, 'failure')).not.toThrow();
+      expect(() => deletePidFile(pidFile, 'sigterm')).not.toThrow();
+      expect(() => deletePidFile(pidFile, 'success')).not.toThrow();
+    });
+
+    it('should handle sigterm context', () => {
+      writeFileSync(pidFile, FAKE_PID.toString(), 'utf-8');
+
+      const result = deletePidFile(pidFile, 'sigterm');
+
+      expect(result.success).toBe(true);
+      expect(existsSync(pidFile)).toBe(false);
+    });
+
+    it('should handle failure context', () => {
+      writeFileSync(pidFile, FAKE_PID.toString(), 'utf-8');
+
+      const result = deletePidFile(pidFile, 'failure');
+
+      expect(result.success).toBe(true);
+      expect(existsSync(pidFile)).toBe(false);
+    });
+  });
+
+  describe('buildPidFilePath', () => {
+    it('should build correct PID file path', () => {
+      const result = buildPidFilePath('/data/jobs', 'job_123');
+
+      expect(result).toBe('/data/jobs/job_123.pid');
+    });
+
+    it('should handle job IDs with various formats', () => {
+      expect(buildPidFilePath('/jobs', 'abc123def')).toBe('/jobs/abc123def.pid');
+      expect(buildPidFilePath('/jobs', 'test-job')).toBe('/jobs/test-job.pid');
+      expect(buildPidFilePath('/jobs', 'job_with_underscore')).toBe(
+        '/jobs/job_with_underscore.pid'
+      );
+    });
+
+    it('should handle paths with trailing slash', () => {
+      // path.join normalizes this
+      const result = buildPidFilePath('/data/jobs/', 'job_123');
+
+      expect(result).toBe('/data/jobs/job_123.pid');
+    });
+  });
+});

package/src/workers/pid-file.ts

@@ -0,0 +1,82 @@
+import fs from 'fs';
+import path from 'path';
+
+/**
+ * Result of a PID file delete operation.
+ * Delete operations are best-effort and should not throw.
+ */
+export interface PidFileResult {
+  success: boolean;
+  error?: Error;
+}
+
+/**
+ * Context for PID file deletion - indicates when the delete is happening.
+ * Used for logging/debugging purposes.
+ */
+export type PidFileDeleteContext = 'sigterm' | 'success' | 'failure';
+
+/**
+ * Write PID file - CRITICAL operation that must succeed.
+ *
+ * If the PID file cannot be written, the job cannot be cancelled through
+ * the job management system. This is a critical failure and the job
+ * should not proceed.
+ *
+ * @param pidFile - Absolute path to the PID file
+ * @param pid - Process ID to write
+ * @throws Error if PID file cannot be written
+ */
+export function writePidFile(pidFile: string, pid: number): void {
+  try {
+    fs.writeFileSync(pidFile, pid.toString(), 'utf-8');
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new Error(
+      `CRITICAL: Failed to write PID file ${pidFile}. ` +
+        `Job cannot be cancelled without PID file. ` +
+        `Original error: ${message}`
+    );
+  }
+}
+
+/**
+ * Delete PID file - best-effort cleanup during shutdown.
+ *
+ * This operation should NEVER throw. During process shutdown (SIGTERM,
+ * job success, job failure), failing to delete a PID file should not
+ * prevent the process from exiting cleanly.
+ *
+ * Stale PID files are cleaned up by JobService.cleanupOldJobs().
+ *
+ * @param pidFile - Absolute path to the PID file
+ * @param _context - Context indicating when the delete is happening (for future logging)
+ * @returns Result indicating success or failure with error details
+ */
+export function deletePidFile(pidFile: string, _context: PidFileDeleteContext): PidFileResult {
+  try {
+    fs.unlinkSync(pidFile);
+    return { success: true };
+  } catch (error) {
+    // ENOENT = file doesn't exist - that's success (nothing to delete)
+    if (error instanceof Error && 'code' in error && error.code === 'ENOENT') {
+      return { success: true };
+    }
+    // Any other error = failure (permission denied, etc.)
+    return {
+      success: false,
+      error: error instanceof Error ? error : new Error(String(error)),
+    };
+  }
+}
+
+/**
+ * Build the path to a PID file for a given job.
+ *
+ * @param jobsDir - Directory where job files are stored
+ * @param jobId - Job identifier
+ * @returns Absolute path to the PID file
+ */
+export function buildPidFilePath(jobsDir: string, jobId: string): string {
+  return path.join(jobsDir, `${jobId}.pid`);
+}

package/src/workers/spawn-worker.test.ts

@@ -3,11 +3,11 @@ import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
 // Mock child_process before importing spawn-worker
 const mockUnref = vi.fn();
 const mockSpawn = vi.fn(() => ({
-  unref: mockUnref
+  unref: mockUnref,
 }));
 
 vi.mock('child_process', () => ({
-  spawn: mockSpawn
+  spawn: mockSpawn,
 }));
 
 // Import after mocking
@@ -50,11 +50,15 @@ describe('spawnBackgroundWorker', () => {
     spawnBackgroundWorker('test-job', '/test/data/dir');
 
     expect(mockSpawn).toHaveBeenCalledTimes(1);
-    const [, , options] = mockSpawn.mock.calls[0] as [string, string[], { detached: boolean; stdio: string }];
+    const [, , options] = mockSpawn.mock.calls[0] as [
+      string,
+      string[],
+      { detached: boolean; stdio: string },
+    ];
 
     expect(options).toMatchObject({
       detached: true,
-      stdio: 'ignore'
+      stdio: 'ignore',
     });
   });
 
@@ -63,11 +67,15 @@ describe('spawnBackgroundWorker', () => {
     spawnBackgroundWorker('test-job', dataDir);
 
     expect(mockSpawn).toHaveBeenCalledTimes(1);
-    const [, , options] = mockSpawn.mock.calls[0] as [string, string[], { env: Record<string, string> }];
+    const [, , options] = mockSpawn.mock.calls[0] as [
+      string,
+      string[],
+      { env: Record<string, string> },
+    ];
 
     expect(options.env).toMatchObject({
       ...process.env,
-      BLUERA_DATA_DIR: dataDir
+      BLUERA_DATA_DIR: dataDir,
     });
   });
 
@@ -76,7 +84,11 @@ describe('spawnBackgroundWorker', () => {
     spawnBackgroundWorker('job-456', testDataDir);
 
     expect(mockSpawn).toHaveBeenCalledTimes(1);
-    const [, , options] = mockSpawn.mock.calls[0] as [string, string[], { env: Record<string, string> }];
+    const [, , options] = mockSpawn.mock.calls[0] as [
+      string,
+      string[],
+      { env: Record<string, string> },
+    ];
 
     expect(options.env.BLUERA_DATA_DIR).toBe(testDataDir);
   });
@@ -86,7 +98,7 @@ describe('spawnBackgroundWorker', () => {
 describe('spawnBackgroundWorker (production mode)', () => {
   const mockUnrefProd = vi.fn();
   const mockSpawnProd = vi.fn(() => ({
-    unref: mockUnrefProd
+    unref: mockUnrefProd,
   }));
 
   beforeEach(() => {
@@ -102,12 +114,12 @@ describe('spawnBackgroundWorker (production mode)', () => {
   it('should use Node.js directly in production mode (dist folder)', async () => {
     // Mock child_process
     vi.doMock('child_process', () => ({
-      spawn: mockSpawnProd
+      spawn: mockSpawnProd,
     }));
 
     // Mock url module to return a path containing /dist/
     vi.doMock('url', () => ({
-      fileURLToPath: () => '/app/dist/workers/spawn-worker.js'
+      fileURLToPath: () => '/app/dist/workers/spawn-worker.js',
     }));
 
     // Import fresh module with production path

package/src/workers/spawn-worker.ts

@@ -1,6 +1,6 @@
 import { spawn } from 'child_process';
-import { fileURLToPath } from 'url';
 import path from 'path';
+import { fileURLToPath } from 'url';
 
 /**
  * Spawn a background worker process to execute a job
@@ -36,12 +36,12 @@ export function spawnBackgroundWorker(jobId: string, dataDir: string): void {
 
   // Spawn the worker process
   const worker = spawn(command, args, {
-    detached: true,      // Detach from parent process
-    stdio: 'ignore',     // Don't pipe stdio (fully independent)
+    detached: true, // Detach from parent process
+    stdio: 'ignore', // Don't pipe stdio (fully independent)
     env: {
-      ...process.env,    // Inherit environment variables
-      BLUERA_DATA_DIR: dataDir  // Pass dataDir to worker
-    }
+      ...process.env, // Inherit environment variables
+      BLUERA_DATA_DIR: dataDir, // Pass dataDir to worker
+    },
   });
 
   // Unref the worker so the parent can exit

package/tests/analysis/ast-parser.test.ts

@@ -43,7 +43,7 @@ export class UserService {
     const parser = new ASTParser();
     const nodes = parser.parse(code, 'typescript');
 
-    const classNode = nodes.find(n => n.type === 'class');
+    const classNode = nodes.find((n) => n.type === 'class');
     expect(classNode).toBeDefined();
     expect(classNode?.name).toBe('UserService');
     expect(classNode?.methods).toHaveLength(3); // constructor + create + delete
@@ -78,11 +78,11 @@ class Bar {
     const parser = new ASTParser();
     const nodes = parser.parse(code, 'typescript');
 
-    const fooNode = nodes.find(n => n.name === 'foo');
+    const fooNode = nodes.find((n) => n.name === 'foo');
     expect(fooNode?.startLine).toBe(2);
     expect(fooNode?.endLine).toBe(4);
 
-    const barNode = nodes.find(n => n.name === 'Bar');
+    const barNode = nodes.find((n) => n.name === 'Bar');
     expect(barNode?.startLine).toBe(6);
     expect(barNode?.endLine).toBe(8);
   });

package/tests/analysis/code-graph.test.ts

@@ -10,15 +10,15 @@ describe('CodeGraph', () => {
         name: 'validateToken',
         exported: true,
         startLine: 1,
-        endLine: 5
+        endLine: 5,
       },
       {
         type: 'function',
         name: 'parseToken',
         exported: false,
         startLine: 7,
-        endLine: 10
-      }
+        endLine: 10,
+      },
     ];
 
     const graph = new CodeGraph();
@@ -52,9 +52,9 @@ export function handler(req) {
     graph.analyzeCallRelationships(code, 'src/handler.ts', 'handler');
 
     const edges = graph.getEdges('src/handler.ts:handler');
-    const callEdges = edges.filter(e => e.type === 'calls');
+    const callEdges = edges.filter((e) => e.type === 'calls');
 
     expect(callEdges.length).toBeGreaterThan(0);
-    expect(callEdges.some(e => e.to.includes('validateToken'))).toBe(true);
+    expect(callEdges.some((e) => e.to.includes('validateToken'))).toBe(true);
   });
 });

package/tests/fixtures/code-snippets/api/error-handling.ts

@@ -17,12 +17,7 @@ export class ApiError extends Error {
   public readonly isOperational: boolean;
   public readonly timestamp: Date;
 
-  constructor(
-    statusCode: number,
-    message: string,
-    code?: string,
-    isOperational = true
-  ) {
+  constructor(statusCode: number, message: string, code?: string, isOperational = true) {
     super(message);
     this.statusCode = statusCode;
     this.code = code || 'API_ERROR';
@@ -77,9 +72,7 @@ export class NotFoundError extends ApiError {
   public readonly resource: string;
 
   constructor(resource: string, id?: string) {
-    const message = id
-      ? `${resource} with ID '${id}' not found`
-      : `${resource} not found`;
+    const message = id ? `${resource} with ID '${id}' not found` : `${resource} not found`;
     super(404, message, 'NOT_FOUND');
     this.resource = resource;
     Object.setPrototypeOf(this, NotFoundError.prototype);
@@ -106,9 +99,7 @@ export class ValidationError extends ApiError {
     value?: unknown;
   }>;
 
-  constructor(
-    errors: Array<{ field: string; message: string; value?: unknown }>
-  ) {
+  constructor(errors: Array<{ field: string; message: string; value?: unknown }>) {
     super(422, 'Validation failed', 'VALIDATION_ERROR');
     this.errors = errors;
     Object.setPrototypeOf(this, ValidationError.prototype);
@@ -239,9 +230,7 @@ export const errorHandler: ErrorRequestHandler = (
 
   // Handle unknown errors
   const internalError = new InternalError(
-    process.env.NODE_ENV === 'production'
-      ? 'An unexpected error occurred'
-      : err.message
+    process.env.NODE_ENV === 'production' ? 'An unexpected error occurred' : err.message
   );
 
   const response = formatErrorResponse(internalError, req, requestId);

package/tests/fixtures/code-snippets/api/rest-controller.ts

@@ -92,7 +92,7 @@ function validateBody<T>(schema: z.ZodSchema<T>, data: unknown): T {
   const result = schema.safeParse(data);
 
   if (!result.success) {
-    const errors = result.error.errors.map(err => ({
+    const errors = result.error.errors.map((err) => ({
       field: err.path.join('.'),
       message: err.message,
     }));
@@ -132,11 +132,7 @@ export class UserController {
       asyncHandler(this.createUser.bind(this))
     );
 
-    this.router.put(
-      '/:id',
-      authenticateToken,
-      asyncHandler(this.updateUser.bind(this))
-    );
+    this.router.put('/:id', authenticateToken, asyncHandler(this.updateUser.bind(this)));
 
     this.router.delete(
       '/:id',
@@ -217,9 +213,7 @@ export class UserController {
     const data = validateBody(createUserSchema, req.body);
 
     // Check for existing user
-    const existingUser = Array.from(users.values()).find(
-      u => u.email === data.email
-    );
+    const existingUser = Array.from(users.values()).find((u) => u.email === data.email);
 
     if (existingUser) {
       throw new BadRequestError('User with this email already exists', {

package/tests/fixtures/code-snippets/auth/jwt-auth.ts

@@ -51,11 +51,7 @@ declare global {
  * @param user - User object containing id, email, and roles
  * @returns JWT access token
  */
-export function generateAccessToken(user: {
-  id: string;
-  email: string;
-  roles: string[];
-}): string {
+export function generateAccessToken(user: { id: string; email: string; roles: string[] }): string {
   const payload: JwtPayload = {
     userId: user.id,
     email: user.email,
@@ -76,11 +72,7 @@ export function generateAccessToken(user: {
 export function generateRefreshToken(userId: string): string {
   const tokenId = randomBytes(16).toString('hex');
 
-  return jwt.sign(
-    { userId, tokenId },
-    REFRESH_SECRET,
-    { expiresIn: REFRESH_TOKEN_EXPIRY }
-  );
+  return jwt.sign({ userId, tokenId }, REFRESH_SECRET, { expiresIn: REFRESH_TOKEN_EXPIRY });
 }
 
 /**
@@ -88,11 +80,7 @@ export function generateRefreshToken(userId: string): string {
  * @param user - User object
  * @returns Token pair with access token, refresh token, and expiry time
  */
-export function generateTokenPair(user: {
-  id: string;
-  email: string;
-  roles: string[];
-}): TokenPair {
+export function generateTokenPair(user: { id: string; email: string; roles: string[] }): TokenPair {
   return {
     accessToken: generateAccessToken(user),
     refreshToken: generateRefreshToken(user.id),
@@ -137,11 +125,7 @@ export function verifyRefreshToken(token: string): { userId: string; tokenId: st
  * Express middleware to authenticate requests using JWT
  * Extracts the token from the Authorization header (Bearer scheme)
  */
-export function authenticateToken(
-  req: Request,
-  res: Response,
-  next: NextFunction
-): void {
+export function authenticateToken(req: Request, res: Response, next: NextFunction): void {
   const authHeader = req.headers['authorization'];
   const token = authHeader && authHeader.split(' ')[1];
 
@@ -179,7 +163,7 @@ export function requireRoles(...requiredRoles: string[]) {
       return;
     }
 
-    const hasRole = req.user.roles.some(role => requiredRoles.includes(role));
+    const hasRole = req.user.roles.some((role) => requiredRoles.includes(role));
 
     if (!hasRole) {
       res.status(403).json({

package/tests/fixtures/code-snippets/auth/oauth-flow.ts

@@ -180,7 +180,7 @@ export async function exchangeCodeForTokens(
     method: 'POST',
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
-      'Accept': 'application/json',
+      Accept: 'application/json',
     },
     body: body.toString(),
   });
@@ -202,8 +202,8 @@ export async function fetchUserInfo(
 ): Promise<Record<string, unknown>> {
   const response = await fetch(config.userInfoUrl, {
     headers: {
-      'Authorization': `Bearer ${accessToken}`,
-      'Accept': 'application/json',
+      Authorization: `Bearer ${accessToken}`,
+      Accept: 'application/json',
     },
   });
 
@@ -232,7 +232,7 @@ export async function refreshAccessToken(
     method: 'POST',
     headers: {
       'Content-Type': 'application/x-www-form-urlencoded',
-      'Accept': 'application/json',
+      Accept: 'application/json',
     },
     body: body.toString(),
   });

package/tests/fixtures/code-snippets/database/repository-pattern.ts

@@ -45,7 +45,11 @@ export interface IRepository<T extends Entity> {
   findById(id: string): Promise<T | null>;
   findOne(options: QueryOptions<T>): Promise<T | null>;
   findMany(options?: QueryOptions<T>): Promise<T[]>;
-  findPaginated(page: number, pageSize: number, options?: QueryOptions<T>): Promise<PaginatedResult<T>>;
+  findPaginated(
+    page: number,
+    pageSize: number,
+    options?: QueryOptions<T>
+  ): Promise<PaginatedResult<T>>;
   create(data: Omit<T, 'id'>): Promise<T>;
   update(id: string, data: Partial<T>): Promise<T>;
   delete(id: string): Promise<void>;
@@ -75,7 +79,7 @@ export abstract class BaseRepository<T extends Entity> implements IRepository<T>
 
     // Apply where filters
     if (options?.where) {
-      result = result.filter(item => {
+      result = result.filter((item) => {
         return Object.entries(options.where!).every(([key, value]) => {
           return item[key as keyof T] === value;
         });
@@ -126,7 +130,11 @@ export abstract class BaseRepository<T extends Entity> implements IRepository<T>
     options?: QueryOptions<T>
   ): Promise<PaginatedResult<T>> {
     const allItems = Array.from(this.items.values());
-    const filtered = this.applyFilters(allItems, { ...options, limit: undefined, offset: undefined });
+    const filtered = this.applyFilters(allItems, {
+      ...options,
+      limit: undefined,
+      offset: undefined,
+    });
     const total = filtered.length;
 
     const offset = (page - 1) * pageSize;

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/aws-lambda/handler.ts

@@ -108,7 +108,7 @@ const streamToNodeStream = async (
 export const streamHandle = <
   E extends Env = Env,
   S extends Schema = {},
-  BasePath extends string = '/'
+  BasePath extends string = '/',
 >(
   app: Hono<E, S, BasePath>
 ): Handler => {
@@ -206,7 +206,7 @@ abstract class EventProcessor<E extends LambdaEvent> {
     const domainName =
       event.requestContext && 'domainName' in event.requestContext
         ? event.requestContext.domainName
-        : event.headers?.['host'] ?? event.multiValueHeaders?.['host']?.[0]
+        : (event.headers?.['host'] ?? event.multiValueHeaders?.['host']?.[0])
     const path = this.getPath(event)
     const urlPath = `https://${domainName}${path}`
     const url = queryString ? `${urlPath}?${queryString}` : urlPath

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-pages/handler.ts

@@ -24,7 +24,7 @@ declare type PagesFunction<
   Env = unknown,
   // eslint-disable-next-line @typescript-eslint/no-explicit-any
   Params extends string = any,
-  Data extends Record<string, unknown> = Record<string, unknown>
+  Data extends Record<string, unknown> = Record<string, unknown>,
 > = (context: EventContext<Env, Params, Data>) => Response | Promise<Response>
 
 export const handle =

package/tests/fixtures/corpus/oss-repos/hono/src/adapter/cloudflare-workers/serve-static.ts

@@ -27,8 +27,8 @@ export const serveStatic = <E extends Env = Env>(
         namespace: options.namespace
           ? options.namespace
           : c.env
-          ? c.env.__STATIC_CONTENT
-          : undefined,
+            ? c.env.__STATIC_CONTENT
+            : undefined,
       })
     }
     return baseServeStatic({

package/tests/fixtures/corpus/oss-repos/hono/src/client/client.ts

@@ -96,8 +96,8 @@ class ClientRequestImpl {
       ...(typeof opt?.headers === 'function'
         ? await opt.headers()
         : opt?.headers
-        ? opt.headers
-        : {}),
+          ? opt.headers
+          : {}),
     }
 
     if (args?.cookie) {