ts-procedures 6.2.0 → 7.0.0-beta.0

package/src/codegen/e2e.test.ts

@@ -422,7 +422,7 @@ describe('E2E: generateClient full pipeline', () => {
       expect(content).toContain('ProcedureCallOptions')
     })
 
-    it('_client.ts is generated and contains createClient, createFetchAdapter, ClientRequestError', async () => {
+    it('_client.ts is generated and contains createClient, createFetchAdapter, ClientHttpError (+ deprecated ClientRequestError alias)', async () => {
       tmpDir = makeTmpDir()
       await generateClient({ envelope, outDir: tmpDir, selfContained: true })
 
@@ -430,6 +430,7 @@ describe('E2E: generateClient full pipeline', () => {
       const content = readFileSync(join(tmpDir, '_client.ts'), 'utf-8')
       expect(content).toContain('createClient')
       expect(content).toContain('createFetchAdapter')
+      expect(content).toContain('ClientHttpError')
       expect(content).toContain('ClientRequestError')
     })
 
@@ -584,6 +585,112 @@ void run
       }).not.toThrow()
     })
 
+    it('generated .safe callable type-checks against bundled Result/ResultNoTyped types', async () => {
+      // Use an envelope with two routes:
+      //   - GetUser: has errors: ['ProcedureError'] → .safe returns Result<T, GetUserErrors>
+      //   - ListUsers: has errors: []               → .safe returns ResultNoTyped<T>
+      // This verifies both the typed-error and no-typed-error branches of .safe.
+      tmpDir = makeTmpDir()
+      const safeEnvelope: DocEnvelope = {
+        basePath: '/api',
+        headers: [],
+        errors: [procedureErrorDoc],
+        routes: [
+          {
+            kind: 'rpc',
+            name: 'GetUser',
+            path: '/users/1',
+            method: 'post',
+            scope: 'users',
+            version: 1,
+            errors: ['ProcedureError'],
+            jsonSchema: {
+              body: {
+                type: 'object',
+                properties: { id: { type: 'string' } },
+                required: ['id'],
+              },
+              response: {
+                type: 'object',
+                properties: { name: { type: 'string' } },
+                required: ['name'],
+              },
+            },
+          } as RPCHttpRouteDoc,
+          {
+            kind: 'rpc',
+            name: 'ListUsers',
+            path: '/users',
+            method: 'post',
+            scope: 'users',
+            version: 1,
+            errors: [],
+            jsonSchema: {
+              body: { type: 'object' },
+              response: {
+                type: 'array',
+                items: {
+                  type: 'object',
+                  properties: { name: { type: 'string' } },
+                  required: ['name'],
+                },
+              },
+            },
+          } as RPCHttpRouteDoc,
+        ],
+      }
+
+      await generateClient({ envelope: safeEnvelope, outDir: tmpDir, selfContained: true })
+
+      // Consumer exercises .safe on both routes and verifies the Result types
+      // are assignable (type-only assertions via declared variables).
+      const consumer = `
+import type { Result, ResultNoTyped } from './_types'
+import { createApiClient } from './index'
+import { createFetchAdapter } from './_client'
+
+const client = createApiClient({
+  adapter: createFetchAdapter(),
+  basePath: 'https://api.example.com',
+})
+
+// Throwing form still compiles
+const _p1: Promise<{ name: string }> = client.users.GetUser({ id: '1' })
+void _p1
+
+// .safe on a route with declared errors returns Result<T, Errors>
+const _p2 = client.users.GetUser.safe({ id: '1' })
+const _p2check: Promise<Result<{ name: string }, unknown>> = _p2 as Promise<Result<{ name: string }, unknown>>
+void _p2check
+
+// .safe on a route without declared errors returns ResultNoTyped<T>
+const _p3 = client.users.ListUsers.safe({})
+const _p3check: Promise<ResultNoTyped<unknown>> = _p3 as Promise<ResultNoTyped<unknown>>
+void _p3check
+`
+      const { writeFileSync } = await import('node:fs')
+      writeFileSync(join(tmpDir, 'consumer.ts'), consumer)
+
+      const tsconfig = {
+        compilerOptions: {
+          strict: true,
+          target: 'ES2022',
+          module: 'ES2022',
+          moduleResolution: 'bundler',
+          noEmit: true,
+          skipLibCheck: true,
+        },
+        include: ['_types.ts', '_client.ts', 'index.ts', 'users.ts', '_errors.ts', 'consumer.ts'],
+      }
+      writeFileSync(join(tmpDir, 'tsconfig.json'), JSON.stringify(tsconfig))
+
+      const { execSync } = await import('node:child_process')
+      const tscPath = join(process.cwd(), 'node_modules', '.bin', 'tsc')
+      expect(() => {
+        execSync(`${tscPath} --noEmit --project ${join(tmpDir, 'tsconfig.json')}`, { stdio: 'pipe' })
+      }).not.toThrow()
+    })
+
     it('augmented RequestMeta rejects wrong types (compile error)', async () => {
       tmpDir = makeTmpDir()
       await generateClient({ envelope, outDir: tmpDir, selfContained: true })

package/src/codegen/emit-client-runtime.test.ts

@@ -46,9 +46,14 @@ describe('emitClientRuntimeFile', () => {
     expect(result).toMatch(/export function createFetchAdapter/)
   })
 
-  it('contains export class ClientRequestError', async () => {
+  it('contains export class ClientHttpError (renamed from ClientRequestError)', async () => {
     const result = await emitClientRuntimeFile()
-    expect(result).toMatch(/export class ClientRequestError/)
+    expect(result).toMatch(/export class ClientHttpError/)
+  })
+
+  it('contains deprecated ClientRequestError alias', async () => {
+    const result = await emitClientRuntimeFile()
+    expect(result).toContain('ClientRequestError')
   })
 
   it('contains export class ClientPathParamError', async () => {

package/src/codegen/emit-client-runtime.ts

@@ -23,6 +23,12 @@ const TYPES_IMPORT = `import type {
   ErrorRegistry,
   ErrorFactory,
   ErrorResponseMeta,
+  ErrorClassifier,
+  ClassifyErrorContext,
+  ClassifiedError,
+  Result,
+  ClientErrorMap,
+  FrameworkFailure,
 } from './_types'`
 
 /**
@@ -31,6 +37,7 @@ const TYPES_IMPORT = `import type {
  */
 const SOURCE_FILES = [
   'errors.ts',
+  'classify-error.ts',
   'error-dispatch.ts',
   'request-builder.ts',
   'resolve-options.ts',

package/src/codegen/emit-client-types.test.ts

@@ -19,21 +19,36 @@ describe('emitClientTypesFile', () => {
 
   it('no import statements', async () => {
     const result = await emitClientTypesFile()
-    // types.ts has zero imports — the emitted file should be fully self-contained
+    // errors.ts and types.ts imports are stripped — the emitted file should be fully self-contained
     expect(result).not.toMatch(/^import\s/m)
   })
 
-  it('output content (after header) matches src/client/types.ts verbatim', async () => {
+  it('includes errors.ts content before types.ts content', async () => {
     const result = await emitClientTypesFile()
 
     const __filename = fileURLToPath(import.meta.url)
     const __dirname = dirname(__filename)
     const packageRoot = resolve(__dirname, '../..')
-    const typesPath = resolve(packageRoot, 'src/client/types.ts')
-    const typesContent = await readFile(typesPath, 'utf-8')
 
-    // The function prepends CODEGEN_HEADER + '\n' + '\n' before the file content
-    const expected = [CODEGEN_HEADER, '', typesContent].join('\n')
-    expect(result).toBe(expected)
+    // Check that both files' unique identifiers are present
+    // errors.ts contains class definitions
+    expect(result).toContain('class ClientHttpError')
+    expect(result).toContain('class ClientNetworkError')
+    // types.ts contains interfaces
+    expect(result).toContain('interface RequestMeta')
+    expect(result).toContain('interface ClientAdapter')
+
+    // errors.ts content should appear before types.ts content
+    const errorsIdx = result.indexOf('class ClientHttpError')
+    const typesIdx = result.indexOf('interface RequestMeta')
+    expect(errorsIdx).toBeLessThan(typesIdx)
+  })
+
+  it('includes Result, ResultNoTyped, ClientErrorMap from types.ts', async () => {
+    const result = await emitClientTypesFile()
+    expect(result).toContain('interface ClientErrorMap')
+    expect(result).toContain('type FrameworkFailure')
+    expect(result).toContain('type Result<T, ETyped>')
+    expect(result).toContain('type ResultNoTyped<T>')
   })
 })

package/src/codegen/emit-client-types.ts

@@ -4,8 +4,26 @@ import { readFile, access } from 'node:fs/promises'
 import { CODEGEN_HEADER } from './constants.js'
 
 /**
- * Reads `src/client/types.ts` from the package root and returns it as the
- * content of a `_types.ts` file, prepended with the auto-generated header.
+ * Strips all `import` statements from source content.
+ * These are inter-file imports that become unnecessary in a single bundled file.
+ *
+ * Note: the regex requires a `from` clause, so side-effect imports like
+ * `import './polyfill.js'` are NOT stripped. This is intentional — src/client/
+ * has no side-effect imports.
+ */
+function stripImports(content: string): string {
+  // Handle both single-line and multi-line import statements
+  return content.replace(/^import\s[\s\S]*?from\s+['"][^'"]+['"]\s*;?\s*$/gm, '')
+}
+
+/**
+ * Reads `src/client/errors.ts` and `src/client/types.ts` from the package
+ * root and returns them bundled as the content of a `_types.ts` file,
+ * prepended with the auto-generated header.
+ *
+ * `errors.ts` is included first (with imports stripped) because `types.ts`
+ * imports the error classes from it. Together they form a fully self-contained
+ * `_types.ts` with no external dependencies.
  *
  * This enables a self-contained codegen mode where consumers don't need
  * `ts-procedures` as a runtime dependency.
@@ -15,13 +33,20 @@ export async function emitClientTypesFile(): Promise<string> {
   const __dirname = dirname(__filename)
   // Works from both src/codegen/ (source) and build/codegen/ (compiled)
   const packageRoot = resolve(__dirname, '../..')
+  const errorsPath = resolve(packageRoot, 'src/client/errors.ts')
   const typesPath = resolve(packageRoot, 'src/client/types.ts')
-  await access(typesPath).catch(() => {
-    throw new Error(
-      `[ts-procedures-codegen] Cannot locate src/client/types.ts at expected path: ${typesPath}. ` +
-      `Ensure ts-procedures is installed correctly.`
-    )
-  })
-  const content = await readFile(typesPath, 'utf-8')
-  return [CODEGEN_HEADER, '', content].join('\n')
+
+  for (const [label, filePath] of [['errors.ts', errorsPath], ['types.ts', typesPath]] as const) {
+    await access(filePath).catch(() => {
+      throw new Error(
+        `[ts-procedures-codegen] Cannot locate src/client/${label} at expected path: ${filePath}. ` +
+        `Ensure ts-procedures is installed correctly.`
+      )
+    })
+  }
+
+  const errorsContent = stripImports(await readFile(errorsPath, 'utf-8')).trim()
+  const typesContent = stripImports(await readFile(typesPath, 'utf-8')).trim()
+
+  return [CODEGEN_HEADER, '', errorsContent, '', typesContent, ''].join('\n')
 }

package/src/codegen/emit-errors.ts

@@ -26,7 +26,7 @@ export interface EmitErrorsOptions {
  *
  * The registry `<ServiceName>ErrorRegistry` maps body `name` values to
  * classes, consumed by the client's `dispatchTypedError` to produce typed
- * errors instead of generic `ClientRequestError` instances.
+ * errors instead of generic `ClientHttpError` instances.
  *
  * When `namespaceTypes` is on, everything is wrapped in `export namespace
  * <ServiceName>Errors { ... }`. Returns `undefined` if no errors have schemas.

package/src/codegen/emit-index.ts

@@ -112,7 +112,7 @@ export function emitIndexFile(groups: ScopeGroup[], options?: EmitIndexOptions):
       ` * Creates a typed client for this service with the generated error`,
       ` * registry pre-configured. Non-2xx responses whose body \`name\` matches`,
       ` * a registered error are thrown as typed class instances instead of`,
-      ` * generic \`ClientRequestError\`s.`,
+      ` * generic \`ClientHttpError\`s.`,
       ` */`,
       `export function ${clientFactoryName}(`,
       `  config: Omit<CreateClientConfig<ReturnType<typeof ${factoryName}>>, 'scopes' | 'errorRegistry'>`,

package/src/codegen/emit-scope.test.ts

@@ -272,7 +272,7 @@ describe('emitScopeFile', () => {
 
     it('imports ClientInstance and ProcedureCallOptions but not TypedStream', async () => {
       const output = await emitScopeFile(rpcGroup)
-      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions } from 'ts-procedures/client'")
+      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, Result, ResultNoTyped } from 'ts-procedures/client'")
       expect(output).not.toContain('TypedStream')
     })
 
@@ -346,7 +346,7 @@ describe('emitScopeFile', () => {
     it('imports TypedStream when stream routes are present', async () => {
       const output = await emitScopeFile(streamGroup)
       expect(output).toContain('TypedStream')
-      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, TypedStream } from 'ts-procedures/client'")
+      expect(output).toContain("import type { ClientInstance, ProcedureCallOptions, TypedStream, Result, ResultNoTyped } from 'ts-procedures/client'")
     })
 
     it('unwraps SSE envelope for yieldType', async () => {
@@ -622,3 +622,325 @@ describe('emitScopeFile', () => {
     })
   })
 })
+
+// ---------------------------------------------------------------------------
+// .safe sibling on RPC callables
+// ---------------------------------------------------------------------------
+
+const rpcGroupWithErrors: ScopeGroup = {
+  scopeKey: 'users',
+  camelCase: 'users',
+  routes: [
+    {
+      kind: 'rpc',
+      name: 'GetUser',
+      path: '/users/1',
+      method: 'post',
+      scope: 'users',
+      version: 1,
+      errors: ['NotFound'],
+      jsonSchema: {
+        body: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        response: {
+          type: 'object',
+          properties: { name: { type: 'string' } },
+          required: ['name'],
+        },
+      },
+    } satisfies RPCHttpRouteDoc,
+  ],
+}
+
+const rpcGroupNoErrors: ScopeGroup = {
+  scopeKey: 'users',
+  camelCase: 'users',
+  routes: [
+    {
+      kind: 'rpc',
+      name: 'GetUser',
+      path: '/users/1',
+      method: 'post',
+      scope: 'users',
+      version: 1,
+      jsonSchema: {
+        body: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        response: {
+          type: 'object',
+          properties: { name: { type: 'string' } },
+          required: ['name'],
+        },
+      },
+    } satisfies RPCHttpRouteDoc,
+  ],
+}
+
+describe('emitScopeFile .safe sibling on RPC', () => {
+  it('emits .safe property on RPC callable when route has errors', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // The callable should use Object.assign
+    expect(out).toMatch(/Object\.assign/)
+    // The safe variant should be a method
+    expect(out).toMatch(/\bsafe\(/)
+    // The safe variant's return type should be Result<Response, RouteErrors> (namespace-qualified)
+    expect(out).toMatch(/Promise<Result<.*\.Response,.*\.Errors>>/)
+  })
+
+  it('emits .safe with ResultNoTyped when route has no errors', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+    // The callable should use Object.assign
+    expect(out).toMatch(/Object\.assign/)
+    // The safe variant should be a method
+    expect(out).toMatch(/\bsafe\(/)
+    // Without declared errors, use ResultNoTyped (namespace-qualified)
+    expect(out).toMatch(/Promise<ResultNoTyped<.*\.Response>>/)
+  })
+
+  it('imports Result and ResultNoTyped from client path', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    expect(out).toContain('Result')
+    expect(out).toContain('ResultNoTyped')
+    expect(out).toContain("from 'ts-procedures/client'")
+  })
+
+  it('namespace mode: safe return type uses route Errors namespace alias', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
+    expect(out).toMatch(/Promise<Result<Users\.GetUser\.Response, Users\.GetUser\.Errors>>/)
+  })
+
+  it('flat mode: safe return type uses route Errors type alias', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      namespaceTypes: false,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in flat mode is the injected GetUserErrors type alias
+    expect(out).toMatch(/Promise<Result<GetUserResponse, GetUserErrors>>/)
+  })
+
+  it('safe sibling calls client.safeCall with typed error param when errors present', async () => {
+    const out = await emitScopeFile(rpcGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.safeCall')
+  })
+
+  it('safe sibling calls client.safeCall without typed error param when no errors', async () => {
+    const out = await emitScopeFile(rpcGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.safeCall')
+  })
+})
+
+// ---------------------------------------------------------------------------
+// .safe sibling on API callables
+// ---------------------------------------------------------------------------
+
+const apiGroupWithErrors: ScopeGroup = {
+  scopeKey: 'posts',
+  camelCase: 'posts',
+  routes: [
+    {
+      kind: 'api',
+      name: 'UpdatePost',
+      path: '/posts/:id',
+      method: 'put',
+      fullPath: '/api/posts/:id',
+      scope: 'posts',
+      errors: ['NotFound'],
+      jsonSchema: {
+        pathParams: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        body: {
+          type: 'object',
+          properties: { title: { type: 'string' } },
+          required: ['title'],
+        },
+        response: {
+          type: 'object',
+          properties: { id: { type: 'string' }, title: { type: 'string' } },
+          required: ['id', 'title'],
+        },
+      },
+    } satisfies APIHttpRouteDoc,
+  ],
+}
+
+const apiGroupNoErrors: ScopeGroup = {
+  scopeKey: 'posts',
+  camelCase: 'posts',
+  routes: [
+    {
+      kind: 'api',
+      name: 'UpdatePost',
+      path: '/posts/:id',
+      method: 'put',
+      fullPath: '/api/posts/:id',
+      scope: 'posts',
+      jsonSchema: {
+        pathParams: {
+          type: 'object',
+          properties: { id: { type: 'string' } },
+          required: ['id'],
+        },
+        body: {
+          type: 'object',
+          properties: { title: { type: 'string' } },
+          required: ['title'],
+        },
+        response: {
+          type: 'object',
+          properties: { id: { type: 'string' }, title: { type: 'string' } },
+          required: ['id', 'title'],
+        },
+      },
+    } satisfies APIHttpRouteDoc,
+  ],
+}
+
+describe('emitScopeFile .safe sibling on API', () => {
+  it('emits .safe property on API callable when route has errors', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // The callable should use Object.assign
+    expect(out).toMatch(/Object\.assign/)
+    // The safe variant should be a method
+    expect(out).toMatch(/\bsafe\(/)
+    // The safe variant's return type should be Result<Response, RouteErrors> (namespace-qualified)
+    expect(out).toMatch(/Promise<Result<.*\.Response,.*\.Errors>>/)
+  })
+
+  it('emits .safe with ResultNoTyped when API route has no errors', async () => {
+    const out = await emitScopeFile(apiGroupNoErrors, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+    // The callable should use Object.assign
+    expect(out).toMatch(/Object\.assign/)
+    // The safe variant should be a method
+    expect(out).toMatch(/\bsafe\(/)
+    // Without declared errors, use ResultNoTyped (namespace-qualified)
+    expect(out).toMatch(/Promise<ResultNoTyped<.*\.Response>>/)
+  })
+
+  it('namespace mode: safe return type uses route Errors namespace alias', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: true,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in namespace mode is the route's Errors type alias: Scope.Route.Errors
+    expect(out).toMatch(/Promise<Result<Posts\.UpdatePost\.Response, Posts\.UpdatePost\.Errors>>/)
+  })
+
+  it('flat mode: safe return type uses route Errors type alias', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      namespaceTypes: false,
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // errorsRef in flat mode is the injected UpdatePostErrors type alias
+    expect(out).toMatch(/Promise<Result<UpdatePostResponse, UpdatePostErrors>>/)
+  })
+
+  it('safe sibling calls client.safeCall when API route has errors', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.safeCall')
+  })
+
+  it('safe sibling calls client.safeCall when API route has no errors', async () => {
+    const out = await emitScopeFile(apiGroupNoErrors, {
+      serviceName: 'Api',
+    })
+    expect(out).toContain('client.safeCall')
+  })
+
+  it('callable uses fullPath not path in both main and safe sibling', async () => {
+    const out = await emitScopeFile(apiGroupWithErrors, {
+      errorKeys: new Set(['NotFound']),
+      serviceName: 'Api',
+    })
+    // Both the main call and safeCall should reference the fullPath
+    const safeCallIdx = out.indexOf('client.safeCall')
+    expect(safeCallIdx).toBeGreaterThan(-1)
+    const afterSafeCall = out.slice(safeCallIdx)
+    expect(afterSafeCall).toContain("path: '/api/posts/:id'")
+  })
+})
+
+// ---------------------------------------------------------------------------
+// Stream callables omit .safe sibling (regression guard for Task 14)
+// ---------------------------------------------------------------------------
+
+describe('emitScopeFile streams omit .safe sibling', () => {
+  it('does not emit .safe on stream callables', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      serviceName: 'Api',
+    })
+
+    // Stream callable should be emitted as a plain method
+    expect(out).toContain('WatchEvents(')
+    // No .safe property on stream callables
+    expect(out).not.toContain('WatchEvents.safe')
+    // Object.assign wrapper is not used for stream routes
+    expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+  })
+
+  it('stream callable returns TypedStream, not Result', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      serviceName: 'Api',
+    })
+
+    // Confirm stream callable returns TypedStream
+    expect(out).toContain('TypedStream<')
+    // Should not have Result or ResultNoTyped in the return type signature for streams
+    // (streams have their own three-way failure surface)
+    expect(out).toMatch(/WatchEvents\([^)]*\)\s*:\s*TypedStream/)
+  })
+
+  it('stream callable with namespace types still omits .safe', async () => {
+    const out = await emitScopeFile(streamGroup, {
+      namespaceTypes: true,
+      serviceName: 'Api',
+    })
+
+    // Stream callable should use namespace-qualified types
+    expect(out).toContain('Events.WatchEvents.Params')
+    expect(out).toContain('TypedStream<Events.WatchEvents.Yield, Events.WatchEvents.Return>')
+    // But still no .safe property
+    expect(out).not.toContain('WatchEvents.safe')
+    expect(out).not.toMatch(/WatchEvents\s*:\s*Object\.assign/)
+  })
+})