@reventlessdev/reventless-spec 3.0.0-alpha.132 → 3.0.0-alpha.134

package/src/components/DcbValidation.res

@@ -73,12 +73,12 @@ let rec schemasAreCompatible = (a: S.t<unknown>, b: S.t<unknown>): bool =>
     let at = av->Array.map(v => v.tagName)->Array.toSorted(String.compare)
     let bt = bv->Array.map(v => v.tagName)->Array.toSorted(String.compare)
     at == bt &&
-    at->Array.every(tag =>
-      switch (av->Array.find(v => v.tagName == tag), bv->Array.find(v => v.tagName == tag)) {
-      | (Some(x), Some(y)) => propsCompatible(x.fields, y.fields)
-      | _ => false
-      }
-    )
+      at->Array.every(tag =>
+        switch (av->Array.find(v => v.tagName == tag), bv->Array.find(v => v.tagName == tag)) {
+        | (Some(x), Some(y)) => propsCompatible(x.fields, y.fields)
+        | _ => false
+        }
+      )
   | _ => false
   }
 // Two property maps are compatible when they carry the same field names and each
@@ -87,12 +87,12 @@ and propsCompatible = (aProps: dict<S.t<unknown>>, bProps: dict<S.t<unknown>>):
   let aKeys = aProps->Dict.keysToArray->Array.toSorted(String.compare)
   let bKeys = bProps->Dict.keysToArray->Array.toSorted(String.compare)
   aKeys == bKeys &&
-  aKeys->Array.every(k =>
-    switch (aProps->Dict.get(k), bProps->Dict.get(k)) {
-    | (Some(av), Some(bv)) => schemasAreCompatible(av, bv)
-    | _ => false
-    }
-  )
+    aKeys->Array.every(k =>
+      switch (aProps->Dict.get(k), bProps->Dict.get(k)) {
+      | (Some(av), Some(bv)) => schemasAreCompatible(av, bv)
+      | _ => false
+      }
+    )
 }
 
 // Get a human-readable type name for a schema
