@metaobjectsdev/codegen-ts 0.7.0-rc.1 → 0.7.0-rc.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@metaobjectsdev/codegen-ts",
-  "version": "0.7.0-rc.1",
+  "version": "0.7.0-rc.11",
   "description": "TypeScript codegen engine for MetaObjects — emits Drizzle, Zod, and Fastify artifacts.",
   "type": "module",
   "main": "./dist/index.js",
@@ -38,7 +38,7 @@
 "access": "public"
 },
 "dependencies": {
-  "@metaobjectsdev/metadata": "0.7.0-rc.1",
+  "@metaobjectsdev/metadata": "0.7.0-rc.11",
   "@biomejs/js-api": "^0.7.0",
   "@biomejs/wasm-nodejs": "^1.9.4",
   "ts-poet": "^6.10.0"
@@ -49,10 +49,11 @@
 },
 "devDependencies": {
   "@biomejs/biome": "^1.9.0",
-  "@metaobjectsdev/codegen-ts-react": "0.7.0-rc.1",
-  "@metaobjectsdev/render": "0.7.0-rc.1",
+  "@metaobjectsdev/codegen-ts-react": "0.7.0-rc.11",
+  "@metaobjectsdev/render": "0.7.0-rc.11",
   "bun-types": "latest",
   "drizzle-orm": "^0.36.0",
+  "hono": "^4.6.0",
   "typescript": "^5.6.0",
   "zod": "^3.23.0"
 }

package/src/column-mapper.ts

@@ -23,6 +23,7 @@ import {
   FIELD_ATTR_REQUIRED,
   FIELD_ATTR_UNIQUE,
   FIELD_ATTR_DEFAULT,
+  FIELD_ATTR_OBJECT_REF,
   VALIDATOR_ATTR_MAX,
 } from "@metaobjectsdev/metadata";
 import { columnNameFromField } from "./naming.js";
@@ -63,6 +64,36 @@ function isSqlExprDefault(value: string): boolean {
   return SQL_EXPR_PATTERNS.some((re) => re.test(value));
 }
 
