@metaobjectsdev/codegen-ts 0.24.5 → 1.0.0-rc.1

package/dist/view-context.d.ts

@@ -0,0 +1,24 @@
+import type { MetaField, MetaView } from "@metaobjectsdev/metadata";
+/**
+ * The surface a generated artifact renders, and therefore the `name` its
+ * emitter looks for among a field's views.
+ *
+ * These are the only two surfaces the packaged generators render. An owned
+ * generator (FR-040) targeting a third may pass its own name — `viewForContext`
+ * takes any string — but it then owns telling its authors what to name.
+ */
+export declare const VIEW_CONTEXT_FORM = "form";
+/** Both grid tiers (TanStack and Angular) render the same surface, so both ask for this. */
+export declare const VIEW_CONTEXT_GRID = "grid";
+/**
+ * The view a field declares for `context`, or `undefined` when it declares none
+ * at all (the caller's existing "no view" path — an inferred default — applies).
+ *
+ * Uses the RESOLVING accessor (ADR-0039): a view inherited through `extends` is
+ * as much the field's view as one declared on it.
+ *
+ * @throws CodegenError when the field declares several views and none is named
+ *   for `context`. The remedy is in the message: name one of them.
+ */
+export declare function viewForContext(field: MetaField, context: string): MetaView | undefined;
+//# sourceMappingURL=view-context.d.ts.map

package/dist/view-context.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-context.d.ts","sourceRoot":"","sources":["../src/view-context.ts"],"names":[],"mappings":"AAgCA,OAAO,KAAK,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAGpE;;;;;;;GAOG;AACH,eAAO,MAAM,iBAAiB,SAAS,CAAC;AACxC,4FAA4F;AAC5F,eAAO,MAAM,iBAAiB,SAAS,CAAC;AAexC;;;;;;;;;GASG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,SAAS,EAAE,OAAO,EAAE,MAAM,GAAG,QAAQ,GAAG,SAAS,CAiBtF"}

package/dist/view-context.js

@@ -0,0 +1,81 @@
+// Selecting a field's view by the SURFACE that renders it (#356).
+//
+// A field may legally declare more than one `view.*` child and every one of them
+// survives the load, so an emitter reading `field.views()[0]` let DECLARATION
+// ORDER decide its output — and because several emitters read that same list,
+// one declaration drove three unrelated surfaces at once. Declaring a
+// `view.text` so a grid cell rendered as text silently degraded the generated
+// FORM to an `<input>`, and swapping two lines of JSON with no semantic change
+// flipped the form's `<select>` back. That is not a modelling mistake; it is the
+// only possible outcome when one declaration serves three readers.
+//
+// The selector is the view's `name` — a reserved structural key already legal on
+// every node — so this needs no new attribute, no provider and no
+// `metamodelVersion` move (ADR-0037 step 0: the vocabulary existed, only the
+// read was wrong). The same shape as #353's resolution.
+//
+// Two rules, and the second is the load-bearing one:
+//
+//   1. A field declaring ONE view keeps its exact current behaviour: that view
+//      applies to every surface, whatever it is named (or unnamed). Existing
+//      models are untouched by construction — a `name` is how a view is
+//      ADDRESSED by `extends` (ADR-0029 `Customer.priceCents.display`), and
+//      re-reading those names as surface names would break addressing.
+//
+//   2. A field declaring SEVERAL views must name one for the surface being
+//      rendered. No match is a hard error, not a fallback: falling back to
+//      `views()[0]` reinstates the positional read for exactly the multi-view
+//      case this exists to fix, and falling back to the inferred default turns a
+//      `name` typo ("forms") into a silently degraded control. A field cannot
+//      declare two views with the SAME name — the loader merges same-(type,
+//      name) siblings into one node — so a match is never ambiguous.
+import { CodegenError } from "./errors.js";
+/**
+ * The surface a generated artifact renders, and therefore the `name` its
+ * emitter looks for among a field's views.
+ *
+ * These are the only two surfaces the packaged generators render. An owned
+ * generator (FR-040) targeting a third may pass its own name — `viewForContext`
+ * takes any string — but it then owns telling its authors what to name.
+ */
+export const VIEW_CONTEXT_FORM = "form";
+/** Both grid tiers (TanStack and Angular) render the same surface, so both ask for this. */
+export const VIEW_CONTEXT_GRID = "grid";
+/** Render `view.dropdown name="form"` / `view.text (no name)` for a diagnostic. */
+function describe(view) {
+    return view.name.length > 0
+        ? `view.${view.subType} name="${view.name}"`
+        : `view.${view.subType} (no name)`;
+}
+/** `Entity.field`, or just the field name when the field has no parent object. */
+function fieldPath(field) {
+    const owner = field.parent?.name;
+    return owner !== undefined && owner.length > 0 ? `${owner}.${field.name}` : field.name;
+}
+/**
+ * The view a field declares for `context`, or `undefined` when it declares none
+ * at all (the caller's existing "no view" path — an inferred default — applies).
+ *
+ * Uses the RESOLVING accessor (ADR-0039): a view inherited through `extends` is
+ * as much the field's view as one declared on it.
+ *
+ * @throws CodegenError when the field declares several views and none is named
+ *   for `context`. The remedy is in the message: name one of them.
+ */
+export function viewForContext(field, context) {
+    const declared = field.views();
+    // One view (or none) is unambiguous: it applies to every surface, exactly as
+    // it did before this selector existed.
+    if (declared.length <= 1)
+        return declared[0];
+    const match = declared.find((v) => v.name === context);
+    if (match !== undefined)
+        return match;
+    throw new CodegenError(`Field "${fieldPath(field)}" declares ${declared.length} views ` +
+        `(${declared.map(describe).join(", ")}) and none is named "${context}", so codegen ` +
+        `cannot tell which one renders the ${context}. Name one of them "${context}" — a ` +
+        `view's \`name\` selects the surface it renders ("${VIEW_CONTEXT_FORM}" or ` +
+        `"${VIEW_CONTEXT_GRID}"). A field declaring a SINGLE view needs no name: that view ` +
+        `applies to every surface.`);
+}
+//# sourceMappingURL=view-context.js.map

