@metaobjectsdev/codegen-ts-tanstack 0.24.4 → 0.25.0

package/src/tanstack-grid-hook.ts

@@ -1,10 +1,29 @@
 import type { MetaObject } from "@metaobjectsdev/metadata";
-import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, entityMetaFileName, renderEntityMetaFile, servesReadApi, isTphSubtype, CODEGEN_ATTR_EMIT_TANSTACK, CODEGEN_ATTR_EMIT_GRID } from "@metaobjectsdev/codegen-ts";
+import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, entityMetaFileName, renderEntityMetaFile, servesReadApi, isTphSubtype,
+  withClientDirective, namesRef, namesConstArg,
+} from "@metaobjectsdev/codegen-ts";
 import { hasDataGridLayout, warnMissingDataGridLayout } from "./data-grid-gate.js";
 import { renderGridHookFile } from "./templates/grid-hook-file.js";
 
 export interface TanstackGridHookOpts {
   filter?: (entity: MetaObject) => boolean;
+  /**
+   * Opt a TPH subtype IN to its own per-subtype grid. Default `() => false`: a
+   * discriminator base emits ONE polymorphic grid and its subtypes emit none, which is
+   * the single-source-of-truth arrangement almost every TPH model wants.
+   *
+   * This is an OPTION rather than a `filter` clause because it WIDENS. A `filter` is
+   * ANDed with the built-in gates, so it can only ever narrow — an opt-in is not
+   * expressible through it. (It is not a metadata attribute either: `@emitGrid` was
+   * never registered vocabulary, so authoring it failed `meta verify`.)
+   *
+   * Pass the SAME predicate to `tanstackGrid()` and `tanstackGridHook()`. If they
+   * disagree you reproduce #287 exactly: the hook emits a `<Sub>.grid.ts` whose sibling
+   * `<Sub>.columns.tsx` is never emitted — a dangling `use<Sub>DefaultGrid()`, and an
+   * outright TS2307 when the inherited layout carries an `@filter` preset, since the hook
+   * then imports `<sub>DefaultFilter` from the missing columns module.
+   */
+  tphSubtypeGrids?: (entity: MetaObject) => boolean;
   target?: string;
 }
 
