@aurorajs.dev/catalyst-cli 1.1.3 → 2.0.0

package/dist/templates/codegen/frontend/module/__module_name__/features/__module_name__-form.component.ts.eta

@@ -25,7 +25,6 @@
   // ================================================================
   // Detect which field types are present (for conditional imports).
   // ================================================================
-  const formFields = it.filters.getFormDetailFieldsProperties(it.schema.aggregateProperties);
   const formGroupFields = it.filters.getFormGroupFieldsProperties(it.schema.aggregateProperties);
 
   // SPEC-12: tabs are only honored in view mode. Dialog mode emits a codegen
@@ -37,13 +36,13 @@
   const tabIds = useFormTabs ? it.filters.getTabsFromProperties(it.schema.aggregateProperties) : [];
 
   // Per-tab metadata used to emit signals, computeds, and findFirstTabWithErrors.
+  // getEmittedFormFieldsForTab consults the SAME predicate form-body.eta
+  // dispatches through (isFormFieldRenderable), so a field with no dispatch
+  // branch (e.g. a bare jsonb) or one excluded upstream (GRID_SELECT_MULTIPLE_ELEMENTS)
+  // never feeds a tab's HasErrors computed.
   const tabMeta = tabIds.map(id => {
     const fieldNames = it.filters
-      .getFormDetailFieldsPropertiesForTab(it.schema.aggregateProperties, id)
-      .filter(p => it.predicates.isAllowProperty(it.schema.moduleName, p))
-      .filter(p => !(p.type === it.propertyType.ID && !p.widget))
-      .filter(p => p.widget?.type !== it.widgetType.GRID_ELEMENTS_MANAGER)
-      .filter(p => p.widget?.type !== it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS)
+      .getEmittedFormFieldsForTab(it.schema.moduleName, it.schema.aggregateProperties, id)
       .map(p => it.fmt.toCamelCase(it.mappers.getPropertyName(p)));
     return {
       id,
@@ -79,23 +78,33 @@
     it.widgetType.ASYNC_MULTIPLE_SEARCH_SELECT,
   ]);
 
-  // Properties that render via a basic-type partial (fields directory) — exclude
-  // primary-key ids without widget (canonical form-body filter) AND
-  // exclude relational widgets (those go through relationship partials,
-  // which carry their own imports).
-  const renderedFields = formFields.filter(p =>
-    !(p.type === it.propertyType.ID && !p.widget) &&
+  // Properties that ACTUALLY emit markup in form-body.eta's dispatch — the
+  // SAME predicate the body itself consults (it.filters.isFormFieldRenderable),
+  // so this import gate and the body can never drift again. In the tabbed
+  // flow the body only ever draws fields grouped per tab, so a renderable
+  // field with no widget.tab (or one outside the aggregate's declared tabs)
+  // is excluded too — it would otherwise open import gates for a control
+  // that never renders.
+  const emittedFormFields = it.filters.getEmittedFormFields(
+    it.schema.moduleName,
+    it.schema.aggregateProperties,
+    useFormTabs,
+  );
+
+  // Properties that render via a basic-type partial (fields directory) —
+  // relational widgets go through relationship partials instead, which
+  // carry their own imports.
+  const renderedFields = emittedFormFields.filter(p =>
     !RELATIONAL_TYPES.has(p.widget?.type)
   );
 
   // Properties that render via a relationship partial (5 SPEC-09 types).
-  // grid-select-multiple-elements is excluded: it renders OUTSIDE the form
-  // in the detail shell as its own <section hlmCard>, so the form has no
-  // I/O contract for it (returns to a dumb leaf — no 10-port passthrough).
-  const relationalFields = formFields.filter(p =>
-    p.relationship &&
-    RELATIONAL_TYPES.has(p.widget?.type) &&
-    p.widget?.type !== it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS
+  // grid-select-multiple-elements never reaches emittedFormFields — excluded
+  // by isFormFieldRenderable, since it renders OUTSIDE the form in the
+  // detail shell as its own <section hlmCard> (the form has no I/O contract
+  // for it — returns to a dumb leaf, no 10-port passthrough).
+  const relationalFields = emittedFormFields.filter(p =>
+    p.relationship && RELATIONAL_TYPES.has(p.widget?.type)
   );
 
   // Per-relation metadata used downstream to declare inputs/computeds.
@@ -104,6 +113,7 @@
     const relSingular = it.fmt.toCamelCase(relRaw);
     const relPascal = it.fmt.toPascalCase(relRaw);
     const targetAggregate = p.relationship.aggregateName;
+    const needsItemToString = p.widget.type === it.widgetType.SELECT || p.widget.type === it.widgetType.MULTIPLE_SELECT;
     return {
       property: p,
       propCamel: it.fmt.toCamelCase(it.mappers.getPropertyName(p)),
@@ -116,7 +126,14 @@
       // upstream — it renders in the detail shell, not in the form.
       needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT,
       needsOnSearch: ASYNC_SEARCH_SELECT_TYPES.has(p.widget.type),
-      needsItemToString: p.widget.type === it.widgetType.SELECT || p.widget.type === it.widgetType.MULTIPLE_SELECT,
+      needsItemToString,
+      // Resolved through the same cross-schema helper select.eta/multiple-select.eta
+      // use, so the trigger's itemToString matches the option list they render.
+      // Falls back to the default when the relationship carries no modulePath (a
+      // synthetic/test property, or a not-yet-resolved cross-BC relation).
+      displayFieldTemplate: needsItemToString && p.relationship?.modulePath
+        ? it.crossSchema.getTargetDisplayFieldTemplate(p.relationship.modulePath)
+        : '{name}',
     };
   });
 
@@ -124,7 +141,12 @@
   // These need an Option[] input declared (the partial already binds [options]="propCamel()").
   // Scoped to SEARCH_SELECT_TYPES only: select/multiple-select/grid-select-element partials
   // compute relSingular+Options unconditionally and do NOT support the no-relationship path.
-  const scalarArrayRelFields = formFields.filter(p =>
+  // Based on emittedFormFields (not the wider visible set): hasSearchSelectField and its
+  // three siblings below OR-in scalarArrayRelFields, so it IS an import gate and must honor
+  // the same tab-scoped emission set. A search-select-family widget already passes
+  // isFormFieldRenderable (the widget branch is checked before the array type branch), so in a
+  // non-tabbed form both sets hold the same properties.
+  const scalarArrayRelFields = emittedFormFields.filter(p =>
     p.type === it.propertyType.ARRAY &&
     !p.relationship &&
     SEARCH_SELECT_TYPES.has(p.widget?.type)
@@ -154,7 +176,14 @@
   // imported from @angular/forms/signals via signalFormValidatorNames below —
   // no longer the hand-authored arrayMinLengthValidator from @aurora.
 
-  const hasAnyRenderedField = renderedFields.length > 0;
+  // <hlm-field> and `| validationMessage` (field-errors.eta) are emitted by
+  // every field partial — the 9 under partials/fields/ (all but
+  // boolean-field.eta, whose control needs no ValidationMessagePipe) AND the
+  // 6 under partials/relationships/ — so both gates below key on the FULL
+  // emitted set, not the scalar-only renderedFields.
+  const hasAnyEmittedField = emittedFormFields.length > 0;
+  const hasAnyNonBooleanEmittedField = emittedFormFields.some(p => p.type !== 'boolean');
+
   const hasTextField = renderedFields.some(p => p.type === 'text');
   const hasBooleanField = renderedFields.some(p => p.type === 'boolean');
   const hasEnumField = renderedFields.some(p => p.type === 'enum' || (p.type === 'array' && p.arrayOptions?.type === 'enum'));
@@ -163,7 +192,32 @@
   const hasPasswordField = renderedFields.some(p => p.type === 'password');
   const hasColorPickerField = renderedFields.some(p => p.widget?.type === it.widgetType.COLOR_PICKER);
   const hasInputField = renderedFields.some(p => ['varchar', 'char', 'int', 'smallint', 'bigint', 'decimal', 'float', 'timestamp'].includes(p.type));
-  const hasNonBooleanField = renderedFields.some(p => p.type !== 'boolean');
+
+  // Build the emitted controls once (M2M opts in only with a widget; same
+  // allow gate), so the signal model type, its defaults, the form() schema
+  // and the @aurora imports the class body needs all stay in lockstep.
+  // Computed here, ahead of the import gates, because the model has NO tab
+  // dimension: it is derived from formGroupFields, not from the tab-scoped
+  // emittedFormFields the template body renders.
+  const emittedFields = formGroupFields
+    .filter((property) => {
+      const isM2m = property.relationship?.type === 'many-to-many';
+      const m2mGateOpen =
+        !isM2m ||
+        (Boolean(property.widget?.type) &&
+          property.widget?.type !== it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS);
+      return m2mGateOpen && it.predicates.isAllowProperty(it.schema.moduleName, property, { allowManyToManyRelationShip: true });
+    })
+    .map((property) => {
+      const name = it.fmt.toCamelCase(it.mappers.getPropertyName(property));
+      return {
+        property,
+        name,
+        valueType: it.pickModel.getControlValueType(property),
+        default: it.pickModel.getPickModelDefault(property),
+        validators: it.validators.getSignalFormValidators(property, 'path.' + name),
+      };
+    });
 
   // ================================================================
   // Build imports array — dumb form, no Apollo / no router / no shell helpers
@@ -187,8 +241,11 @@
       })
       .flatMap((property) => it.validators.getSignalFormValidatorNames(property))
   )].sort();
