fix(orval): re-export client extra files from the tags-split barrel

In `tags-split` mode with `tagsSplitDeduplication`, `writeSplitTagsMode` emits
`<clientDir>/index.ts` — the only complete client entry point — but builds it
from the per-tag implementation files alone. Client extra files are produced by
the client builder, so Angular's `retrievalClient: 'both'` left every per-tag
`*.resource.ts` unreachable from the barrel:

  client/pets/pets.service.ts
  client/pets/pets.resource.ts
  client/index.ts   ->  export * from './pets/pets.service';   # resource missing

Consumers wanting the resource API had to import per-tag paths directly, which
is exactly what a module-boundary-enforced monorepo forbids.

`builder.extraFiles` is already in scope in `writeSplitTagsMode`, so the
re-exports are composed into the barrel content before it is written rather
than patched in afterwards. They are derived from the emitted paths, not from
tag names: a mutation-only tag produces no resource file, and a name-derived
barrel would export a file that is never written. Files outside the client
directory belong to another barrel and are left alone.

Each `*.resource.ts` carries its own copy of the shared httpResource
boilerplate, so plain wildcards make those names ambiguous — TypeScript reports
TS2308 and recommends exactly this remedy. The names are declared by the
generator that emits them (`ClientFileBuilder.sharedExports`), built from the
same constants the templates interpolate, and re-exported from a single file
ahead of the wildcards. Ownership is per name rather than per file, so a
generator emitting some of its shared declarations conditionally stays correct.

Declared rather than inferred from the generated source: inference cannot tell
intentional boilerplate from an accidental collision between two tags, and
would silently resolve the latter to one arbitrary file — a wrong type at the
call site in place of a build failure. Generators whose extra files carry no
repeated declarations (hono, mcp) declare nothing and are unaffected.

New `httpResourceBothTagsSplitBarrel` fixture covers it; the generated-output
typecheck gate passes for all 16 clients. `http-resource.test.ts` asserts the
declaration against the names two generated resource files actually share, so a
new shared declaration cannot be added without being listed. No existing
snapshot changed — no prior fixture combined `tagsSplitDeduplication` with a
client emitting extra files.

Workspace output still has the same gap: it emits no client barrel at all, and
its workspace barrel omits extra files for the same ordering reason. The shared
helper sits in core's utils so closing that is additive.

Co-Authored-By: Claude Opus 5 <noreply@anthropic.com>

Author: the-ult

packages/angular/src/http-resource.test.ts

@@ -3333,6 +3333,78 @@ describe('angular httpResource generator', () => {
         expect(mapImportLine).toContain("from 'rxjs'");
       }
     });
+
+    // `sharedExports` tells the tags-split barrel writer which names it must
+    // re-export from a single file to avoid TS2308. The list is built from the
+    // same constants the templates interpolate, so it cannot drift on a
+    // *rename* — but it would drift if a new shared declaration were added to
+    // the boilerplate without being listed. This asserts the declaration
+    // against the names two generated resource files actually share.
+    it('declares exactly the names its per-tag resource files share', async () => {
+      const petsVerb = createVerbOption({ tags: ['Pets'] });
+      const healthVerb = createVerbOption({
+        operationId: 'getHealth',
+        operationName: 'getHealth',
+        route: '/health',
+        pathRoute: '/health',
+        tags: ['Health'],
+        params: [],
+        props: [],
+      });
+
+      const output = createOutput({
+        target: '/tmp/endpoints.ts',
+        mode: 'tags-split',
+        override: {
+          ...createOutput().override,
+          angular: {
+            ...angularOverride('both'),
+          },
+        },
+      });
+
+      const context = createContextSpec(output, {
+        workspace: '/tmp',
+        target: '/tmp/endpoints.ts',
+        projectName: 'pets',
+      });
+
+      const extraFiles = await generateHttpResourceExtraFiles(
+        { getPetById: petsVerb, getHealth: healthVerb },
+        output,
+        context,
+      );
+
+      expect(extraFiles).toHaveLength(2);
+
+      const exportedNames = (content: string): Set<string> =>
+        new Set(
+          content
+            .split('\n')
+            .map(
+              (line) =>
+                line.match(
+                  /^export\s+(?:declare\s+)?(?:abstract\s+)?(?:type|interface|const|let|var|function|class|enum)\s+([A-Za-z_$][\w$]*)/,
+                )?.[1],
+            )
+            .filter((name): name is string => name !== undefined),
+        );
+
+      const [first, second] = extraFiles;
+      const secondNames = exportedNames(second.content);
+      const actuallyShared = [...exportedNames(first.content)]
+        .filter((name) => secondNames.has(name))
+        .toSorted();
+
+      expect(actuallyShared.length).toBeGreaterThan(0);
+      expect(
+        [
+          ...(first.sharedExports?.types ?? []),
+          ...(first.sharedExports?.values ?? []),
+        ].toSorted(),
+      ).toEqual(actuallyShared);
+      expect(second.sharedExports).toEqual(first.sharedExports);
+    });
   });
 
   // ── urlEncodeParameters ─────────────────────────────────────────────

