@githolon/dsl 0.103.12 → 0.103.13

package/src/codegen_dart.ts

@@ -29,6 +29,7 @@
  * generated, so they stay reproducible from the domain definitions.
  */
 import { z } from "zod";
+import { enumTypeNameOf } from "./enum_type.js";
 import { voMetaOf, collectPayloadValueObjectDescriptors, idOfMetaOf, idOfTargetKindOf, refOfMetaOf, versionedRefOfMetaOf, brandedIdMetaOf, NOMOS_UNIT_BRAND } from "./value_object.js";
 import { recursiveTypeBaseName, zodUnwrapLazy } from "./zod_lazy.js";
 import type { AggregateHandle } from "./aggregate.js";
@@ -46,7 +47,7 @@ import { finishSum, type AnySum } from "./sum.js";
 import { finishExtremum, type AnyExtremum } from "./extremum.js";
 import { finishExists, type AnyExists } from "./exists.js";
 import type { OrderedReadDecl } from "./ordered_read.js";
-import type { DerivedDecl } from "./derived.js";
+import type { AnyDerivedDecl } from "./derived.js";
 import type { CombinedDecl } from "./combined.js";
 import { emitProviderSdk, type ImpureCapabilityDecl } from "./codegen_provider_dart.js";
 import type { WorkspaceTypeDecl } from "./workspace_type.js";
@@ -69,7 +70,10 @@ export function dartActionInputClassName(directive: AnyDirective): string {
   if (businessBirth?.aggregateId !== undefined && !isBusinessIntent(directive)) {
     return `Create${concreteClassName(businessBirth.aggregateId)}Input`;
   }
-  return `${cap(directive.id)}${isBusinessIntent(directive) ? "Input" : "Payload"}`;
+  const suffix = isBusinessIntent(directive)
+    ? directive.targetBinding === undefined ? "Input" : "Facts"
+    : "Payload";
+  return `${cap(directive.id)}${suffix}`;
 }
 
 // ---- Zod payload introspection --------------------------------------------
