@reventlessdev/reventless-core 3.0.0-alpha.258 → 3.0.0-alpha.259

package/src/components/Api/SchemaType.res

@@ -10,6 +10,13 @@ type rec schemaType =
   | ScalarBigInt
   | EntityId
   | DateTime
+  | /** A calendar day, with no instant in it. A shape of its own rather than a
+        plain string so `format: "date"` reaches the JSON Schema — but, unlike
+        `DateTime`, it is not excluded from the generic semantic wrapper below,
+        so it carries `x-reventless-semantic` as well. `DateTime`'s exclusion
+        exists because its bare-`format` output predates the marker and is a
+        published contract; a new semantic has no such history. */
+  CalendarDate
   | Nullable(schemaType)
   | ArrayOf(schemaType)
   | ObjectRef(string, dict<schemaType>)
@@ -32,6 +39,7 @@ type rec schemaType =
 
 let isTagged = Reventless.DcbTag.isTagged
 let isDateTime = Reventless.DateTime.isDateTime
+let isCalendarDate = Reventless.CalendarDate.isCalendarDate
 
 let isIdFieldName = (name: string): bool => {
   let lower = String.toLowerCase(name)
@@ -107,6 +115,7 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
     switch schema {
     | String({const: ?Some(_)}) => ScalarString
     | String(_) if isDateTime(schema) => DateTime
+    | String(_) if isCalendarDate(schema) => CalendarDate
     | String(_) => isIdFieldName(fieldName) ? EntityId : ScalarString
     // `Int32` and `Port` are both whole-number formats; anything else (or no
     // format at all) is a `float` as far as the schema is concerned.
@@ -348,15 +357,71 @@ let optionalFieldNames = (schema: S.t<unknown>): array<string> =>
   | _ => []
   }
 
+// A lifecycle trail's entries are `{state, at}`, and `state` holds the record's
+// own lifecycle. Walked under the lifecycle field's name so it resolves to the
+// enum that field already emits, rather than a second copy under the trail's
+// path — the trail and the current state must read as one vocabulary.
+let trailShape = (
+  ~parentName: string,
+  ~trailField: string,
+  ~lifecycleField: string,
+  schema: S.t<unknown>,
+): schemaType => {
+  let entryName =
+    parentName ++
+    trailField->String.charAt(0)->String.toUpperCase ++
+    trailField->String.slice(~start=1, ~end=trailField->String.length)
+  let entrySchema = switch schema {
+  | Array({additionalItems: Schema(item)}) => Some(item)
+  | _ => None
+  }
+  switch entrySchema {
+  | Some(Object({properties})) =>
+    let fields = Dict.make()
+    properties
+    ->Dict.toArray
+    ->Array.forEach(((propName, propSchema)) =>
+      fields->Dict.set(
+        propName,
+        propName === "state"
+          ? fromSury(~parentName, ~fieldName=lifecycleField, propSchema)
+          : fromSury(~parentName=entryName, ~fieldName=propName, propSchema),
+      )
+    )
+    let shape = ArrayOf(ObjectRef(entryName, fields))
+    // Walking the entries by shape skips the semantic dispatch `fromSury` does,
+    // so the marker is re-applied here. Without it the trail reaches a consumer
+    // as an unremarkable array of objects, and recognising it would come down to
+    // the field's name.
+    switch Reventless.Semantic.get(schema) {
+    | Some(sem) => Semantic(sem, shape)
+    | None => shape
+    }
+  | _ => fromSury(~parentName, ~fieldName=trailField, schema)
+  }
+}
+
 let fromSuryObject = (~typeName: string, schema: S.t<unknown>): option<dict<schemaType>> =>
   switch schema {
   | Object({properties}) =>
+    let trail = switch (
+      Reventless.Lifecycle.Trail.fieldName(schema),
+      Reventless.Lifecycle.fieldName(schema),
+    ) {
+    | (Some(trailField), Some(lifecycleField)) => Some((trailField, lifecycleField))
+    | _ => None
+    }
     let fields = Dict.make()
     properties
     ->Dict.toArray
     ->Array.forEach(((propName, propSchema)) => {
       if propName !== "TAG" {
-        fields->Dict.set(propName, fromSury(~parentName=typeName, ~fieldName=propName, propSchema))
+        let shape = switch trail {
+        | Some((trailField, lifecycleField)) if trailField === propName =>
+          trailShape(~parentName=typeName, ~trailField, ~lifecycleField, propSchema)
+        | _ => fromSury(~parentName=typeName, ~fieldName=propName, propSchema)
+        }
+        fields->Dict.set(propName, shape)
       }
     })
     Some(fields)

package/src/components/Api/SchemaType.res.mjs

@@ -3,10 +3,12 @@
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/types/DateTime.res.mjs";
+import * as DateTime$Reventless from "@reventlessdev/reventless-spec/src/semantic/DateTime.res.mjs";
 import * as Semantic$Reventless from "@reventlessdev/reventless-spec/src/semantic/Semantic.res.mjs";
+import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as TaggedUnion$Reventless from "@reventlessdev/reventless-spec/src/components/TaggedUnion.res.mjs";
+import * as CalendarDate$Reventless from "@reventlessdev/reventless-spec/src/semantic/CalendarDate.res.mjs";
 
 function isIdFieldName(name) {
   let lower = name.toLowerCase();
@@ -79,6 +81,8 @@ function shapeOf(parentName, fieldName, schema) {
         return "ScalarString";
       } else if (DateTime$Reventless.isDateTime(schema)) {
         return "DateTime";
+      } else if (CalendarDate$Reventless.isCalendarDate(schema)) {
+        return "CalendarDate";
       } else if (isIdFieldName(fieldName)) {
         return "EntityId";
       } else {
@@ -324,17 +328,72 @@ function optionalFieldNames(schema) {
   }
 }
 
+function trailShape(parentName, trailField, lifecycleField, schema) {
+  let entryName = parentName + trailField.charAt(0).toUpperCase() + trailField.slice(1, trailField.length);
+  let entrySchema;
+  if (schema.type === "array") {
+    let item = schema.additionalItems;
+    entrySchema = item === "strip" || item === "strict" ? undefined : item;
+  } else {
+    entrySchema = undefined;
+  }
+  if (entrySchema === undefined) {
+    return fromSury(parentName, trailField, schema);
+  }
+  if (entrySchema.type !== "object") {
+    return fromSury(parentName, trailField, schema);
+  }
+  let fields = {};
+  Object.entries(entrySchema.properties).forEach(param => {
+    let propSchema = param[1];
+    let propName = param[0];
+    fields[propName] = propName === "state" ? fromSury(parentName, lifecycleField, propSchema) : fromSury(entryName, propName, propSchema);
+  });
+  let shape = {
+    TAG: "ArrayOf",
+    _0: {
+      TAG: "ObjectRef",
+      _0: entryName,
+      _1: fields
+    }
+  };
+  let sem = Semantic$Reventless.get(schema);
+  if (sem !== undefined) {
+    return {
+      TAG: "Semantic",
+      _0: sem,
+      _1: shape
+    };
+  } else {
+    return shape;
+  }
+}
+
 function fromSuryObject(typeName, schema) {
   if (schema.type !== "object") {
     return;
   }
+  let match = Lifecycle$Reventless.Trail.fieldName(schema);
+  let match$1 = Lifecycle$Reventless.fieldName(schema);
+  let trail = match !== undefined && match$1 !== undefined ? [
+      match,
+      match$1
+    ] : undefined;
   let fields = {};
   Object.entries(schema.properties).forEach(param => {
     let propName = param[0];
-    if (propName !== "TAG") {
-      fields[propName] = fromSury(typeName, propName, param[1]);
+    if (propName === "TAG") {
       return;
     }
+    let propSchema = param[1];
+    let shape;
+    if (trail !== undefined) {
+      let trailField = trail[0];
+      shape = trailField === propName ? trailShape(typeName, trailField, trail[1], propSchema) : fromSury(typeName, propName, propSchema);
+    } else {
+      shape = fromSury(typeName, propName, propSchema);
+    }
+    fields[propName] = shape;
   });
   return fields;
 }
@@ -343,11 +402,14 @@ let isTagged = DcbTag$Reventless.isTagged;
 
 let isDateTime = DateTime$Reventless.isDateTime;
 
+let isCalendarDate = CalendarDate$Reventless.isCalendarDate;
+
 let maxReportDepth = 12;
 
 export {
   isTagged,
   isDateTime,
+  isCalendarDate,
   isIdFieldName,
   isIdsFieldName,
   semanticCompositeNames,
@@ -358,6 +420,7 @@ export {
   collectUnclassifiedUnions,
   unclassifiedUnions,
   optionalFieldNames,
+  trailShape,
   fromSuryObject,
 }
 /* DcbTag-Reventless Not a pure module */

package/src/components/Api/SuryToJsonSchema.res

@@ -207,6 +207,7 @@ let rec fromSchemaType = (~inputNames: bool=false, st: SchemaType.schemaType): J
   | ScalarBigInt => jsonObject([("type", str("integer"))])
   | EntityId => jsonObject([("type", str("string")), ("format", str("uuid"))])
   | DateTime => jsonObject([("type", str("string")), ("format", str("date-time"))])
+  | CalendarDate => jsonObject([("type", str("string")), ("format", str("date"))])
   | Nullable(inner) =>
     let innerSchema = fromSchemaType(~inputNames, inner)
     jsonObject([("oneOf", JSON.Encode.array([innerSchema, jsonObject([("type", str("null"))])]))])

package/src/components/Api/SuryToJsonSchema.res.mjs

@@ -212,6 +212,17 @@ function fromSchemaType(inputNamesOpt, st) {
             "date-time"
           ]
         ]);
+      case "CalendarDate" :
+        return Object.fromEntries([
+          [
+            "type",
+            "string"
+          ],
+          [
+            "format",
+            "date"
+          ]
+        ]);
       case "ScalarString" :
       case "Unknown" :
         return Object.fromEntries([[

package/src/components/ReadModel/ReadModel_Callback.res

@@ -31,13 +31,16 @@ module Make = (
               json,
             )} actions:${actionsStr}`,
         )->Effect.runSync
-        actions
+        // Rewritten here rather than at the apply below: a trail entry is
+        // stamped with this envelope's own time.
+        actions->Array.map(
+          Projection.rewriteAction(_, ~at=context.meta.time, ReadModelSpec.stateSchema),
+        )
       })
       ->Array.flat
       ->Array.reduce(Effect.succeed(), (acc, action) =>
         acc->Effect.flatMap(
           _ => {
-            let action = Projection.rewriteAction(action, ReadModelSpec.stateSchema)
             Effect.promise(
               () => Projection.handleAction(~comp, action, Spec.operations, ReadModelSpec.subIdConfig),
             )->Effect.map(_ => ())

package/src/components/ReadModel/ReadModel_Callback.res.mjs

@@ -28,11 +28,8 @@ function Make(ReadModelSpec) {
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         let idxStr = (idx + 1 | 0).toString();
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, json, `handling event ` + idxStr + `/` + total + ` from ` + sourceName + `: ` + LogFormat$ReventlessCore.eventDetail(json) + ` actions:` + actionsStr));
-        return actions;
-      }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
-        let action$1 = Projection$ReventlessCore.rewriteAction(action, ReadModelSpec.stateSchema);
-        return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, Spec.operations, ReadModelSpec.subIdConfig)), param => {});
-      }));
+        return actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, context.meta.time, ReadModelSpec.stateSchema));
+      }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, Spec.operations, ReadModelSpec.subIdConfig)), param => {})));
     });
     return {
       EventProjector: EventProjector,

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -148,18 +148,19 @@ module Make = (
                     ~detail=eventData,
                     `handling event ${idxStr}/${total}: ${LogFormat.bold(eventType)}${fieldsStr} ${actionsStr}`,
                   )->Effect.runSync
-                  actions
+                  // A slice's state carries the same synthetic `displayName` the
+                  // ppx injects for a read model's, and the same lifecycle trail.
+                  // Rewritten here rather than at the apply below because the
+                  // trail entry is stamped with this envelope's own time.
+                  actions->Array.map(
+                    FrameworkProjection.rewriteAction(_, ~at=meta.time, Spec.stateSchema),
+                  )
                 | None => []
                 }
               })
               ->Array.flat
               ->Array.reduce(Effect.succeed(), (acc, action) =>
                 acc->Effect.flatMap(_ => {
-                  // A slice's state carries the same synthetic `displayName` the
-                  // ppx injects for a read model's, so it is composed on the same
-                  // terms — without this the column stays null and every surface
-                  // names the row by its id.
-                  let action = FrameworkProjection.rewriteAction(action, Spec.stateSchema)
                   Effect.promise(() =>
                     FrameworkProjection.handleAction(~comp, action, projectionOps, Spec.subIdConfig)
                   )->Effect.map(_ => ())

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -120,11 +120,8 @@ function Make(RuntimeEnvironment) {
               let f = Object.entries(dataDict).map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
               let fieldsStr = f === "" ? "" : `({` + f + `})`;
               Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, dataDict, `handling event ` + idxStr + `/` + total + `: ` + LogFormat$ReventlessCore.bold(eventType) + fieldsStr + ` ` + actionsStr));
-              return actions;
-            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => {
-              let action$1 = Projection$ReventlessCore.rewriteAction(action, Spec.stateSchema);
-              return Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action$1, projectionOps, Spec.subIdConfig)), param => {});
-            }));
+              return actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, meta.time, Spec.stateSchema));
+            }).flat(), Effect.succeed(), (acc, action) => Effect.flatMap(acc, () => Effect.map(Effect.promise(() => Projection$ReventlessCore.handleAction(comp, action, projectionOps, Spec.subIdConfig)), param => {})));
           });
           let handler = SpecificEventCollector.makeHandler(ec, jsonEventsHandler);
           let resources = Component$ReventlessCore.outputs(queryDb).resources;

package/src/components/StateViewSlice/StateViewSlice_Callback.res

@@ -48,7 +48,9 @@ module Make = (
           `handling event ${idx.contents->Int.toString}/${count}: ${LogFormat.bold(raw.eventType)}(${id}) ${actionsStr}`,
         )->Effect.runSync
         allActions->Array.pushMany(
-          actions->Array.map(FrameworkProjection.rewriteAction(_, Spec.stateSchema)),
+          actions->Array.map(
+            FrameworkProjection.rewriteAction(_, ~at=raw.meta.time, Spec.stateSchema),
+          ),
         )
         Some(event)
       | None => None

package/src/components/StateViewSlice/StateViewSlice_Callback.res.mjs

@@ -35,7 +35,7 @@ function Make(Spec) {
         });
         let actionsStr = LogFormat$ReventlessCore.actionNames(actions);
         Effect.runSync(EffectLogger$ReventlessCore.logInfo(comp, raw.data, `handling event ` + idx.contents.toString() + `/` + count + `: ` + LogFormat$ReventlessCore.bold(raw.eventType) + `(` + id + `) ` + actionsStr));
-        allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, Spec.stateSchema)));
+        allActions.push(...actions.map(__x => Projection$ReventlessCore.rewriteAction(__x, raw.meta.time, Spec.stateSchema)));
         return Primitive_option.some(event);
       });
       let skipped = rawEvents.length - events.length | 0;

package/src/plugin/component/Plugin_Structure.res

@@ -21,20 +21,6 @@ let rec isLabelShape = (t: SchemaType.schemaType): bool =>
   | _ => false
   }
 
-// Whether a field can hold a lifecycle: a closed set of values, or an optional
-// one. A free-text `lifecycle: string` is not a lifecycle — filtering a command
-// menu against `allowedStates` needs states to compare with.
-let rec isLifecycleShape = (t: SchemaType.schemaType): bool =>
-  switch t {
-  | Enum(_, _) => true
-  | Nullable(inner) => isLifecycleShape(inner)
-  // A union is a closed set of *shapes*, not of values, and `allowedStates`
-  // compares values. The same answer the ppx gives `@lifecycle` on a union
-  // field, which is a compile error — this is the convention rung agreeing.
-  | TaggedUnion(_, _) => false
-  | _ => false
-  }
-
 // Field names that say "this one is the record's name" in the only way
 // available short of the `@displayName` annotation. Matched case-insensitively
 // and *exactly*: `customerName` holds a customer's name, not this record's.
@@ -43,33 +29,10 @@ let conventionalLabelNames = ["name", "title", "label", "displayname"]
 let shapeOfField = (~entityName: string, ~name: string, schema: S.t<unknown>): SchemaType.schemaType =>
   SchemaType.fromSury(~parentName=entityName, ~fieldName=name, schema)
 
-// The field holding the entity's lifecycle, for filtering a per-row command menu:
-// `@lifecycle`, else an enum field literally named `lifecycle`, else None. Not
-// keyed on `status` — a promiscuous name that would guess, and guess often.
-let lifecycleFieldFromStateSchema = (
-  ~entityName: string,
-  stateSchema: S.t<unknown>,
-): option<string> => {
-  let annotated = switch Reventless.StateAnnotations.getSpec(stateSchema) {
-  | Some(spec) => spec.lifecycle
-  | None => None
-  }
-  switch annotated {
-  | Some(_) as some => some
-  | None =>
-    switch stateSchema {
-    | Object({properties}) =>
-      properties
-      ->Dict.get("lifecycle")
-      ->Option.flatMap(schema =>
-        isLifecycleShape(shapeOfField(~entityName, ~name="lifecycle", schema))
-          ? Some("lifecycle")
-          : None
-      )
-    | _ => None
-    }
-  }
-}
+// The field holding the entity's lifecycle, for filtering a per-row command
+// menu. One rule, stated in `Reventless.Lifecycle` — the projection machinery
+// resolves the field a trail entry records against from the same place.
+let lifecycleFieldFromStateSchema = Reventless.Lifecycle.fieldName
 
 // The field whose truth withdraws a row from ordinary reads. Annotation-only —
 // no convention rung, since guessing wrong here makes rows vanish.
@@ -113,7 +76,7 @@ let checkRetiredValue = (~entityName: string, stateSchema: S.t<unknown>): retire
   | None | Some({values: None}) => NotDeclared
   | Some({field, values: Some(values)}) =>
     let named = values->Array.join(", ")
-    let lifecycle = lifecycleFieldFromStateSchema(~entityName, stateSchema)
+    let lifecycle = lifecycleFieldFromStateSchema(stateSchema)
     if lifecycle != Some(field) {
       log.warn(
         ~comp="Plugin_Structure",
@@ -190,7 +153,7 @@ let lifecycleStatesFromStateSchema = (
   ~entityName: string,
   stateSchema: S.t<unknown>,
 ): option<array<string>> =>
-  lifecycleFieldFromStateSchema(~entityName, stateSchema)->Option.flatMap(field =>
+  lifecycleFieldFromStateSchema(stateSchema)->Option.flatMap(field =>
     switch stateSchema {
     | Object({properties}) =>
       properties
@@ -965,7 +928,7 @@ let queryableDefFromSpec = (
     labelField: label.field,
     searchableFields: label.searchableFields,
     labelFieldSource: Some(labelFieldSourceToString(label.source)),
-    lifecycleField: lifecycleFieldFromStateSchema(~entityName=name, stateSchema),
+    lifecycleField: lifecycleFieldFromStateSchema(stateSchema),
     ownerField: Reventless.Owner.fieldNames(stateSchema)->Array.get(0),
     retiredField: retiredFieldFromStateSchema(stateSchema),
     retiredValues: retiredValuesFromStateSchema(stateSchema),
@@ -1410,7 +1373,7 @@ let make = (
         labelField: label.field,
         searchableFields: label.searchableFields,
         labelFieldSource: Some(labelFieldSourceToString(label.source)),
-        lifecycleField: lifecycleFieldFromStateSchema(~entityName=R.Spec.name, stateSchema),
+        lifecycleField: lifecycleFieldFromStateSchema(stateSchema),
         // Same schema `lifecycleField` reads, so the two cannot disagree about which
         // fields this view has.
         ownerField: Reventless.Owner.fieldNames(stateSchema)->Array.get(0),
@@ -1451,7 +1414,7 @@ let make = (
         labelField: label.field,
         searchableFields: label.searchableFields,
         labelFieldSource: Some(labelFieldSourceToString(label.source)),
-        lifecycleField: lifecycleFieldFromStateSchema(~entityName=SVS.Spec.name, stateSchema),
+        lifecycleField: lifecycleFieldFromStateSchema(stateSchema),
         ownerField: Reventless.Owner.fieldNames(stateSchema)->Array.get(0),
         retiredField: retiredFieldFromStateSchema(stateSchema),
         retiredValues: retiredValuesFromStateSchema(stateSchema),

package/src/plugin/component/Plugin_Structure.res.mjs

@@ -12,6 +12,7 @@ import * as Primitive_string from "@rescript/runtime/lib/es6/Primitive_string.js
 import * as Trait$Reventless from "@reventlessdev/reventless-spec/src/types/Trait.res.mjs";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Message$Reventless from "@reventlessdev/reventless-spec/src/types/Message.res.mjs";
+import * as Lifecycle$Reventless from "@reventlessdev/reventless-spec/src/types/Lifecycle.res.mjs";
 import * as Reference$Reventless from "@reventlessdev/reventless-spec/src/components/Reference.res.mjs";
 import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
@@ -47,24 +48,6 @@ function isLabelShape(_t) {
   };
 }
 
-function isLifecycleShape(_t) {
-  while (true) {
-    let t = _t;
-    if (typeof t !== "object") {
-      return false;
-    }
-    switch (t.TAG) {
-      case "Nullable" :
-        _t = t._0;
-        continue;
-      case "Enum" :
-        return true;
-      default:
-        return false;
-    }
-  };
-}
-
 let conventionalLabelNames = [
   "name",
   "title",
@@ -74,22 +57,6 @@ let conventionalLabelNames = [
 
 let shapeOfField = SchemaType$ReventlessCore.fromSury;
 
-function lifecycleFieldFromStateSchema(entityName, stateSchema) {
-  let spec = StateAnnotations$Reventless.getSpec(stateSchema);
-  let annotated = spec !== undefined ? spec.lifecycle : undefined;
-  if (annotated !== undefined) {
-    return annotated;
-  } else if (stateSchema.type === "object") {
-    return Stdlib_Option.flatMap(stateSchema.properties["lifecycle"], schema => {
-      if (isLifecycleShape(SchemaType$ReventlessCore.fromSury(entityName, "lifecycle", schema))) {
-        return "lifecycle";
-      }
-    });
-  } else {
-    return;
-  }
-}
-
 function retiredFromStateSchema(stateSchema) {
   let spec = StateAnnotations$Reventless.getSpec(stateSchema);
   if (spec !== undefined) {
@@ -120,7 +87,7 @@ function checkRetiredValue(entityName, stateSchema) {
   }
   let field = match.field;
   let named = values.join(", ");
-  let lifecycle = lifecycleFieldFromStateSchema(entityName, stateSchema);
+  let lifecycle = Lifecycle$Reventless.fieldName(stateSchema);
   if (Primitive_object.notequal(lifecycle, field)) {
     log.warn("Plugin_Structure", undefined, entityName + `: @retired(` + named + `) is on "` + field + `", which is not this record's lifecycle field` + Stdlib_Option.getOr(Stdlib_Option.map(lifecycle, f => ` (that is "` + f + `")`), " (it declares none)") + `. A retirement state no command's declared edge can name loses the command filtering the state form exists for.`);
   }
@@ -169,7 +136,7 @@ function reportRetiredStates(pluginName, failures, unchecked) {
 }
 
 function lifecycleStatesFromStateSchema(entityName, stateSchema) {
-  return Stdlib_Option.flatMap(lifecycleFieldFromStateSchema(entityName, stateSchema), field => {
+  return Stdlib_Option.flatMap(Lifecycle$Reventless.fieldName(stateSchema), field => {
     if (stateSchema.type === "object") {
       return Stdlib_Option.map(stateSchema.properties[field], schema => {
         let match = SchemaType$ReventlessCore.fromSury(entityName, field, schema);
@@ -715,7 +682,7 @@ function queryableDefFromSpec(plugin, name, stateSchema, authorization, visibili
     labelField: label.field,
     searchableFields: label.searchableFields,
     labelFieldSource: labelFieldSourceToString(label.source),
-    lifecycleField: lifecycleFieldFromStateSchema(name, stateSchema),
+    lifecycleField: Lifecycle$Reventless.fieldName(stateSchema),
     ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
     retiredField: retiredFieldFromStateSchema(stateSchema),
     retiredValues: retiredValuesFromStateSchema(stateSchema),
@@ -1024,7 +991,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelField: label.field,
       searchableFields: label.searchableFields,
       labelFieldSource: labelFieldSourceToString(label.source),
-      lifecycleField: lifecycleFieldFromStateSchema(R.Spec.name, stateSchema),
+      lifecycleField: Lifecycle$Reventless.fieldName(stateSchema),
       ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
       retiredField: retiredFieldFromStateSchema(stateSchema),
       retiredValues: retiredValuesFromStateSchema(stateSchema),
@@ -1056,7 +1023,7 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
       labelField: label.field,
       searchableFields: label.searchableFields,
       labelFieldSource: labelFieldSourceToString(label.source),
-      lifecycleField: lifecycleFieldFromStateSchema(SVS.Spec.name, stateSchema),
+      lifecycleField: Lifecycle$Reventless.fieldName(stateSchema),
       ownerField: Owner$Reventless.fieldNames(stateSchema)[0],
       retiredField: retiredFieldFromStateSchema(stateSchema),
       retiredValues: retiredValuesFromStateSchema(stateSchema),
@@ -1383,11 +1350,12 @@ function make(name, aggregatesOpt, readModelsOpt, stateViewSlicesOpt, stateChang
   };
 }
 
+let lifecycleFieldFromStateSchema = Lifecycle$Reventless.fieldName;
+
 export {
   log,
   declaredTransitionsOnly,
   isLabelShape,
-  isLifecycleShape,
   conventionalLabelNames,
   shapeOfField,
   lifecycleFieldFromStateSchema,

package/src/plugin/connect/PluginExtensionPoint_UiFragment.res.mjs

@@ -2,7 +2,7 @@
 
 import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
 import * as Plugin$ReventlessCore from "../component/Plugin.res.mjs";
-import * as UiFragmentRegistry$ReventlessCore from "../../admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs";
+import * as UiFragmentRegistry$ReventlessCore from "../../admin/UiFragmentRegistry/StateChange/UiFragmentRegistry.res.mjs";
 import * as ExtensionPointMapping$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/ExtensionPointMapping.res.mjs";
 import * as PluginExtensionPointSpec$ReventlessInfra from "@reventlessdev/reventless-infra/src/types/PluginExtensionPointSpec.res.mjs";
 

package/tests/admin/AdminApiSchemaDriftTest.res.mjs

@@ -4,7 +4,7 @@ import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as SchemaType$ReventlessCore from "../../src/components/Api/SchemaType.res.mjs";
-import * as UiFragments$ReventlessCore from "../../src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs";
+import * as UiFragments$ReventlessCore from "../../src/admin/UiFragmentRegistry/StateView/UiFragments.res.mjs";
 import * as Platform_UIFragmentsApi$ReventlessCore from "../../src/admin/Platform_UIFragmentsApi.res.mjs";
 import * as Platform_PluginStructuresApi$ReventlessCore from "../../src/admin/Platform_PluginStructuresApi.res.mjs";
 import * as Platform_ComponentDefinitionsApi$ReventlessCore from "../../src/admin/Platform_ComponentDefinitionsApi.res.mjs";

package/tests/api/BrandedMarkerCompositionTest.res

@@ -0,0 +1,74 @@
+open JestGlobals
+
+// A field marker and a branded semantic type on the same field. Both markers
+// used to test for the literal `string` keyword, so both saw the brand instead
+// of the string and refused a field they should have taken — which would have
+// made declaring what a field *is* cost it whatever the marker gave.
+//
+// The composition assertion is the one that matters. `@owner` cannot see the
+// schema sury-ppx derives from `Email.t`, so the tempting fix is to inject
+// `Owner.string` over it: that type-checks, passes an "is it marked" test, and
+// silently leaves the field a plain string with the address grammar gone.
+// Asserting the marker is there proves nothing on its own — the rejection below
+// is what says the brand survived.
+describe("a field marker on a branded semantic:", () => {
+  let stateSchema = PsBrandedMarkersReadModel.stateSchema->S.castToUnknown
+
+  let fieldOf = name =>
+    switch stateSchema {
+    | Object({properties}) => properties->Dict.get(name)
+    | _ => None
+    }
+
+  describe("@owner on an Email field:", () => {
+    testSync("marks the field as the owner", () =>
+      expect(fieldOf("email")->Option.mapOr(false, Reventless.Owner.isFieldOwner))->toBe(true)
+    )
+
+    testSync("keeps the email semantic", () =>
+      expect(
+        fieldOf("email")
+        ->Option.flatMap(Reventless.Semantic.getFrom)
+        ->Option.map(s => s.id),
+      )->toEqual(Some("email"))
+    )
+
+    // The regression a substituting fix would land, and it lands in silence:
+    // the row still scopes to its owner, and the field accepts anything.
+    testSync("still rejects what is not an address", () => {
+      let parses = raw =>
+        switch fieldOf("email") {
+        | Some(schema) =>
+          switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
+          | _ => true
+          | exception _ => false
+          }
+        | None => false
+        }
+      expect((parses("buyer@example.com"), parses("buyer")))->toEqual((true, false))
+    })
+  })
+
+  describe("@displayName on a DateTime field:", () => {
+    testSync("names the row by it", () =>
+      expect(
+        S.Metadata.get(stateSchema, ~id=Reventless.DisplayName.displayNameId)->Option.map(d =>
+          d.fields
+        ),
+      )->toEqual(Some(["openedAt"]))
+    )
+
+    testSync("and the instant grammar survives", () => {
+      let parses = raw =>
+        switch fieldOf("openedAt") {
+        | Some(schema) =>
+          switch raw->JSON.Encode.string->S.parseOrThrow(~to=schema) {
+          | _ => true
+          | exception _ => false
+          }
+        | None => false
+        }
+      expect((parses("2026-03-02T09:00:00Z"), parses("tomorrow")))->toEqual((true, false))
+    })
+  })
+})