@@ -185,26 +185,27 @@ let validateCompositeReads = (
       ->Array.forEach(cmdKeys => {
         let querySet = dedupeKeys(cmdKeys)
         if querySet->Array.length >= 2 {
-          consumedTypes->Array.forEach(consumedType =>
-            switch producedTagKeys->Dict.get(consumedType) {
-            | None => ()
-            | Some(producedKeys) =>
-              let producedSet = dedupeKeys(producedKeys)
-              let isSuperset = querySet->Array.every(k => producedSet->Array.includes(k))
-              if isSuperset && producedSet->Array.length > querySet->Array.length {
-                let extra = producedSet->Array.filter(k => !(querySet->Array.includes(k)))
-                let _ = warnings->Array.push({
-                  sliceName,
-                  message: `composite read on tags [${querySet->Array.join(
-                      ", ",
-                    )}] will silently miss '${consumedType}', which also carries [${extra->Array.join(
-                      ", ",
-                    )}] — the tag_composite key includes ALL of an event's tags, so a composite query matches only events tagged exactly [${querySet->Array.join(
-                      ", ",
-                    )}]. Align the event's tag set with the query, or read '${consumedType}' via a single-tag clause.`,
-                })
-              }
-            }
+          consumedTypes->Array.forEach(
+            consumedType =>
+              switch producedTagKeys->Dict.get(consumedType) {
+              | None => ()
+              | Some(producedKeys) =>
+                let producedSet = dedupeKeys(producedKeys)
+                let isSuperset = querySet->Array.every(k => producedSet->Array.includes(k))
+                if isSuperset && producedSet->Array.length > querySet->Array.length {
+                  let extra = producedSet->Array.filter(k => !(querySet->Array.includes(k)))
+                  let _ = warnings->Array.push({
+                    sliceName,
+                    message: `composite read on tags [${querySet->Array.join(
+                        ", ",
+                      )}] will silently miss '${consumedType}', which also carries [${extra->Array.join(
+                        ", ",
+                      )}] — the tag_composite key includes ALL of an event's tags, so a composite query matches only events tagged exactly [${querySet->Array.join(
+                        ", ",
+                      )}]. Align the event's tag set with the query, or read '${consumedType}' via a single-tag clause.`,
+                  })
+                }
+              },
           )
         }
       })
@@ -231,7 +232,9 @@ let validateProducedAndConsumed = (
 
   // Rule 1: Payload equivalence across producers
   // All producers of the same TAG must have identical fields, types, and tag annotations
-  producerMap->Dict.toArray->Array.forEach(((tagName, entries)) => {
+  producerMap
+  ->Dict.toArray
+  ->Array.forEach(((tagName, entries)) => {
     if entries->Array.length > 1 {
       let first = entries->Array.getUnsafe(0)
       let firstFields = first.variant.fields->Dict.keysToArray->Array.toSorted(String.compare)
@@ -243,70 +246,85 @@ let validateProducedAndConsumed = (
           let entryTagged = entry.variant.taggedFields->Array.toSorted(String.compare)
 
           // Check field names match
-          if firstFields->Array.length != entryFields->Array.length ||
-            firstFields->Array.some(f => !(entryFields->Array.includes(f))) {
-            let missingInEntry =
-              firstFields->Array.filter(f => !(entryFields->Array.includes(f)))
-            let extraInEntry =
-              entryFields->Array.filter(f => !(firstFields->Array.includes(f)))
+          if (
+            firstFields->Array.length != entryFields->Array.length ||
+              firstFields->Array.some(f => !(entryFields->Array.includes(f)))
+          ) {
+            let missingInEntry = firstFields->Array.filter(f => !(entryFields->Array.includes(f)))
+            let extraInEntry = entryFields->Array.filter(f => !(firstFields->Array.includes(f)))
             let parts = []
             if missingInEntry->Array.length > 0 {
               let _ =
                 parts->Array.push(
-                  `'${first.sliceName}' has fields [${missingInEntry->Array.join(", ")}] which '${entry.sliceName}' is missing`,
+                  `'${first.sliceName}' has fields [${missingInEntry->Array.join(
+                      ", ",
+                    )}] which '${entry.sliceName}' is missing`,
                 )
             }
             if extraInEntry->Array.length > 0 {
               let _ =
                 parts->Array.push(
-                  `'${entry.sliceName}' has fields [${extraInEntry->Array.join(", ")}] which '${first.sliceName}' is missing`,
+                  `'${entry.sliceName}' has fields [${extraInEntry->Array.join(
+                      ", ",
+                    )}] which '${first.sliceName}' is missing`,
                 )
             }
-            let _ =
-              errors->Array.push({
-                sliceName: entry.sliceName,
-                message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but with different fields: ${parts->Array.join("; ")}`,
-              })
+            let _ = errors->Array.push({
+              sliceName: entry.sliceName,
+              message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but with different fields: ${parts->Array.join(
+                  "; ",
+                )}`,
+            })
           } else {
             // Fields match by name — check types are compatible
-            firstFields->Array.forEach(fieldName => {
-              let firstSchema = first.variant.fields->Dict.getUnsafe(fieldName)
-              let entrySchema = entry.variant.fields->Dict.getUnsafe(fieldName)
-              if !schemasAreCompatible(firstSchema, entrySchema) {
-                let _ =
-                  errors->Array.push({
+            firstFields->Array.forEach(
+              fieldName => {
+                let firstSchema = first.variant.fields->Dict.getUnsafe(fieldName)
+                let entrySchema = entry.variant.fields->Dict.getUnsafe(fieldName)
+                if !schemasAreCompatible(firstSchema, entrySchema) {
+                  let _ = errors->Array.push({
                     sliceName: entry.sliceName,
-                    message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but field '${fieldName}' has type '${schemaTypeName(firstSchema)}' in '${first.sliceName}' and '${schemaTypeName(entrySchema)}' in '${entry.sliceName}'`,
+                    message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but field '${fieldName}' has type '${schemaTypeName(
+                        firstSchema,
+                      )}' in '${first.sliceName}' and '${schemaTypeName(
+                        entrySchema,
+                      )}' in '${entry.sliceName}'`,
                   })
-              }
-            })
+                }
+              },
+            )
           }
 
           // Check tag annotations match
-          if firstTagged->Array.length != entryTagged->Array.length ||
-            firstTagged->Array.some(f => !(entryTagged->Array.includes(f))) {
-            let untaggedInEntry =
-              firstTagged->Array.filter(f => !(entryTagged->Array.includes(f)))
-            let untaggedInFirst =
-              entryTagged->Array.filter(f => !(firstTagged->Array.includes(f)))
+          if (
+            firstTagged->Array.length != entryTagged->Array.length ||
+              firstTagged->Array.some(f => !(entryTagged->Array.includes(f)))
+          ) {
+            let untaggedInEntry = firstTagged->Array.filter(f => !(entryTagged->Array.includes(f)))
+            let untaggedInFirst = entryTagged->Array.filter(f => !(firstTagged->Array.includes(f)))
             let parts = []
             if untaggedInEntry->Array.length > 0 {
               let _ =
                 parts->Array.push(
-                  `[${untaggedInEntry->Array.join(", ")}] tagged in '${first.sliceName}' but not in '${entry.sliceName}'`,
+                  `[${untaggedInEntry->Array.join(
+                      ", ",
+                    )}] tagged in '${first.sliceName}' but not in '${entry.sliceName}'`,
                 )
             }
             if untaggedInFirst->Array.length > 0 {
               let _ =
                 parts->Array.push(
-                  `[${untaggedInFirst->Array.join(", ")}] tagged in '${entry.sliceName}' but not in '${first.sliceName}'`,
+                  `[${untaggedInFirst->Array.join(
+                      ", ",
+                    )}] tagged in '${entry.sliceName}' but not in '${first.sliceName}'`,
                 )
             }
-            let _ =
-              errors->Array.push({
-                sliceName: entry.sliceName,
-                message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but tag annotations differ: ${parts->Array.join("; ")}`,
-              })
+            let _ = errors->Array.push({
+              sliceName: entry.sliceName,
+              message: `Producers '${first.sliceName}' and '${entry.sliceName}' both produce '${tagName}' but tag annotations differ: ${parts->Array.join(
+                  "; ",
+                )}`,
+            })
           }
         }
       })
@@ -321,35 +339,42 @@ let validateProducedAndConsumed = (
     variants->Array.forEach(variant => {
       switch producerMap->Dict.get(variant.tagName) {
       | None =>
-        let _ =
-          errors->Array.push({
-            sliceName,
-            message: `Slice '${sliceName}' consumes '${variant.tagName}' but no slice produces it`,
-          })
+        let _ = errors->Array.push({
+          sliceName,
+          message: `Slice '${sliceName}' consumes '${variant.tagName}' but no slice produces it`,
+        })
       | Some(producers) =>
         // Use first producer as the authoritative shape (Rule 1 ensures they're all identical)
         let producer = producers->Array.getUnsafe(0)
 
         // Skip field checks for payload-less consumed variants
         if !isPayloadLess(variant) {
-          variant.fields->Dict.toArray->Array.forEach(((fieldName, consumedFieldSchema)) => {
-            switch producer.variant.fields->Dict.get(fieldName) {
-            | None =>
-              let _ =
-                errors->Array.push({
+          variant.fields
+          ->Dict.toArray
+          ->Array.forEach(
+            ((fieldName, consumedFieldSchema)) => {
+              switch producer.variant.fields->Dict.get(fieldName) {
+              | None =>
+                let _ = errors->Array.push({
                   sliceName,
-                  message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' (${schemaTypeName(consumedFieldSchema)}) but produced '${variant.tagName}' has no field '${fieldName}'`,
+                  message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' (${schemaTypeName(
+                      consumedFieldSchema,
+                    )}) but produced '${variant.tagName}' has no field '${fieldName}'`,
                 })
-            | Some(producedFieldSchema) =>
-              if !schemasAreCompatible(consumedFieldSchema, producedFieldSchema) {
-                let _ =
-                  errors->Array.push({
+              | Some(producedFieldSchema) =>
+                if !schemasAreCompatible(consumedFieldSchema, producedFieldSchema) {
+                  let _ = errors->Array.push({
                     sliceName,
-                    message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' as ${describeSchema(consumedFieldSchema)} but producer '${producer.sliceName}' declares it as ${describeSchema(producedFieldSchema)}`,
+                    message: `Slice '${sliceName}' consumes '${variant.tagName}.${fieldName}' as ${describeSchema(
+                        consumedFieldSchema,
+                      )} but producer '${producer.sliceName}' declares it as ${describeSchema(
+                        producedFieldSchema,
+                      )}`,
                   })
+                }
               }
-            }
-          })
+            },
+          )
         }
       }
     })
