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

package/CHANGELOG.md

@@ -3,6 +3,34 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.258 (2026-09-07)
+
+### Bug Fixes
+
+* **core:** a state view slice composes its [@display](https://github.com/display)Name like a read model ([851aa1d](https://github.com/ReventlessDev/reventless-core/commit/851aa1d12ddae9dd39f91084f5719cd98fe1cbd4))
+
+
+# 3.0.0-alpha.257 (2026-09-07)
+
+### Bug Fixes
+
+* **core:** hold a monitoring announcement until someone is listening ([9cc4526](https://github.com/ReventlessDev/reventless-core/commit/9cc4526d3a21ce130e219b6da88fd4f3201974bd))
+* **logging:** log a message's identity, not its serialisation ([cd7467a](https://github.com/ReventlessDev/reventless-core/commit/cd7467abdc59609279f16f358cdd8884cc49f063))
+* **ui:** a declared slot module is named, not only written ([de000ba](https://github.com/ReventlessDev/reventless-core/commit/de000baf428249f64cfc719ed52df3760198b82a))
+* feat(dcb)!: a record inside an array is still a reference and a key ([bcb9b13](https://github.com/ReventlessDev/reventless-core/commit/bcb9b13958323d8319d7fcf25c055800e84150f3))
+### Features
+
+* **core:** a command's lifecycle edge comes from its scenarios, not its claim ([1879d05](https://github.com/ReventlessDev/reventless-core/commit/1879d0570a981e7fae5bcd3808f8a36e898bd0fd))
+
+### BREAKING CHANGES
+
+* an `int` field is now `Int` in the generated SDL and
+`"integer"` in JSON Schema, where it was `Float`/`"number"`. A client
+declaring `$retryCount: Float!` against one of these fields must move to
+`Int!`.
+
+
+
 # 3.0.0-alpha.256 (2026-09-04)
 
 * feat(spec)!: one optional encoding on the wire, with no annotation ([320f91d](https://github.com/ReventlessDev/reventless-core/commit/320f91daa8bd90812a6e82069e7a1cb473041930))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.256",
+  "version": "3.0.0-alpha.258",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,22 +28,22 @@
   "dependencies": {
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.9",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.9",
     "@reventlessdev/rescript-node": "2.0.0-alpha.9",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
     "@reventlessdev/rescript-ssh2": "2.0.0-alpha.9",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.159",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.35",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.157",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.129"
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.131",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.35"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.77"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.78"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/adapter/Monitoring/Monitoring.res

@@ -100,17 +100,83 @@ module Noop: Backend = {
 
 let backend: ref<module(Backend)> = ref(module(Noop: Backend))
 
+/** Whether `use` has run. Distinguishes "nobody is listening yet" — which is
+    what the buffer below exists for — from "a backend that deliberately does
+    nothing with this unit", which is the backend's decision to make, not ours. */
+let registered = ref(false)
+
+/**
+An announcement made before any backend was registered, held until one is.
+
+"Before the build" is not early enough for every provisioning site. A module that
+creates its resources at import time announces them while the deploy program's own
+body — including its `use` call — has not started running, because an imported
+module is evaluated to completion first. The dead-letter sink is such a site, and
+it was the one execution unit in a monitored estate that no alarm ever covered:
+not because a backend declined to handle its kind, but because it was told at a
+moment when the answer to "who is listening" was permanently no one.
+
+Buffering makes the seam insensitive to that ordering. What a backend sees is the
+same set of units in the same order; only the moment it hears about the early ones
+moves, to the first instant there is anybody to hear it.
+*/
+type announcement = {
+  kind: unitKind,
+  name: string,
+  component: ReventlessInfra.Adapter.resource,
+  plugin: option<string>,
+  platform: option<string>,
+  logLocator: option<Pulumi.Output.t<string>>,
+}
+
+let pending: ref<array<announcement>> = ref([])
+
+let deliver = (module(B: Backend), a: announcement) =>
+  B.onProvisioned(
+    ~kind=a.kind,
+    ~name=a.name,
+    ~component=a.component,
+    ~plugin=a.plugin,
+    ~platform=a.platform,
+    ~logLocator=a.logLocator,
+  )
+
 /**
 Register the monitoring backend. Must run before the platform/plugin build in the
 deploy program (plain statement order — the registry is consulted lazily at each
 provisioning site). Called once, by the extension, first.
+
+Announcements from sites that ran at import time — before any statement of the
+deploy program — are replayed here, in the order they were made, and the buffer is
+drained so a second registration does not receive them twice.
 */
-let use = (b: module(Backend)) => backend := b
+let use = (b: module(Backend)) => {
+  backend := b
+  registered := true
+  let replay = pending.contents
+  pending := []
+  replay->Array.forEach(a => deliver(b, a))
+}
+
+/** Restores the registry to its initial state: no backend, nothing buffered.
+
+    A deploy program never needs this — it registers once and runs once. Tests do,
+    because the registry and the buffer are module state that outlives a single
+    case, and `use(Noop)` is a *registration* rather than an undo: it would leave
+    later announcements delivered-and-dropped instead of held. */
+let reset = () => {
+  backend := module(Noop: Backend)
+  registered := false
+  pending := []
+}
 
 /**
 Announce a provisioned execution unit to the registered backend. Called by
-runtime backends at their provisioning sites (once per unit). No-op until an
-extension registers a backend.
+runtime backends at their provisioning sites (once per unit).
+
+Held until an extension registers a backend, rather than dropped — see
+`announcement` above for why that distinction decides whether a unit provisioned
+at import time is ever monitored.
 */
 let notify = (
   ~kind: unitKind,
@@ -118,13 +184,21 @@ let notify = (
   ~component: ReventlessInfra.Adapter.resource,
   ~logLocator: option<Pulumi.Output.t<string>>=?,
 ) => {
-  module B = unpack(backend.contents)
   // The owning plugin/platform come from the ambient context the plugin builder publishes
   // (ResourceAttribution.enter) — populated exactly when this fires, so the call sites need not
   // thread the names. `None` outside a plugin construct (platform substrate).
+  //
+  // Read here rather than at delivery, because a buffered announcement is replayed from a deploy
+  // program's body, where the ambient context is whatever the *next* construct left behind. The
+  // owner belongs to the moment the unit was provisioned.
   let {ResourceAttribution.plugin: plugin, platform} = ResourceAttribution.current.contents
   // `~logLocator`, unlike the owner, is NOT ambient: only the provisioning site knows where it
   // pointed the unit's logs. So it is passed, and optional — a call site with nothing to say omits
   // it rather than being forced to invent an address.
-  B.onProvisioned(~kind, ~name, ~component, ~plugin, ~platform, ~logLocator)
+  let announcement = {kind, name, component, plugin, platform, logLocator}
+  if registered.contents {
+    deliver(backend.contents, announcement)
+  } else {
+    pending := pending.contents->Array.concat([announcement])
+  }
 }

package/src/adapter/Monitoring/Monitoring.res.mjs

@@ -14,20 +14,60 @@ let backend = {
   contents: Noop
 };
 
+let registered = {
+  contents: false
+};
+
+let pending = {
+  contents: []
+};
+
+function deliver(B, a) {
+  B.onProvisioned(a.kind, a.name, a.component, a.plugin, a.platform, a.logLocator);
+}
+
 function use(b) {
   backend.contents = b;
+  registered.contents = true;
+  let replay = pending.contents;
+  pending.contents = [];
+  replay.forEach(a => deliver(b, a));
+}
+
+function reset() {
+  backend.contents = Noop;
+  registered.contents = false;
+  pending.contents = [];
 }
 
 function notify(kind, name, component, logLocator) {
-  let B = backend.contents;
   let match = ResourceAttribution$ReventlessCore.current.contents;
-  B.onProvisioned(kind, name, component, match.plugin, match.platform, logLocator);
+  let announcement_plugin = match.plugin;
+  let announcement_platform = match.platform;
+  let announcement = {
+    kind: kind,
+    name: name,
+    component: component,
+    plugin: announcement_plugin,
+    platform: announcement_platform,
+    logLocator: logLocator
+  };
+  if (registered.contents) {
+    return deliver(backend.contents, announcement);
+  } else {
+    pending.contents = pending.contents.concat([announcement]);
+    return;
+  }
 }
 
 export {
   Noop,
   backend,
+  registered,
+  pending,
+  deliver,
   use,
+  reset,
   notify,
 }
 /* No side effect */

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -7,7 +7,7 @@ import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/Plugin
 
 let pluginId = "Platform";
 
-let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, PluginSpec$ReventlessCore.commandSchema);
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandTransition, undefined, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 

package/src/admin/Platform_ComponentDefinitionsApi.res

@@ -18,7 +18,7 @@ open Reventless.Plugin
 // consumers long after they were being encoded.
 let sdlTypes: array<string> = [
   `type Platform_FieldReference {\n  fieldName: String!\n  entity: String!\n  plugin: String\n}`,
-  `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n  requiredAccess: [String!]\n  ownerField: String\n}`,
+  `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  allowedStatesSource: String\n  apiExposed: Boolean\n  requiredAccess: [String!]\n  ownerField: String\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   // Same fields as Platform_EventDef, kept a distinct type because a refusal is not
   // a fact: a caller selecting `errors` is asking what a command can be rejected
@@ -84,6 +84,10 @@ let encodeCommandDef = (c: commandDef): JSON.t =>
       c.allowedStates->Option.mapOr(JSON.Encode.null, encodeStrings),
     ),
     ("targetState", c.targetState->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    (
+      "allowedStatesSource",
+      c.allowedStatesSource->Option.mapOr(JSON.Encode.null, JSON.Encode.string),
+    ),
     ("apiExposed", c.apiExposed->Option.mapOr(JSON.Encode.null, JSON.Encode.bool)),
     // Null, not `[]`: a rule asking for nothing checkable and a def written
     // before the field existed are the same answer to a client — "no key gates

package/src/admin/Platform_ComponentDefinitionsApi.res.mjs

@@ -6,7 +6,7 @@ import * as Plugin$ReventlessCore from "../plugin/component/Plugin.res.mjs";
 
 let sdlTypes = [
   `type Platform_FieldReference {\n  fieldName: String!\n  entity: String!\n  plugin: String\n}`,
-  `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  apiExposed: Boolean\n  requiredAccess: [String!]\n  ownerField: String\n}`,
+  `type Platform_CommandDef {\n  name: String!\n  schema: String!\n  level: String!\n  aggregateIdField: String\n  mutationField: String!\n  references: [Platform_FieldReference!]!\n  allowedStates: [String!]\n  targetState: String\n  allowedStatesSource: String\n  apiExposed: Boolean\n  requiredAccess: [String!]\n  ownerField: String\n}`,
   `type Platform_EventDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_ErrorDef {\n  name: String!\n  schema: String!\n  references: [Platform_FieldReference!]!\n}`,
   `type Platform_WriteSideDef {\n  name: String!\n  commands: [Platform_CommandDef!]!\n  linkedViews: [String!]!\n  consistencyRead: String\n  producedEventTypes: [String!]!\n  consumedEventTypes: [String!]!\n  events: [Platform_EventDef!]!\n  errors: [Platform_ErrorDef!]!\n  chapter: String\n}`,
@@ -78,6 +78,10 @@ function encodeCommandDef(c) {
       "targetState",
       Stdlib_Option.mapOr(c.targetState, null, prim => prim)
     ],
+    [
+      "allowedStatesSource",
+      Stdlib_Option.mapOr(c.allowedStatesSource, null, prim => prim)
+    ],
     [
       "apiExposed",
       Stdlib_Option.mapOr(c.apiExposed, null, prim => prim)

package/src/admin/Platform_UiSlots.res

@@ -0,0 +1,21 @@
+// Where a deployment's slot module goes, and what the shell is told to fetch.
+//
+// Stated once, in core, for the reason `Platform_BakedManifest.defaultKey`
+// gives: four places have to agree on this string — the AWS `BucketObject` key,
+// the `uiSlotsUrl` the AWS deploy writes into `config.json`, the file the local
+// platform serves out of the host-shell `dist/`, and the `uiSlotsUrl` that
+// platform overlays. A platform that spelled it differently from the one that
+// wrote the config key would put the module where nothing imports it, and the
+// symptom is a surface that draws its own regions — indistinguishable from a
+// deployment that declared no slots at all.
+//
+// Both platforms write the module beside `config.json` at what is also the
+// shell's URL root, so the file name and the path the browser asks for are one
+// string.
+
+let fileName = "ui-slots.js"
+
+/** The `config.json` key naming the module, as `SlotModules.load` reads it. */
+let configKey = "uiSlotsUrl"
+
+let url = "/" ++ fileName

package/src/admin/Platform_UiSlots.res.mjs

@@ -0,0 +1,15 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let fileName = "ui-slots.js";
+
+let url = "/" + fileName;
+
+let configKey = "uiSlotsUrl";
+
+export {
+  fileName,
+  configKey,
+  url,
+}
+/* No side effect */

package/src/admin/UiFragmentRegistry/StateChangeSlice/UiFragmentRegistry.res.mjs

@@ -47,7 +47,7 @@ function commandAuthorization(param) {
 }
 
 function commandTransition(param) {
-  return "Unrestricted";
+  return "Undeclared";
 }
 
 let traits = [];

package/src/components/Aggregate/Aggregate_Callback.res

@@ -66,15 +66,25 @@ module Make = (
   // A domain rejection from Behavior.decide is recorded as `CmdRejected` (no state change,
   // surviving commands in the batch continue); a successful decide records `CmdOk(events)`
   // and advances state via `Behavior.evolve`.
-  let processCommand = (
+  //
+  // `~seq` is the replayed sequence number the batch decides from, carried in so
+  // the line below can name the state rather than serialise it.
+  let processCommand = (~seq: int) => (
     (state, outcomes): (Behavior.state, array<(string, cmdOutcome, Message.meta)>),
     topicItem: CommandTopic.topicItem<Message.command'<Spec.Id.t, Spec.command>>,
   ) => {
     let {reference, command: command'} = topicItem
     let meta = command'->updateMeta
+    let id = command'.id->Spec.Id.toString
+    // Identity, not content: the folded state grows with the entity's whole
+    // history, so serialising it here makes the line's size a function of how
+    // long the system has been in use. The state at decision time is a
+    // debugger's subject, not a log's.
+    let cmdName =
+      command'.command->Message.encode(Spec.commandSchema)->Message.variantNameOfJson->LogFormat.bold
     EffectLogger.logDebug(
       ~comp,
-      `deciding on state: ${state->JSON.stringifyAny->Option.getOr("<unserializable>")}`,
+      `deciding: id=${id} seq=${seq->Int.toString} cmd=${cmdName}`,
     )->Effect.runSync
     switch Behavior.decide(state, command'.command) {
     | Ok(generatedEvents) =>
@@ -89,7 +99,6 @@ module Make = (
         payloadDict->Dict.toArray->Array.length == 0
           ? ""
           : payloadDict->JSON.Encode.object->JSON.stringify
-      let id = command'.id->Spec.Id.toString
       EffectLogger.logError(
         ~comp,
         `decide rejected: ${errorCode} ${errorDetail} id=${id}`,
@@ -336,7 +345,7 @@ module Make = (
     readState
     ->Effect.flatMap(((initialState, sequenceNr)) => {
       let (finalState, outcomes) =
-        topicItemsForId->Array.reduce((initialState, []), processCommand)
+        topicItemsForId->Array.reduce((initialState, []), processCommand(~seq=sequenceNr))
 
       let eventsToAppend =
         outcomes

package/src/components/Aggregate/Aggregate_Callback.res.mjs

@@ -29,13 +29,15 @@ function Make(Spec) {
       Spec.Id.makeFromString(param[0]),
       param[1]
     ]));
-    let processCommand = (param, topicItem) => {
+    let processCommand = seq => ((param, topicItem) => {
       let reference = topicItem.reference;
       let command$p = topicItem.command;
       let outcomes = param[1];
       let state = param[0];
       let meta = Message$ReventlessCore.deriveMeta(command$p.meta, undefined);
-      Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding on state: ` + Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>")));
+      let id = Spec.Id.toString(command$p.id);
+      let cmdName = LogFormat$ReventlessCore.bold(Message$ReventlessCore.variantNameOfJson(Message$ReventlessCore.encode(command$p.command, Spec.commandSchema)));
+      Effect.runSync(EffectLogger$ReventlessCore.logDebug(comp, undefined, `deciding: id=` + id + ` seq=` + seq.toString() + ` cmd=` + cmdName));
       let generatedEvents = Behavior.decide(state, command$p.command);
       if (generatedEvents.TAG === "Ok") {
         let generatedEvents$1 = generatedEvents._0;
@@ -57,7 +59,6 @@ function Make(Spec) {
       let match = Message$ReventlessCore.splitMessage(errorJson);
       let payloadDict = match[1];
       let errorDetail = Object.entries(payloadDict).length === 0 ? "" : JSON.stringify(payloadDict);
-      let id = Spec.Id.toString(command$p.id);
       Effect.runSync(EffectLogger$ReventlessCore.logError(comp, undefined, `decide rejected: ` + errorCode + ` ` + errorDetail + ` id=` + id));
       return [
         state,
@@ -71,7 +72,7 @@ function Make(Spec) {
             meta
           ]])
       ];
-    };
+    });
     let replayCache = Lru$ReventlessCore.make(100);
     let resetCache = () => Lru$ReventlessCore.clear(replayCache);
     let snapshotConfig = Behavior.snapshot;
@@ -249,7 +250,7 @@ function Make(Spec) {
         let match = Stdlib_Array.reduce(topicItemsForId, [
           initialState,
           []
-        ], processCommand);
+        ], processCommand(sequenceNr));
         let outcomes = match[1];
         let finalState = match[0];
         let eventsToAppend = outcomes.map(param => {

package/src/components/Api/GraphQL_FragmentGenerator.res

@@ -42,6 +42,7 @@ let rec fromSchemaType = (
   switch st {
   | ScalarString => `String${bang}`
   | ScalarNumber => `Float${bang}`
+  | ScalarInt => `Int${bang}`
   | ScalarBoolean => `Boolean${bang}`
   | ScalarBigInt => `String${bang}`
   | EntityId => `ID${bang}`
@@ -286,6 +287,7 @@ let rec scalarOfSchemaType = (st: SchemaType.schemaType): string =>
   switch st {
   | ScalarString => "String"
   | ScalarNumber => "Float"
+  | ScalarInt => "Int"
   | ScalarBoolean => "Boolean"
   | ScalarBigInt => "String"
   | EntityId => "ID"

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

@@ -43,6 +43,8 @@ function fromSchemaType(_required, _asInputOpt, _st, collectedTypes, seenTypes)
       switch (st) {
         case "ScalarNumber" :
           return `Float` + bang;
+        case "ScalarInt" :
+          return `Int` + bang;
         case "ScalarBoolean" :
           return `Boolean` + bang;
         case "EntityId" :
@@ -219,6 +221,8 @@ function scalarOfSchemaType(_st) {
       switch (st) {
         case "ScalarNumber" :
           return "Float";
+        case "ScalarInt" :
+          return "Int";
         case "ScalarBoolean" :
           return "Boolean";
         case "EntityId" :

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

@@ -24,7 +24,7 @@ function generateTools(pluginName, mutationEntries) {
         if (fieldName.length <= 0) {
           return;
         }
-        let inputSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema);
+        let inputSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, schema);
         let base = entryDescription.length > 0 ? entryDescription : `Execute ` + fieldName + ` on ` + pluginName;
         let desc = buildDescriptionSuffix(base, entry);
         tools.push({
@@ -39,7 +39,7 @@ function generateTools(pluginName, mutationEntries) {
           if (fieldName.length <= 0) {
             return;
           }
-          let inputSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(variantSchema);
+          let inputSchema = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(undefined, undefined, variantSchema);
           let obj = Stdlib_JSON.Decode.object(inputSchema);
           let withId;
           if (obj !== undefined) {

package/src/components/Api/SchemaType.res

@@ -1,6 +1,11 @@
 type rec schemaType =
   | ScalarString
   | ScalarNumber
+  | /** A number the schema says is whole. sury carries the fact on the number's
+        `format`, and it was being dropped here — so every `int` in the domain
+        reached the SDL as `Float` and JSON Schema as `"number"`, and a quantity
+        was a field a client could legally send `2.5` in. */
+  ScalarInt
   | ScalarBoolean
   | ScalarBigInt
   | EntityId
@@ -103,6 +108,9 @@ and shapeOf = (~parentName: string, ~fieldName: string, schema: S.t<unknown>): s
     | String({const: ?Some(_)}) => ScalarString
     | String(_) if isDateTime(schema) => DateTime
     | 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.
+    | Number({format: ?Some(Int32 | Port)}) => ScalarInt
     | Number(_) => ScalarNumber
     | Boolean(_) => ScalarBoolean
     | BigInt(_) => ScalarBigInt

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

@@ -85,7 +85,17 @@ function shapeOf(parentName, fieldName, schema) {
         return "ScalarString";
       }
     case "number" :
-      return "ScalarNumber";
+      let match = schema.format;
+      if (match === undefined) {
+        return "ScalarNumber";
+      }
+      switch (match) {
+        case "int32" :
+        case "port" :
+          return "ScalarInt";
+        case "integer" :
+          return "ScalarNumber";
+      }
     case "bigint" :
       return "ScalarBigInt";
     case "boolean" :
@@ -168,12 +178,12 @@ function shapeOf(parentName, fieldName, schema) {
           return $$enum;
         }
       }
-      let match = TaggedUnion$Reventless.classify(schema);
-      if (match === undefined) {
+      let match$1 = TaggedUnion$Reventless.classify(schema);
+      if (match$1 === undefined) {
         return "Unknown";
       }
-      let unionName = match[0];
-      let armTypes = match[1].map(param => {
+      let unionName = match$1[0];
+      let armTypes = match$1[1].map(param => {
         let armSchema = param.schema;
         let tag = param.tag;
         let memberName = TaggedUnion$Reventless.memberTypeName(unionName, tag);