packages/angular/src/http-resource.ts

@@ -30,6 +30,7 @@ import {
   OutputMode,
   pascal,
   type ResReqTypesValue,
+  type SharedExports,
   toObjectString,
   upath,
   getImportExtension,
@@ -298,6 +299,38 @@ type HttpResourceFactoryName =
   | 'httpResource.blob';
 
 const HTTP_RESOURCE_OPTIONS_TYPE_NAME = 'OrvalHttpResourceOptions';
+const HTTP_RESOURCE_REQUEST_EXTENSION_TYPE_NAME =
+  'OrvalHttpResourceRequestExtension';
+const RESOURCE_STATE_TYPE_NAME = 'ResourceState';
+const APPLY_REQUEST_EXTENSION_FUNCTION_NAME = 'applyOrvalRequestExtension';
+const TO_RESOURCE_STATE_FUNCTION_NAME = 'toResourceState';
+
+/**
+ * Boilerplate every generated `*.resource.ts` declares.
+ *
+ * @remarks
+ * `buildHttpResourceOptionsUtilities` and `buildResourceStateUtilities` are
+ * called unconditionally for each resource file, so in tag-based modes each
+ * tag repeats all five declarations. A barrel wildcard-exporting more than one
+ * of those files would make every name here ambiguous (TS2308), so the names
+ * are declared for the barrel writer to re-export explicitly from one file.
+ *
+ * These are the same constants the templates interpolate, so a rename cannot
+ * desynchronise the two. `http-resource.test.ts` additionally asserts this list
+ * against the names two generated resource files actually share, which catches
+ * a *new* shared declaration being added without being listed here.
+ */
+const HTTP_RESOURCE_SHARED_EXPORTS: SharedExports = {
+  types: [
+    HTTP_RESOURCE_OPTIONS_TYPE_NAME,
+    HTTP_RESOURCE_REQUEST_EXTENSION_TYPE_NAME,
+    RESOURCE_STATE_TYPE_NAME,
+  ],
+  values: [
+    APPLY_REQUEST_EXTENSION_FUNCTION_NAME,
+    TO_RESOURCE_STATE_FUNCTION_NAME,
+  ],
+};
 
 const getHttpResourceFactory = (
   response: { readonly isBlob: boolean },
@@ -1221,7 +1254,7 @@ export function ${resourceName}(${implementationArgs}): HttpResourceRef<${resour
 };
 
 const buildHttpResourceOptionsUtilities = (omitParse: boolean): string => `
-export interface OrvalHttpResourceRequestExtension {
+export interface ${HTTP_RESOURCE_REQUEST_EXTENSION_TYPE_NAME} {
   /** Extra headers merged over generated headers. Pass a function to read signals reactively. */
   headers?: HttpResourceRequest['headers'] | (() => HttpResourceRequest['headers']);
   /** Angular HttpContext forwarded to the underlying request. Pass a function to derive it reactively. */
@@ -1234,7 +1267,7 @@ export type ${HTTP_RESOURCE_OPTIONS_TYPE_NAME}<TValue, TRaw = unknown, TOmitPars
   (TOmitParse extends true
     ? Omit<HttpResourceOptions<TValue, TRaw>, 'parse'>
     : HttpResourceOptions<TValue, TRaw>) &
-  OrvalHttpResourceRequestExtension;
+  ${HTTP_RESOURCE_REQUEST_EXTENSION_TYPE_NAME};
 
 function mergeOrvalResourceHeaders(
   base: HttpResourceRequest['headers'],
@@ -1270,9 +1303,9 @@ function mergeOrvalResourceHeaders(
   return { ...base, ...extra };
 }
 
-export function applyOrvalRequestExtension(
+export function ${APPLY_REQUEST_EXTENSION_FUNCTION_NAME}(
   request: string | HttpResourceRequest,
-  options?: OrvalHttpResourceRequestExtension,
+  options?: ${HTTP_RESOURCE_REQUEST_EXTENSION_TYPE_NAME},
 ): HttpResourceRequest {
   const base: HttpResourceRequest = typeof request === 'string' ? { url: request } : request;
   if (
@@ -1349,7 +1382,7 @@ const buildResourceStateUtilities = (): string => `
  *
  * Uses \`globalThis.Error\` to avoid collision with API model types named \`Error\`.
  */
-export interface ResourceState<T> {
+export interface ${RESOURCE_STATE_TYPE_NAME}<T> {
   readonly value: Signal<T | undefined>;
   readonly status: Signal<ResourceStatus>;
   readonly error: Signal<globalThis.Error | undefined>;
@@ -1362,7 +1395,7 @@ export interface ResourceState<T> {
  * Wraps an HttpResourceRef to expose a consistent ResourceState interface.
  * Useful when integrating with NgRx SignalStore via withResource().
  */
-export function toResourceState<T>(ref: HttpResourceRef<T>): ResourceState<T> {
+export function ${TO_RESOURCE_STATE_FUNCTION_NAME}<T>(ref: HttpResourceRef<T>): ${RESOURCE_STATE_TYPE_NAME}<T> {
   return {
     value: ref.value,
     status: ref.status,
@@ -1774,6 +1807,7 @@ const buildHttpResourceExtraFile = (
   return {
     content: `${header}${importImplementation}${mutatorImports}${implementation}`,
     path: outputPath,
+    sharedExports: HTTP_RESOURCE_SHARED_EXPORTS,
   };
 };
 

packages/core/src/types.ts

@@ -1759,9 +1759,42 @@ export type ClientBuilder = (
   output?: NormalizedOutputOptions,
 ) => GeneratorClient | Promise<GeneratorClient>;
 
+/**
+ * Names a generated file declares that its sibling files of the same kind
+ * declare identically.
+ *
+ * @remarks
+ * A generator that emits one file per tag repeats any shared boilerplate in
+ * every one of them. Wildcard-exporting two such files from a barrel makes
+ * each repeated name ambiguous (TS2308), so the barrel writer re-exports them
+ * explicitly from a single file first.
+ *
+ * The generator declares these rather than the barrel writer inferring them
+ * from the emitted source. Inference cannot distinguish intentional
+ * duplication from an accidental name collision between two tags, and would
+ * silently resolve the latter to one arbitrary file — turning a compile error
+ * into a wrong type at the call site.
+ */
+export interface SharedExports {
+  /**
+   * Type-only declarations. Re-exported via `export type { ... }` — kept
+   * separate from {@link SharedExports.values} because a type re-exported
+   * without the `type` modifier is an error under `verbatimModuleSyntax`,
+   * which Angular projects enable by default.
+   */
+  readonly types: readonly string[];
+  /** Value declarations, re-exported via `export { ... }`. */
+  readonly values: readonly string[];
+}
+
 export interface ClientFileBuilder {
   path: string;
   content: string;
+  /**
+   * Declared by generators whose extra files repeat shared boilerplate. Omit
+   * when a file declares nothing its siblings also declare.
+   */
+  sharedExports?: SharedExports;
 }
 export type ClientExtraFilesBuilder = (
   verbOptions: Record<string, GeneratorVerbOptions>,

packages/core/src/utils/barrel-re-exports.test.ts

@@ -0,0 +1,108 @@
+import { describe, expect, it } from 'vitest';
+
+import { buildBarrelReExports } from './barrel-re-exports';
+
+// Mirrors Angular's `retrievalClient: 'both'` output: one file per tag, each
+// repeating the same httpResource boilerplate.
+const resourceEntry = (tag: string) => ({
+  specifier: `./${tag}/${tag}.resource`,
+  sharedExports: {
+    types: ['OrvalHttpResourceOptions', 'ResourceState'],
+    values: ['toResourceState'],
+  },
+});
+
+describe('buildBarrelReExports', () => {
+  it('wildcard-exports every entry', () => {
+    expect(
+      buildBarrelReExports([
+        { specifier: './pets/pets.resource' },
+        { specifier: './health/health.resource' },
+      ]),
+    ).toEqual([
+      "export * from './pets/pets.resource';",
+      "export * from './health/health.resource';",
+    ]);
+  });
+
+  it('re-exports names declared by more than one entry ahead of the wildcards', () => {
+    const lines = buildBarrelReExports([
+      resourceEntry('health'),
+      resourceEntry('pets'),
+    ]);
+
+    expect(lines).toEqual([
+      "export type { OrvalHttpResourceOptions, ResourceState } from './health/health.resource';",
+      "export { toResourceState } from './health/health.resource';",
+      "export * from './health/health.resource';",
+      "export * from './pets/pets.resource';",
+    ]);
+  });
+
+  it('leaves a name declared by a single entry on its wildcard', () => {
+    const lines = buildBarrelReExports([
+      resourceEntry('health'),
+      {
+        specifier: './pets/pets.resource',
+        sharedExports: { types: ['SomethingElse'], values: [] },
+      },
+    ]);
+
+    expect(lines.join('\n')).not.toContain('SomethingElse');
+    expect(lines.join('\n')).not.toContain('OrvalHttpResourceOptions');
+  });
+
+  it('attributes each shared name to the first entry declaring it', () => {
+    // `ResourceState` is absent from the first entry, so intersecting the
+    // shared set with entry one would drop it and leave TS2308 unresolved.
+    const lines = buildBarrelReExports([
+      {
+        specifier: './a/a.resource',
+        sharedExports: { types: ['Shared'], values: [] },
+      },
+      {
+        specifier: './b/b.resource',
+        sharedExports: { types: ['Shared', 'ResourceState'], values: [] },
+      },
+      {
+        specifier: './c/c.resource',
+        sharedExports: { types: ['ResourceState'], values: [] },
+      },
+    ]);
+
+    expect(lines).toEqual([
+      "export type { Shared } from './a/a.resource';",
+      "export type { ResourceState } from './b/b.resource';",
+      "export * from './a/a.resource';",
+      "export * from './b/b.resource';",
+      "export * from './c/c.resource';",
+    ]);
+  });
+
+  it('skips names the barrel already re-exports by name', () => {
+    const lines = buildBarrelReExports(
+      [resourceEntry('health'), resourceEntry('pets')],
+      ['ResourceState'],
+    );
+
+    expect(lines).toContain(
+      "export type { OrvalHttpResourceOptions } from './health/health.resource';",
+    );
+    expect(lines.join('\n')).not.toContain(
+      'export type { OrvalHttpResourceOptions, ResourceState }',
+    );
+  });
+
+  it('ignores entries that declare no shared exports', () => {
+    const lines = buildBarrelReExports([
+      { specifier: './pets/pets.handlers' },
+      { specifier: './health/health.handlers' },
+    ]);
+
+    expect(lines.every((line) => line.startsWith('export *'))).toBe(true);
+  });
+
+  it('returns nothing for no entries', () => {
+    expect(buildBarrelReExports([])).toEqual([]);
+  });
+});