package/dist/view-context.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"view-context.js","sourceRoot":"","sources":["../src/view-context.ts"],"names":[],"mappings":"AAAA,kEAAkE;AAClE,EAAE;AACF,iFAAiF;AACjF,8EAA8E;AAC9E,8EAA8E;AAC9E,sEAAsE;AACtE,8EAA8E;AAC9E,+EAA+E;AAC/E,iFAAiF;AACjF,mEAAmE;AACnE,EAAE;AACF,iFAAiF;AACjF,kEAAkE;AAClE,6EAA6E;AAC7E,wDAAwD;AACxD,EAAE;AACF,qDAAqD;AACrD,EAAE;AACF,+EAA+E;AAC/E,6EAA6E;AAC7E,wEAAwE;AACxE,4EAA4E;AAC5E,uEAAuE;AACvE,EAAE;AACF,2EAA2E;AAC3E,2EAA2E;AAC3E,8EAA8E;AAC9E,iFAAiF;AACjF,8EAA8E;AAC9E,4EAA4E;AAC5E,qEAAqE;AAGrE,OAAO,EAAE,YAAY,EAAE,MAAM,aAAa,CAAC;AAE3C;;;;;;;GAOG;AACH,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC;AACxC,4FAA4F;AAC5F,MAAM,CAAC,MAAM,iBAAiB,GAAG,MAAM,CAAC;AAExC,mFAAmF;AACnF,SAAS,QAAQ,CAAC,IAAc;IAC9B,OAAO,IAAI,CAAC,IAAI,CAAC,MAAM,GAAG,CAAC;QACzB,CAAC,CAAC,QAAQ,IAAI,CAAC,OAAO,UAAU,IAAI,CAAC,IAAI,GAAG;QAC5C,CAAC,CAAC,QAAQ,IAAI,CAAC,OAAO,YAAY,CAAC;AACvC,CAAC;AAED,kFAAkF;AAClF,SAAS,SAAS,CAAC,KAAgB;IACjC,MAAM,KAAK,GAAG,KAAK,CAAC,MAAM,EAAE,IAAI,CAAC;IACjC,OAAO,KAAK,KAAK,SAAS,IAAI,KAAK,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,GAAG,KAAK,IAAI,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC,CAAC,KAAK,CAAC,IAAI,CAAC;AACzF,CAAC;AAED;;;;;;;;;GASG;AACH,MAAM,UAAU,cAAc,CAAC,KAAgB,EAAE,OAAe;IAC9D,MAAM,QAAQ,GAAG,KAAK,CAAC,KAAK,EAAE,CAAC;IAC/B,6EAA6E;IAC7E,uCAAuC;IACvC,IAAI,QAAQ,CAAC,MAAM,IAAI,CAAC;QAAE,OAAO,QAAQ,CAAC,CAAC,CAAC,CAAC;IAE7C,MAAM,KAAK,GAAG,QAAQ,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,CAAC,CAAC,IAAI,KAAK,OAAO,CAAC,CAAC;IACvD,IAAI,KAAK,KAAK,SAAS;QAAE,OAAO,KAAK,CAAC;IAEtC,MAAM,IAAI,YAAY,CACpB,UAAU,SAAS,CAAC,KAAK,CAAC,cAAc,QAAQ,CAAC,MAAM,SAAS;QAC9D,IAAI,QAAQ,CAAC,GAAG,CAAC,QAAQ,CAAC,CAAC,IAAI,CAAC,IAAI,CAAC,wBAAwB,OAAO,gBAAgB;QACpF,qCAAqC,OAAO,uBAAuB,OAAO,QAAQ;QAClF,oDAAoD,iBAAiB,OAAO;QAC5E,IAAI,iBAAiB,+DAA+D;QACpF,2BAA2B,CAC9B,CAAC;AACJ,CAAC"}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaobjectsdev/codegen-ts",
-  "version": "0.24.5",
+  "version": "1.0.0-rc.1",
   "description": "TypeScript codegen engine for MetaObjects — emits Drizzle, Zod, and Fastify artifacts.",
   "type": "module",
   "main": "./dist/index.js",
