ts-procedures 8.0.0 → 8.1.1

package/src/codegen/e2e.test.ts

@@ -5,6 +5,7 @@ import { join } from 'node:path'
 import { tmpdir } from 'node:os'
 import type { DocEnvelope, RPCHttpRouteDoc, APIHttpRouteDoc, StreamHttpRouteDoc, HttpStreamRouteDoc, ErrorDoc } from '../implementations/types.js'
 import { runTsc } from './test-helpers/run-tsc.js'
+import { Type } from 'typebox'
 
 // ---------------------------------------------------------------------------
 // Fixtures
@@ -929,4 +930,357 @@ void run
       })
     })
   })
+
+  // ── Duplicate-identifier bug: type shared between params and returnType ──────
+  //
+  // End-to-end gold-standard guards. ajsc glues sibling extracted sub-types
+  // with a single "\n"; emit-types only renames/dedups the first one, so a
+  // route whose body and response both yield >=2 sub-types emits the non-first
+  // sub-type twice -> `error TS2300: Duplicate identifier`. These compile the
+  // real generated output with tsc.
+  describe('shared nested types across body/response', () => {
+    const contactShape = {
+      type: 'object',
+      required: ['name', 'address'],
+      properties: {
+        name: { type: 'string' },
+        address: {
+          type: 'object',
+          required: ['street', 'city'],
+          properties: { street: { type: 'string' }, city: { type: 'string' } },
+        },
+      },
+    }
+
+    const sharedNestedEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SaveContact',
+          path: '/contacts/save/1',
+          method: 'post',
+          scope: 'contacts',
+          version: 1,
+          jsonSchema: {
+            body: { type: 'object', required: ['contact'], properties: { contact: contactShape } },
+            response: {
+              type: 'object',
+              required: ['contact', 'savedAt'],
+              properties: { savedAt: { type: 'string' }, contact: contactShape },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('generated client compiles when a nested object is shared between body and response', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: sharedNestedEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+
+      runTsc({
+        tmpDir,
+        tsconfigInline: {
+          compilerOptions: {
+            strict: true,
+            target: 'ES2022',
+            module: 'ES2022',
+            moduleResolution: 'bundler',
+            verbatimModuleSyntax: true,
+            noEmit: true,
+            skipLibCheck: true,
+          },
+          include: ['_types.ts', '_client.ts', 'index.ts', 'contacts.ts', '_errors.ts'],
+        },
+      })
+    })
+
+    // Latent correctness guard: same property name (`detail`), DIFFERENT shape
+    // in body vs response. If the rename leaves the response's sub-type pointing
+    // at the body's `Detail`, a consumer that reads the response-only field fails
+    // to compile — catching the silent wrong-reference bug that TS2300 hides when
+    // the shapes happen to be structurally identical.
+    const divergentEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SyncData',
+          path: '/sync/1',
+          method: 'post',
+          scope: 'sync',
+          version: 1,
+          jsonSchema: {
+            body: {
+              type: 'object',
+              required: ['outer'],
+              properties: {
+                outer: {
+                  type: 'object',
+                  required: ['detail'],
+                  properties: {
+                    detail: {
+                      type: 'object',
+                      required: ['fromClient'],
+                      properties: { fromClient: { type: 'string' } },
+                    },
+                  },
+                },
+              },
+            },
+            response: {
+              type: 'object',
+              required: ['outer'],
+              properties: {
+                outer: {
+                  type: 'object',
+                  required: ['detail'],
+                  properties: {
+                    detail: {
+                      type: 'object',
+                      required: ['fromServer'],
+                      properties: { fromServer: { type: 'number' } },
+                    },
+                  },
+                },
+              },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('response sub-type keeps its own shape when a name collides with a differently-shaped body sub-type', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: divergentEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+
+      // Consumer asserts the response's `detail` exposes `fromServer: number`
+      // (its own shape) — not the body's `{ fromClient: string }`. Imports the
+      // scope file directly to validate the generated route type precisely.
+      const consumer = `
+import type { Sync } from './sync'
+const r: Sync.SyncData.Response = null as any
+const n: number = r.outer.detail.fromServer
+void n
+`
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+
+      runTsc({
+        tmpDir,
+        tsconfigInline: {
+          compilerOptions: {
+            strict: true,
+            target: 'ES2022',
+            module: 'ES2022',
+            moduleResolution: 'bundler',
+            verbatimModuleSyntax: true,
+            noEmit: true,
+            skipLibCheck: true,
+          },
+          include: ['_types.ts', '_client.ts', 'index.ts', 'sync.ts', '_errors.ts', '__consumer.ts'],
+        },
+      })
+    })
+  })
+
+  // ── Complex TypeBox-derived schemas (broad duplication / correctness sweep) ──
+  //
+  // Builds realistic schemas with TypeBox, round-trips them to plain JSON Schema
+  // (exactly what lands in a DocEnvelope), and stresses every known collision
+  // vector at once:
+  //   - a deeply-nested object (Product → Manufacturer → Hq/Warehouse → Geo)
+  //     shared between a route's body AND response (forces the response copy to
+  //     rename all of its sub-types and re-point every cross-reference);
+  //   - the same Product reused by a SECOND route in the same scope (separate
+  //     route namespaces must not clash);
+  //   - a sub-type (Geo) referenced by two siblings (Hq + Warehouse) — the
+  //     rename must patch BOTH referrers;
+  //   - shared Filter/Range across an API route's query + body channels;
+  //   - a body property literally named `params`, colliding with the route's
+  //     own `Params` shortName;
+  //   - arrays-of-objects, optionals, literal unions, and records.
+  //
+  // Run under the default (inline-union) mode AND `enumStyle: 'enum'`, where a
+  // 3-literal union explodes into three separate enums (plus ajsc's own
+  // internal renaming) — the largest fused declaration block we emit. The tsc
+  // compile is the authoritative duplicate-identifier (TS2300) and
+  // dangling/wrong-reference guard; the consumer additionally pins deep field
+  // access through the renamed types.
+  describe('complex TypeBox-derived schemas', () => {
+    const clean = (s: unknown): Record<string, unknown> =>
+      JSON.parse(JSON.stringify(s)) as Record<string, unknown>
+
+    const Geo = Type.Object({ lat: Type.Number(), lng: Type.Number() })
+    const Address = Type.Object({ street: Type.String(), city: Type.String(), geo: Geo })
+    const Manufacturer = Type.Object({
+      name: Type.String(),
+      hq: Address,
+      warehouses: Type.Array(Address),
+    })
+    const Variant = Type.Object({
+      sku: Type.String(),
+      price: Type.Number(),
+      inStock: Type.Boolean(),
+    })
+    const Product = Type.Object({
+      id: Type.String(),
+      category: Type.Union([Type.Literal('book'), Type.Literal('food'), Type.Literal('toy')]),
+      status: Type.Optional(Type.Union([Type.Literal('active'), Type.Literal('archived')])),
+      dimensions: Type.Object({ w: Type.Number(), h: Type.Number(), d: Type.Number() }),
+      tags: Type.Array(Type.String()),
+      variants: Type.Array(Variant),
+      manufacturer: Manufacturer,
+    })
+
+    const Range = Type.Object({ min: Type.Number(), max: Type.Number() })
+    const Filter = Type.Object({
+      category: Type.Optional(Type.Union([Type.Literal('book'), Type.Literal('food')])),
+      price: Range,
+    })
+    const SavedSearch = Type.Object({ name: Type.String(), filter: Filter })
+
+    // Route 1: rpc — body + response share Product; body also has a `params`
+    // property colliding with the route's Params shortName.
+    const upsertProduct: RPCHttpRouteDoc = {
+      kind: 'rpc',
+      name: 'UpsertProduct',
+      path: '/catalog/upsert/1',
+      method: 'post',
+      scope: 'catalog',
+      version: 1,
+      jsonSchema: {
+        body: clean(Type.Object({ product: Product, params: Type.Object({ dryRun: Type.Boolean() }) })),
+        response: clean(
+          Type.Object({
+            product: Product,
+            audit: Type.Object({
+              revision: Type.Integer(),
+              editor: Type.Object({ id: Type.String(), name: Type.String() }),
+            }),
+          }),
+        ),
+      },
+    }
+
+    // Route 2: api — query + body share Filter/Range; res reuses Product.
+    const searchCatalog: APIHttpRouteDoc = {
+      kind: 'api',
+      name: 'SearchCatalog',
+      path: '/catalog/search',
+      fullPath: '/api/catalog/search',
+      method: 'post',
+      scope: 'catalog',
+      jsonSchema: {
+        req: {
+          query: clean(Type.Object({ page: Type.Integer(), filter: Type.Optional(Filter) })),
+          body: clean(Type.Object({ saved: Type.Array(SavedSearch) })),
+        },
+        res: {
+          body: clean(
+            Type.Object({
+              items: Type.Array(Product),
+              total: Type.Integer(),
+              byCategory: Type.Record(Type.String(), Type.Integer()),
+            }),
+          ),
+        },
+      },
+    }
+
+    const complexEnvelope: DocEnvelope = {
+      basePath: '/api',
+      headers: [],
+      errors: [],
+      routes: [upsertProduct, searchCatalog],
+    }
+
+    const consumer = `
+import type { Catalog } from './catalog'
+
+// Route 1 response: deep access through the shared-and-renamed Product, plus
+// the sub-type (Geo) shared by two referrers (hq + warehouses[]).
+const up: Catalog.UpsertProduct.Response = null as any
+const lat: number = up.product.manufacturer.hq.geo.lat
+const wlng: number = up.product.manufacturer.warehouses[0]!.geo.lng
+const sku: string = up.product.variants[0]!.sku
+const w: number = up.product.dimensions.w
+const rev: number = up.audit.revision
+const editorName: string = up.audit.editor.name
+void lat; void wlng; void sku; void w; void rev; void editorName
+
+// Route 1 params (body): shared Product + the colliding 'params' property.
+const body: Catalog.UpsertProduct.Params = null as any
+const pid: string = body.product.id
+const dry: boolean = body.params.dryRun
+void pid; void dry
+
+// Route 2 request: Filter/Range shared across query + body channels.
+const req: Catalog.SearchCatalog.Req = null as any
+const page: number = req.query.page
+const qMin: number | undefined = req.query.filter?.price.min
+const bMax: number = req.body.saved[0]!.filter.price.max
+void page; void qMin; void bMax
+
+// Route 2 response: array of the shared Product + a record.
+const res: Catalog.SearchCatalog.Response.Body = null as any
+const total: number = res.total
+const firstSku: string = res.items[0]!.variants[0]!.sku
+const bookCount: number | undefined = res.byCategory['book']
+void total; void firstSku; void bookCount
+`
+
+    const tsconfig = {
+      compilerOptions: {
+        strict: true,
+        target: 'ES2022',
+        module: 'ES2022',
+        moduleResolution: 'bundler',
+        verbatimModuleSyntax: true,
+        noEmit: true,
+        skipLibCheck: true,
+      },
+      include: ['_types.ts', '_client.ts', 'index.ts', 'catalog.ts', '_errors.ts', '__consumer.ts'],
+    }
+
+    it('compiles end-to-end with deep shared/renamed types (default inline-union mode)', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: complexEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+      })
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+      runTsc({ tmpDir, tsconfigInline: tsconfig })
+    })
+
+    it('compiles end-to-end under enumStyle: enum (union-of-literals explodes into many enums)', async () => {
+      tmpDir = makeTmpDir()
+      await generateClient({
+        envelope: complexEnvelope,
+        outDir: tmpDir,
+        selfContained: true,
+        namespaceTypes: true,
+        ajsc: { enumStyle: 'enum' },
+      })
+      // In enum mode `category` becomes enum unions; the deep object access still
+      // holds, so reuse the consumer (it never pins the enum member types).
+      writeFileSync(join(tmpDir, '__consumer.ts'), consumer)
+      runTsc({ tmpDir, tsconfigInline: tsconfig })
+    })
+  })
 })

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