-  // `form`, `FormField` and `submit` are always needed for a Signal Form.
-  const signalsImports = ['form', 'FormField', 'submit', ...signalFormValidatorNames];
+  // `form` and `submit` drive the class body unconditionally (the model and
+  // the submit() method exist even with zero controls). `FormField` is a
+  // template-only directive — needed only when a control actually binds it.
+  const signalsImports = ['form', 'submit', ...signalFormValidatorNames];
+  if (hasAnyEmittedField) signalsImports.push('FormField');
 
   /* D3: non-translatable fields (getNotI18nProperties — existing helper, no new
      one invented) are disabled when editing a translation whose language is
@@ -197,10 +254,22 @@
   const notI18nFieldNames = it.isI18n
     ? new Set(it.filters.getNotI18nProperties(formGroupFields).map((property) => it.fmt.toCamelCase(it.mappers.getPropertyName(property))))
     : new Set();
-  if (it.isI18n) signalsImports.push('disabled');
+  // createOnly (add-create-only-property-semantics): the control stays
+  // editable in `new` mode and is disabled in `edit` mode via the same
+  // `disabled()` primitive i18n already uses — never a read-only marker,
+  // which is silently dropped on non-native controls (design D7).
+  // Checking the plain `formGroupFields` (not the m2m/isAllowProperty-
+  // filtered set the emission loop below computes as `emittedFields`) is
+  // safe here: the loader refuses `createOnly` on every `type: 'relationship'`
+  // property (many-to-many, one-to-many/one-to-one navigation —
+  // `schema-loader.ts`), so a createOnly field can only be a plain scalar or
+  // a many-to-one FK's scalar entry, and the m2m/isAllowProperty filter
+  // never excludes either of those — it has nothing left to filter out.
+  const hasCreateOnlyFormFields = it.filters.hasCreateOnlyProperties(formGroupFields);
+  if (it.isI18n || hasCreateOnlyFormFields) signalsImports.push('disabled');
 
   const auroraImports = [];
-  if (hasNonBooleanField) auroraImports.push('ValidationMessagePipe');
+  if (hasAnyNonBooleanEmittedField) auroraImports.push('ValidationMessagePipe');
   if (hasAnySearchSelectField) auroraImports.push('ToOptionsPipe');
   if (hasSearchSelectField) auroraImports.push('SearchSelect');
   if (hasMultipleSearchSelectField) auroraImports.push('MultipleSearchSelect');
@@ -215,12 +284,13 @@
   if (hasDateField) auroraImports.push('DatePicker');
   // DateTime fields render via <au-datetime-picker> (@aurora).
   if (hasDateTimeField) auroraImports.push('DateTimePicker');
-  /* The server applies no formatting to a date field, so a read yields the raw
-     Postgres timestamptz text while the write side demands the canonical shape.
-     The model is seeded through these normalizers so an untouched field still
-     round-trips something the server accepts. */
-  if (hasDateField) auroraImports.push('toWireDate');
-  if (hasDateTimeField) auroraImports.push('toWireDateTime');
+  /* GraphQLISODateTime is a passthrough (no @Scalar() implementation), so the
+     Postgres driver's raw text reaches the browser unchanged — a dateTime
+     reads back as "2026-08-30 22:00:00+00". That text always carries an
+     explicit offset, and both the picker (valueAsDate: new Date(iso)) and the
+     server's write handler (DateTimeTypeHandler.sanitize) parse it correctly
+     on their own: nothing is normalized on the way into the form model. Do
+     not reintroduce a wrapper for date or dateTime. */
   // Color-picker fields render via <au-color-picker> (@aurora) — a Signal Forms-native
   // FormValueControl wrapper for hex color selection.
   if (hasColorPickerField) auroraImports.push('ColorPickerImports');