@@ -12,30 +31,40 @@ export interface TanstackGridHookOpts {
  * Per-entity generator that emits <Entity>.grid.ts — one
  * use<Entity><Grid>Grid() hook per layout[dataGrid] declared on the entity.
  *
- * Per-entity opt-out via @emitTanstack: false. Per-entity opt-IN: presence of
- * at least one dataGrid layout on the object (mirrors tanstackGrid).
+ * Per-entity opt-IN: presence of at least one dataGrid layout on the object
+ * (mirrors tanstackGrid).
+ *
+ * A TPH subtype additionally needs `tphSubtypeGrids` — pass the SAME predicate to
+ * tanstackGrid(), or this generator emits a `<Sub>.grid.ts` with no `<Sub>.columns.tsx`
+ * beside it.
+ *
+ * Decide per generator what you consume: wire only the generators whose output you
+ * actually import, and narrow this one with its `filter` option. There is no `@emit*`
+ * metadata attribute — those were never registered vocabulary, so `meta verify` rejects
+ * them (ERR_UNKNOWN_ATTR).
  */
 export const tanstackGridHook = function tanstackGridHook(opts?: TanstackGridHookOpts): Generator {
   const userFilter = opts?.filter ?? (() => true);
+  // Default OFF — byte-identical to the behaviour every project that never declared a
+  // per-subtype grid already had.
+  const tphSubtypeGrids = opts?.tphSubtypeGrids ?? (() => false);
   // Every gate EXCEPT the dataGrid-layout opt-in: the framework instance-artifact
-  // guard (skips abstract types), the metadata opt-out, and the user filter. Split
-  // out so the discoverability note can name exactly the entities the LAYOUT gate
-  // alone held back (#287).
+  // guard (skips abstract types) and the user filter. Split out so the discoverability
+  // note can name exactly the entities the LAYOUT gate alone held back (#287).
   //
-  // The TPH clause must MATCH tanstackGrid's exactly. A TPH subtype inherits its base's
+  // The TPH clause must MATCH tanstackGrid's exactly, which means the SAME
+  // `tphSubtypeGrids` predicate must be passed to both. A TPH subtype inherits its base's
   // dataGrid layout via extends, so `hasDataGridLayout` is true for it — but tanstackGrid
-  // deliberately emits no per-subtype columns without an own `@emitGrid: true` (the base's
-  // polymorphic grid is the single source of truth). Without the same clause here, a TPH
-  // subtype got a `<Sub>.grid.ts` whose sibling `<Sub>.columns.tsx` is never emitted:
-  // a dangling `use<Sub>DefaultGrid()` with nothing to pair it with, and an outright
-  // TS2307 when the inherited layout carries an `@filter` preset (the hook then imports
-  // `<sub>DefaultFilter` from the missing columns module).
+  // deliberately emits no per-subtype columns unless `tphSubtypeGrids` opts it in (the
+  // base's polymorphic grid is the single source of truth). Where the two predicates
+  // disagree, a TPH subtype gets a `<Sub>.grid.ts` whose sibling `<Sub>.columns.tsx` is
+  // never emitted: a dangling `use<Sub>DefaultGrid()` with nothing to pair it with, and an
+  // outright TS2307 when the inherited layout carries an `@filter` preset (the hook then
+  // imports `<sub>DefaultFilter` from the missing columns module).
   const passesOtherGates = (e: MetaObject): boolean =>
     servesReadApi(e)
-    // ADR-0039: resolving — a concrete entity may inherit its @emit* opt-out flag via extends.
-    && e.attr(CODEGEN_ATTR_EMIT_TANSTACK) !== false
     && userFilter(e)
-    && (!isTphSubtype(e) || e.attr(CODEGEN_ATTR_EMIT_GRID) === true);
+    && (!isTphSubtype(e) || tphSubtypeGrids(e));
   const emit = perEntity(async (entity: MetaObject, ctx) => {
     if (!ctx.renderContext) {
       throw new Error("tanstack-grid-hook: renderContext is required (provided by runGen)");
@@ -45,17 +74,31 @@ export const tanstackGridHook = function tanstackGridHook(opts?: TanstackGridHoo
     // the entity generator is scaffold-and-own (ADR-0034), so it cannot be changed
     // from the package. Emissions are byte-identical between generators, which the
     // runner collapses (#266).
+    //
+    // §A6/§B2 — same `namesRef` pair every other §A6 site builds, scoped to THIS
+    // generator's own render context (see tanstack-query.ts's matching comment for why
+    // `.meta.ts` needs its own target-scoped check rather than reusing the entity
+    // module's).
+    const rc = ctx.renderContext;
+    const metaNames = namesRef(entity, rc);
     return [{
       path: entityOutputPath(ctx.renderContext.outputLayout, entity.package,
         entityMetaFileName(entity.name)),
-      content: await formatTs(renderEntityMetaFile(entity, ctx.renderContext.apiPrefix)),
+      content: await formatTs(renderEntityMetaFile(
+        entity,
+        ctx.renderContext.apiPrefix,
+        namesConstArg(metaNames),
+      )),
     }, {
       path: entityOutputPath(
         ctx.renderContext.outputLayout,
         entity.package,
         `${entity.name}.grid.ts`,
       ),
-      content: await formatTs(renderGridHookFile(entity, ctx.renderContext)),
+      content: withClientDirective(
+        await formatTs(renderGridHookFile(entity, ctx.renderContext)),
+        ctx.renderContext.clientDirective,
+      ),
     }];
   });
   const generator: Generator = {

package/src/tanstack-grid.ts

@@ -1,41 +1,71 @@
 import type { MetaObject } from "@metaobjectsdev/metadata";
-import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, servesReadApi, isTphSubtype, CODEGEN_ATTR_EMIT_TANSTACK, CODEGEN_ATTR_EMIT_GRID } from "@metaobjectsdev/codegen-ts";
+import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, servesReadApi, isTphSubtype,
+  withClientDirective,
+} from "@metaobjectsdev/codegen-ts";
 import { hasDataGridLayout, warnMissingDataGridLayout } from "./data-grid-gate.js";
 import { renderColumnsFile } from "./templates/columns-file.js";
 
 export interface TanstackGridOpts {
   filter?: (entity: MetaObject) => boolean;
+  /**
+   * Opt a TPH subtype IN to its own per-subtype grid. Default `() => false`: a
+   * discriminator base emits ONE polymorphic grid and its subtypes emit none, which is
+   * the single-source-of-truth arrangement almost every TPH model wants.
+   *
+   * This is an OPTION rather than a `filter` clause because it WIDENS. A `filter` is
+   * ANDed with the built-in gates, so it can only ever narrow — an opt-in is not
+   * expressible through it. (It is not a metadata attribute either: `@emitGrid` was
+   * never registered vocabulary, so authoring it failed `meta verify`.)
+   *
+   * Pass the SAME predicate to `tanstackGrid()` and `tanstackGridHook()`. If they
+   * disagree you reproduce #287 exactly: the hook emits a `<Sub>.grid.ts` whose sibling
+   * `<Sub>.columns.tsx` is never emitted — a dangling `use<Sub>DefaultGrid()`, and an
+   * outright TS2307 when the inherited layout carries an `@filter` preset, since the hook
+   * then imports `<sub>DefaultFilter` from the missing columns module.
+   */
+  tphSubtypeGrids?: (entity: MetaObject) => boolean;
   target?: string;
 }
 
 /**
- * Per-entity opt-out via `@emitTanstack: false`. Per-entity opt-IN: presence of
- * at least one `dataGrid` layout on the object. If both pass and the user-supplied
- * filter passes, the generator emits.
+ * Per-entity opt-IN: presence of at least one `dataGrid` layout on the object. If that
+ * passes and the user-supplied filter passes, the generator emits.
+ *
+ * A TPH subtype additionally needs `tphSubtypeGrids` — pass the SAME predicate to
+ * tanstackGridHook(), or the emitted `<Sub>.grid.ts` has no `<Sub>.columns.tsx`.
+ *
+ * Decide per generator what you consume: wire only the generators whose output you
+ * actually import, and narrow this one with its `filter` option. There is no `@emit*`
+ * metadata attribute — those were never registered vocabulary, so `meta verify` rejects
+ * them (ERR_UNKNOWN_ATTR).
  */
 export const tanstackGrid = function tanstackGrid(opts?: TanstackGridOpts): Generator {
   const userFilter = opts?.filter ?? (() => true);
+  // Default OFF — byte-identical to the behaviour every project that never declared a
+  // per-subtype grid already had.
+  const tphSubtypeGrids = opts?.tphSubtypeGrids ?? (() => false);
   // Every gate EXCEPT the dataGrid-layout opt-in: the framework instance-artifact
-  // guard (skips abstract types), the metadata opt-out, and the user filter.
+  // guard (skips abstract types) and the user filter.
   // FR-017 Tier 3: a TPH discriminator base emits ONE polymorphic grid. Its
   // subtypes inherit the base's dataGrid layout via extends, but per-subtype grids
-  // are opt-IN only (own `@emitGrid: true`) — otherwise the polymorphic grid is the
-  // single source of truth.
+  // are opt-IN only, via the `tphSubtypeGrids` option — otherwise the polymorphic
+  // grid is the single source of truth. Pass the SAME predicate to tanstackGridHook().
   // Split out so the discoverability note can name exactly the entities the LAYOUT
-  // gate alone held back (#287) — an opted-out or abstract type is not a surprise.
+  // gate alone held back (#287) — an abstract type is not a surprise.
   const passesOtherGates = (e: MetaObject): boolean =>
     servesReadApi(e)
-    // ADR-0039: resolving — a concrete entity may inherit its @emit* opt-out flag via extends.
-    && e.attr(CODEGEN_ATTR_EMIT_TANSTACK) !== false
     && userFilter(e)
-    && (!isTphSubtype(e) || e.attr(CODEGEN_ATTR_EMIT_GRID) === true);
+    && (!isTphSubtype(e) || tphSubtypeGrids(e));
   const emit = perEntity(async (entity: MetaObject, ctx) => {
     if (!ctx.renderContext) {
       throw new Error("tanstack-grid: renderContext is required (provided by runGen)");
     }
     return {
       path: entityOutputPath(ctx.renderContext.outputLayout, entity.package, `${entity.name}.columns.tsx`),
-      content: await formatTs(renderColumnsFile(entity, ctx.renderContext)),
+      content: withClientDirective(
+        await formatTs(renderColumnsFile(entity, ctx.renderContext)),
+        ctx.renderContext.clientDirective,
+      ),
     };
   });
   const generator: Generator = {

package/src/tanstack-query.ts

@@ -1,5 +1,7 @@
 import type { MetaObject } from "@metaobjectsdev/metadata";
-import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, entityMetaFileName, renderEntityMetaFile, servesReadApi, isTphSubtype, CODEGEN_ATTR_EMIT_TANSTACK } from "@metaobjectsdev/codegen-ts";
+import { perEntity, type Generator, type GeneratorFactory, formatTs, entityOutputPath, entityMetaFileName, renderEntityMetaFile, servesReadApi, isTphSubtype,
+  withClientDirective, namesRef, namesConstArg,
+} from "@metaobjectsdev/codegen-ts";
 import { renderHooksFile } from "./templates/hooks-file.js";
 
 export interface TanstackQueryOpts {
@@ -11,21 +13,24 @@ export interface TanstackQueryOpts {
  * Per-entity generator that emits <Entity>.hooks.ts — a query-key factory
  * plus 2 query hooks and 3 mutation hooks backed by useEntityFetcher().
  *
- * Per-entity opt-out via `@emitTanstack: false` is honored. If the user
- * supplies their own filter, both must pass (AND).
+ * If the user supplies their own filter, it AND-composes with the built-in gates.
+ *
+ * Decide per generator what you consume: wire only the generators whose output you
+ * actually import, and narrow this one with its `filter` option. There is no `@emit*`
+ * metadata attribute — those were never registered vocabulary, so `meta verify` rejects
+ * them (ERR_UNKNOWN_ATTR).
  */
 export const tanstackQuery = function tanstackQuery(opts?: TanstackQueryOpts): Generator {
   const userFilter = opts?.filter ?? (() => true);
   const generator: Generator = {
     name: "tanstack-query",
     // AND-composes the framework instance-artifact guard (skips abstract types —
-    // they contribute shape via inheritance only and have no instance to query),
-    // the metadata opt-out, and the optional user filter. Projections still pass
-    // here and get read-only hooks via renderHooksFile's isProjection branch.
+    // they contribute shape via inheritance only and have no instance to query)
+    // with the optional user filter. Projections still pass here and get read-only
+    // hooks via renderHooksFile's isProjection branch.
     // FR-017 Tier 3: TPH subtypes get no standalone hooks file — their per-subtype
     // hooks live in the discriminator base's hooks file (polymorphic + per-subtype).
-    // ADR-0039: resolving — a concrete entity may inherit @emitTanstack via extends.
-    filter: (e: MetaObject) => servesReadApi(e) && e.attr(CODEGEN_ATTR_EMIT_TANSTACK) !== false && !isTphSubtype(e) && userFilter(e),
+    filter: (e: MetaObject) => servesReadApi(e) && !isTphSubtype(e) && userFilter(e),
     generate: perEntity(async (entity, ctx) => {
       if (!ctx.renderContext) {
         throw new Error(
@@ -36,14 +41,33 @@ export const tanstackQuery = function tanstackQuery(opts?: TanstackQueryOpts): G
       // generator: the entity generator is scaffold-and-own (ADR-0034), so it cannot
       // be changed from the package. Emissions are byte-identical between generators,
       // which the runner collapses (#266).
+      //
+      // §A6/§B2 — same `namesRef` pair every other §A6 site builds, scoped to THIS
+      // generator's own render context: `.meta.ts` is a UI-generator artifact that can
+      // sit on a DIFFERENT target from `namesFile()` (unlike the entity module, which
+      // shares a target with names by construction — see names-file.ts).
+      // `ctx.renderContext.includeNames` is already computed per-target by the runner,
+      // so it is false here whenever the names artifact does not land in THIS
+      // generator's own target — no separate check needed.
+      const rc = ctx.renderContext;
+      const metaNames = namesRef(entity, rc);
       const metaFile = {
         path: entityOutputPath(ctx.renderContext.outputLayout, entity.package,
           entityMetaFileName(entity.name)),
-        content: await formatTs(renderEntityMetaFile(entity, ctx.renderContext.apiPrefix)),
+        content: await formatTs(renderEntityMetaFile(
+          entity,
+          ctx.renderContext.apiPrefix,
+          namesConstArg(metaNames),
+        )),
       };
       return [metaFile, {
         path: entityOutputPath(ctx.renderContext.outputLayout, entity.package, `${entity.name}.hooks.ts`),
-        content: await formatTs(renderHooksFile(entity, ctx.renderContext)),
+        // Outside formatTs deliberately: the directive must stay the module's first
+        // token, and a formatter is entitled to move a leading string expression.
+        content: withClientDirective(
+          await formatTs(renderHooksFile(entity, ctx.renderContext)),
+          ctx.renderContext.clientDirective,
+        ),
       }];
     }),
   };

package/src/templates/columns-file.ts

@@ -9,6 +9,7 @@ import {
   LAYOUT_DATA_GRID_ATTR_FILTER,
   LAYOUT_DATA_GRID_ATTR_COLUMNS,
   OBJECT_ATTR_DISCRIMINATOR,
+  VIEW_SUBTYPE_HIDDEN,
 } from "@metaobjectsdev/metadata";
 import type { RenderContext } from "@metaobjectsdev/codegen-ts";
 import {
@@ -16,6 +17,9 @@ import {
   entityModuleSpecifier,
   isTphDiscriminatorBase,
   collectTphSubtypeFields,
+  isSortableField,
+  viewForContext,
+  VIEW_CONTEXT_GRID,
 } from "@metaobjectsdev/codegen-ts";
 
 /** FR-017 TPH grid context, threaded into extractGrids when the entity is a
@@ -52,16 +56,27 @@ function humanize(s: string): string {
 }
 
 function fieldViewKind(field: MetaField): string {
+  // #356: the view declared for the GRID, never whichever view came first — a
+  // field declaring a form control and a grid cell must render both.
   // ADR-0039: resolving — a field's view may be inherited via extends.
-  const view = field.views()[0];
+  const view = viewForContext(field, VIEW_CONTEXT_GRID);
   return view?.subType ?? "text";
 }
 
 function fieldLabel(field: MetaField): string {
-  // ADR-0039: resolving — a field's view (and its @label) may be inherited via extends.
-  const view = field.views()[0];
-  const label = view?.attr("label");
-  if (typeof label === "string") return label;
+  // #353 — this read `@label`, which NO provider registers, so the override branch was
+  // unreachable: authoring it fails the strict load `meta verify` runs (ERR_UNKNOWN_ATTR)
+  // and every header fell back to humanize(). `title` is already a registered common attr
+  // on every node and already means "a noun phrase", so nothing was registered for this
+  // — ADR-0037 step 0: the vocabulary existed, only the read was wrong.
+  // View first, then the field itself: a view-level title is the more specific override
+  // (this rendering of the field); a field-level one names the field wherever it appears.
+  // ADR-0039: resolving — a field's view (and its @title) may be inherited via extends.
+  // #356: the GRID's own view — a form control's @title must not retitle a column.
+  const viewTitle = viewForContext(field, VIEW_CONTEXT_GRID)?.attr("title");
+  if (typeof viewTitle === "string" && viewTitle.length > 0) return viewTitle;
+  const fieldTitle = field.attr("title");
+  if (typeof fieldTitle === "string" && fieldTitle.length > 0) return fieldTitle;
   return humanize(field.name);
 }
 
@@ -106,10 +121,28 @@ function extractGrids(entity: MetaObject, tph?: TphGridInfo): GridSpec[] {
     const columns: ColumnSpec[] = columnNames.flatMap((name) => {
       const field = fieldsByName.get(name);
       if (!field) return [];     // columns ref that doesn't exist on entity; defensive skip
+      const viewKind = fieldViewKind(field);
+      // #355 — `view.hidden` is registered as "Not rendered; carried but not shown", and
+      // the generated FORM has always honoured that (an <input type="hidden">). The grid
+      // did not: no renderer is keyed `hidden`, so EntityGrid's `if (!renderer) return col`
+      // fell through to TanStack's default cell and PRINTED the value — the opposite of
+      // what the subtype says. Emitting a blank cell would not fix it either: the column
+      // would still hold a header and a sort target, so the value would be hidden while
+      // the column was not. The column is dropped instead, which is what "not rendered"
+      // means. This applies even when @columns names the field: a declaration that the
+      // field is a column and a declaration that it is not rendered contradict each other,
+      // and the one about RENDERING is the specific answer to the question a grid asks.
+      if (viewKind === VIEW_SUBTYPE_HIDDEN) return [];
       const spec: ColumnSpec = {
         id:       name,
         header:   fieldLabel(field),
-        viewKind: fieldViewKind(field),
+        viewKind,
+        // #352 — ALWAYS emitted, never left absent. EntityGrid gates on
+        // `meta?.sortable !== false`, so an omitted flag reads as "offer it" and the
+        // header renders clickable for a field the server's SortAllowlist rejects
+        // (400 `sort.unknown_field`). isSortableField is the SAME predicate that builds
+        // that allowlist — imported (#354), never reimplemented, so the two cannot drift.
+        sortable: isSortableField(field),
       };
       // FR-017: the discriminator column renders as a subtype badge.
       if (tph && name === tph.discField) spec.renderer = "badge";

package/src/templates/grid-hook-file.ts

@@ -138,7 +138,7 @@ export function ${hookName}() {
   const query = ${useQuerySym}<{ rows: ${entityName}Row[]; total: number }>({
     queryKey: [${JSON.stringify(lcEntity)}, "grid", ${JSON.stringify(grid.name)}, qs],
     queryFn: () => fetcher<{ rows: ${entityName}Row[]; total: number }>(
-      \`\${${entityName}.$apiPrefix}\${${entityName}.$path}?\${qs}\`,
+      \`\${${entityName}.$path}?\${qs}\`,
     ),
   });
 

package/src/templates/hooks-file.ts

@@ -144,7 +144,7 @@ export function ${hookName}(
   const fetcher = ${useEntityFetcherSym}();
   return ${useQuerySym}<${targetSym}[]>({
     queryKey: ${keysVar}.relation(${relLit}, sourceId),
-    queryFn: () => fetcher<${targetSym}[]>(\`\${${source}.$apiPrefix}\${${source}.$path}/\${sourceId}/${e.name}\`),
+    queryFn: () => fetcher<${targetSym}[]>(\`\${${source}.$path}/\${sourceId}/${e.name}\`),
     enabled: sourceId != null && (opts?.enabled ?? true),
     ...opts,
   });
@@ -206,7 +206,7 @@ export function use${entityName}(
   const fetcher = ${useEntityFetcherSym}();
   return ${useQuerySym}<${entityName}Row>({
     queryKey: ${keysVar}.detail(id),
-    queryFn: () => fetcher<${entityName}Row>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}/\${id}\`),
+    queryFn: () => fetcher<${entityName}Row>(\`\${${entityName}.$path}/\${id}\`),
     ...opts,
   });
 }
@@ -219,7 +219,7 @@ export function use${entityNamePlural}(
   const qs = filter ? "?" + ${buildFilterQsSym}(filter as Record<string, unknown>) : "";
   return ${useQuerySym}<${entityName}Row[]>({
     queryKey: ${keysVar}.list(filter),
-    queryFn: () => fetcher<${entityName}Row[]>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}\${qs}\`),
+    queryFn: () => fetcher<${entityName}Row[]>(\`\${${entityName}.$path}\${qs}\`),
     ...opts,
   });
 }
@@ -287,7 +287,7 @@ export function use${entityName}(
   const fetcher = ${useEntityFetcherSym}();
   return ${useQuerySym}<${entityName}Row>({
     queryKey: ${keysVar}.detail(id),
-    queryFn: () => fetcher<${entityName}Row>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}/\${id}\`),
+    queryFn: () => fetcher<${entityName}Row>(\`\${${entityName}.$path}/\${id}\`),
     ...opts,
   });
 }
@@ -300,7 +300,7 @@ export function use${entityNamePlural}(
   const qs = filter ? "?" + ${buildFilterQsSym}(filter as Record<string, unknown>) : "";
   return ${useQuerySym}<${entityName}Row[]>({
     queryKey: ${keysVar}.list(filter),
-    queryFn: () => fetcher<${entityName}Row[]>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}\${qs}\`),
+    queryFn: () => fetcher<${entityName}Row[]>(\`\${${entityName}.$path}\${qs}\`),
     ...opts,
   });
 }
@@ -315,7 +315,7 @@ export function useCreate${entityName}(
   const fetcher = ${useEntityFetcherSym}();
   const qc = ${useQueryClientSym}();
   return ${useMutationSym}<${entityName}Row, Error, ${entityName}Insert>({
-    mutationFn: (input) => fetcher<${entityName}Row>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}\`, {
+    mutationFn: (input) => fetcher<${entityName}Row>(\`\${${entityName}.$path}\`, {
       method: "POST",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input),
@@ -334,7 +334,7 @@ export function useUpdate${entityName}(
   const fetcher = ${useEntityFetcherSym}();
   const qc = ${useQueryClientSym}();
   return ${useMutationSym}({
-    mutationFn: ({ id, input }) => fetcher<${entityName}Row>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}/\${id}\`, {
+    mutationFn: ({ id, input }) => fetcher<${entityName}Row>(\`\${${entityName}.$path}/\${id}\`, {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input),
@@ -353,7 +353,7 @@ export function useDelete${entityName}(
   const fetcher = ${useEntityFetcherSym}();
   const qc = ${useQueryClientSym}();
   return ${useMutationSym}({
-    mutationFn: (id) => fetcher<void>(\`\${${entityName}.$apiPrefix}\${${entityName}.$path}/\${id}\`, { method: "DELETE" }),
+    mutationFn: (id) => fetcher<void>(\`\${${entityName}.$path}/\${id}\`, { method: "DELETE" }),
     ...opts,
     onSuccess: (...args) => {
       qc.invalidateQueries({ queryKey: ${keysVar}.all() });
@@ -401,7 +401,7 @@ function renderTphHooksFile(base: MetaObject, ctx: RenderContext, baseModule: st
 
   const subtypes = plan.subtypes;
 
-  // `${baseName}` imports BOTH the constants value (for $path/$apiPrefix) and the
+  // `${baseName}` imports BOTH the constants value (for $path) and the
   // discriminated-union type (declaration merge). Each subtype contributes its
   // interface type AND its own filter type (discriminator-excluded — the route
   // pins it), so per-subtype hooks filter on the fields the per-subtype
@@ -442,7 +442,7 @@ export function use${baseName}(
   const fetcher = ${useEntityFetcherSym}();
   return ${useQuerySym}<${baseName}>({
     queryKey: ${keysVar}.detail(id),
-    queryFn: () => fetcher<${baseName}>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/\${id}\`),
+    queryFn: () => fetcher<${baseName}>(\`\${${baseName}.$path}/\${id}\`),
     ...opts,
   });
 }
@@ -455,7 +455,7 @@ export function use${pluralize(baseName)}(
   const qs = filter ? "?" + ${buildFilterQsSym}(filter as Record<string, unknown>) : "";
   return ${useQuerySym}<${baseName}[]>({
     queryKey: ${keysVar}.list(filter),
-    queryFn: () => fetcher<${baseName}[]>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}\${qs}\`),
+    queryFn: () => fetcher<${baseName}[]>(\`\${${baseName}.$path}\${qs}\`),
     ...opts,
   });
 }
@@ -467,7 +467,7 @@ export function use${pluralize(baseName)}(
     const valueLit = JSON.stringify(value);
     const createInput = `Omit<${subName}, ${JSON.stringify(discField)}>`;
     const updateInput = `Partial<${createInput}>`;
-    const subPath = `\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/${seg}\``;
+    const subPath = `\`\${${baseName}.$path}/${seg}\``;
     return code`
 export function use${pluralize(subName)}(
   filter?: ${subName}Filter,
@@ -477,7 +477,7 @@ export function use${pluralize(subName)}(
   const qs = filter ? "?" + ${buildFilterQsSym}(filter as Record<string, unknown>) : "";
   return ${useQuerySym}<${subName}[]>({
     queryKey: ${keysVar}.subtypeList(${valueLit}, filter),
-    queryFn: () => fetcher<${subName}[]>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/${seg}\${qs}\`),
+    queryFn: () => fetcher<${subName}[]>(\`\${${baseName}.$path}/${seg}\${qs}\`),
     ...opts,
   });
 }
@@ -489,7 +489,7 @@ export function use${subName}(
   const fetcher = ${useEntityFetcherSym}();
   return ${useQuerySym}<${subName}>({
     queryKey: ${keysVar}.subtypeDetail(${valueLit}, id),
-    queryFn: () => fetcher<${subName}>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/${seg}/\${id}\`),
+    queryFn: () => fetcher<${subName}>(\`\${${baseName}.$path}/${seg}/\${id}\`),
     ...opts,
   });
 }
@@ -519,7 +519,7 @@ export function useUpdate${subName}(
   const fetcher = ${useEntityFetcherSym}();
   const qc = ${useQueryClientSym}();
   return ${useMutationSym}({
-    mutationFn: ({ id, input }) => fetcher<${subName}>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/${seg}/\${id}\`, {
+    mutationFn: ({ id, input }) => fetcher<${subName}>(\`\${${baseName}.$path}/${seg}/\${id}\`, {
       method: "PATCH",
       headers: { "Content-Type": "application/json" },
       body: JSON.stringify(input),
@@ -538,7 +538,7 @@ export function useDelete${subName}(
   const fetcher = ${useEntityFetcherSym}();
   const qc = ${useQueryClientSym}();
   return ${useMutationSym}({
-    mutationFn: (id) => fetcher<void>(\`\${${baseName}.$apiPrefix}\${${baseName}.$path}/${seg}/\${id}\`, { method: "DELETE" }),
+    mutationFn: (id) => fetcher<void>(\`\${${baseName}.$path}/${seg}/\${id}\`, { method: "DELETE" }),
     ...opts,
     onSuccess: (...args) => {
       qc.invalidateQueries({ queryKey: ${keysVar}.all() });