+/**
+ * For an isArray:true field stored in SQLite as text(...,{mode:"json"}), return
+ * the TS element type used in the emitted .$type<E[]>() chain. Returns undefined
+ * when the field's subType doesn't have a stable scalar TS mapping (e.g.,
+ * field.object — leave the inferred `unknown[]` so the consumer can layer a
+ * richer schema on top).
+ */
+function sqliteJsonArrayElementTsType(subType: string): string | undefined {
+  switch (subType) {
+    case FIELD_SUBTYPE_STRING:
+    case FIELD_SUBTYPE_ENUM:
+    case FIELD_SUBTYPE_CLASS:
+    case FIELD_SUBTYPE_DATE:
+    case FIELD_SUBTYPE_TIME:
+    case FIELD_SUBTYPE_TIMESTAMP:
+    case FIELD_SUBTYPE_DECIMAL:
+      return "string";
+    case FIELD_SUBTYPE_INT:
+    case FIELD_SUBTYPE_LONG:
+    case FIELD_SUBTYPE_CURRENCY:
+    case FIELD_SUBTYPE_DOUBLE:
+    case FIELD_SUBTYPE_FLOAT:
+      return "number";
+    case FIELD_SUBTYPE_BOOLEAN:
+      return "boolean";
+    default:
+      return undefined;
+  }
+}
+
 /** Map a recognized SQL expression to its canonical raw form (uppercase keywords). */
 function canonicalizeSqlExpr(value: string): string {
   const lower = value.toLowerCase();
@@ -93,6 +124,17 @@ export interface ColumnSpec {
   leadingComment?: string;
   /** Optional CHECK constraint expression for the column (e.g., `status IN ('A', 'B')`). */
   checkConstraint?: string;
+  /**
+   * Optional `.$type<...>()` chain target. Renderer (drizzle-schema.ts) emits
+   * `.$type<TS[]>()` ahead of the modifiers chain, using ts-poet `imp()` for
+   * objectRef variants so the cross-module type import auto-hoists.
+   * `kind: "scalar"` covers string[]/number[]/boolean[] — no import needed.
+   * `kind: "objectRef"` covers SourceLens[]/Dissent[]/etc. — `module` is the
+   * relative import path to that entity's emitted module.
+   */
+  dollarTypeRef?:
+    | { kind: "scalar"; tsType: "string" | "number" | "boolean" }
+    | { kind: "objectRef"; name: string; module: string };
 }
 
 /** Resolve max length from validator.length child or @maxLength attr.
@@ -220,12 +262,36 @@ export function mapColumnType(
     }
   }
 
+  // Enum literal types: pass the values as `{ enum: [...] as const }` to
+  // Drizzle's text(...) so the inferred column type is a literal union
+  // ("a" | "b" | ...) instead of bare `string`. Skip when isArray — JSON
+  // arrays use { mode: "json" }, and the enum members go through Zod
+  // validation at the Insert/Update layer instead. Mirrors the Zod
+  // emission, which already uses z.enum([...]).
+  if (subType === FIELD_SUBTYPE_ENUM && !isArray && fnName === "text") {
+    const values = enumValues(field);
+    if (values !== undefined && values.length > 0) {
+      fnOptions = { ...(fnOptions ?? {}), enum: values };
+    }
+  }
+
   const modifiers: string[] = [];
 
   if (dialect === "postgres" && isArray) {
     modifiers.push(".array()");
   }
 
+  // SQLite stores arrays as JSON in a text column; Drizzle's text(...,{mode:"json"})
+  // infers the column as `unknown` without a $type<T>() annotation. Emit the
+  // chain via spec.dollarTypeRef so the renderer can hoist a type-only import
+  // for object refs (SourceLens[], Dissent[], etc.). Scalars (string/number/
+  // boolean) need no import. Postgres uses .array() above which is already
+  // element-typed by Drizzle.
+  // Determined ABOVE the modifiers chain so the renderer can position
+  // `.$type<>()` ahead of `.notNull()` etc.
+  // Note: dollarTypeRef is read alongside (and rendered ahead of) `modifiers`
+  // by `renderColumn` — see drizzle-schema.ts.
+
   if (isRequired(field)) {
     modifiers.push(".notNull()");
   }
@@ -258,6 +324,23 @@ export function mapColumnType(
     }
   }
 
+  // SQLite isArray columns route through {mode:"json"} above; compute the
+  // $type<E[]>() target so the renderer can hoist any cross-module imports.
+  let dollarTypeRef: ColumnSpec["dollarTypeRef"];
+  if (dialect === "sqlite" && isArray) {
+    if (subType === FIELD_SUBTYPE_OBJECT) {
+      const ref = field.ownAttr(FIELD_ATTR_OBJECT_REF);
+      if (typeof ref === "string" && ref.length > 0) {
+        dollarTypeRef = { kind: "objectRef", name: ref, module: `./${ref}.js` };
+      }
+    } else {
+      const scalar = sqliteJsonArrayElementTsType(subType);
+      if (scalar !== undefined) {
+        dollarTypeRef = { kind: "scalar", tsType: scalar as "string" | "number" | "boolean" };
+      }
+    }
+  }
+
   const result: ColumnSpec = {
     fnName,
     dbName,
@@ -267,6 +350,7 @@ export function mapColumnType(
   };
   if (fnOptions !== undefined) result.fnOptions = fnOptions;
   if (defaultExpr !== undefined) result.defaultExpr = defaultExpr;
+  if (dollarTypeRef !== undefined) result.dollarTypeRef = dollarTypeRef;
   if (leadingComment !== undefined) result.leadingComment = leadingComment;
 
   // Enum fields: emit a CHECK constraint listing the valid member values.

package/src/generators/docs-file.ts

@@ -0,0 +1,64 @@
+// docsFile() — emits `<Entity>.md` next to each generated entity module.
+//
+// Markdown is port-agnostic: the same metadata produces the same documentation
+// page regardless of dialect, output layout, or runtime target. The page covers
+// description / type / source / package preamble; storage table + identity +
+// relationships for table-backed entities; validation entry points; "used by"
+// template cross-references; and the generated-code surface (which sibling
+// files codegen produces). See `templates/docs-file.ts` for the body.
+
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { perEntity, type Generator, type GeneratorFactory } from "../generator.js";
+import { renderDocsFile } from "../templates/docs-file.js";
+import { entityOutputPath } from "../import-path.js";
+
+export interface DocsFileOpts {
+  filter?: (entity: MetaObject) => boolean;
+  target?: string;
+}
+
+export const docsFile = function docsFile(opts?: DocsFileOpts): Generator {
+  const generator: Generator = {
+    name: "docs-file",
+    generate: perEntity((entity, ctx) => {
+      if (!ctx.renderContext) {
+        throw new Error("docs-file: renderContext is required (provided by runGen)");
+      }
+      const rc = ctx.renderContext;
+      const generatorNames = readGeneratorNames(ctx);
+      return {
+        path: entityOutputPath(
+          ctx.config.outputLayout ?? "flat",
+          entity.package,
+          `${entity.name}.md`,
+        ),
+        content: renderDocsFile(entity, {
+          dialect: rc.dialect,
+          columnNamingStrategy: rc.columnNamingStrategy,
+          loadedRoot: rc.loadedRoot,
+          generatorNames,
+        }),
+      };
+    }),
+  };
+  if (opts?.filter) {
+    generator.filter = opts.filter;
+  }
+  if (opts?.target) {
+    generator.target = opts.target;
+  }
+  return generator;
+} as GeneratorFactory<DocsFileOpts>;
+
+/**
+ * `GenContext` does not currently carry the full generator list — that lives on
+ * the resolved config inside the runner. Rather than thread a new field through
+ * just to populate one optional markdown section, we always list every
+ * potential companion. The "Generated code" section becomes "files that may be
+ * generated alongside this one" — adopters cross-reference their own
+ * `metaobjects.config.ts` to confirm which they actually wired in. This matches
+ * the spec guidance "list them all and let the reader figure out which exist."
+ */
+function readGeneratorNames(_ctx: unknown): ReadonlySet<string> {
+  return new Set(["queries-file", "routes-file", "routes-file-hono"]);
+}

package/src/generators/entity-file.ts

@@ -7,9 +7,25 @@ import { entityOutputPath } from "../import-path.js";
 export interface EntityFileOpts {
   filter?: (entity: MetaObject) => boolean;
   target?: string;
+  /**
+   * Whether generated entity files include the Fastify-flavored
+   * `<Entity>FilterAllowlist` + `<Entity>SortAllowlist` blocks (and the
+   * `@metaobjectsdev/runtime-ts/drizzle-fastify` type-only imports they
+   * require). Default `true` for back-compat.
+   *
+   * Set to `false` for Worker/Lambda-style consumers that don't mount
+   * Fastify-style server routes — the generated entity file then has no
+   * `runtime-ts/drizzle-fastify` imports at all and `@metaobjectsdev/runtime-ts`
+   * can be omitted from the consumer's dependency tree.
+   *
+   * The client-side `<Entity>Filter` type is always emitted — it's a pure
+   * client-side type with no runtime-ts dependency.
+   */
+  allowlists?: boolean;
 }
 
 export const entityFile = function entityFile(opts?: EntityFileOpts): Generator {
+  const allowlists = opts?.allowlists ?? true;
   const generator: Generator = {
     name: "entity-file",
     emitsEntityModule: true,
@@ -19,7 +35,7 @@ export const entityFile = function entityFile(opts?: EntityFileOpts): Generator
       }
       return {
         path: entityOutputPath(ctx.config.outputLayout ?? "flat", entity.package, `${entity.name}.ts`),
-        content: await formatTs(renderEntityFile(entity, ctx.renderContext)),
+        content: await formatTs(renderEntityFile(entity, ctx.renderContext, { allowlists })),
       };
     }),
   };