@@ -1399,4 +1399,190 @@ describe('emitScopeFile http-stream kind', () => {
       expect(out).toContain('TypedStream<Feed.StreamFeed.Yield, Feed.StreamFeed.ReturnType>')
     })
   })
+
+  // -------------------------------------------------------------------------
+  // Duplicate-identifier bug: a type shared between params and returnType.
+  //
+  // ajsc (inlineTypes:false) glues SIBLING extracted declarations with a
+  // single "\n" inside one block, separating only the Root with "\n\n". When
+  // a route's request and response schemas each yield >=2 extracted sub-types,
+  // the rename/dedup logic in emit-types only ever sees the FIRST declaration
+  // in each fused block, so the non-first sub-types are emitted twice in the
+  // same namespace -> `error TS2300: Duplicate identifier`.
+  //
+  // These assertions are fix-agnostic: they check the emitted contract (no
+  // duplicate top-level identifiers in a route namespace; references resolve),
+  // not any particular internal representation of the fix.
+  // -------------------------------------------------------------------------
+  describe('shared nested types across params/response (duplicate identifier)', () => {
+    /** Every `export type|enum|interface <Name>` identifier declared in the output. */
+    function declaredNames(output: string): string[] {
+      const names: string[] = []
+      const re = /export\s+(?:type|enum|interface)\s+(\w+)/g
+      let m: RegExpExecArray | null
+      while ((m = re.exec(output)) !== null) names.push(m[1]!)
+      return names
+    }
+
+    /** Identifiers that appear more than once. */
+    function duplicates(names: string[]): string[] {
+      const seen = new Set<string>()
+      const dup = new Set<string>()
+      for (const n of names) {
+        if (seen.has(n)) dup.add(n)
+        else seen.add(n)
+      }
+      return [...dup]
+    }
+
+    /** All identifiers referenced inside `export type <Name> = <body>` bodies. */
+    function referencedNames(output: string): Set<string> {
+      const refs = new Set<string>()
+      const re = /export\s+(?:type|interface)\s+\w+\s*=?\s*([^\n]*)/g
+      let m: RegExpExecArray | null
+      while ((m = re.exec(output)) !== null) {
+        for (const id of m[1]!.matchAll(/\b([A-Z]\w*)\b/g)) refs.add(id[1]!)
+      }
+      return refs
+    }
+
+    const contactShape = {
+      type: 'object',
+      required: ['name', 'address'],
+      properties: {
+        name: { type: 'string' },
+        address: {
+          type: 'object',
+          required: ['street', 'city'],
+          properties: { street: { type: 'string' }, city: { type: 'string' } },
+        },
+      },
+    }
+
+    // body and response both contain `contact` (-> Contact + Address sub-types).
+    const sharedNestedGroup: ScopeGroup = {
+      scopeKey: 'contacts',
+      camelCase: 'contacts',
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SaveContact',
+          path: '/contacts/save/1',
+          method: 'post',
+          scope: 'contacts',
+          version: 1,
+          jsonSchema: {
+            body: {
+              type: 'object',
+              required: ['contact'],
+              properties: { contact: contactShape },
+            },
+            response: {
+              type: 'object',
+              required: ['contact', 'savedAt'],
+              properties: { savedAt: { type: 'string' }, contact: contactShape },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('does not emit duplicate identifiers when a nested object is shared between body and response', async () => {
+      const output = await emitScopeFile(sharedNestedGroup, { namespaceTypes: true })
+      const dups = duplicates(declaredNames(output))
+      expect(dups).toEqual([])
+    })
+
+    it('every type referenced in a body resolves to a declared (or built-in) name', async () => {
+      const output = await emitScopeFile(sharedNestedGroup, { namespaceTypes: true })
+      const declared = new Set(declaredNames(output))
+      // Built-in / framework type names that need no local declaration.
+      const builtins = new Set(['Array', 'Record', 'Partial', 'Promise', 'TypedStream'])
+      const unresolved = [...referencedNames(output)].filter(
+        (r) => !declared.has(r) && !builtins.has(r),
+      )
+      expect(unresolved).toEqual([])
+    })
+
+    // Two sibling object properties shared between body and response — also
+    // produces a fused 2-declaration block, duplicating the second sub-type.
+    const sharedSiblingsGroup: ScopeGroup = {
+      scopeKey: 'records',
+      camelCase: 'records',
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'PutRecord',
+          path: '/records/1',
+          method: 'post',
+          scope: 'records',
+          version: 1,
+          jsonSchema: {
+            body: {
+              type: 'object',
+              required: ['alpha', 'beta'],
+              properties: {
+                alpha: { type: 'object', required: ['x'], properties: { x: { type: 'string' } } },
+                beta: { type: 'object', required: ['y'], properties: { y: { type: 'string' } } },
+              },
+            },
+            response: {
+              type: 'object',
+              required: ['alpha', 'beta'],
+              properties: {
+                alpha: { type: 'object', required: ['x'], properties: { x: { type: 'string' } } },
+                beta: { type: 'object', required: ['y'], properties: { y: { type: 'string' } } },
+              },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('does not emit duplicate identifiers when two sibling objects are shared', async () => {
+      const output = await emitScopeFile(sharedSiblingsGroup, { namespaceTypes: true })
+      const dups = duplicates(declaredNames(output))
+      expect(dups).toEqual([])
+    })
+
+    // Regression guard for the working case: a single shared nested sub-type
+    // (1 extracted declaration per block) already renames correctly to *Inner.
+    // This MUST stay green — the fix must not regress the single-sub-type path.
+    const singleNestedGroup: ScopeGroup = {
+      scopeKey: 'cities',
+      camelCase: 'cities',
+      routes: [
+        {
+          kind: 'rpc',
+          name: 'SaveCity',
+          path: '/cities/1',
+          method: 'post',
+          scope: 'cities',
+          version: 1,
+          jsonSchema: {
+            body: {
+              type: 'object',
+              required: ['city'],
+              properties: {
+                city: { type: 'object', required: ['name'], properties: { name: { type: 'string' } } },
+              },
+            },
+            response: {
+              type: 'object',
+              required: ['city'],
+              properties: {
+                city: { type: 'object', required: ['name'], properties: { name: { type: 'string' } } },
+              },
+            },
+          },
+        } satisfies RPCHttpRouteDoc,
+      ],
+    }
+
+    it('single shared nested sub-type stays free of duplicates (regression guard)', async () => {
+      const output = await emitScopeFile(singleNestedGroup, { namespaceTypes: true })
+      const dups = duplicates(declaredNames(output))
+      expect(dups).toEqual([])
+    })
+  })
 })

package/src/codegen/emit-scope.ts

@@ -10,6 +10,7 @@ import {
   jsonSchemaToTypeBody,
   jsonSchemaToExtractedTypes,
   renameExtractedTypes,
+  extractedDeclName,
   type AjscOptions,
   type ExtractedTypeOutput,
 } from './emit-types.js'
@@ -109,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
@@ -144,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
@@ -165,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}`)
@@ -310,7 +348,7 @@ async function formatSubNamespace(
 ): Promise<{ nsBlock: string | null; refs: Record<string, string> }> {
   const refs: Record<string, string> = {}
   const nsLines: string[] = []
-  const seenDeclarations = new Set<string>()
+  const collector = new DeclarationCollector(`namespace ${routePascal}.${nsName}`)
 
   // Pre-reserve short names to prevent sub-type extraction collision
   for (const t of types) {
@@ -327,10 +365,8 @@ async function formatSubNamespace(
       const result = renameExtractedTypes(rawResult, taken)
 
       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}`)
@@ -580,17 +616,15 @@ async function emitHttpStreamRoute(route: HttpStreamRouteDoc, ctx: EmitRouteCont
       { shortName: 'Yield', schema: yieldSchema },
       { shortName: 'ReturnType', schema: returnSchema },
     ]
-    const seenDeclarations = new Set<string>()
+    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) {
-        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}`)
     }