@metaobjectsdev/codegen-ts 1.0.0-rc.3 → 1.0.0-rc.5

package/src/templates/filter-shared.ts

@@ -1,10 +1,31 @@
-// Shared predicate for "is this field sortable?" — used by both filter-allowlist.ts
-// (SortAllowlist generation) and filter-type.ts (sort union generation).
-// Both must agree on which fields are sortable; keeping them in sync via this shared
-// helper prevents client/server mismatches.
+// Shared answers to "how does this entity sort?" — used by every tier that has to
+// answer it, so none of them can answer it differently.
+//
+// Two questions live here:
+//   WHICH fields sort   — isSortableField / sortableFields, read by the generated
+//                         <Entity>SortAllowlist (filter-allowlist.ts), the client
+//                         <Entity>Filter sort union (filter-type.ts) and the agent
+//                         UI page.
+//   WHICH WAY one sorts — declaredSortDefaultOrder / sortDefaultOrder /
+//                         resolveGridDefaultSort, read by the same allowlist, the
+//                         generated grid const + grid hook, and the agent UI page.
+//
+// Keeping both here is what prevents a client/server mismatch: a header the grid
+// renders clickable for a field the endpoint rejects, or a grid whose initial sort
+// runs the opposite way from the endpoint it queries.
 
-import { MetaField, MetaObject } from "@metaobjectsdev/metadata";
-import { FIELD_ATTR_FILTERABLE, FIELD_ATTR_SORTABLE } from "@metaobjectsdev/metadata";
+import { MetaField, MetaObject, type MetaData } from "@metaobjectsdev/metadata";
+import {
+  FIELD_ATTR_FILTERABLE,
+  FIELD_ATTR_SORTABLE,
+  FIELD_ATTR_SORTABLE_DEFAULT_ORDER,
+  LAYOUT_DATA_GRID_ATTR_DEFAULT_SORT_FIELD,
+  LAYOUT_DATA_GRID_ATTR_DEFAULT_SORT_ORDER,
+} from "@metaobjectsdev/metadata";
+
+/** A resolved sort direction. Never widened to `string`: every door below either
+ *  returns one of these two or says it has no answer. */
+export type SortOrder = "asc" | "desc";
 
 /**
  * Returns true if the given field should be included in sort operations.
@@ -28,3 +49,67 @@ export function sortableFields(entity: MetaObject): MetaField[] {
   // fields() returns effective fields, so inherited fields (from extends:/super:) are included in sort ops.
   return entity.fields().filter(isSortableField);
 }
+
+/**
+ * The direction `@sortableDefaultOrder` DECLARES on this field, or undefined when
+ * the field declares none.
+ *
+ * The declared value is what the generated `<Entity>SortAllowlist` carries, so an
+ * undeclared field stays `{}` there and the runtime's own `?? "asc"` remains the
+ * single place the fallback is spelled. Callers that need a concrete direction
+ * rather than a declaration use `sortDefaultOrder`.
+ *
+ * ADR-0039: resolving — `@sortableDefaultOrder` may be inherited via `extends`.
+ */
+export function declaredSortDefaultOrder(field: MetaField): SortOrder | undefined {
+  const v = field.attr(FIELD_ATTR_SORTABLE_DEFAULT_ORDER);
+  return v === "asc" || v === "desc" ? v : undefined;
+}
+
+/** The direction a sort runs when it names this field without giving one. */
+export function sortDefaultOrder(field: MetaField): SortOrder {
+  return declaredSortDefaultOrder(field) ?? "asc";
+}
+
+/** A grid's initial sort: the field it runs on and the direction it runs. */
+export interface GridDefaultSort {
+  field: string;
+  order: SortOrder;
+}
+
+/**
+ * A `layout.dataGrid`'s initial sort, resolved once for every tier that renders it.
+ *
+ * `@defaultSortOrder` wins when the layout declares one. When it does not, the
+ * NAMED FIELD's `@sortableDefaultOrder` applies — that is what the attribute has
+ * always been registered to mean ("the direction a sort takes when it names this
+ * field but omits the order"), and it is the same rule the runtime applies to
+ * `?sort=<field>` with no `:order`. Without this the two ends of one declaration
+ * disagree: the endpoint returns the field's declared order while the grid that
+ * queries it renders the opposite.
+ *
+ * Returns undefined when the layout names no field — a grid with no initial sort.
+ *
+ * The field lookup cannot miss on a LOADED model: `validateDataGridSortFields`
+ * refuses `@defaultSortField` naming a field the entity does not have
+ * (`ERR_BAD_DEFAULT_SORT_FIELD`). "asc" is the answer for a hand-built node that
+ * never went through the loader, so codegen degrades rather than throwing.
+ */
+// `layout` is typed as the base MetaData rather than MetaLayout because the three
+// call sites hold the node at different static types (`entity.layouts()` gives
+// MetaLayout, the agent page's own `dataGrids()` gives MetaData) and this reads
+// nothing but `attr()`, which is declared there. Widening beats a cast per caller.
+export function resolveGridDefaultSort(
+  entity: MetaObject,
+  layout: MetaData,
+): GridDefaultSort | undefined {
+  // ADR-0039: resolving — a layout may inherit its grid attrs via extends.
+  const fieldName = layout.attr(LAYOUT_DATA_GRID_ATTR_DEFAULT_SORT_FIELD);
+  if (typeof fieldName !== "string" || fieldName === "") return undefined;
+
+  const declared = layout.attr(LAYOUT_DATA_GRID_ATTR_DEFAULT_SORT_ORDER);
+  if (declared === "asc" || declared === "desc") return { field: fieldName, order: declared };
+
+  const field = entity.fields().find((f) => f.name === fieldName);
+  return { field: fieldName, order: field === undefined ? "asc" : sortDefaultOrder(field) };
+}