@@ -111,8 +111,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@metaobjectsdev/metadata": "0.24.5",
-    "@metaobjectsdev/render": "0.24.5",
+    "@metaobjectsdev/metadata": "1.0.0-rc.1",
+    "@metaobjectsdev/render": "1.0.0-rc.1",
     "@biomejs/js-api": "^0.7.0",
     "@biomejs/wasm-nodejs": "^1.9.4",
     "@toon-format/toon": "^2.3.0",
@@ -124,9 +124,9 @@
   },
   "devDependencies": {
     "@biomejs/biome": "^1.9.0",
-    "@metaobjectsdev/codegen-ts-react": "0.24.5",
-    "@metaobjectsdev/migrate-ts": "0.24.5",
-    "@metaobjectsdev/runtime-ts": "0.24.5",
+    "@metaobjectsdev/codegen-ts-react": "1.0.0-rc.1",
+    "@metaobjectsdev/migrate-ts": "1.0.0-rc.1",
+    "@metaobjectsdev/runtime-ts": "1.0.0-rc.1",
     "bun-types": "latest",
     "drizzle-orm": "^0.38.0",
     "hono": "^4.6.0",

package/src/api-surface.ts

@@ -20,7 +20,16 @@
 
 import type { MetaObject } from "@metaobjectsdev/metadata";
 import { isAbstract } from "./instance-artifacts.js";
+import { isProjection } from "./projection/projection-detector.js";
 import { hasAnyRdbSource, hasWritableRdbSource } from "./source-detect.js";
+import { resourcePath, restPath } from "./templates/entity-ui-descriptor.js";
+import {
+  declaresTphDiscriminator,
+  isTphSubtype,
+  tphDiscriminatorBase,
+  tphDiscriminatorPin,
+} from "./templates/zod-validators.js";
+import { tphRouteSegment } from "./templates/tph-discriminator.js";
 
 /**
  * True when the object is served by a generated READ endpoint — so a hook has
@@ -43,3 +52,47 @@ export function servesReadApi(entity: MetaObject): boolean {
 export function servesWriteApi(entity: MetaObject): boolean {
   return !isAbstract(entity) && hasWritableRdbSource(entity);
 }
+
+// `restPath` MOVED to templates/entity-ui-descriptor.ts, beside `resourcePath` and the
+// descriptor that emits `$path` from it. Re-exported here because this module is where
+// the package barrel and `generators/agent-ui-page.ts` import it from, and neither should
+// have to care that the composition moved.
+export { restPath } from "./templates/entity-ui-descriptor.js";
+
+/**
+ * The address the generated routes actually SERVE an object at: the mount prefix plus the
+ * object's REST path.
+ *
+ * One function, because getting this wrong is the defect it exists to prevent, twice over.
+ * `agent/ui.md` documented `/authors` for routes mounted at `/api/authors`; the API
+ * reference did the same, separately, in two more places — three doors composing one
+ * address, each free to drift from the others. `templates/routes-file-hono.ts` and
+ * `routes-file.ts` compose the same thing into GENERATED code and remain the runtime
+ * authority; this is the documentation side mirroring them.
+ */
+export function servedPath(entity: MetaObject, apiPrefix: string): string {
+  return `${apiPrefix}${restPath(entity)}`;
+}
+
+/**
+ * True when a FORM is generated for this object.
+ *
+ * `servesWriteApi` is NOT the same question, and the difference is a TPH hierarchy. The
+ * discriminator BASE has a writable SOURCE — which is all `servesWriteApi` asks — but no
+ * write ENDPOINT: `routes-file.ts` mounts it with `expose: ["list", "get"]`, because the
+ * discriminated union has no single writable shape. So it gets no form, and there would be
+ * nowhere to submit one. Each concrete SUBTYPE gets a form, even though it owns no writable
+ * source of its own. A read-only projection gets none: it is instantiable for read, never
+ * for write.
+ *
+ * This is the form generator's own filter, hoisted so `agent/ui.md` can say "there is
+ * deliberately no form here" for the same set of objects the generator skips. Asking
+ * `servesWriteApi` on the page instead announced a form for every discriminator base.
+ */
+export function hasGeneratedForm(entity: MetaObject): boolean {
+  if (isTphSubtype(entity)) return true; // per-subtype form
+  // A discriminator base is never form-rendered directly; `entity` is already known not
+  // to be a subtype.
+  if (declaresTphDiscriminator(entity)) return false;
+  return servesWriteApi(entity) && !isProjection(entity);
+}

package/src/column-mapper.ts

@@ -264,6 +264,18 @@ export interface ColumnSpec {
   leadingComment?: string;
   /** Optional CHECK constraint expression for the column (e.g., `status IN ('A', 'B')`). */
   checkConstraint?: string;
+  /**
+   * The member list of {@link checkConstraint}, without the leading column name — e.g.
+   * `'A', 'B'` or `0, 5, 9`.
+   *
+   * Carried separately so the RENDERER can compose the constraint against the column's
+   * `<Entity>Names` constant instead of the literal `dbName` baked in above. Splitting it
+   * here rather than re-deriving it there keeps ONE builder for the member list, which is
+   * the half that must match `migrate-ts`'s `buildChecks` exactly or `meta verify` reports
+   * permanent drift. `checkConstraint` stays the composed literal, for the documented arm
+   * where no names artifact is in the run.
+   */
+  checkConstraintValues?: string;
   /**
    * Optional `.$type<...>()` chain target. Renderer (drizzle-schema.ts) emits
    * it ahead of the modifiers chain, using ts-poet `imp()` for objectRef
@@ -799,6 +811,7 @@ export function mapColumnType(
         list = values.map((v) => `'${v.replace(/'/g, "''")}'`).join(", ");
       }
       result.checkConstraint = `${dbName} IN (${list})`;
+      result.checkConstraintValues = list;
     }
   }
 

package/src/constants.ts

@@ -1,28 +1,103 @@
 // Local constants for codegen-ts.
 
-/** The marker that says "codegen owns this file" — drives the overwrite policy. */
+/**
+ * The header line every emitter puts at the top of a generated file.
+ *
+ * Informational ON THIS PORT. It used to be documented here as the thing that "drives
+ * the overwrite policy", and it does not: `overwrite-policy.ts` decides from the
+ * `.gen-state` snapshot body and the committed hash manifest and never reads this
+ * string (grep it — no non-template module imports it). Deleting the header from a
+ * generated file does not take ownership of it here; it just changes the content, so
+ * the hash stops matching and the file is refused like any other edit.
+ *
+ * The JVM ports are the opposite: there the marker IS the decision
+ * (`GeneratedFileWriter`), and deleting it is exactly how you take ownership. Both
+ * behaviours are stated in `docs/features/own-your-codegen.md` — do not collapse them
+ * into one sentence, because the gesture that protects a file differs per port.
+ */
 export const GENERATED_HEADER = "@generated by @metaobjectsdev/codegen-ts";
 
-/** Suffix for sibling user extension files (codegen never touches these). */
-export const EXTRA_SUFFIX = ".extra";
+// `EXTRA_SUFFIX = ".extra"` was removed here. It was a public export of this package
+// wired to nothing: no generator, orphan sweep or write path ever compared a path
+// against it, so its presence implied tool support for a name that is pure convention.
+// A `<Entity>.extra.ts` sibling is safe because codegen only writes the paths it
+// records in `.gen-state/.hashes.json` — not because of its name — and the generated
+// barrel is built from the model, so it does not re-export it. Say that in prose;
+// do not re-add a constant that suggests the engine knows the name.
 
 /** Default outDir used by tests + as a sane default for generate(). */
 export const DEFAULT_OUT_DIR = "./src/db/entities";
 
 // ---------------------------------------------------------------------------
-// Codegen-control attributes.
+// Retired codegen-control attributes.
 //
-// These are per-entity opt-in/opt-out flags read by generators (NOT metamodel
-// vocabulary — they tune codegen, not the model). Named here so the literals
-// aren't scattered as magic strings across the generator packages (compile-time
-// typo safety), matching the metadata package's constants discipline.
+// `@emitRoutes` / `@emitTanstack` / `@emitForm` / `@emitGrid` / `@emitAngular`
+// were read off metadata by generator filters and were NEVER registered
+// metamodel vocabulary. The strict loader rejects every one of them with
+// ERR_UNKNOWN_ATTR — and `meta verify` loads strict — while `meta gen` loads
+// non-strict and honoured them. So an adopter who authored the documented
+// per-entity opt-out got the behaviour AND a red `meta verify`: half-working,
+// which is worse than either half, and exactly the class ADR-0023 §2 names.
+//
+// Registering them was refused. That moves `metamodelVersion` and forces a
+// four-registry publish for a TypeScript-only generator kill switch that four
+// of five ports would never read. The replacement already exists and is
+// verified end to end: decide per generator what you consume — wire only the
+// generators whose output you actually import, and narrow one with its
+// `filter` option. The one clause that was opt-IN rather than opt-out (a TPH
+// subtype's own per-subtype grid) cannot be a `filter`, since a filter is
+// ANDed with the built-in gates and can only NARROW; it is the
+// `tphSubtypeGrids` option on tanstackGrid()/tanstackGridHook() instead.
+//
+// No generator reads any of these names now. They survive HERE and nowhere
+// else, so `meta gen` can recognise a stale one still sitting in an adopter's
+// metadata and say what replaced it (see retired-codegen-attrs.ts). Keeping
+// the name and its replacement in ONE record is the point: a warning whose
+// text lives apart from the list it is warning about drifts from it.
 // ---------------------------------------------------------------------------
 
-/** `@emitTanstack: false` — skip the TanStack hooks + grid generators for an entity. */
-export const CODEGEN_ATTR_EMIT_TANSTACK = "emitTanstack";
-/** `@emitGrid: true` — opt a TPH subtype IN to its own per-subtype grid (default: the polymorphic base grid is the single source). */
-export const CODEGEN_ATTR_EMIT_GRID = "emitGrid";
-/** `@emitForm: false` — skip the React form generator for an entity. */
-export const CODEGEN_ATTR_EMIT_FORM = "emitForm";
-/** `@emitRoutes: false` — skip the Fastify routes generator for an entity. */
-export const CODEGEN_ATTR_EMIT_ROUTES = "emitRoutes";
+/** One retired codegen-control attribute, paired with what an adopter does instead. */
+export interface RetiredCodegenAttr {
+  /** The bare attribute name, as it appears in metadata (no `@` sigil). */
+  readonly name: string;
+  /** What to do instead, phrased as an instruction and naming a real API. */
+  readonly replacement: string;
+}
+
+/** Every retired codegen-control attribute. Read ONLY by the `meta gen` warning. */
+export const RETIRED_CODEGEN_ATTRS: readonly RetiredCodegenAttr[] = [
+  {
+    name: "emitRoutes",
+    replacement:
+      'drop routesFile() / routesFileHono() from `generators` in metaobjects.config.ts if ' +
+      'you do not consume REST routes, or narrow it — routesFile({ filter: (e) => e.name !== "Ledger" })',
+  },
+  {
+    name: "emitTanstack",
+    replacement:
+      'drop tanstackQuery() / tanstackGrid() / tanstackGridHook() from `generators` in ' +
+      'metaobjects.config.ts if you do not consume their output, or narrow one — ' +
+      'tanstackQuery({ filter: (e) => e.name !== "InternalAudit" })',
+  },
+  {
+    name: "emitForm",
+    replacement:
+      'drop formFile() from `generators` in metaobjects.config.ts if you do not consume ' +
+      'generated forms, or narrow it — formFile({ filter: (e) => e.name !== "InternalAudit" })',
+  },
+  {
+    name: "emitGrid",
+    replacement:
+      'pass the `tphSubtypeGrids` option — tanstackGrid({ tphSubtypeGrids: (e) => e.name === ' +
+      '"CopayAuth" }) — and pass the SAME predicate to tanstackGridHook(), or the emitted ' +
+      '<Sub>.grid.ts has no <Sub>.columns.tsx to import. This one is an opt-IN, so a `filter` ' +
+      'cannot express it: a filter is ANDed with the built-in gates and can only narrow',
+  },
+  {
+    name: "emitAngular",
+    replacement:
+      'drop angularServiceFile() / angularFormFile() / angularGridFile() from `generators` in ' +
+      'metaobjects.config.ts if you do not consume Angular output, or narrow one — ' +
+      'angularServiceFile({ filter: (e) => e.name !== "InternalAudit" })',
+  },
+] as const;

package/src/db-emitting.ts

@@ -0,0 +1,31 @@
+// Which objects make a project a DATABASE project — and therefore require a `dialect`.
+//
+// THIS IS THE ONE ANSWER, and it is hoisted here because two commands need it and a second
+// copy would be a second answer. `runGen` throws when a model emits database code and the
+// config declares no dialect (see `missingDialectMessage`), and it throws BEFORE
+// `normalizeConfig` fills its defaults on purpose: `DEFAULT_DIALECT` is INERT, existing
+// only so a value-object-only project need not name one. A DB project that forgot it gets
+// a named error rather than silently-defaulted output — "a Postgres project quietly
+// emitting sqlite", as the runner's own comment puts it.
+//
+// `meta docs` needs the same answer for `agent/schema.md`. Reading `?? DEFAULT_DIALECT`
+// there instead would document a sqlite schema for a project `meta gen` refuses to build
+// — asserting an answer the toolchain never gave.
+
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { hasAnyRdbSource } from "./source-detect.js";
+
+/** The concrete objects a run would emit database code for. Empty ⇒ no dialect needed. */
+export function dbEmittingObjects(entities: readonly MetaObject[]): MetaObject[] {
+  return entities.filter((e) => !e.isAbstract && hasAnyRdbSource(e));
+}
+
+/** The one wording for "this model needs a dialect and the config has none". */
+export function missingDialectMessage(dbEmitting: readonly MetaObject[]): string {
+  const names = dbEmitting.map((e) => e.name).join(", ");
+  return (
+    `codegen config is missing dialect — required because this model ` +
+    `generates database code for: ${names}. Set dialect in ` +
+    `metaobjects.config.ts. (A model of only value objects and/or sourceless projections may omit it.)`
+  );
+}

package/src/generator-registry.ts

@@ -18,13 +18,17 @@
 //                 door for documentation is `meta docs` (D1).
 
 import type { Generator } from "./generator.js";
+// The four ADR-0034 ownable generators are no longer exported from ./generators/index.js
+// (1.0 removed them — see that file's header). They remain the engine's internal composers
+// and the stable-name registry still constructs them, so import them from their own modules.
+import { entityFile } from "./generators/entity-file.js";
+import { queriesFile } from "./generators/queries-file.js";
+import { routesFile } from "./generators/routes-file.js";
+import { barrel } from "./generators/barrel.js";
 import {
-  entityFile,
-  queriesFile,
   callableFile,
-  routesFile,
   routesFileHono,
-  barrel,
+  namesFile,
   mermaidErDiagram,
   promptRender,
   outputParser,
@@ -111,6 +115,12 @@ export const generatorRegistry: Record<string, GeneratorRegistryEntry> = {
     factory: () => barrel(),
     options: "target?",
   },
+  names: {
+    name: "names",
+    description: "Per-entity physical database name constants (table/view, schema, columns).",
+    tier: "native",
+    factory: () => namesFile(),
+  },
   "prompt-render": {
     name: "prompt-render",
     description: "Per-template prompt-render helper over the render engine.",

package/src/generator.ts

@@ -63,6 +63,11 @@ export interface Generator {
    *  that Hono routes are actually being emitted and document them — rather than
    *  silently omitting the Hono CRUD registrars whenever the variant is wired. */
   emitsHonoRoutes?: boolean;
+  /** §A6 — marks the generator that emits the <Entity>Names artifact. The runner
+   *  aggregates this across the suite into ResolvedGenConfig.includeNames, which the
+   *  entity generator reads to decide whether it may reference those constants.
+   *  Same mechanism as emitsHonoRoutes/includeHonoRoutes. */
+  emitsNames?: boolean;
 }
 
 export type GeneratorFactory<TOpts = void> = TOpts extends void