@@ -248,8 +318,10 @@
     importsArray.push({ items: ['environment'], path: 'environments/environment' });
   }
 
-  // Conditional Spartan imports — only emit what at least one rendered field uses.
-  if (hasAnyRenderedField) {
+  // Conditional Spartan imports — only emit what at least one emitted field uses.
+  // <hlm-field> wraps every field/relationship partial, so this gates on the
+  // full emitted set, not the scalar-only renderedFields.
+  if (hasAnyEmittedField) {
     importsArray.push({ items: ['HlmFieldImports'], path: '@spartan-ng/helm/field' });
   }
   if (hasInputField) {
@@ -272,12 +344,11 @@
   // ================================================================
   // Build component imports list for @Component.imports — mirrors importsArray
   // ================================================================
-  const componentImports = [
-    'FormField',
-    'TranslocoDirective',
-  ];
-  if (hasNonBooleanField) componentImports.push('ValidationMessagePipe');
-  if (hasAnyRenderedField) componentImports.push('HlmFieldImports');
+  const componentImports = [];
+  if (hasAnyEmittedField) componentImports.push('FormField');
+  componentImports.push('TranslocoDirective');
+  if (hasAnyNonBooleanEmittedField) componentImports.push('ValidationMessagePipe');
+  if (hasAnyEmittedField) componentImports.push('HlmFieldImports');
   if (hasInputField) componentImports.push('HlmInputImports');
   if (hasTextField) componentImports.push('HlmTextareaImports');
   if (hasBooleanField) componentImports.push('HlmSwitchImports');
@@ -319,6 +390,18 @@ export class <%= modPascal %>FormComponent {
   // inputs
   readonly initial = input<<%= aggregate %> | null>(null);
   readonly mode = input.required<'new' | 'edit'>();
+  // createOnly (add-create-only-property-semantics): distinct from `mode`,
+  // which stays the ROUTE/presentation mode — it drives the verb and title
+  // upstream (view-frame.eta, the detail shell's breadcrumb) and is
+  // untouched by this input. `transportMode`, when bound, is the mode this
+  // save actually travels as. The two diverge on an embedded-i18n
+  // aggregate's "create the first translation of an EXISTING row" route
+  // (`new/:id/:langId`): the route mode is 'new', but the row already
+  // exists, so the save goes out as an update. Optional and always
+  // declared (like `mode`) — falls back to `mode()` wherever the caller has
+  // nothing different to report, which is every non-i18n or table-strategy
+  // caller.
+  readonly transportMode = input<'new' | 'edit'>();
 <% if (it.isI18n) { -%>
   // D3: true while editing a translation whose language is not the base one —
   // disables every field in getNotI18nProperties (only the isI18n fields stay editable).
@@ -356,7 +439,9 @@ export class <%= modPascal %>FormComponent {
 <% if (hasSelectField) { -%>
 
 <% for (const meta of relMeta) { -%>
-<% if (meta.needsItemToString) { -%>
+<% if (meta.needsItemToString && meta.displayFieldTemplate !== '{name}') { -%>
+  protected readonly <%= meta.relSingular %>ItemToString = itemLabelOf(this.<%= meta.relSingular %>Options, '<%= meta.displayFieldTemplate %>');
+<% } else if (meta.needsItemToString) { -%>
   protected readonly <%= meta.relSingular %>ItemToString = itemLabelOf(this.<%= meta.relSingular %>Options);
 <% } -%>
 <% } -%>
@@ -369,30 +454,15 @@ export class <%= modPascal %>FormComponent {
 <% } -%>
 <% } -%>
 <%_
-  // Build the emitted controls once (M2M opts in only with a widget; same
-  // allow gate), so the signal model type, its defaults, and the form() schema
-  // stay in lockstep.
-  const emittedFields = formGroupFields
-    .filter((property) => {
-      const isM2m = property.relationship?.type === 'many-to-many';
-      const m2mGateOpen =
-        !isM2m ||
-        (Boolean(property.widget?.type) &&
-          property.widget?.type !== it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS);
-      return m2mGateOpen && it.predicates.isAllowProperty(it.schema.moduleName, property, { allowManyToManyRelationShip: true });
-    })
-    .map((property) => {
-      const name = it.fmt.toCamelCase(it.mappers.getPropertyName(property));
-      return {
-        property,
-        name,
-        valueType: it.pickModel.getControlValueType(property),
-        default: it.pickModel.getPickModelDefault(property),
-        validators: it.validators.getSignalFormValidators(property, 'path.' + name),
-      };
-    });
   const hasAnyValidator = emittedFields.some((f) => f.validators.length > 0);
 
+  // createOnly (add-create-only-property-semantics): the field stays in the
+  // model/initializer/validators in BOTH modes (unlike readOnly, which is
+  // filtered out upstream) — only the disabled state of the control and the
+  // emitted payload differ by mode.
+  const createOnlyFields = emittedFields.filter((f) => f.property.createOnly === true);
+  const hasCreateOnlyFields = createOnlyFields.length > 0;
+
   // Embedded i18n fields (design.md — this fix): the model keeps the SCALAR
   // control name (e.g. `label`) as the editable field, but its initial value
   // and its submit payload are sliced from / merged into the full per-locale
@@ -430,10 +500,6 @@ export class <%= modPascal %>FormComponent {
       <%= f.name %>: (init?.<%= f.name %> ?? []).flatMap((v) => (v != null ? [v] : [])),
 <% } else if (f.property.relationship?.type === 'many-to-many') { -%>
       <%= f.name %>: (init?.<%= it.fmt.toCamelCase(f.property.name) %> ?? []).flatMap((item) => (item?.id ? [item.id] : [])),
-<% } else if (f.property.type === it.propertyType.DATE) { -%>
-      <%= f.name %>: toWireDate(init?.<%= f.name %>),
-<% } else if (f.property.type === it.propertyType.DATE_TIME) { -%>
-      <%= f.name %>: toWireDateTime(init?.<%= f.name %>),
 <% } else { -%>
       <%= f.name %>: init?.<%= f.name %> ?? <%= f.default %>,
 <% } -%>
@@ -441,7 +507,7 @@ export class <%= modPascal %>FormComponent {
     };
   });
 
-<% if (hasAnyValidator || it.isI18n) { -%>
+<% if (hasAnyValidator || it.isI18n || hasCreateOnlyFields) { -%>
   readonly signalForm = form(this.model, (path) => {
 <% for (const f of emittedFields) { -%>
 <% for (const validator of f.validators) { -%>
@@ -454,6 +520,9 @@ export class <%= modPascal %>FormComponent {
     disabled(path.<%= f.name %>, { when: () => this.disableNotI18nFields() });
 <% } -%>
 <% } -%>
+<% } -%>
+<% for (const f of createOnlyFields) { -%>
+    disabled(path.<%= f.name %>, { when: () => (this.transportMode() ?? this.mode()) === 'edit' });
 <% } -%>
   });
 <% } else { -%>
@@ -494,9 +563,31 @@ export class <%= modPascal %>FormComponent {
       }
 <% } -%>
 <% } -%>
+
+<%_
+  // createOnly (add-create-only-property-semantics): the emitted payload
+  // must omit the key entirely in edit mode, never null/undefined it. Never
+  // ALSO embedded-i18n: the loader refuses `isI18n` + `createOnly`
+  // unconditionally (schema-loader.ts), so `createOnlyFields` and
+  // `embeddedI18nFields` are disjoint by construction — no separate
+  // "non-i18n" filter is needed to avoid a duplicate binding against `rest`.
+_%>
+<% if (hasCreateOnlyFields) { -%>
+      const { <%= createOnlyFields.map((f) => f.name).join(', ') %>, ...createOnlyRest } = rest;
+      this.save.emit({
+        ...((this.transportMode() ?? this.mode()) === 'edit' ? createOnlyRest : rest),
+        <%= embeddedI18nFields.map((f) => f.i18nName).join(', ') %>,
+      } as unknown as <%= aggregate %>);
+<% } else { -%>
       this.save.emit({ ...rest, <%= embeddedI18nFields.map((f) => f.i18nName).join(', ') %> } as unknown as <%= aggregate %>);
+<% } -%>
+<% } else { -%>
+<% if (hasCreateOnlyFields) { -%>
+      const { <%= createOnlyFields.map((f) => f.name).join(', ') %>, ...createOnlyRest } = this.model();
+      this.save.emit(((this.transportMode() ?? this.mode()) === 'edit' ? createOnlyRest : this.model()) as unknown as <%= aggregate %>);
 <% } else { -%>
       this.save.emit(this.model() as unknown as <%= aggregate %>);
+<% } -%>
 <% } -%>
     });
 <% if (useFormTabs) { -%>

package/dist/templates/codegen/frontend/module/__module_name__/features/__module_name__-list.component.ts.eta

@@ -91,10 +91,13 @@
   const dialogNeedsRelational = dialogEmitted && hasRelational;
   const dialogNeedsAsyncSearch = dialogNeedsRelational && relMeta.some(m => m.isAsync);
 
-  // SPEC-17: aggregate has at least one many-to-one FK → list-component imports
-  // getRelationsNode and forwards the DSL `relations` node via the
-  // usePaginatedDataTable callback.
-  const hasManyToOneFk = (it.schema.aggregateProperties || []).some(p => p.relationship?.type === 'many-to-one');
+  // SPEC-17: aggregate has at least one FK relation (many-to-one, or
+  // one-to-one with `field`) → list-component imports getRelationsNode and
+  // forwards the DSL `relations` node via the usePaginatedDataTable
+  // callback. T-122: unified via `it.filters.hasForeignKeyRelationshipProperties`
+  // -- previously many-to-one only, leaving a one-to-one+field FK's column
+  // (emitted by columns.ts.eta) never actually requested from the server.
+  const hasForeignKey = it.filters.hasForeignKeyRelationshipProperties(it.schema.aggregateProperties || []);
 
   // SPEC-19: m2m relations with a declared widget contribute STATIC entries to
   // the DSL `relations` node —
@@ -148,7 +151,7 @@
   ];
   auroraItems.push(dialogEmitted ? 'useAggregateShell' : 'useGraphqlList');
   if (dialogNeedsAsyncSearch) auroraItems.push('useAsyncSearchList');
-  if (hasManyToOneFk) auroraItems.push('getRelationsNode');
+  if (hasForeignKey) auroraItems.push('getRelationsNode');
   auroraItems.push('type DataTableColumnDef', 'type DataTableData');
 
   const importsArray = [
@@ -534,7 +537,7 @@ export default class <%= modPascal %>ListComponent<% if (supportsEmbed) { %> imp
   protected readonly exportableColumns = () => getExportableColumns(this.baseColumns);
   protected readonly toggleableColumns = () => getToggleableColumns(this.baseColumns);
   private readonly searchColumns = getSearchableColumnIds(this.baseColumns);
-<% if (hasManyToOneFk) { -%>
+<% if (hasForeignKey) { -%>
   private readonly relations = getRelationsNode(this.baseColumns);
 <% } -%>
   protected readonly columns: DataTableColumnDef<<%= aggregate %>>[] = [
@@ -603,9 +606,9 @@ export default class <%= modPascal %>ListComponent<% if (supportsEmbed) { %> imp
       return pf ? { [pf.field]: { eq: pf.value } } : null;
     },
 <% } -%>
-<% if (hasManyToOneFk && hasM2mInclude) { -%>
+<% if (hasForeignKey && hasM2mInclude) { -%>
     relations: () => ({ ...this.relations, <%= m2mRelationEntries.join(', ') %> }),
-<% } else if (hasManyToOneFk) { -%>
+<% } else if (hasForeignKey) { -%>
     relations: () => this.relations,
 <% } else if (hasM2mInclude) { -%>
     relations: () => ({ <%= m2mRelationEntries.join(', ') %> }),

package/dist/templates/codegen/partials/fields/enum-field.eta

@@ -10,12 +10,14 @@
   const enumOptions = it.property.enumOptions ?? it.property.arrayOptions?.enumOptions ?? [];
   const enumKeyPrefix = it.bcKebab + '.' + it.modKebab + '.' + it.fmt.toPascalCase(it.property.name);
   /* Mirrors field-label.eta and property-validators.ts::getValidators
-     (non-editable-field-codegen): the !readonly term keeps this partial's
-     copy of the required predicate in lockstep with the validator and the
-     asterisk. It is the only aria-required emission site (of 11 total across
-     the form partials) that carries the term today -- the other 10 remain a
-     tracked gap (tasks.md section 10.6). */
-  const isRequired = it.property.nullable === false && it.property.type !== 'boolean' && !it.property.readonly;
+     (non-editable-field-codegen, renamed by add-create-only-property-semantics):
+     the !readOnly term keeps this partial's copy of the required predicate
+     in lockstep with the validator and the asterisk. Deliberately NOT
+     extended with createOnly — a createOnly property is genuinely required
+     at create time. It is the only aria-required emission site (of 11 total
+     across the form partials) that carries the term today -- the other 10
+     remain a tracked gap (tasks.md section 10.6). */
+  const isRequired = it.property.nullable === false && it.property.type !== 'boolean' && !it.property.readOnly;
 -%>
 <hlm-field class="<%= it.colSpan %>">
   <%~ include('/partials/form/field-label', it) %>

package/dist/templates/codegen/partials/form/field-label.eta

@@ -2,12 +2,15 @@
   // Centralized label emission for Family A form-field partials.
   //
   // Required-field rule (mirrors property-validators.ts::getValidators):
-  //   property.nullable === false && property.type !== 'boolean' && !property.readonly
+  //   property.nullable === false && property.type !== 'boolean' && !property.readOnly
   //   -> the label receives a styled asterisk suffix.
   //
-  // The readonly term (non-editable-field-codegen): a readonly property is
-  // filtered out of the form field set upstream and never reaches this
-  // partial in practice. The predicate is also replicated in
+  // The readOnly term (non-editable-field-codegen, renamed by
+  // add-create-only-property-semantics): a readOnly property is filtered out
+  // of the form field set upstream and never reaches this partial in
+  // practice. A createOnly property, in contrast, DOES reach this partial —
+  // it is genuinely required at create time, so the predicate is
+  // deliberately NOT extended with it. The predicate is also replicated in
   // property-validators.ts and in each partial that emits aria-required (11
   // sites total); as of this change only the aria-required copy in
   // enum-field.eta carries the term -- the other 10 do not yet (tracked
@@ -26,7 +29,7 @@
   //
   // Boolean fields (rendered as <hlm-switch>) are exempt — boolean-field.eta
   // keeps its own label and does NOT include this partial.
-  const isRequired = it.property.nullable === false && it.property.type !== 'boolean' && !it.property.readonly;
+  const isRequired = it.property.nullable === false && it.property.type !== 'boolean' && !it.property.readOnly;
 -%>
 <label hlmFieldLabel>
   {{ t('<%= it.propLabel %>') }}<% if (isRequired) { %><span aria-hidden="true" class="text-muted-foreground/70 align-top text-xs">*</span><% } %>

package/dist/templates/codegen/partials/form/form-body.eta

@@ -33,38 +33,15 @@
   const FORM_GRID_CLASS = 'grid grid-cols-1 md:grid-cols-12 gap-x-4 gap-y-5';
   const NO_GROUP = '__no_group__';
 
+  // SINGLE source of truth for "this property emits markup inside the form"
+  // (harden-frontend-form-field-emission-parity) — the form component
+  // templates' `renderedFields`/`relationalFields` MUST consume the SAME
+  // `it.filters.isFormFieldRenderable`, or the two drift again: a property
+  // this gate drops (e.g. a one-to-many relationship with no widget, or one
+  // matching no `dispatchField` branch below) would still count as
+  // "rendered" for the component's import gates.
   function isRenderableField(field) {
-    if (!it.predicates.isAllowProperty(it.schema.moduleName, field)) return false;
-    // Drop primary-key and FK ids ONLY when they have no widget. Ids with
-    // a widget pass through to the relational dispatch.
-    if (field.type === it.propertyType.ID && !field.widget) return false;
-    // SPEC-15: grid-elements-manager properties are NOT form fields. They
-    // render as a section in the parent's detail shell (outside the form),
-    // emitted by the detail-component template. Skip silently here.
-    if (field.widget?.type === it.widgetType.GRID_ELEMENTS_MANAGER) return false;
-    // grid-select-multiple-elements widgets are NOT form fields. Like
-    // grid-elements-manager, they render as a section in the parent's
-    // detail shell (outside the form) — emitted by the detail-component
-    // template. The widget is skipped in ALL modes:
-    //   - view mode: detail shell emits the section
-    //   - dialog mode: front.handler.ts emits a warning + skip (no detail
-    //     shell exists for dialog-mode aggregates anyway)
-    if (field.widget?.type === it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS) {
-      return false;
-    }
-    // An array whose arrayOptions.type is not enum, and which carries no
-    // relational/color widget, matches no dispatchField branch: it renders
-    // nothing. If left in, it still consumes a grid slot in the SPEC-14 span
-    // accounting (array default span is 12), corrupting auto-expand for the
-    // real fields around it. Drop it from the form entirely.
-    if (
-      field.type === 'array' &&
-      field.arrayOptions?.type !== 'enum' &&
-      !field.widget?.type
-    ) {
-      return false;
-    }
-    return true;
+    return it.filters.isFormFieldRenderable(it.schema.moduleName, field);
   }
 
   function groupFieldsByGroup(fields) {

package/dist/templates/codegen/partials/form/view-frame-tabbed.eta

@@ -43,12 +43,27 @@
     it.widgetType.ASYNC_SEARCH_SELECT,
     it.widgetType.ASYNC_MULTIPLE_SEARCH_SELECT,
   ]);
-  const ccRelMeta = (it.schema.aggregateProperties || [])
+  /* Same helper, same reason as view-frame.eta — see that file for the full
+     rationale. The useFormTabs argument is true here: the detail shell
+     includes THIS partial exactly when hasFormTabsProperties is true
+     (__module_name__-detail.component.ts.eta) and the shell is view-mode
+     only, which is the same pair of conditions the form component resolves
+     its own useFormTabs from. Without it the shell would bind a
+     <rel>Options input for a relational field with no widget.tab: the
+     tabbed form body never draws it and the form component never declares
+     it. Same duplicated-toolbar caveat as the rest of this partial: keep
+     both in lockstep. */
+  const emittedFormFields = it.filters.getEmittedFormFields(
+    it.schema.moduleName,
+    it.schema.aggregateProperties,
+    true,
+  );
+  const ccRelMeta = emittedFormFields
     .filter(p => p.relationship && RELATIONAL_TYPES.has(p.widget?.type))
     .map(p => ({
       relSingular: it.fmt.toCamelCase(it.mappers.getRelationshipSingularName(p)),
       relPascal: it.fmt.toPascalCase(it.mappers.getRelationshipSingularName(p)),
-      needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT || p.widget.type === it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS,
+      needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT,
       isAsync: ASYNC_SEARCH_SELECT_TYPES.has(p.widget?.type),
     }));
 
@@ -126,6 +141,7 @@ _%>
 <% } -%>
 <% if (ccIsEmbeddedI18n) { -%>
         [editLang]="editLang()"
+        [transportMode]="effectiveMode()"
 <% } -%>
 <%_
   // Manager-pattern (grid-multi) widgets render OUTSIDE the form as their

package/dist/templates/codegen/partials/form/view-frame.eta

@@ -38,12 +38,31 @@
     it.widgetType.ASYNC_SEARCH_SELECT,
     it.widgetType.ASYNC_MULTIPLE_SEARCH_SELECT,
   ]);
-  const ccRelMeta = (it.schema.aggregateProperties || [])
+  /* emittedFormFields resolves through the SAME helper the form component
+     template uses (it.filters.getEmittedFormFields), so the shell can only
+     bind a <rel>Options input the form actually declares. Both frames route
+     to that one function precisely so they cannot drift apart. The
+     useFormTabs argument is false here: this is the non-tabbed frame, which
+     the detail shell includes exactly when no property declares a
+     widget.tab. A one-to-many relationship WITH a widget passes
+     getFormDetailFieldsProperties but is dropped by isFormFieldRenderable
+     (isAllowProperty defaults allowOneToManyRelationShip to false), so
+     binding it would be an NG8002 against an input the form never declares.
+     grid-select-multiple-elements is excluded by isFormFieldRenderable
+     itself (renders outside the form, in its own detail-shell section — see
+     ccGridMultiByRel below), so needsColumns only needs the single-pick
+     grid variant. */
+  const emittedFormFields = it.filters.getEmittedFormFields(
+    it.schema.moduleName,
+    it.schema.aggregateProperties,
+    false,
+  );
+  const ccRelMeta = emittedFormFields
     .filter(p => p.relationship && RELATIONAL_TYPES.has(p.widget?.type))
     .map(p => ({
       relSingular: it.fmt.toCamelCase(it.mappers.getRelationshipSingularName(p)),
       relPascal: it.fmt.toPascalCase(it.mappers.getRelationshipSingularName(p)),
-      needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT || p.widget.type === it.widgetType.GRID_SELECT_MULTIPLE_ELEMENTS,
+      needsColumns: p.widget.type === it.widgetType.GRID_SELECT_ELEMENT,
       isAsync: ASYNC_SEARCH_SELECT_TYPES.has(p.widget?.type),
     }));
 
@@ -136,6 +155,7 @@ _%>
 <% } -%>
 <% if (ccIsEmbeddedI18n) { -%>
             [editLang]="editLang()"
+            [transportMode]="effectiveMode()"
 <% } -%>
 <%_
   // Manager-pattern (grid-multi) widgets render OUTSIDE the form as their