package/src/templates/inferred-types.ts

@@ -42,6 +42,7 @@ import { renderDocsFor } from "./jsdoc.js";
 import { sharedEnumForField } from "../enum-shared.js";
 import { sharedEnumImportSpecifier, providedEnumImportSpecifier } from "../enum-import.js";
 import { fieldDeclaringPackage, type RenderContext } from "../render-context.js";
+import { effectivePackage } from "../docs-paths.js";
 
 /**
  * Emit Drizzle's InferSelectModel / InferInsertModel aliases for an entity.
@@ -179,7 +180,7 @@ export function renderEnumTypeAliases(entity: MetaObject, ctx?: RenderContext):
     // configured external module; never redeclare the union here.
     const spec = shared.provided
       ? providedEnumImportSpecifier(ctx!, shared.name)
-      : sharedEnumImportSpecifier(ctx!, entity.package);
+      : sharedEnumImportSpecifier(ctx!, effectivePackage(entity));
     // Re-export the runtime constant beside the type for a MATERIALIZED shared enum, so a
     // consumer reaches its members the same way it reaches an inline enum's, without having
     // to know which kind it is or which module the shared one landed in.
@@ -305,9 +306,10 @@ function valueObjectFieldType(entity: MetaObject, field: MetaField, ctx?: Render
       // layout/package/extStyle-aware helper (the SAME one the Zod schema +
       // Drizzle .$type<> use) so all three agree. Without a ctx (bare unit-test
       // calls) fall back to the bare name + flat same-dir specifier.
-      const refName = ctx ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, entity.package)) : stripPackage(ref);
+      const entityPkg = effectivePackage(entity);
+      const refName = ctx ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, entityPkg)) : stripPackage(ref);
       const moduleSpec = ctx
-        ? valueObjectModuleSpecifier(refName, ctx.packageOf, entity.package, ctx.outputLayout, ctx.extStyle)
+        ? valueObjectModuleSpecifier(refName, ctx.packageOf, entityPkg, ctx.outputLayout, ctx.extStyle)
         : `./${refName}.js`;
       const refImp = imp(`${refName}@${moduleSpec}`);
       return field.resolvedIsArray() ? code`${refImp}[]` : code`${refImp}`;
@@ -319,9 +321,10 @@ function valueObjectFieldType(entity: MetaObject, field: MetaField, ctx?: Render
   if (field.subType === FIELD_SUBTYPE_MAP) {
     const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref === "string" && ref.length > 0) {
-      const refName = ctx ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, entity.package)) : stripPackage(ref);
+      const entityPkg = effectivePackage(entity);
+      const refName = ctx ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, entityPkg)) : stripPackage(ref);
       const moduleSpec = ctx
-        ? valueObjectModuleSpecifier(refName, ctx.packageOf, entity.package, ctx.outputLayout, ctx.extStyle)
+        ? valueObjectModuleSpecifier(refName, ctx.packageOf, entityPkg, ctx.outputLayout, ctx.extStyle)
         : `./${refName}.js`;
       const refImp = imp(`${refName}@${moduleSpec}`);
       return code`Record<string, ${refImp}>`;
@@ -349,7 +352,7 @@ function valueObjectFieldType(entity: MetaObject, field: MetaField, ctx?: Render
         if (shared !== undefined) {
           const spec = shared.provided
             ? providedEnumImportSpecifier(ctx, shared.name)
-            : sharedEnumImportSpecifier(ctx, entity.package);
+            : sharedEnumImportSpecifier(ctx, effectivePackage(entity));
           const sym = imp(`t:${shared.name}@${spec}`);
           return field.resolvedIsArray() ? code`${sym}[]` : code`${sym}`;
         }

package/src/templates/projection-decl.ts

@@ -23,6 +23,7 @@ import { renderFilterType } from "./filter-type.js";
 import { buildUiFieldDescriptor, resourcePath } from "./entity-ui-descriptor.js";
 import { renderExistingViewDecl, renderViewReadZodObject } from "./view-decl.js";
 import { primaryIdentityFieldNames } from "./zod-validators.js";
+import { effectivePackage } from "../docs-paths.js";
 
 // ---------------------------------------------------------------------------
 // Public interface
@@ -103,14 +104,15 @@ export function renderProjectionDecl(
   // package-qualified on a cross-package short-name collision, so the projection's
   // VO import matches the entity's. Layout/package/extStyle-aware when a render
   // context is present, else a flat same-dir import (zodFieldExpr's fallback).
+  const projectionPkg = effectivePackage(projection);
   const voRef = (field: MetaField): { name: string; module: string } => {
     const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     const rawRef = typeof ref === "string" ? ref : "";
     const name = ctx
-      ? ctx.resolveValueObjectName(rawRef, fieldDeclaringPackage(field, projection.package))
+      ? ctx.resolveValueObjectName(rawRef, fieldDeclaringPackage(field, projectionPkg))
       : stripPackage(rawRef);
     const module = ctx
-      ? valueObjectModuleSpecifier(name, ctx.packageOf, projection.package, ctx.outputLayout, ctx.extStyle)
+      ? valueObjectModuleSpecifier(name, ctx.packageOf, projectionPkg, ctx.outputLayout, ctx.extStyle)
       : `./${name}.js`;
     return { name, module };
   };

package/src/templates/queries-file.ts

@@ -26,6 +26,7 @@ import { GENERATED_HEADER } from "../constants.js";
 import { isTphDiscriminatorBase, tphConcreteSubtypes } from "./tph-discriminator.js";
 import { isProjection, isWriteThrough } from "../projection/projection-detector.js";
 import { hasAutoSetFields } from "./zod-validators.js";
+import { effectivePackage } from "../docs-paths.js";
 
 /**
  * The dialect-correct Drizzle `Db` type alias + its import — parameter-passed into every
@@ -94,7 +95,7 @@ export function renderQueriesFile(obj: MetaObject, ctx: RenderContext): string {
   const entityFileName = entityModuleSpecifier(
     ctx.selfTarget,
     ctx.entityModuleTarget,
-    obj.package,
+    effectivePackage(obj),
     entityName,
     ctx.extStyle,
   );
@@ -163,7 +164,7 @@ function renderProjectionQueriesFile(obj: MetaObject, ctx: RenderContext): strin
   const camelName = entityName.charAt(0).toLowerCase() + entityName.slice(1);
   const viewVar = `${camelName}View`;
   const entityFileName = entityModuleSpecifier(
-    ctx.selfTarget, ctx.entityModuleTarget, obj.package, entityName, ctx.extStyle,
+    ctx.selfTarget, ctx.entityModuleTarget, effectivePackage(obj), entityName, ctx.extStyle,
   );
   const { fieldName: pkField, tsType: pkType } = getPkInfo(obj, ctx);
   const eqSym = imp("eq@drizzle-orm");
@@ -215,7 +216,7 @@ function renderWriteThroughQueriesFile(obj: MetaObject, ctx: RenderContext): str
   const tableVar = ctx.collectionName(entityName);
   const singularVar = camelName;
   const entityFileName = entityModuleSpecifier(
-    ctx.selfTarget, ctx.entityModuleTarget, obj.package, entityName, ctx.extStyle,
+    ctx.selfTarget, ctx.entityModuleTarget, effectivePackage(obj), entityName, ctx.extStyle,
   );
   const { fieldName: pkField, tsType: pkType } = getPkInfo(obj, ctx);
   const pkFields = getPkFields(obj);
@@ -309,7 +310,7 @@ function renderTphQueriesFile(base: MetaObject, ctx: RenderContext): string {
   const { fieldName: pkField, tsType: pkType } = getPkInfo(base, ctx);
 
   const baseFileSpec = entityModuleSpecifier(
-    ctx.selfTarget, ctx.entityModuleTarget, base.package, baseName, ctx.extStyle,
+    ctx.selfTarget, ctx.entityModuleTarget, effectivePackage(base), baseName, ctx.extStyle,
   );
   const tableSym = imp(`${tableVar}@${baseFileSpec}`);
   const baseTypeSym = imp(`t:${baseName}@${baseFileSpec}`);
@@ -342,7 +343,7 @@ export async function list${pluralize(baseName)}(db: Db, opts?: { limit?: number
     const value = sub.ownAttr(OBJECT_ATTR_DISCRIMINATOR_VALUE) as string;
     const valueLit = JSON.stringify(value);
     const subFileSpec = entityModuleSpecifier(
-      ctx.selfTarget, ctx.entityModuleTarget, sub.package, sub.name, ctx.extStyle,
+      ctx.selfTarget, ctx.entityModuleTarget, effectivePackage(sub), sub.name, ctx.extStyle,
     );
     const subTypeSym = imp(`t:${sub.name}@${subFileSpec}`);
     const subSchemaSym = imp(`${sub.name}Schema@${subFileSpec}`);

package/src/templates/relations-block.ts

@@ -7,6 +7,7 @@ import { CARDINALITY_ONE, CARDINALITY_MANY } from "@metaobjectsdev/metadata";
 import { type RenderContext } from "../render-context.js";
 import { crossEntitySpecifier } from "../import-path.js";
 import type { RelationEntry } from "../relation-resolver.js";
+import { effectivePackage } from "../docs-paths.js";
 
 /**
  * Render the relations() block for one entity.
@@ -28,7 +29,7 @@ export function renderRelationsBlock(entity: MetaObject, ctx: RenderContext): Co
   if (hasMany) paramParts.push("many");
   const params = `{ ${paramParts.join(", ")} }`;
 
-  const thisEntityPackage = entity.package;
+  const thisEntityPackage = effectivePackage(entity);
   const lines: Code[] = entries.map((entry) =>
     renderRelationEntry(entry, ctx, varName, thisEntityPackage),
   );

package/src/templates/render-helper.ts

@@ -53,6 +53,8 @@ import {
   type VerifyError,
 } from "@metaobjectsdev/render";
 import { templateSymbolBase } from "../naming.js";
+import { GENERATED_HEADER } from "../constants.js";
+import type { ExtStyle } from "../metaobjects-config.js";
 
 // ADR-0039: resolving — root has no super (children()==ownChildren()); a top-level object/template may itself extend, so resolve rather than work-by-accident.
 // ADR-0042: package-local — resolveObjectRef binds a bare @objectRef in `referrerPkg` first (else root-level), an FQN exactly.
@@ -65,6 +67,20 @@ function findTemplate(root: MetaData, name: string): MetaData | undefined {
   return root.children().find((c) => c.type === TYPE_TEMPLATE && c.name === name);
 }
 
+/**
+ * The three lines every emitted render-helper module opens with: the generated-file
+ * marker, the `render()` import, and the typed payload import. Identical between the
+ * email and document kinds below — only the `@metaobjectsdev/render` type import
+ * differs (email additionally needs `EmailDocument`), so that piece is a parameter
+ * rather than a second near-copy of this block.
+ */
+function renderHelperHeader(typeImports: string, payloadTypeName: string, ext: string): string {
+  return `// ${GENERATED_HEADER} — DO NOT EDIT.
+import { render } from "@metaobjectsdev/render";
+import type { ${typeImports} } from "@metaobjectsdev/render";
+import type { ${payloadTypeName} } from "./${payloadTypeName}${ext}";`;
+}
+
 /**
  * Walk an `object.value` view-object into a render `PayloadField[]`. Object-ref
  * fields recurse into their referenced view-object; a `seen` set guards a
@@ -150,6 +166,16 @@ export function renderRenderHelper(
   root: MetaData,
   templateName: string,
   provider: Provider,
+  /**
+   * The project's import-extension style, as every other emitter honours it.
+   * Defaults to "js" — the engine default — so an existing caller is unchanged.
+   *
+   * This file used to hardcode `.js` regardless. Both spellings happen to resolve
+   * under nodenext AND bundler, so nothing broke; it was simply the one emitter
+   * that did not read the setting, which is how a project with `extStyle: "none"`
+   * ended up with one file spelling its imports differently from every other.
+   */
+  extStyle: ExtStyle = "js",
 ): string {
   const tmpl = findTemplate(root, templateName);
   if (!tmpl) {
@@ -186,6 +212,9 @@ export function renderRenderHelper(
   // resolution above (findObject/derivePayloadFieldTree) intentionally keeps
   // using the raw `payloadRef`.
   const payloadTypeName = stripPackage(payloadRef);
+  // The emitted relative import's extension, from the project's setting rather than
+  // hardcoded — see the `extStyle` parameter doc.
+  const ext = extStyle === "none" ? "" : ".js";
 
   // ADR-0039: resolving — a template may inherit its @* refs/format/kind via extends.
   const kind = ((tmpl.attr(TEMPLATE_ATTR_KIND) as string | undefined) ?? TEMPLATE_KIND_DEFAULT)
@@ -215,9 +244,7 @@ export function renderRenderHelper(
         ? `\n    textBody: render({ ref: ${JSON.stringify(textBodyRef)}, payload, format: "text", provider, verify: ${ft} }),`
         : "";
 
-    return `import { render } from "@metaobjectsdev/render";
-import type { Provider, EmailDocument } from "@metaobjectsdev/render";
-import type { ${payloadTypeName} } from "./${payloadTypeName}.js";
+    return `${renderHelperHeader("Provider, EmailDocument", payloadTypeName, ext)}
 
 /**
  * Render the ${templateName} email (subject + html body${typeof textBodyRef === "string" ? " + text body" : ""}) from a
@@ -255,9 +282,7 @@ export function ${fnName}(payload: ${payloadTypeName}, provider: Provider): Emai
   const maxCharsArg =
     maxChars !== undefined && Number.isFinite(maxChars) ? `, maxChars: ${maxChars}` : "";
 
-  return `import { render } from "@metaobjectsdev/render";
-import type { Provider } from "@metaobjectsdev/render";
-import type { ${payloadTypeName} } from "./${payloadTypeName}.js";
+  return `${renderHelperHeader("Provider", payloadTypeName, ext)}
 
 /**
  * Render the ${templateName} document from a typed ${payloadTypeName} payload. Wraps the

package/src/templates/routes-file-hono.ts

@@ -31,6 +31,7 @@ import { entityModuleSpecifier } from "../import-path.js";
 import { GENERATED_HEADER } from "../constants.js";
 import { isProjection, isWriteThrough } from "../projection/projection-detector.js";
 import { type CrudVerb, exposeLine } from "../routes-expose.js";
+import { effectivePackage } from "../docs-paths.js";
 
 export function renderRoutesFileHono(
   entity: MetaObject,
@@ -49,7 +50,7 @@ export function renderRoutesFileHono(
   const entityFileSpec = entityModuleSpecifier(
     ctx.selfTarget,
     ctx.entityModuleTarget,
-    entity.package,
+    effectivePackage(entity),
     entityName,
     ctx.extStyle,
   );

package/src/templates/routes-file.ts

@@ -30,6 +30,7 @@ import { isProjection, isWriteThrough } from "../projection/projection-detector.
 import type { RelationEntry } from "../relation-resolver.js";
 import { isTphDiscriminatorBase, tphPlan } from "./tph-discriminator.js";
 import { type CrudVerb, exposeLine, intersectExpose, TPH_POLYMORPHIC_VERBS } from "../routes-expose.js";
+import { effectivePackage } from "../docs-paths.js";
 
 export function renderRoutesFile(
   entity: MetaObject,
@@ -49,16 +50,17 @@ export function renderRoutesFile(
 
   const entityName = entity.name;
   const handlerName = routesHandlerName(entityName);
+  const entityPkg = effectivePackage(entity);
   // Import the entity's own file. Same target → relative "./Entity"; cross
   // target → importBase-qualified package path.
   const entityFileSpec = entityModuleSpecifier(
     ctx.selfTarget,
     ctx.entityModuleTarget,
-    entity.package,
+    entityPkg,
     entityName,
     ctx.extStyle,
   );
-  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, entity.package, ctx.dbImport, ctx.extStyle);
+  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, entityPkg, ctx.dbImport, ctx.extStyle);
 
   const header =
     `// ${GENERATED_HEADER} — DO NOT EDIT.\n` +
@@ -260,10 +262,15 @@ function renderM2mMount(
   ctx: RenderContext,
   fastifyVar: string,
 ): Code {
+  // `source` never changes across this function, so its effective package is computed
+  // once and reused below (both crossEntitySpecifier calls, and the three
+  // resolveJunctionColumn calls' `fromPackage` — see that comment for why it must be
+  // SOURCE's package rather than the junction/target entity's own).
+  const sourcePkg = effectivePackage(source);
   const junctionVarSym = imp(
     `${ctx.collectionName(entry.junctionEntity)}@${crossEntitySpecifier(
       ctx.outputLayout,
-      source.package,
+      sourcePkg,
       ctx.packageOf.get(entry.junctionEntity),
       entry.junctionEntity,
       ctx.extStyle,
@@ -272,7 +279,7 @@ function renderM2mMount(
   const targetVarSym = imp(
     `${ctx.collectionName(entry.targetEntity)}@${crossEntitySpecifier(
       ctx.outputLayout,
-      source.package,
+      sourcePkg,
       ctx.packageOf.get(entry.targetEntity),
       entry.targetEntity,
       ctx.extStyle,
@@ -284,13 +291,13 @@ function renderM2mMount(
   // fromPackage = source.package: this routes file is SOURCE's own module, never the
   // junction's or the target's — see resolveJunctionColumn's doc comment (B1).
   const sourceColumn: Code = junction
-    ? resolveJunctionColumn(junction, entry.sourceJoinField!, ctx, source.package)
+    ? resolveJunctionColumn(junction, entry.sourceJoinField!, ctx, sourcePkg)
     : code`${JSON.stringify(entry.sourceJoinField!)}`;
   const targetColumn: Code = junction
-    ? resolveJunctionColumn(junction, entry.targetJoinField!, ctx, source.package)
+    ? resolveJunctionColumn(junction, entry.targetJoinField!, ctx, sourcePkg)
     : code`${JSON.stringify(entry.targetJoinField!)}`;
   const targetPkColumn: Code = target
-    ? resolveJunctionColumn(target, ctx.pkMap.get(entry.targetEntity)?.fieldName ?? "id", ctx, source.package)
+    ? resolveJunctionColumn(target, ctx.pkMap.get(entry.targetEntity)?.fieldName ?? "id", ctx, sourcePkg)
     : code`${JSON.stringify("id")}`;
 
   return code`  ${mountM2mRouteSym}({
@@ -368,10 +375,11 @@ function renderTphRoutesFile(
   const discField = plan.discriminatorField;
   const tableVar = ctx.collectionName(baseName);
 
+  const basePkg = effectivePackage(base);
   const baseFileSpec = entityModuleSpecifier(
-    ctx.selfTarget, ctx.entityModuleTarget, base.package, baseName, ctx.extStyle,
+    ctx.selfTarget, ctx.entityModuleTarget, basePkg, baseName, ctx.extStyle,
   );
-  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, base.package, ctx.dbImport, ctx.extStyle);
+  const dbImportSpec = relativeModuleSpecifier(ctx.outputLayout, basePkg, ctx.dbImport, ctx.extStyle);
 
   const FastifyInstanceSym = imp("t:FastifyInstance@fastify");
   const mountCrudRoutesSym = imp("mountCrudRoutes@@metaobjectsdev/runtime-ts/drizzle-fastify");
@@ -405,7 +413,7 @@ function renderTphRoutesFile(
 
   const subtypeMounts: Code[] = plan.subtypes.map(({ entity: sub, value, routeSegment: segment }) => {
     const subFileSpec = entityModuleSpecifier(
-      ctx.selfTarget, ctx.entityModuleTarget, sub.package, sub.name, ctx.extStyle,
+      ctx.selfTarget, ctx.entityModuleTarget, effectivePackage(sub), sub.name, ctx.extStyle,
     );
     const subInsertSym = imp(`${sub.name}InsertSchema@${subFileSpec}`);
     // FR-036 Program B: the per-subtype UPDATE must carry the FR-035 present-key

package/src/templates/zod-validators.ts

@@ -42,6 +42,7 @@ import { valueObjectModuleSpecifier } from "../import-path.js";
 // FR-035: the SAME required-predicate that drives the Drizzle column's .notNull()
 // drives the UpdateSchema's .nullable() exclusion — shared so they cannot drift.
 import { isRequired } from "../column-mapper.js";
+import { effectivePackage } from "../docs-paths.js";
 
 /**
  * FR-017 Tier 1 — when this object is a TPH subtype (@discriminatorValue set
@@ -593,9 +594,10 @@ function zodFieldExpr(
       // layout/package/extStyle-aware helper (the SAME one the field's TS type +
       // Drizzle .$type<> use) so all three agree. Without owner/ctx (bare
       // unit-test calls) fall back to the bare name + flat same-dir.
-      const refName = (ctx && owner) ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, owner.package)) : stripPackage(ref);
+      const ownerPkg = (ctx && owner) ? effectivePackage(owner) : undefined;
+      const refName = (ctx && owner) ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, ownerPkg)) : stripPackage(ref);
       const moduleSpec = (ctx && owner)
-        ? valueObjectModuleSpecifier(refName, ctx.packageOf, owner.package, ctx.outputLayout, ctx.extStyle)
+        ? valueObjectModuleSpecifier(refName, ctx.packageOf, ownerPkg, ctx.outputLayout, ctx.extStyle)
         : `./${refName}.js`;
       const refImp = imp(`${refName}InsertSchema@${moduleSpec}`);
       let base: Code = code`${refImp}`;
@@ -614,9 +616,10 @@ function zodFieldExpr(
   if (field.subType === FIELD_SUBTYPE_MAP) {
     const ref = field.attr(FIELD_ATTR_OBJECT_REF);
     if (typeof ref === "string" && ref.length > 0) {
-      const refName = (ctx && owner) ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, owner.package)) : stripPackage(ref);
+      const ownerPkg = (ctx && owner) ? effectivePackage(owner) : undefined;
+      const refName = (ctx && owner) ? ctx.resolveValueObjectName(ref, fieldDeclaringPackage(field, ownerPkg)) : stripPackage(ref);
       const moduleSpec = (ctx && owner)
-        ? valueObjectModuleSpecifier(refName, ctx.packageOf, owner.package, ctx.outputLayout, ctx.extStyle)
+        ? valueObjectModuleSpecifier(refName, ctx.packageOf, ownerPkg, ctx.outputLayout, ctx.extStyle)
         : `./${refName}.js`;
       const refImp = imp(`${refName}InsertSchema@${moduleSpec}`);
       return appendValidatorChain(code`z.record(z.string(), ${refImp})`, field, forceRequired);