@@ -564,7 +568,7 @@ function introspectField(
       return { name, dartType: "bool", toJson: "scalar" };
     case "ZodEnum": {
       const values = zodEnumValues(zt);
-      const key = values.join("|");
+      const key = dartEnumLookupKey(zt);
       const dartType = enumDartTypes.get(key) ?? `${cap(name)}Enum`;
       return { name, dartType, toJson: "enum", enumValues: values };
     }
@@ -695,6 +699,8 @@ interface AggFieldSpec {
    * fields like a create's id/name).
    */
   optional: boolean;
+  /** Native read fields which should be preferred for age/status decisions over this raw clock. */
+  temporalEnumIds?: readonly string[];
   /**
    * For a `map`-kind field: the inner VALUE field's kind (`field.mapValueKind`). A
    * `"json"`-valued map (`t.map(t.json())`) is surfaced as `Map<String, Object?>` (each
@@ -1117,8 +1123,9 @@ function aggFieldSpec(
       return { name, wireName, kind: field.kind, dartType: "bool", optional };
     case "enum": {
       // Pull the enum values out of the Zod schema (unwrapping `.optional()`).
-      const values = zodEnumValues(unwrapZod(field.zod));
-      const key = values.join("|");
+      const schema = unwrapZod(field.zod);
+      const values = zodEnumValues(schema);
+      const key = dartEnumLookupKey(schema);
       const dartType = enumDartTypes.get(key) ?? `${dartTypeNameFromField(wireName)}Enum`;
       return { name, wireName, kind: field.kind, dartType, enumValues: values, optional };
     }
@@ -1202,14 +1209,17 @@ function aggregateFieldSpecs(
         : f.isFromBirth === true
           ? { ...base, optional: false }
           : { ...base, optional: true };
+      const temporalSpec: AggFieldSpec = (f.temporalEnums?.length ?? 0) > 0
+        ? { ...baseSpec, temporalEnumIds: f.temporalEnums!.map((read) => read.id) }
+        : baseSpec;
       // SURFACED MERGE CONFLICTS (architecture/surfaced_merge_conflict.md): a `.merge(Surfaced(...))`
       // field types `SurfacedValue<T>?` and decodes via `SurfacedValue.decode`. ALWAYS nullable —
       // even `.fromBirth()` (the wrapper's pending arm has no non-null plain-scalar reading).
       // aggregate() already v1-scoped the driver to Lww-class scalar kinds; excludes nullAdmits.
       const surfacedSpec: AggFieldSpec =
         (f.driver as { kind?: string } | undefined)?.kind === "Surfaced"
-          ? { ...baseSpec, optional: true, surfaced: true }
-          : baseSpec;
+          ? { ...temporalSpec, optional: true, surfaced: true }
+          : temporalSpec;
       // NULL SEMANTICS (null_semantics.md): a null-admitting scalar carries the tri-state slot.
       const nmeta = nullMetaOf(f);
       const spec: AggFieldSpec = admitsNull(f)
@@ -1290,12 +1300,14 @@ function dartNameStem(aggregateType: string): string {
 }
 
 /** Collect all enum value-sets across aggregates + directives, name each ONCE. */
-function collectEnums(
+export function collectDartEnums(
   aggregates: AggregateHandle[],
   directives: AnyDirective[],
   domainKey: string,
+  valueObjects: readonly ValueObjectDescriptor[] = [],
+  deriveds: readonly AnyDerivedDecl[] = [],
 ): { dartTypes: Map<string, string>; decls: string[] } {
-  const dartTypes = new Map<string, string>(); // "a|b|c" -> DartEnumName
+  const dartTypes = new Map<string, string>(); // structural values or declared nominal identity -> DartEnumName
   const usedNames = new Set<string>(); // every emitted enum name (collision guard)
   const decls: string[] = [];
   // Generated enum types are DOMAIN-QUALIFIED (`EstateStatusEnum`,
@@ -1310,10 +1322,20 @@ function collectEnums(
   // shared across owners keeps the FIRST owner's name (one identical type, aggregates register
   // before payloads so the aggregate's name wins). Numeric suffixes survive only as the
   // last-resort collision guard — with owner-qualified bases they should never fire.
-  const register = (preferredName: string, values: readonly string[], owner = "") => {
-    const key = values.join("|");
+  const register = (
+    preferredName: string,
+    values: readonly string[],
+    owner = "",
+    declaredName?: string,
+  ) => {
+    // Anonymous enums remain structural: the same wire vocabulary can share one
+    // generated Dart type. A declared enumType is nominal: its exported name is
+    // part of its identity, so two business concepts never collapse merely because
+    // their current wire values happen to be equal.
+    const key = dartEnumLookupKey(values, declaredName);
     if (dartTypes.has(key)) return;
-    const base = `${domainPrefix}${dartTypeNameFromField(owner)}${dartTypeNameFromField(preferredName)}`;
+    const base = declaredName ??
+      `${domainPrefix}${dartTypeNameFromField(owner)}${dartTypeNameFromField(preferredName)}`;
     let name = base;
     let n = 1;
     while (usedNames.has(name)) {
@@ -1336,29 +1358,83 @@ function collectEnums(
         `}`,
     );
   };
-  for (const agg of aggregates) {
-    for (const [name, field] of Object.entries(
-      agg.fields as Record<string, Field>,
-    )) {
-      if (field.kind === "enum") {
-        // Unwrap `.optional()` so an optional enum field still registers its options.
-        register(name, zodEnumValues(unwrapZod(field.zod)), agg.id);
+  // Named enum declarations win before anonymous occurrence-derived names, irrespective of source
+  // or aggregate ordering. Reorganising files therefore cannot rename a declared public type.
+  for (const descriptor of valueObjects) {
+    for (const field of voEnumFields(descriptor)) {
+      if (field.declaredName !== undefined) {
+        register(field.fieldName, field.values, field.owner ?? descriptor.name, field.declaredName);
       }
     }
   }
-  for (const d of directives) {
-    if (zodTypeName(d.payloadSchema as z.ZodTypeAny) !== "ZodObject") continue;
-    const shape = zodObjectShape(d.payloadSchema as z.ZodTypeAny);
-    for (const [name, zt] of Object.entries(shape)) {
-      const inner = unwrapZod(zt as z.ZodTypeAny);
-      if (zodTypeName(inner) === "ZodEnum") {
-        register(name, zodEnumValues(inner), (d as { aggregateId?: string }).aggregateId ?? d.id);
+  for (const namedPass of [true, false]) {
+    for (const agg of aggregates) {
+      for (const [name, field] of Object.entries(
+        agg.fields as Record<string, Field>,
+      )) {
+        if (field.kind === "enum") {
+          const schema = unwrapZod(field.zod);
+          const declaredName = enumTypeNameOf(schema);
+          if ((declaredName !== undefined) !== namedPass) continue;
+          register(name, zodEnumValues(schema), agg.id, declaredName);
+        }
+      }
+    }
+    for (const d of directives) {
+      if (zodTypeName(d.payloadSchema as z.ZodTypeAny) !== "ZodObject") continue;
+      const shape = zodObjectShape(d.payloadSchema as z.ZodTypeAny);
+      for (const [name, zt] of Object.entries(shape)) {
+        const inner = unwrapZod(zt as z.ZodTypeAny);
+        if (zodTypeName(inner) === "ZodEnum") {
+          const declaredName = enumTypeNameOf(inner);
+          if ((declaredName !== undefined) !== namedPass) continue;
+          register(
+            name,
+            zodEnumValues(inner),
+            (d as { aggregateId?: string }).aggregateId ?? d.id,
+            declaredName,
+          );
+        }
       }
     }
   }
+  for (const declaration of deriveds) {
+    if ("kind" in declaration && declaration.kind === "temporalEnum") {
+      register(
+        declaration.id,
+        zodEnumValues(declaration.returns),
+        declaration.of,
+      );
+    }
+  }
   return { dartTypes, decls };
 }
 
+/** Resolve an enum field to the exact nominal Dart type emitted for its value set. */
+export function dartEnumTypeForField(
+  field: Field | undefined,
+  dartTypes: ReadonlyMap<string, string>,
+): string | undefined {
+  if (field?.kind !== "enum") return undefined;
+  return dartTypes.get(dartEnumLookupKey(unwrapZod(field.zod)));
+}
+
+function dartEnumLookupKey(
+  schemaOrValues: z.ZodTypeAny | readonly string[],
+  declaredName?: string,
+): string {
+  if (Array.isArray(schemaOrValues)) {
+    return declaredName === undefined
+      ? `values:${schemaOrValues.join("|")}`
+      : `declared:${declaredName}`;
+  }
+  const schema = unwrapZod(schemaOrValues as z.ZodTypeAny);
+  const name = enumTypeNameOf(schema);
+  return name === undefined
+    ? `values:${zodEnumValues(schema).join("|")}`
+    : `declared:${name}`;
+}
+
 /** Dart reserved words that cannot be bare identifiers (enum members / fields). A
  * value like `"new"` (feedback status) collides, so it is suffixed (`new_`). */
 const DART_RESERVED = new Set([
@@ -1584,10 +1660,17 @@ function emitAggregate(
       : []),
     ...specs.flatMap((s) => {
       const doc = s.nullReason !== undefined ? [`  /// null semantic: ${s.nullReason}`] : [];
+      const temporalGuidance = s.temporalEnumIds === undefined
+        ? []
+        : [
+            `  /// Raw captured timestamp. Prefer ${s.temporalEnumIds.map((id) => `[${id}]`).join(" or ")} for age-based business/UI decisions.`,
+            `  @Deprecated('Use ${s.temporalEnumIds.join(" or ")} for age/freshness decisions; this raw timestamp is for display and audit.')`,
+          ];
       // SURFACED MERGE CONFLICTS: the field reads as the plain scalar, or [SurfacedPending]
       // while genuinely concurrent writes await a business merge (resolve = an ordinary next write).
       if (s.surfaced === true) {
         return [
+          ...temporalGuidance,
           `  /// Surfaced merge conflicts: [SurfacedResolved] steady state, [SurfacedPending] under conflict.`,
           `  final SurfacedValue<${s.dartType}>? ${s.name};`,
         ];
@@ -1808,9 +1891,9 @@ const geometryFactoryNameDart: Record<string, string> = {
  * IDENTITY = THE VO FIELD, not the value set: two identical value-sets in DIFFERENT
  * VOs stay separate types (VO names are package-unique, so so are these).
  */
-function voEnumName(voName: string, fieldName: string): string {
+function voEnumName(voName: string, fieldName: string, declaredName?: string): string {
   // SEMANTIC NAME (co2 feedback): `<VoName><Field>` — `SiteLocationSource`, not `…SourceEnum`.
-  return `${voName}${dartTypeNameFromField(fieldName)}`;
+  return declaredName ?? `${voName}${dartTypeNameFromField(fieldName)}`;
 }
 
 /** The tolerant-decode SENTINEL case name — dodge a literal enum value that would
@@ -1825,8 +1908,8 @@ function voEnumSentinel(values: readonly string[]): string {
  * a new value added by a later law must NOT crash an old client): `fromWire` maps an
  * unrecognized wire string to the [sentinel] case instead of throwing (the deliberate
  * divergence from the strict aggregate-enum `fromWire`; VO data crosses law versions). */
-function emitVoEnum(voName: string, fieldName: string, values: readonly string[]): string {
-  const name = voEnumName(voName, fieldName);
+function emitVoEnum(voName: string, fieldName: string, values: readonly string[], declaredName?: string): string {
+  const name = voEnumName(voName, fieldName, declaredName);
   const sentinel = voEnumSentinel(values);
   const variants = values.map((v) => `  ${dartIdent(v)}('${v}')`).join(",\n");
   return [
@@ -1852,10 +1935,25 @@ function emitVoEnum(voName: string, fieldName: string, values: readonly string[]
 
 /** Every (fieldName, values) enum pair a VO descriptor carries (arrays recursed —
  * an array-of-enum field's element enum is named by the FIELD). */
-function voEnumFields(d: ValueObjectDescriptor): { fieldName: string; values: readonly string[]; owner?: string }[] {
-  const out: { fieldName: string; values: readonly string[]; owner?: string }[] = [];
+function voEnumFields(d: ValueObjectDescriptor): {
+  fieldName: string;
+  values: readonly string[];
+  owner?: string;
+  declaredName?: string;
+}[] {
+  const out: {
+    fieldName: string;
+    values: readonly string[];
+    owner?: string;
+    declaredName?: string;
+  }[] = [];
   const walk = (fieldName: string, f: ValueObjectFieldDescriptor, owner?: string): void => {
-    if (f.type === "enum") out.push({ fieldName, values: f.values, ...(owner !== undefined ? { owner } : {}) });
+    if (f.type === "enum") out.push({
+      fieldName,
+      values: f.values,
+      ...(owner !== undefined ? { owner } : {}),
+      ...(f.name === undefined ? {} : { declaredName: f.name }),
+    });
     else if (f.type === "array") walk(fieldName, f.items, owner);
     else if (f.type === "map") walk(fieldName, f.values, owner);
   };
@@ -1891,7 +1989,7 @@ function dartTypeOfVoField(f: ValueObjectFieldDescriptor, voName: string, fieldN
       return "bool";
     case "enum":
       // A REAL generated Dart enum (`emitVoEnum`), named by the owning VO field.
-      return voEnumName(voName, fieldName);
+      return voEnumName(voName, fieldName, f.name);
     case "literal":
       return "String"; // surfaced as a constant getter, not a ctor param
     case "array":
@@ -1923,7 +2021,7 @@ function voFromExpr(
       return f.brand !== undefined ? `${f.brand}(${expr} as String)` : `${expr} as String`;
     case "enum":
       // TOLERANT typed decode — an unknown wire value becomes the sentinel case.
-      return `${voEnumName(voName, fieldName)}.fromWire(${expr} as String)`;
+      return `${voEnumName(voName, fieldName, f.name)}.fromWire(${expr} as String)`;
     case "number":
       if (f.unit !== undefined) return `${f.unit}((${expr} as num).toDouble())`;
       return f.int === true ? `(${expr} as num).toInt()` : `(${expr} as num).toDouble()`;
@@ -3316,7 +3414,7 @@ function parseReadModelField(s: AggFieldSpec, aggregate: string): string {
 function emitReadModel(
   agg: AggregateHandle,
   enumDartTypes: Map<string, string>,
-  deriveds: DerivedDecl[] = [],
+  deriveds: AnyDerivedDecl[] = [],
   combineds: CombinedDecl[] = [],
   refIdClassForAggregate: (aggregateType: string) => string = concreteClassName,
   ownIdFields: ReadonlySet<string> = new Set(),
@@ -3347,21 +3445,32 @@ function emitReadModel(
     `  final NomosRef<${concreteClassName(agg.id)}> ref;`,
     ...specs.flatMap((s) => {
       const doc = s.nullReason !== undefined ? [`  /// null semantic: ${s.nullReason}`] : [];
+      const temporalGuidance = s.temporalEnumIds === undefined
+        ? []
+        : [
+            `  /// Raw captured timestamp. Prefer ${s.temporalEnumIds.map((id) => `[${id}]`).join(" or ")} for age-based business/UI decisions.`,
+            `  @Deprecated('Use ${s.temporalEnumIds.join(" or ")} for age/freshness decisions; this raw timestamp is for display and audit.')`,
+          ];
       // SURFACED MERGE CONFLICTS: pending observations surface typed; resolve = ordinary next write.
       if (s.surfaced === true) {
         return [
+          ...temporalGuidance,
           `  /// Surfaced merge conflicts: [SurfacedResolved] steady state, [SurfacedPending] under conflict.`,
           `  final SurfacedValue<${readModelDartType(s)}>? ${s.name};`,
         ];
       }
       return s.nullAdmits === true
-        ? [...doc, `  final NomosSlot<${stripNullable(readModelDartType(s))}> ${s.name};`]
-        : [`  final ${readModelDartType(s)}${readModelNullableSuffix(s)} ${s.name};`];
+        ? [...doc, ...temporalGuidance, `  final NomosSlot<${stripNullable(readModelDartType(s))}> ${s.name};`]
+        : [...temporalGuidance, `  final ${readModelDartType(s)}${readModelNullableSuffix(s)} ${s.name};`];
+    }),
+    ...deriveds.map((d) => {
+      if ("kind" in d && d.kind === "temporalEnum") {
+        const values = zodEnumValues(d.returns);
+        const dartType = enumDartTypes.get(dartEnumLookupKey(d.returns)) ?? `${dartTypeNameFromField(d.id)}Enum`;
+        return `  /// Native temporal enum read field evaluated at the captured read clock.\n  final ${dartType} ${d.id};`;
+      }
+      return `  /// Engine-projected DERIVED read field (pure fn of the folded fields; NOT kernel state).\n  final ${projectionReturnDartType(d.returns)} ${d.id};`;
     }),
-    ...deriveds.map(
-      (d) =>
-        `  /// Engine-projected DERIVED read field (pure fn of the folded fields; NOT kernel state).\n  final ${projectionReturnDartType(d.returns)} ${d.id};`,
-    ),
     ...combineds.map(
       (c) =>
         `  /// Engine-projected COMBINED read field (JOIN across aggregates; NOT kernel state).\n  final ${projectionReturnDartType(c.returns)} ${c.id};`,
@@ -3380,7 +3489,11 @@ function emitReadModel(
           : `    required this.${s.name},`,
     ),
     // Derived/combined fields are always nullable (null until the engine pass runs).
-    ...deriveds.map((d) => `    this.${d.id},`),
+    ...deriveds.map((d) =>
+      "kind" in d && d.kind === "temporalEnum"
+        ? `    required this.${d.id},`
+        : `    this.${d.id},`
+    ),
     ...combineds.map((c) => `    this.${c.id},`),
   ].join("\n");
 
@@ -3418,7 +3531,14 @@ function emitReadModel(
           : `      ${s.name}: ${parseReadModelField(s, wireType)},`,
     ),
     // Derived/combined fields decode from the engine-produced bare JSON leaf.
-    ...deriveds.map((d) => `      ${d.id}: ${parseProjectionReturnField(d.id, d.returns)},`),
+    ...deriveds.map((d) => {
+      if ("kind" in d && d.kind === "temporalEnum") {
+        const values = zodEnumValues(d.returns);
+        const dartType = enumDartTypes.get(dartEnumLookupKey(d.returns)) ?? `${dartTypeNameFromField(d.id)}Enum`;
+        return `      ${d.id}: ${dartType}.fromWire(readStr(data, '${agg.id}', '${d.id}')),`;
+      }
+      return `      ${d.id}: ${parseProjectionReturnField(d.id, d.returns)},`;
+    }),
     ...combineds.map((c) => `      ${c.id}: ${parseProjectionReturnField(c.id, c.returns)},`),
   ].join("\n");
 
@@ -3470,10 +3590,15 @@ function emitDirective(
   const foreignReferenceInputs = dartForeignReferenceInputs(d, aggregates);
   const foreignReferenceIds = new Set(foreignReferenceInputs.map((input) => input.idField));
   const principalField = d.businessPrincipalField;
+  const targetBinding = isBusinessIntent(d) ? d.targetBinding : undefined;
+  const targetType = targetBinding === undefined
+    ? undefined
+    : `NomosRef<${concreteClassName(targetBinding.aggregateId)}>`;
   const derivedFields = new Set([
     ...recordInputs.flatMap((input) => [input.idField, input.workspaceField]),
     ...foreignReferenceInputs.map((input) => input.workspaceField),
     ...(principalField === undefined ? [] : [principalField]),
+    ...(targetBinding === undefined ? [] : [targetBinding.field]),
   ]);
   const publicSpecs = specs.filter((spec) => !derivedFields.has(spec.name));
   // Optional first-class relationships are OPTIONAL on the wire but REQUIRED
@@ -3483,6 +3608,9 @@ function emitDirective(
   const isOptionalReferenceChoice = (spec: PayloadFieldSpec): boolean =>
     spec.optional && spec.toJson === "ref";
   const internalPayloadArguments = [
+    ...(targetBinding === undefined
+      ? []
+      : [`required ${targetType} nmsInternalTarget`]),
     ...(principalField === undefined ? [] : ["required String nmsInternalPrincipal"]),
     ...(recordInputs.length === 0
       ? []
@@ -3541,6 +3669,9 @@ function emitDirective(
       s.nullAdmits !== true
     )
     .map((s) => `    '${s.name}': ${toJsonExpr(s, s.name)},`);
+  const targetEntry = targetBinding === undefined
+    ? []
+    : [`    '${targetBinding.field}': NmsInternalNomosRefs.id(nmsInternalTarget),`];
   const optionalLines = specs
     .filter((s) =>
       !derivedFields.has(s.name) &&
@@ -3631,6 +3762,7 @@ function emitDirective(
           `  Map<String, Object?> nmsInternalToPayloadJson(${internalPayloadSignature}) {`,
           `    final data = <String, Object?>{`,
           ...requiredEntries,
+          ...targetEntry,
           ...requiredForeignReferenceEntries,
           ...optionalLines,
           ...(principalField === undefined ? [] : [`      '${principalField}': nmsInternalPrincipal,`]),
@@ -3649,6 +3781,7 @@ function emitDirective(
       : [
           `  Map<String, Object?> nmsInternalToPayloadJson(${internalPayloadSignature}) => <String, Object?>{`,
           ...requiredEntries,
+          ...targetEntry,
           ...requiredForeignReferenceEntries,
           ...optionalLines,
           ...(principalField === undefined ? [] : [`    '${principalField}': nmsInternalPrincipal,`]),
@@ -4662,7 +4795,7 @@ export interface DomainModule {
    * read engine (`nomos_readmodel`) stores each derived value as an ordinary projected
    * field, so a reader decodes it like any other field.
    */
-  deriveds?: DerivedDecl[];
+  deriveds?: AnyDerivedDecl[];
   /**
    * The domain's ENGINE-PROJECTED COMBINED read fields (read-engine: combined read
    * fields) — the JOIN analogue of {@link deriveds}. Each is a PURE fn of ONE owner
@@ -4881,7 +5014,9 @@ export function generateDartDomain(mod: DomainModule, opts: GenerateDartDomainOp
       ? [
           emitVoHelpers(),
           ...localValueObjects.flatMap((d) => [
-            ...voEnumFields(d).map((e) => emitVoEnum(e.owner ?? d.name, e.fieldName, e.values)),
+            ...voEnumFields(d)
+              .filter((e) => e.declaredName === undefined)
+              .map((e) => emitVoEnum(e.owner ?? d.name, e.fieldName, e.values)),
             emitValueObjectClass(d),
           ]),
         ]
@@ -4906,10 +5041,12 @@ export function generateDartDomain(mod: DomainModule, opts: GenerateDartDomainOp
   const localQueries = (mod.queries ?? []).filter((q) => !skipQueryIds.has(q.id));
   // Enums are collected from the LOCALLY-emitted symbols only — a framework directive/aggregate's
   // enums ride the shared `nomos_framework.dart`, so a domain that skips them emits no dangling enum.
-  const { dartTypes, decls } = collectEnums(
+  const { dartTypes, decls } = collectDartEnums(
     localAggregates,
     localDirectives,
     domainKey,
+    localValueObjects,
+    mod.deriveds ?? [],
   );
   const refIdClassForAggregate = refIdClassResolver(mod);
   const packageAggregateDomains = opts.packageAggregateDomains ?? {};
@@ -4965,7 +5102,7 @@ export function generateDartDomain(mod: DomainModule, opts: GenerateDartDomainOp
   // `…ReadModel` ALSO carries the engine-projected derived fields its type declares (e.g.
   // `SupportSessionReadModel.isTerminal`), decoded like a normal projected field from the
   // row's `data` (the Rust read engine stores it there as a json-leaf).
-  const derivedsByType = new Map<string, DerivedDecl[]>();
+  const derivedsByType = new Map<string, AnyDerivedDecl[]>();
   for (const d of mod.deriveds ?? []) {
     const list = derivedsByType.get(d.of) ?? [];
     list.push(d);