package/src/generators/index.ts

@@ -1,7 +1,9 @@
 export { entityFile, type EntityFileOpts } from "./entity-file.js";
 export { queriesFile, type QueriesFileOpts } from "./queries-file.js";
 export { routesFile, type RoutesFileOpts } from "./routes-file.js";
+export { routesFileHono, type RoutesFileHonoOpts } from "./routes-file-hono.js";
 export { barrel, type BarrelOpts } from "./barrel.js";
 export { mermaidErDiagram, type MermaidErOptions } from "./mermaid-er.js";
 export { promptRender, type PromptRenderOpts } from "./prompt-render-file.js";
 export { outputParser, type OutputParserOpts } from "./output-parser-file.js";
+export { docsFile, type DocsFileOpts } from "./docs-file.js";

package/src/generators/prompt-render-file.ts

@@ -16,9 +16,10 @@ import {
   oncePerRun,
 } from "../generator.js";
 import {
-  generatePayloadInterfaces,
+  generatePayloadInterfacesBatch,
   generateRenderHandle,
 } from "../payload-codegen.js";
+import { GENERATED_HEADER } from "../constants.js";
 
 export interface PromptRenderOpts {
   /** Output file path relative to the target's outDir. Default: "prompts.ts". */
@@ -27,6 +28,17 @@ export interface PromptRenderOpts {
   target?: string;
 }
 
+// Hoisted into the emitted file once. generateRenderHandle() emits this line
+// per-handle (for the standalone scenario); we strip its per-handle copies.
+const RENDER_IMPORT = `import { render, type Provider } from "@metaobjectsdev/render";`;
+
+// Matches the `import type { ... } from "./payloads.js";` that generateRenderHandle
+// emits for the standalone two-file scenario. In the single-file output here the
+// payload interfaces are already defined above, so the import is dead.
+function isStandalonePayloadImport(line: string): boolean {
+  return line.startsWith("import type {") && line.includes('"./payloads.js"');
+}
+
 export const promptRender = function promptRender(opts?: PromptRenderOpts): Generator {
   const outFile = opts?.outFile ?? "prompts.ts";
   const generator: Generator = {
@@ -41,21 +53,35 @@ export const promptRender = function promptRender(opts?: PromptRenderOpts): Gene
         return [];
       }
 
-      const parts: string[] = [];
-      for (const p of payloads) {
-        parts.push(generatePayloadInterfaces(ctx.loadedRoot, p.name));
+      const parts: string[] = [`// ${GENERATED_HEADER} — DO NOT EDIT.`];
+
+      // Hoist the @metaobjectsdev/render import once (only when prompts emit handles).
+      if (prompts.length > 0) {
+        parts.push(RENDER_IMPORT);
+      }
+
+      // Emit payload interfaces with a single shared dedupe set so a lens
+      // referenced by multiple payloads appears exactly once.
+      const payloadInterfaces = generatePayloadInterfacesBatch(
+        ctx.loadedRoot,
+        payloads.map((p) => p.name),
+      );
+      if (payloadInterfaces.length > 0) {
+        parts.push(payloadInterfaces);
       }
-      // Strip the `import type { ... } from "./payloads.js"` line that
-      // generateRenderHandle() emits for the standalone two-file scenario.
-      // In the single-file output here the payload interfaces are already
-      // defined above, so the import is a self-reference to a non-existent module.
+
+      // Append each render handle with its per-handle imports stripped — both
+      // the now-hoisted render/Provider import and the standalone payloads.js
+      // import. Also drop any leading blank lines left behind by the strip so
+      // the joined output doesn't accumulate double blank gaps between parts.
       for (const t of prompts) {
-        const handle = generateRenderHandle(ctx.loadedRoot, t.name)
+        const lines = generateRenderHandle(ctx.loadedRoot, t.name)
           .split("\n")
-          .filter((line) => !line.startsWith("import type {") || !line.includes("./payloads.js"))
-          .join("\n");
-        parts.push(handle);
+          .filter((line) => line !== RENDER_IMPORT && !isStandalonePayloadImport(line));
+        while (lines.length > 0 && lines[0]!.trim() === "") lines.shift();
+        parts.push(lines.join("\n"));
       }
+
       return [{
         path: outFile,
         content: parts.filter((s) => s.length > 0).map((s) => s.trimEnd()).join("\n\n") + "\n",

package/src/generators/queries-file.ts

@@ -1,4 +1,4 @@
-import type { MetaObject } from "@metaobjectsdev/metadata";
+import { OBJECT_SUBTYPE_VALUE, type MetaObject } from "@metaobjectsdev/metadata";
 import { perEntity, type Generator, type GeneratorFactory } from "../generator.js";
 import { renderQueriesFile } from "../templates/queries-file.js";
 import { formatTs } from "../format.js";
@@ -9,9 +9,21 @@ export interface QueriesFileOpts {
   target?: string;
 }
 
+// object.value records have no primary identity, so the rendered queries module
+// emits findById/updateById/deleteById against a non-existent column. Skipping
+// value subtypes is unconditional — the user-supplied filter (if any) is applied
+// on top via boolean AND.
+const skipValueTypes = (e: MetaObject): boolean => e.subType !== OBJECT_SUBTYPE_VALUE;
+
 export const queriesFile = function queriesFile(opts?: QueriesFileOpts): Generator {
+  const userFilter = opts?.filter;
+  const filter: (e: MetaObject) => boolean = userFilter
+    ? (e) => skipValueTypes(e) && userFilter(e)
+    : skipValueTypes;
+
   const generator: Generator = {
     name: "queries-file",
+    filter,
     generate: perEntity(async (entity, ctx) => {
       if (!ctx.renderContext) {
         throw new Error("queries-file: renderContext is required (provided by runGen)");
@@ -22,9 +34,6 @@ export const queriesFile = function queriesFile(opts?: QueriesFileOpts): Generat
       };
     }),
   };
-  if (opts?.filter) {
-    generator.filter = opts.filter;
-  }
   if (opts?.target) {
     generator.target = opts.target;
   }

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

@@ -0,0 +1,48 @@
+import type { MetaObject } from "@metaobjectsdev/metadata";
+import { perEntity, type Generator, type GeneratorFactory } from "../generator.js";
+import { renderRoutesFileHono } from "../templates/routes-file-hono.js";
+import { formatTs } from "../format.js";
+import { entityOutputPath } from "../import-path.js";
+
+export interface RoutesFileHonoOpts {
+  filter?: (entity: MetaObject) => boolean;
+  target?: string;
+}
+
+/**
+ * Hono variant of routesFile() — emits `<Entity>.routes.hono.ts` mounting
+ * the same five CRUD verbs (GET list / GET :id / POST / PATCH+PUT / DELETE)
+ * against `@metaobjectsdev/runtime-ts/hono` rather than `…/drizzle-fastify`.
+ *
+ * Same cross-port wire contract (envelope shape, status codes, filter +
+ * sort + withCount semantics) as the Fastify flavor. Workers / Bun / Node
+ * consumers running Hono can replace hand-written route registration with
+ * this generator output one entity at a time.
+ *
+ * Per-entity opt-out via `@emitRoutes: false` is honored. If the user
+ * supplies their own filter, both must pass (AND).
+ */
+export const routesFileHono = function routesFileHono(opts?: RoutesFileHonoOpts): Generator {
+  const userFilter = opts?.filter ?? (() => true);
+  const generator: Generator = {
+    name: "routes-file-hono",
+    filter: (e: MetaObject) => e.ownAttr("emitRoutes") !== false && userFilter(e),
+    generate: perEntity(async (entity, ctx) => {
+      if (!ctx.renderContext) {
+        throw new Error("routes-file-hono: renderContext is required (provided by runGen)");
+      }
+      return {
+        path: entityOutputPath(
+          ctx.config.outputLayout ?? "flat",
+          entity.package,
+          `${entity.name}.routes.hono.ts`,
+        ),
+        content: await formatTs(renderRoutesFileHono(entity, ctx.renderContext)),
+      };
+    }),
+  };
+  if (opts?.target) {
+    generator.target = opts.target;
+  }
+  return generator;
+} as GeneratorFactory<RoutesFileHonoOpts>;

package/src/index.ts

@@ -9,7 +9,7 @@ export type { RunGenOpts, RunGenResult } from "./runner.js";
 export type { Generator, GenContext, EmittedFile, GeneratorFactory } from "./generator.js";
 export { perEntity, oncePerRun } from "./generator.js";
 
-export type { MetaobjectsGenConfig, NormalizedMetaobjectsGenConfig, ResolvedGenConfig, Dialect, ExtStyle, ColumnNamingStrategy } from "./metaobjects-config.js";
+export type { MetaobjectsGenConfig, NormalizedMetaobjectsGenConfig, ResolvedGenConfig, Dialect, ExtStyle, ColumnNamingStrategy, MetaDataTypeProvider } from "./metaobjects-config.js";
 export { defineConfig, normalizeConfig } from "./metaobjects-config.js";
 
 export type { ColumnSpec, DefaultExpr } from "./column-mapper.js";
@@ -44,4 +44,4 @@ export { emitViewDdl } from "./projection/view-ddl-emit.js";
 export type { EmitOptions as ViewDdlEmitOptions } from "./projection/view-ddl-emit.js";
 export type { JoinNode, JoinTree, SelectColumn, SelectSpec, ViewSpec } from "./projection/view-spec.js";
 // Prompt construction (FR-004): typed payload + render-handle codegen.
-export { generatePayloadInterfaces, generateRenderHandle } from "./payload-codegen.js";
+export { generatePayloadInterfaces, generatePayloadInterfacesBatch, generateRenderHandle } from "./payload-codegen.js";

package/src/metaobjects-config.ts

@@ -1,11 +1,11 @@
-import { DEFAULT_COLUMN_NAMING_STRATEGY, type ColumnNamingStrategy } from "@metaobjectsdev/metadata";
+import { DEFAULT_COLUMN_NAMING_STRATEGY, type ColumnNamingStrategy, type MetaDataTypeProvider } from "@metaobjectsdev/metadata";
 import type { Generator } from "./generator.js";
 import type { ExtStyle } from "./render-context.js";
 import type { OutputLayout, ResolvedTarget } from "./import-path.js";
 
 export type Dialect = "sqlite" | "postgres";
 /** Re-exported from metadata so codegen-ts consumers see one canonical type. */
-export type { ColumnNamingStrategy } from "@metaobjectsdev/metadata";
+export type { ColumnNamingStrategy, MetaDataTypeProvider } from "@metaobjectsdev/metadata";
 export type { ExtStyle };
 export type { OutputLayout };
 export type { ResolvedTarget };
@@ -41,6 +41,13 @@ export interface MetaobjectsGenConfig extends ResolvedGenConfig {
   targets?: Record<string, TargetConfig>;
   /** importBase for the default target (top-level outDir). */
   importBase?: string;
+  /**
+   * Consumer-supplied {@link MetaDataTypeProvider}s. Threaded to `loadMemory`
+   * by the CLI's gen/migrate commands so a project can register its own
+   * subtypes/attrs (e.g. a `template.toolcall` subtype) without forking the
+   * loader. Composed AFTER the default core+forge bundle.
+   */
+  providers?: readonly MetaDataTypeProvider[];
 }
 
 /** MetaobjectsGenConfig after applying defaults. All fields required.

package/src/payload-codegen.ts

@@ -17,6 +17,7 @@ import {
   TYPE_TEMPLATE,
   FIELD_SUBTYPE_OBJECT,
   FIELD_ATTR_OBJECT_REF,
+  FIELD_ATTR_REQUIRED,
   TEMPLATE_ATTR_PAYLOAD_REF,
   TEMPLATE_ATTR_TEXT_REF,
   TEMPLATE_ATTR_FORMAT,
@@ -55,7 +56,13 @@ function fieldTsType(field: MetaData): { type: string; refVo?: string } {
     if (typeof ref === "string") result.refVo = ref;
     return result;
   }
-  return { type: SCALAR_TS[field.subType] ?? "unknown" };
+  const scalar = SCALAR_TS[field.subType] ?? "unknown";
+  return { type: field.isArray ? `${scalar}[]` : scalar };
+}
+
+/** True iff the field's @required is explicitly set to true. */
+function isFieldRequired(field: MetaData): boolean {
+  return field.ownAttr(FIELD_ATTR_REQUIRED) === true;
 }
 
 function emitInterface(root: MetaData, voName: string, emitted: Set<string>, out: string[]): void {
@@ -67,7 +74,15 @@ function emitInterface(root: MetaData, voName: string, emitted: Set<string>, out
   const refs: string[] = [];
   for (const f of vo.children().filter((c) => c.type === TYPE_FIELD)) {
     const { type, refVo } = fieldTsType(f);
-    lines.push(`  ${f.name}: ${type};`);
+    // Required fields: `name: T;`
+    // Optional fields: `name?: T | null;` — the `| null` lets values from
+    // Drizzle entity rows (which return `null` for nullable columns) flow
+    // straight in. Without it, TS treats undefined-vs-null as a hard error
+    // at the entity → payload boundary.
+    const isRequired = isFieldRequired(f);
+    const tsType = isRequired ? type : `${type} | null`;
+    const optional = isRequired ? "" : "?";
+    lines.push(`  ${f.name}${optional}: ${tsType};`);
     if (refVo) refs.push(refVo);
   }
   lines.push("}");
@@ -82,6 +97,23 @@ export function generatePayloadInterfaces(root: MetaData, voName: string): strin
   return out.join("\n\n") + "\n";
 }
 
+/**
+ * Emit interfaces for several payloads at once, using a single shared dedupe
+ * set so nested types (e.g. lens projections referenced by multiple payloads)
+ * appear exactly once in the combined output.
+ *
+ * Returns the empty string when `voNames` is empty.
+ */
+export function generatePayloadInterfacesBatch(root: MetaData, voNames: readonly string[]): string {
+  if (voNames.length === 0) return "";
+  const out: string[] = [];
+  const emitted = new Set<string>();
+  for (const name of voNames) {
+    emitInterface(root, name, emitted, out);
+  }
+  return out.length === 0 ? "" : out.join("\n\n") + "\n";
+}
+
 function pascal(s: string): string {
   return s.length > 0 ? s[0]!.toUpperCase() + s.slice(1) : s;
 }

package/src/source-detect.ts

@@ -0,0 +1,28 @@
+// Source-detect helpers — discriminate table-backed entities from value-only
+// objects (and other in-memory / transit shapes) by inspecting source.* children.
+//
+// Used by the entity-file composer to pick a streamlined "value-only" emission
+// path for metaobjects that declare no writable relational source. Pure
+// metadata-driven, not a typeId discriminator: any object subtype can opt out
+// of Drizzle table emission simply by omitting source.rdb.
+
+import { MetaSource } from "@metaobjectsdev/metadata";
+import { TYPE_SOURCE, SOURCE_SUBTYPE_RDB } from "@metaobjectsdev/metadata";
+import type { MetaObject } from "@metaobjectsdev/metadata";
+
+/**
+ * True when the entity declares at least one writable source.rdb child.
+ * Discriminates table-backed entities (full Drizzle file: table + Insert/Update
+ * schemas + filter allowlists + constants) from value-only objects (TS
+ * interface + Zod schema only). Absence of source.rdb means in-memory /
+ * transit data — no migration, no ORM table to point at.
+ */
+export function hasWritableRdbSource(entity: MetaObject): boolean {
+  for (const child of entity.ownChildren()) {
+    if (child.type !== TYPE_SOURCE) continue;
+    if (child.subType !== SOURCE_SUBTYPE_RDB) continue;
+    if (!(child instanceof MetaSource)) continue;
+    if (child.isWritable()) return true;
+  }
+  return false;
+}