ts-procedures 7.3.0 → 8.1.0

package/src/codegen/emit-scope.ts

@@ -3,12 +3,14 @@ import type {
   RPCHttpRouteDoc,
   APIHttpRouteDoc,
   StreamHttpRouteDoc,
+  HttpStreamRouteDoc,
 } from '../implementations/types.js'
 import {
   jsonSchemaToTypeString,
   jsonSchemaToTypeBody,
   jsonSchemaToExtractedTypes,
   renameExtractedTypes,
+  extractedDeclName,
   type AjscOptions,
   type ExtractedTypeOutput,
 } from './emit-types.js'
@@ -58,7 +60,8 @@ interface EmitRouteContext {
  * This provides backward compatibility with servers running older ts-procedures
  * versions that don't set `kind` on route docs.
  */
-function inferRouteKind(route: Record<string, unknown>): 'rpc' | 'api' | 'stream' {
+function inferRouteKind(route: Record<string, unknown>): 'rpc' | 'api' | 'stream' | 'http-stream' {
+  if ('streamMode' in route && 'fullPath' in route) return 'http-stream'
   if ('streamMode' in route) return 'stream'
   if ('fullPath' in route) return 'api'
   return 'rpc'
@@ -107,6 +110,45 @@ function indent(text: string, prefix: string): string {
   return text.split('\n').map((line) => (line ? prefix + line : line)).join('\n')
 }
 
+/**
+ * Tracks extracted declarations emitted into a single namespace, guarding
+ * against duplicate identifiers (defense-in-depth on top of the rename pass).
+ *
+ * - Exact-string duplicates (the same sub-type extracted from two schemas) are
+ *   silently skipped.
+ * - A same-name-but-different-body declaration is a genuine collision the
+ *   rename pass failed to resolve; emitting it would produce an opaque
+ *   `TS2300: Duplicate identifier` in the consumer's build. We fail fast at
+ *   codegen with a message that names the offending identifier instead.
+ *
+ * Returns the indented declaration line to push, or `null` when it should be
+ * skipped (exact duplicate).
+ */
+class DeclarationCollector {
+  private readonly seenStrings = new Set<string>()
+  private readonly seenNames = new Map<string, string>()
+
+  constructor(private readonly context: string) {}
+
+  /** Returns the indented line to emit, or `null` for an exact duplicate. */
+  accept(decl: string, indentPrefix: string): string | null {
+    if (this.seenStrings.has(decl)) return null
+    const name = extractedDeclName(decl)
+    if (name != null) {
+      if (this.seenNames.has(name)) {
+        throw new Error(
+          `[ts-procedures-codegen] duplicate identifier '${name}' while emitting ${this.context}. ` +
+            `An extracted sub-type collided with another of the same name and could not be renamed. ` +
+            `This is a codegen bug — please report it with the offending schema.`,
+        )
+      }
+      this.seenNames.set(name, decl)
+    }
+    this.seenStrings.add(decl)
+    return indent(decl, indentPrefix)
+  }
+}
+
 interface NamedType {
   /** Short name for namespace mode (e.g., 'Params', 'Response'). */
   shortName: string
@@ -142,7 +184,7 @@ async function formatTypes(
 
   if (ctx.namespaceTypes) {
     const nsLines: string[] = []
-    const seenDeclarations = new Set<string>()
+    const collector = new DeclarationCollector(`namespace ${routePascal}`)
 
     // Pre-reserve every name the route will declare itself (each shortName +
     // any caller-supplied extras). Extracted sub-types whose names land in
@@ -163,12 +205,10 @@ async function formatTypes(
 
       const result = renameExtractedTypes(rawResult, taken)
 
-      // Collect extracted sub-types (deduplicate across schemas by exact-string)
+      // Collect extracted sub-types (dedupe exact dups; throw on real collisions)
       for (const decl of result.declarations) {
-        if (!seenDeclarations.has(decl)) {
-          seenDeclarations.add(decl)
-          nsLines.push(indent(decl, '    '))
-        }
+        const line = collector.accept(decl, '    ')
+        if (line != null) nsLines.push(line)
       }
 
       nsLines.push(`    export type ${shortName} = ${result.body}`)
@@ -291,92 +331,379 @@ async function emitRpcRoute(route: RPCHttpRouteDoc, ctx: EmitRouteContext): Prom
   return { typeDeclarations: declarations, callable, hasStream: false, hasErrors: hasErrorsInjected }
 }
 
+/**
+ * Formats a group of named types into a nested sub-namespace block (for namespace mode).
+ * Returns an array of lines to be inserted into the parent namespace, and a map of
+ * shortName → qualified type reference for use in callables.
+ *
+ * In flat mode, returns declarations like `export type ${prefix}${shortName} = ...`
+ * and refs like `${prefix}${shortName}`.
+ */
+async function formatSubNamespace(
+  routePascal: string,
+  nsName: string,           // e.g. 'Req' or 'Response'
+  types: NamedType[],
+  ctx: EmitRouteContext,
+  taken: Set<string>,
+): Promise<{ nsBlock: string | null; refs: Record<string, string> }> {
+  const refs: Record<string, string> = {}
+  const nsLines: string[] = []
+  const collector = new DeclarationCollector(`namespace ${routePascal}.${nsName}`)
+
+  // Pre-reserve short names to prevent sub-type extraction collision
+  for (const t of types) {
+    if (t.schema != null) taken.add(t.shortName)
+  }
+
+  for (const { shortName, schema } of types) {
+    if (schema == null) continue
+
+    if (ctx.namespaceTypes) {
+      const rawResult = await jsonSchemaToExtractedTypes(schema, ctx.ajsc)
+      if (rawResult == null) continue
+
+      const result = renameExtractedTypes(rawResult, taken)
+
+      for (const decl of result.declarations) {
+        const line = collector.accept(decl, '      ')
+        if (line != null) nsLines.push(line)
+      }
+
+      nsLines.push(`      export type ${shortName} = ${result.body}`)
+      refs[shortName] = `${ctx.scopePascal}.${routePascal}.${nsName}.${shortName}`
+    } else {
+      const flatName = `${routePascal}${nsName}${shortName}`
+      const body = await jsonSchemaToTypeBody(schema, ctx.ajsc)
+      if (body == null) continue
+      refs[shortName] = flatName
+    }
+  }
+
+  if (ctx.namespaceTypes) {
+    if (nsLines.length === 0) return { nsBlock: null, refs }
+    const nsBlock = `    export namespace ${nsName} {\n${nsLines.join('\n')}\n    }`
+    return { nsBlock, refs }
+  }
+
+  return { nsBlock: null, refs }
+}
+
+/**
+ * Builds the conditional return type string for an API or http-stream callable.
+ *
+ * - Both body + headers → `{ body: <Body>; headers: <Headers> }`
+ * - Only body           → `<Body>`
+ * - Only headers        → `{ headers: <Headers> }`
+ * - Neither             → `void`
+ */
+function buildApiReturnType(
+  bodyRef: string | undefined,
+  headersRef: string | undefined,
+): string {
+  if (bodyRef && headersRef) {
+    return `{ body: ${bodyRef}; headers: ${headersRef} }`
+  }
+  if (bodyRef) return bodyRef
+  if (headersRef) return `{ headers: ${headersRef} }`
+  return 'void'
+}
+
 async function emitApiRoute(route: APIHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
   const pascal = toPascalCase(route.name)
-  const channelKeys = ['pathParams', 'query', 'body', 'headers'] as const
+  const req = route.jsonSchema.req ?? {}
+  const res = route.jsonSchema.res ?? {}
 
-  // Build channel types + structured Params type
-  const channelTypes: NamedType[] = []
+  // Request channels
+  const reqChannelKeys = ['pathParams', 'query', 'body', 'headers'] as const
+  const reqTypes: NamedType[] = []
   const presentChannels: string[] = []
 
-  for (const channel of channelKeys) {
-    const channelSchema = route.jsonSchema[channel]
-    if (channelSchema != null) {
-      channelTypes.push({ shortName: toPascalCase(channel), schema: channelSchema })
+  for (const channel of reqChannelKeys) {
+    const schema = req[channel]
+    if (schema != null) {
+      reqTypes.push({ shortName: toPascalCase(channel), schema })
       presentChannels.push(channel)
     }
   }
 
-  // Add response
-  channelTypes.push({ shortName: 'Response', schema: route.jsonSchema.response })
+  // Response slots
+  const resTypes: NamedType[] = [
+    { shortName: 'Body', schema: res.body },
+    { shortName: 'Headers', schema: res.headers },
+  ]
 
-  // `Params` is injected into the namespace below (after formatTypes), so
-  // reserve it up-front to keep ajsc-extracted sub-types from shadowing it.
-  const { declarations, refs } = await formatTypes(
-    pascal,
-    channelTypes,
-    ctx,
-    new Set(['Params']),
-  )
+  const scopeStr = route.scope ?? 'default'
+  const errorUnion = buildErrorUnion(route.errors, ctx)
+  const hasErrors = errorUnion !== null
+  const errorsRef = ctx.namespaceTypes
+    ? `${ctx.scopePascal}.${pascal}.Errors`
+    : `${pascal}Errors`
 
-  // Compose structured Params type from channels
+  const declarations: string[] = []
   let paramsTypeName = 'unknown'
-  if (presentChannels.length > 0) {
-    if (ctx.namespaceTypes) {
-      const structureFields = presentChannels
-        .map((ch) => `${ch}: ${toPascalCase(ch)}`)
+  let returnTypeName = 'void'
+
+  // Track reserved names across all sub-namespaces
+  const taken = new Set<string>(['Req', 'Response'])
+
+  if (ctx.namespaceTypes) {
+    // Namespace mode: emit nested Req {} and Response {} namespaces inside route namespace.
+    // Also emit merged type aliases `export type Req = { ... }` and `export type Response = ...`
+    // so they can be used as type arguments to bindCallable (TS requires a TYPE, not a namespace).
+    const nsLines: string[] = []
+
+    const { nsBlock: reqBlock, refs: reqRefs } = await formatSubNamespace(
+      pascal, 'Req', reqTypes, ctx, taken
+    )
+    if (reqBlock) {
+      nsLines.push(reqBlock)
+      // Merged type alias for Req so it can be used as a generic type arg
+      const reqFields = presentChannels
+        .map((ch) => `${ch}: Req.${toPascalCase(ch)}`)
         .join('; ')
-      // Insert Params type into the namespace block (before closing brace)
-      const lastIdx = declarations.length - 1
-      if (lastIdx >= 0) {
-        const lastDecl = declarations[lastIdx]!
-        const closingIdx = lastDecl.lastIndexOf('  }')
-        if (closingIdx !== -1) {
-          declarations[lastIdx] =
-            lastDecl.slice(0, closingIdx) +
-            `    export type Params = { ${structureFields} }\n` +
-            lastDecl.slice(closingIdx)
-        }
-      }
-      paramsTypeName = `${ctx.scopePascal}.${pascal}.Params`
-    } else {
+      nsLines.push(`    export type Req = { ${reqFields} }`)
+    }
+
+    const { nsBlock: resBlock, refs: resRefs } = await formatSubNamespace(
+      pascal, 'Response', resTypes, ctx, taken
+    )
+    if (resBlock) {
+      nsLines.push(resBlock)
+      // No merged Response type alias needed: we reference Response.Body / Response.Headers
+      // directly in the return type string, which are namespace-qualified paths (valid).
+    }
+
+    // Emit Errors type last (injected by injectRouteErrors below)
+    // Build the route namespace block
+    if (nsLines.length > 0) {
+      declarations.push(`  export namespace ${pascal} {\n${nsLines.join('\n\n')}\n  }`)
+    }
+
+    // Params type: use the merged Req type alias
+    if (presentChannels.length > 0) {
+      paramsTypeName = `${ctx.scopePascal}.${pascal}.Req`
+    }
+
+    // Return type
+    const bodyRef = resRefs['Body']
+    const headersRef = resRefs['Headers']
+    returnTypeName = buildApiReturnType(bodyRef, headersRef)
+  } else {
+    // Flat mode: emit individual types prefixed with route + sub-namespace name
+    for (const { shortName, schema } of reqTypes) {
+      if (schema == null) continue
+      const flatName = `${pascal}Req${shortName}`
+      const body = await jsonSchemaToTypeBody(schema, ctx.ajsc)
+      if (body == null) continue
+      declarations.push(`export type ${flatName} = ${body}`)
+    }
+
+    // Flat mode: compose structured Req type
+    if (presentChannels.length > 0) {
       const structureFields = presentChannels
-        .map((ch) => `${ch}: ${refs[toPascalCase(ch)]}`)
+        .map((ch) => `${ch}: ${pascal}Req${toPascalCase(ch)}`)
         .join('; ')
-      declarations.push(`export type ${pascal}Params = { ${structureFields} }`)
-      paramsTypeName = `${pascal}Params`
+      declarations.push(`export type ${pascal}Req = { ${structureFields} }`)
+      paramsTypeName = `${pascal}Req`
     }
-  }
 
-  const responseTypeName = refs['Response'] ?? 'unknown'
-  const scopeStr = route.scope ?? 'default'
+    // Flat mode: emit response types
+    let bodyRef: string | undefined
+    let headersRef: string | undefined
 
-  const errorUnion = buildErrorUnion(route.errors, ctx)
-  const hasErrors = errorUnion !== null
-  const errorsRef = ctx.namespaceTypes
-    ? `${ctx.scopePascal}.${pascal}.Errors`
-    : `${pascal}Errors`
+    for (const { shortName, schema } of resTypes) {
+      if (schema == null) continue
+      const flatName = `${pascal}Response${shortName}`
+      const body = await jsonSchemaToTypeBody(schema, ctx.ajsc)
+      if (body == null) continue
+      declarations.push(`export type ${flatName} = ${body}`)
+      if (shortName === 'Body') bodyRef = flatName
+      if (shortName === 'Headers') headersRef = flatName
+    }
+
+    returnTypeName = buildApiReturnType(bodyRef, headersRef)
+
+    // Flat mode errors
+    if (errorUnion) {
+      declarations.push(`export type ${pascal}Errors = ${errorUnion}`)
+    }
+  }
+
+  const responseHeadersDeclared = res.headers != null
   const helperCall = hasErrors
-    ? `client.bindCallableTyped<${paramsTypeName}, ${responseTypeName}, ${errorsRef}>`
-    : `client.bindCallable<${paramsTypeName}, ${responseTypeName}>`
+    ? `client.bindCallableTyped<${paramsTypeName}, ${returnTypeName}, ${errorsRef}>`
+    : `client.bindCallable<${paramsTypeName}, ${returnTypeName}>`
 
-  // Property key uses route.name verbatim (preserving the prior API emission contract).
-  const callable = [
-    `    /** ${route.method.toUpperCase()} ${route.fullPath} */`,
-    `    ${route.name}: ${helperCall}({`,
+  const descriptorLines = [
     `      name: '${route.name}',`,
     `      scope: '${scopeStr}',`,
     `      path: '${route.fullPath}',`,
     `      method: '${route.method}',`,
     `      kind: 'api',`,
+    ...(responseHeadersDeclared ? [`      responseHeadersDeclared: true,`] : []),
+  ]
+
+  const callable = [
+    `    /** ${route.method.toUpperCase()} ${route.fullPath} */`,
+    `    ${route.name}: ${helperCall}({`,
+    ...descriptorLines,
     `    }),`,
   ].join('\n')
 
-  const hasErrorsInjected = injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
+  const hasErrorsInjected = ctx.namespaceTypes
+    ? injectRouteErrors(declarations, pascal, errorUnion, ctx.namespaceTypes)
+    : errorUnion !== null  // flat mode already emitted errors above
 
   return { typeDeclarations: declarations, callable, hasStream: false, hasErrors: hasErrorsInjected }
 }
 
+async function emitHttpStreamRoute(route: HttpStreamRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
+  const pascal = toPascalCase(route.name)
+  const req = route.jsonSchema.req ?? {}
+  const res = route.jsonSchema.res ?? {}
+
+  // Request channels
+  const reqChannelKeys = ['pathParams', 'query', 'body', 'headers'] as const
+  const reqTypes: NamedType[] = []
+  const presentChannels: string[] = []
+
+  for (const channel of reqChannelKeys) {
+    const schema = req[channel]
+    if (schema != null) {
+      reqTypes.push({ shortName: toPascalCase(channel), schema })
+      presentChannels.push(channel)
+    }
+  }
+
+  // Yield + ReturnType
+  const yieldSchema = route.jsonSchema.yield
+  const returnSchema = route.jsonSchema.returnType
+  const resHeadersSchema = res.headers
+
+  const scopeStr = route.scope ?? 'default'
+  const declarations: string[] = []
+  let paramsTypeName = 'unknown'
+  let yieldTypeName = 'unknown'
+  let returnTypeName = 'void'
+
+  const taken = new Set<string>(['Req', 'Response', 'Yield', 'ReturnType'])
+
+  if (ctx.namespaceTypes) {
+    const nsLines: string[] = []
+
+    // Req sub-namespace
+    const { nsBlock: reqBlock, refs: reqRefs } = await formatSubNamespace(
+      pascal, 'Req', reqTypes, ctx, taken
+    )
+    if (reqBlock) {
+      nsLines.push(reqBlock)
+      // Merged type alias so Req can be used as a generic type arg (same pattern as emitApiRoute)
+      const reqFields = presentChannels
+        .map((ch) => `${ch}: Req.${toPascalCase(ch)}`)
+        .join('; ')
+      nsLines.push(`    export type Req = { ${reqFields} }`)
+    }
+
+    // Response sub-namespace (headers only for http-stream)
+    const resTypes: NamedType[] = [{ shortName: 'Headers', schema: resHeadersSchema }]
+    const { nsBlock: resBlock } = await formatSubNamespace(
+      pascal, 'Response', resTypes, ctx, taken
+    )
+    if (resBlock) nsLines.push(resBlock)
+
+    // Yield and ReturnType directly in the route namespace
+    const directTypes: NamedType[] = [
+      { shortName: 'Yield', schema: yieldSchema },
+      { shortName: 'ReturnType', schema: returnSchema },
+    ]
+    const collector = new DeclarationCollector(`namespace ${pascal}`)
+    for (const { shortName, schema } of directTypes) {
+      if (schema == null) continue
+      const rawResult = await jsonSchemaToExtractedTypes(schema, ctx.ajsc)
+      if (rawResult == null) continue
+      const result = renameExtractedTypes(rawResult, taken)
+      for (const decl of result.declarations) {
+        const line = collector.accept(decl, '    ')
+        if (line != null) nsLines.push(line)
+      }
+      nsLines.push(`    export type ${shortName} = ${result.body}`)
+    }
+
+    if (nsLines.length > 0) {
+      declarations.push(`  export namespace ${pascal} {\n${nsLines.join('\n')}\n  }`)
+    }
+
+    if (presentChannels.length > 0) {
+      paramsTypeName = `${ctx.scopePascal}.${pascal}.Req`
+    }
+
+    if (yieldSchema != null) yieldTypeName = `${ctx.scopePascal}.${pascal}.Yield`
+    if (returnSchema != null) returnTypeName = `${ctx.scopePascal}.${pascal}.ReturnType`
+  } else {
+    // Flat mode
+    for (const { shortName, schema } of reqTypes) {
+      if (schema == null) continue
+      const flatName = `${pascal}Req${shortName}`
+      const body = await jsonSchemaToTypeBody(schema, ctx.ajsc)
+      if (body == null) continue
+      declarations.push(`export type ${flatName} = ${body}`)
+    }
+
+    if (presentChannels.length > 0) {
+      const structureFields = presentChannels
+        .map((ch) => `${ch}: ${pascal}Req${toPascalCase(ch)}`)
+        .join('; ')
+      declarations.push(`export type ${pascal}Req = { ${structureFields} }`)
+      paramsTypeName = `${pascal}Req`
+    }
+
+    if (resHeadersSchema != null) {
+      const body = await jsonSchemaToTypeBody(resHeadersSchema, ctx.ajsc)
+      if (body != null) declarations.push(`export type ${pascal}ResponseHeaders = ${body}`)
+    }
+
+    if (yieldSchema != null) {
+      const body = await jsonSchemaToTypeBody(yieldSchema, ctx.ajsc)
+      if (body != null) {
+        declarations.push(`export type ${pascal}Yield = ${body}`)
+        yieldTypeName = `${pascal}Yield`
+      }
+    }
+
+    if (returnSchema != null) {
+      const body = await jsonSchemaToTypeBody(returnSchema, ctx.ajsc)
+      if (body != null) {
+        declarations.push(`export type ${pascal}ReturnType = ${body}`)
+        returnTypeName = `${pascal}ReturnType`
+      }
+    }
+  }
+
+  const callable = [
+    `    /** ${route.method.toUpperCase()} ${route.fullPath} */`,
+    `    ${route.name}(req: ${paramsTypeName}, options?: ProcedureCallOptions): TypedStream<${yieldTypeName}, ${returnTypeName}> {`,
+    `      return client.stream<${yieldTypeName}, ${returnTypeName}>({`,
+    `        name: '${route.name}',`,
+    `        scope: '${scopeStr}',`,
+    `        path: '${route.fullPath}',`,
+    `        method: '${route.method}',`,
+    `        kind: 'http-stream',`,
+    `        streamMode: '${route.streamMode}',`,
+    `        params: req,`,
+    `      }, options)`,
+    `    },`,
+  ].join('\n')
+
+  const hasErrors = injectRouteErrors(
+    declarations,
+    pascal,
+    buildErrorUnion(route.errors, ctx),
+    ctx.namespaceTypes
+  )
+
+  return { typeDeclarations: declarations, callable, hasStream: true, hasErrors }
+}
+
 async function emitStreamRoute(route: StreamHttpRouteDoc, ctx: EmitRouteContext): Promise<RouteChunks> {
   const pascal = versionedPascal(route.name, route.version)
 
@@ -470,6 +797,8 @@ export async function emitScopeFile(
         chunks = await emitApiRoute(route as APIHttpRouteDoc, ctx)
       } else if (kind === 'stream') {
         chunks = await emitStreamRoute(route as StreamHttpRouteDoc, ctx)
+      } else if (kind === 'http-stream') {
+        chunks = await emitHttpStreamRoute(route as HttpStreamRouteDoc, ctx)
       } else {
         throw new Error(`Unknown route kind "${kind}"`)
       }

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

@@ -1,5 +1,5 @@
 import { describe, expect, it, vi } from 'vitest'
-import { jsonSchemaToTypeString, jsonSchemaToTypeBody, jsonSchemaToExtractedTypes } from './emit-types.js'
+import { jsonSchemaToTypeString, jsonSchemaToTypeBody, jsonSchemaToExtractedTypes, renameExtractedTypes, extractedDeclName } from './emit-types.js'
 
 // ---------------------------------------------------------------------------
 // Tests
@@ -212,6 +212,78 @@ describe('jsonSchemaToExtractedTypes', () => {
     )
     expect(hasItemsDecl).toBe(true)
   })
+
+  // Root-cause guard: ajsc glues SIBLING extracted declarations with a single
+  // "\n" inside one block. If they aren't split into separate elements, the
+  // downstream rename/dedup logic only sees the first one -> duplicate
+  // identifiers (TS2300). Each extracted sub-type must occupy its own element.
+  it('returns one declaration per element when a schema yields multiple sub-types', async () => {
+    const schema = {
+      type: 'object',
+      required: ['contact'],
+      properties: {
+        contact: {
+          type: 'object',
+          required: ['name', 'address'],
+          properties: {
+            name: { type: 'string' },
+            address: {
+              type: 'object',
+              required: ['city'],
+              properties: { city: { type: 'string' } },
+            },
+          },
+        },
+      },
+    }
+    const result = await jsonSchemaToExtractedTypes(schema)
+    expect(result).not.toBeUndefined()
+    // Two sub-types are extracted: Contact and Address.
+    const names = result!.declarations.map((d) => extractedDeclName(d))
+    expect(names).toContain('Contact')
+    expect(names).toContain('Address')
+    // Each declaration element holds exactly one `export type|enum|interface`.
+    for (const decl of result!.declarations) {
+      const count = decl.match(/export\s+(?:type|enum|interface)\s+/g)?.length ?? 0
+      expect(count).toBe(1)
+    }
+  })
+})
+
+describe('renameExtractedTypes', () => {
+  it('renames a colliding declaration and patches its references in the body', () => {
+    const result = {
+      declarations: ['export type Address = { city: string; }'],
+      body: '{ address: Address; }',
+    }
+    const out = renameExtractedTypes(result, new Set(['Address']))
+    expect(out.declarations[0]).toContain('export type AddressInner =')
+    expect(out.body).toBe('{ address: AddressInner; }')
+  })
+
+  // Latent correctness guard: extracted sub-types reference each other. When a
+  // referenced sub-type is renamed, the reference inside its SIBLING
+  // declaration must be patched too — otherwise the renamed type silently
+  // resolves to a same-named sub-type from a different schema.
+  it('patches cross-references between sibling declarations on rename', () => {
+    const result = {
+      declarations: [
+        'export type Contact = { address: Address; }',
+        'export type Address = { city: string; }',
+      ],
+      body: '{ contact: Contact; }',
+    }
+    // Both names already taken (as if extracted from a second schema sharing them).
+    const out = renameExtractedTypes(result, new Set(['Contact', 'Address']))
+    // Both declarations renamed.
+    expect(out.declarations[0]).toContain('export type ContactInner =')
+    expect(out.declarations[1]).toContain('export type AddressInner =')
+    // The reference inside ContactInner now points at AddressInner, not the
+    // stale Address (which would belong to the other schema).
+    expect(out.declarations[0]).toContain('address: AddressInner')
+    expect(out.declarations[0]).not.toMatch(/address: Address\b/)
+    expect(out.body).toBe('{ contact: ContactInner; }')
+  })
 })
 
 describe('jsonSchemaToTypeString (prefix stripping)', () => {