@@ -375,9 +400,9 @@ one warning per producer that carries a key some *other* producer declared
 
 @param producers `(sliceName, producedEventSchema)` per producing slice.
 */
-let validateCrossPartitionScope = (
-  ~producers: array<(string, S.t<unknown>)>,
-): array<validationError> => {
+let validateCrossPartitionScope = (~producers: array<(string, S.t<unknown>)>): array<
+  validationError,
+> => {
   let perProducer = producers->Array.map(((name, schema)) => {
     let cpSet = Set.make()
     DcbTag.extractCrossPartitionTagKeys(schema)->Array.forEach(k => cpSet->Set.add(k))

package/src/components/DisplayName.res

@@ -14,8 +14,10 @@ type displayNameSpec = {
 }
 
 /** Sury metadata ID used to attach a `displayNameSpec` to a state schema. */
-let displayNameId: S.Metadata.Id.t<displayNameSpec> =
-  S.Metadata.Id.make(~namespace="reventless", ~name="displayName")
+let displayNameId: S.Metadata.Id.t<displayNameSpec> = S.Metadata.Id.make(
+  ~namespace="reventless",
+  ~name="displayName",
+)
 
 /** Returns the spec attached to a state schema, if any. */
 let getSpec = (schema: S.t<unknown>): option<displayNameSpec> =>

package/src/components/ExtensionPoint.res

@@ -24,4 +24,3 @@ module type Spec = {
   @schema
   type directive
 }
-

package/src/components/FieldDefault.res

@@ -0,0 +1,52 @@
+/**
+The value a field opens with where nobody has said otherwise, published as JSON
+Schema's own `default` keyword.
+
+A statement about the domain: an order line is for one of the thing unless the
+shopper says two. A consumer that finds no default opens the field blank rather
+than inventing one.
+
+Write `@default(1)` — see `DefaultInference`, which desugars to the constructors
+below. The marker rides on the field's own schema rather than in a record-level
+spec keyed by field name, which is what makes it work at any depth: a record
+nested inside a command carries no such spec, and its fields are the ones a
+repeating group opens blank.
+
+@example
+```rescript
+@schema
+type lineItem = {
+  @ref("AvailableProducts") productId: string,
+  @default(1) quantity: int,
+}
+```
+*/
+let defaultId: S.Metadata.Id.t<JSON.t> = S.Metadata.Id.make(
+  ~namespace="reventless",
+  ~name="default",
+)
+
+/** Layers a default onto whatever the field already resolved to. Wraps rather
+    than replaces, for the reason `Sensitive.mark` does: a field carries at most
+    one `@s.matches`. */
+let mark = (schema: S.t<'a>, value: JSON.t): S.t<'a> => schema->S.Metadata.set(~id=defaultId, value)
+
+let int = (schema: S.t<int>, value: int): S.t<int> => schema->mark(JSON.Encode.int(value))
+
+let float = (schema: S.t<float>, value: float): S.t<float> => schema->mark(JSON.Encode.float(value))
+
+let string = (schema: S.t<string>, value: string): S.t<string> =>
+  schema->mark(JSON.Encode.string(value))
+
+let bool = (schema: S.t<bool>, value: bool): S.t<bool> => schema->mark(JSON.Encode.bool(value))
+
+/** The default a field declares. An optional field keeps its marker inside the
+    wrapper sury builds for `f?: t`, so the outer schema is read first and a
+    marker on the wrapper wins — the precedence `Semantic.getFrom` follows. */
+let rec getFrom = (schema: S.t<unknown>): option<JSON.t> =>
+  switch S.Metadata.get(schema, ~id=defaultId) {
+  | Some(_) as found => found
+  | None => schema->Semantic.unwrapOptional->Option.flatMap(getFrom)
+  }
+
+let get = (fieldSchema: S.t<'a>): option<JSON.t> => fieldSchema->S.castToUnknown->getFrom

package/src/components/FieldDefault.res.mjs

@@ -0,0 +1,50 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Semantic$Reventless from "../semantic/Semantic.res.mjs";
+
+let defaultId = Sury.$Metadata_Id_make("reventless", "default");
+
+function mark(schema, value) {
+  return Sury.$Metadata_set(schema, defaultId, value);
+}
+
+function int(schema, value) {
+  return Sury.$Metadata_set(schema, defaultId, value);
+}
+
+function float(schema, value) {
+  return Sury.$Metadata_set(schema, defaultId, value);
+}
+
+function string(schema, value) {
+  return Sury.$Metadata_set(schema, defaultId, value);
+}
+
+function bool(schema, value) {
+  return Sury.$Metadata_set(schema, defaultId, value);
+}
+
+function getFrom(schema) {
+  let found = Sury.$Metadata_get(schema, defaultId);
+  if (found !== undefined) {
+    return found;
+  } else {
+    return Stdlib_Option.flatMap(Semantic$Reventless.unwrapOptional(schema), getFrom);
+  }
+}
+
+let get = getFrom;
+
+export {
+  defaultId,
+  mark,
+  int,
+  float,
+  string,
+  bool,
+  getFrom,
+  get,
+}
+/* defaultId Not a pure module */

package/src/components/InboundTranslationSlice.res

@@ -31,7 +31,6 @@ let translate = input => switch input.status {
 }
 ```
 */
-
 /**
 The lean Spec for an InboundTranslationSlice — types, identity, schemas.
 */
@@ -96,4 +95,3 @@ module type Translation = {
   /** File URL of this Translation module (`import.meta.url`). */
   let moduleUrl: string
 }
-

package/src/components/OutboundTranslationSlice.res

@@ -44,7 +44,6 @@ let maxRetries = 3
 let heartbeatInterval = 60
 ```
 */
-
 /**
 The lean Spec for an OutboundTranslationSlice — types, identity, schemas, sweep config.
 */
@@ -167,9 +166,11 @@ module type Translation = {
   the framework knows nothing about still reaches it directly and simply ignores
   this argument.
   */
-  let translate: (string, Spec.outboundItem, ~capabilities: Capabilities.t) => promise<
-    result<option<(string, Spec.inboundCommand)>, string>,
-  >
+  let translate: (
+    string,
+    Spec.outboundItem,
+    ~capabilities: Capabilities.t,
+  ) => promise<result<option<(string, Spec.inboundCommand)>, string>>
 
   /**
   The retry budget is spent: this item will never be attempted again.
@@ -186,11 +187,12 @@ module type Translation = {
   The row is marked `Abandoned` either way; this decides only whether anything
   downstream hears about it.
   */
-  let onExhausted: (string, Spec.outboundItem, ~lastError: option<string>) => option<
-    (string, Spec.inboundCommand),
-  >
+  let onExhausted: (
+    string,
+    Spec.outboundItem,
+    ~lastError: option<string>,
+  ) => option<(string, Spec.inboundCommand)>
 
   /** File URL of this Translation module (`import.meta.url`). */
   let moduleUrl: string
 }
-

package/src/components/Owner.res

@@ -78,10 +78,10 @@ the view on the wrong value.
 */
 let isFieldOwner = (schema: S.t<unknown>): bool =>
   isOwner(schema) ||
-    switch schema->Semantic.unwrapOptional {
-    | Some(inner) => isOwner(inner)
-    | None => false
-    }
+  switch schema->Semantic.unwrapOptional {
+  | Some(inner) => isOwner(inner)
+  | None => false
+  }
 
 /**
 The owner fields declared on an object schema, in declaration order.

package/src/components/Plugin.res

@@ -79,7 +79,10 @@ type apiTarget = Domain | Platform
 // nothing to annotate. The `T | null` these fields used to carry worked around a sury
 // bug — undefined failing jsonableValidation inside a union variant payload — fixed in
 // 11.0.0-alpha.11. `Offload` below is not an optional wrapper but an either-or codec.
-let apiSchemaFragmentOffloadSchema = Offload.optionSchema(~store="pluginApiFragments", apiSchemaFragmentSchema)
+let apiSchemaFragmentOffloadSchema = Offload.optionSchema(
+  ~store="pluginApiFragments",
+  apiSchemaFragmentSchema,
+)
 
 // ── UI fragment manifest types ────────────────────────────────────────────────
 
@@ -489,7 +492,10 @@ type pluginStructure = {
   traitDeclarations: option<array<traitDeclaration>>,
 }
 
-let pluginStructureOffloadSchema = Offload.optionSchema(~store="pluginStructures", pluginStructureSchema)
+let pluginStructureOffloadSchema = Offload.optionSchema(
+  ~store="pluginStructures",
+  pluginStructureSchema,
+)
 
 /**
 The self-description of a deployed plugin, persisted in the plugin's event store.
@@ -510,7 +516,8 @@ type pluginDefinition = {
   extensionProtocols: array<extensionProtocol>,
   // Offloadable: a large SDL fragment is content-addressed to the pluginApiFragments
   // store and carried by reference; a small one stays Inline.
-  apiSchemaFragment: @s.matches(apiSchemaFragmentOffloadSchema) option<Offload.payload<apiSchemaFragment>>,
+  apiSchemaFragment: @s.matches(apiSchemaFragmentOffloadSchema)
+  option<Offload.payload<apiSchemaFragment>>,
   // Schema routing in split-API mode: None/"Domain" → DomainApi, Some("Platform") →
   // PlatformApi (and excluded from the DomainApi runtime schema).
   apiTarget: option<string>,
@@ -524,4 +531,3 @@ type pluginDefinition = {
   // variant → a bare JSON string.
   kind: pluginKind,
 }
-

package/src/components/ReadModel.res

@@ -205,4 +205,3 @@ module type Spec = {
       provisioning. */
   let visibility: Visibility.t
 }
-

package/src/components/Reference.res

@@ -99,10 +99,7 @@ Only one record deep, matching [`DcbTag.nestedRecordProperties`], which is the
 walk shared with the tag extraction so a marker is found in the same places by
 both.
 */
-let collectFieldTargets = (
-  fieldName: string,
-  schema: S.t<unknown>,
-): array<(string, target)> =>
+let collectFieldTargets = (fieldName: string, schema: S.t<unknown>): array<(string, target)> =>
   switch getFieldTarget(schema) {
   | Some(target) => [(fieldName, target)]
   | None =>
@@ -115,10 +112,7 @@ let collectFieldTargets = (
       ->Array.filterMap(((propName, propSchema)) =>
         propName === "TAG"
           ? None
-          : getFieldTarget(propSchema)->Option.map(target => (
-              `${prefix}.${propName}`,
-              target,
-            ))
+          : getFieldTarget(propSchema)->Option.map(target => (`${prefix}.${propName}`, target))
       )
     }
   }

package/src/components/Sensitive.res

@@ -83,10 +83,10 @@ the enclosing one would withhold a whole record because one leaf is private.
 */
 let isFieldSensitive = (schema: S.t<unknown>): bool =>
   isSensitive(schema) ||
-    switch schema->Semantic.unwrapOptional {
-    | Some(inner) => isSensitive(inner)
-    | None => false
-    }
+  switch schema->Semantic.unwrapOptional {
+  | Some(inner) => isSensitive(inner)
+  | None => false
+  }
 
 /**
 The sensitive fields declared on an object schema, in declaration order.

package/src/components/StateAnnotations.res

@@ -211,8 +211,10 @@ type stateAnnotationSpec = {
 }
 
 /** Sury metadata ID used to attach a `stateAnnotationSpec` to a state schema. */
-let stateAnnotationsId: S.Metadata.Id.t<stateAnnotationSpec> =
-  S.Metadata.Id.make(~namespace="reventless", ~name="stateAnnotations")
+let stateAnnotationsId: S.Metadata.Id.t<stateAnnotationSpec> = S.Metadata.Id.make(
+  ~namespace="reventless",
+  ~name="stateAnnotations",
+)
 
 /** Returns the spec attached to a state schema, if any. */
 let getSpec = (schema: S.t<unknown>): option<stateAnnotationSpec> =>

package/src/components/StateChangeSlice.res

@@ -41,7 +41,6 @@ let decide = (state, command) => switch command {
 }
 ```
 */
-
 /**
 The lean Spec for a StateChangeSlice — types, identity, schemas. State and
 state-evolution functions live in the sibling `Behavior` module type.
@@ -150,4 +149,3 @@ module type Behavior = {
   /** File URL of this Behavior module (`import.meta.url`). */
   let moduleUrl: string
 }
-

package/src/components/StateViewSlice.res

@@ -34,7 +34,6 @@ let project = ({event}) => switch event {
 }
 ```
 */
-
 /**
 The lean Spec for a StateViewSlice — types, identity, schemas, infra config.
 Per D2, `state` lives here (not in `Projection`) because the projected state
@@ -120,4 +119,3 @@ module type Projection = {
   /** File URL of this Projection module (`import.meta.url`). */
   let moduleUrl: string
 }
-

package/src/components/TaggedUnion.res

@@ -113,8 +113,7 @@ let armsOf = (schema: S.t<unknown>): option<array<arm>> =>
           | Some(String({const: ?Some(tag)})) =>
             let fields = properties->Dict.toArray->Array.filter(((name, _)) => name !== "TAG")
             if (
-              fields->Array.length == 0 ||
-                fields->Array.some(((name, _)) => isPositionalName(name))
+              fields->Array.length == 0 || fields->Array.some(((name, _)) => isPositionalName(name))
             ) {
               None
             } else {

package/src/components/Task.res

@@ -59,4 +59,3 @@ type config = {
   buckets?: array<bucketSpec>,
   sideEffects?: sideEffects,
 }
-

package/src/components/TraitCertificate.res

@@ -26,7 +26,6 @@ The framework does not own the runner. A consumer runs their own suite, their ow
 way, and hands the report here — so this module is a pure transformation with no
 opinion about Jest, CI, or where files live. `fromReport` is the whole of it.
 */
-
 /** One assertion, and whether it held. Named, not numbered: a count that changed
     tells a reader nothing, and a name that disappeared tells them everything. */
 @schema
@@ -101,5 +100,6 @@ let render = (certificate: t): string =>
     console reader and a machine reader agree without either restating the rule. */
 let summarize = (certificate: t): string =>
   `${certificate.trait}@${certificate.traitVersion} → ${certificate.host}: ` ++
-  `${certificate.passed->Int.toString}/${(certificate.assertions->Array.length)
+  `${certificate.passed->Int.toString}/${certificate.assertions
+    ->Array.length
     ->Int.toString} assertions, ` ++ (certificate->verified ? "verified" : "NOT verified")