@reventlessdev/reventless-core 3.0.0-alpha.252 → 3.0.0-alpha.254

package/CHANGELOG.md

@@ -3,6 +3,31 @@
 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.254 (2026-09-02)
+
+* feat(aws)!: the messaging sender is configuration, and a stack can choose to only log ([23b8b4b](https://github.com/ReventlessDev/reventless-core/commit/23b8b4bfe9c70555de4d74266ca686cb427485ca))
+### Features
+
+* **dcb:** a boundary that cannot derive its scope says so ([db79969](https://github.com/ReventlessDev/reventless-core/commit/db79969df36bd90607425f6a22b4624227cfc4a0))
+
+### BREAKING CHANGES
+
+* `Capability_Messaging_Ses.make` is replaced by
+`Capability_Messaging.make(~name)`, which reads the transport and the address
+from config; the SES module keeps only `emailSender`. A deployment that named its
+sender in code must move it to `platform:messagingEmailSender` or the deploy is
+refused.
+
+
+
+# 3.0.0-alpha.253 (2026-09-01)
+
+**Note:** Version bump only for package @reventlessdev/reventless-core
+
+
+
+
+
 # 3.0.0-alpha.252 (2026-09-01)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.252",
+  "version": "3.0.0-alpha.254",
   "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.8",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.8",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-node": "2.0.0-alpha.8",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.153",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.125"
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.8",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.155",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.127",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.34"
   },
   "devDependencies": {
     "rescript": "12.3.0",
     "sury-ppx": "11.0.0-rc.2",
-    "@reventlessdev/reventless-ppx": "1.0.0-alpha.75"
+    "@reventlessdev/reventless-ppx": "1.0.0-alpha.76"
   },
   "peerDependencies": {
     "rescript": "12.3.0"

package/src/adapter/Messaging/Messaging_Log_Backend.res

@@ -0,0 +1,98 @@
+// A logging messaging transport: accepts every message, delivers none, prints
+// each one to the log.
+//
+// Provider-neutral and therefore here rather than beside either platform's own
+// transport: both use it, and two copies would drift into two different ideas of
+// what a logged send looks like. It is the counterpart to
+// `Messaging_Ses_Backend` and deliberately the same shape — `channels` derived
+// from the sender, `send` answering the shared `Messaging` vocabulary, `provider`
+// closing over the sender. A slice reaches it through the injected capability
+// record and cannot tell which one it got, which is the property that makes
+// running a shop against it worth anything.
+//
+// **Accepting is the honest answer here, not a shortcut.** The alternative is
+// `Capabilities.none`, which reports `Unavailable` — a *retryable* outage, so
+// every notification is retried three times and then recorded as failed. A
+// delivery view that is all failures teaches the wrong thing about a competency
+// that works. Nothing leaves the process either way; the difference is only
+// whether the outcome tells the truth about the domain.
+//
+// It refuses nothing a real provider would refuse, and that is the tradeoff to
+// know: SES rejects a message with no subject, this does not, so a bug of that
+// shape is caught on the real transport and not here.
+//
+// Runtime-pure: no Pulumi import, so it can be bundled into a Lambda entry point
+// without dragging deploy-time modules into the cold-start graph.
+
+let log = Logger.fromEnv()
+
+/** Logged messages are numbered rather than given a random id: someone reading two
+    log lines wants to know they are two messages, and a counter says so at a
+    glance where a uuid does not. Per process, like the transport itself. */
+let sent = ref(0)
+
+/**
+The channels this transport can attempt.
+
+Derived from the sender exactly as SES derives it, so a platform that chose this
+transport but named no address publishes the same empty list an unprovisioned
+deployment does. SMS and push are absent for the same reason they are absent
+there — no transport — and answer `UnsupportedChannel`, which is settled rather
+than retried.
+*/
+let channels = (~sender: string): array<Reventless.Messaging.channel> =>
+  sender == "" ? [] : [Email]
+
+/** The message as it would have gone out, headers and all.
+
+    The whole point of the transport: someone checking that a notification says the
+    right thing needs the words, not a line saying words were sent. Rendered as
+    one record rather than a line per header so two concurrent sends cannot
+    interleave into one unreadable message. */
+let render = (
+  ~ref_: string,
+  ~sender: string,
+  ~to_: string,
+  ~message: Reventless.Messaging.message,
+) =>
+  [
+    `${ref_} — logged, not sent`,
+    `  From:    ${sender}`,
+    `  To:      ${to_}`,
+    `  Subject: ${message.subject->Option.getOr("(none)")}`,
+    "",
+    message.body,
+  ]->Array.join("\n")
+
+/** Accept the message, print it, deliver nothing. */
+let send = async (
+  ~sender: string,
+  ~recipient: Reventless.Messaging.recipient,
+  ~message: Reventless.Messaging.message,
+): result<Reventless.Messaging.receipt, Reventless.Messaging.failure> =>
+  switch recipient {
+  | ToSms(_) => Error(UnsupportedChannel(Sms))
+  | ToPush(_) => Error(UnsupportedChannel(Push))
+  | ToEmail(address) =>
+    if sender == "" {
+      // The wording an unprovisioned platform gave before this transport existed.
+      // It is what lands in the delivery view's `detail`, and a platform that
+      // provisions nothing should still read the way it always did.
+      Error(Unavailable("no messaging provider is configured for this platform"))
+    } else {
+      sent := sent.contents + 1
+      let ref_ = `log:${sent.contents->Int.toString}`
+      log.info(
+        ~comp="Messaging:Log",
+        render(~ref_, ~sender, ~to_=address->Reventless.Email.toString, ~message),
+      )
+      Ok({ref: ref_})
+    }
+  }
+
+/** The port, closed over the sender this platform was given. What a platform's
+    capability record carries when logging is the chosen transport. */
+let provider = (~sender: string): Reventless.Messaging.provider => {
+  channels: channels(~sender),
+  send: (~recipient, ~message) => send(~sender, ~recipient, ~message),
+}

package/src/adapter/Messaging/Messaging_Log_Backend.res.mjs

@@ -0,0 +1,86 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let sent = {
+  contents: 0
+};
+
+function channels(sender) {
+  if (sender === "") {
+    return [];
+  } else {
+    return ["Email"];
+  }
+}
+
+function render(ref_, sender, to_, message) {
+  return [
+    ref_ + ` — logged, not sent`,
+    `  From:    ` + sender,
+    `  To:      ` + to_,
+    `  Subject: ` + Stdlib_Option.getOr(message.subject, "(none)"),
+    "",
+    message.body
+  ].join("\n");
+}
+
+async function send(sender, recipient, message) {
+  switch (recipient.TAG) {
+    case "ToEmail" :
+      if (sender === "") {
+        return {
+          TAG: "Error",
+          _0: {
+            TAG: "Unavailable",
+            _0: "no messaging provider is configured for this platform"
+          }
+        };
+      }
+      sent.contents = sent.contents + 1 | 0;
+      let ref_ = `log:` + sent.contents.toString();
+      log.info("Messaging:Log", undefined, render(ref_, sender, recipient._0, message));
+      return {
+        TAG: "Ok",
+        _0: {
+          ref: ref_
+        }
+      };
+    case "ToSms" :
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnsupportedChannel",
+          _0: "Sms"
+        }
+      };
+    case "ToPush" :
+      return {
+        TAG: "Error",
+        _0: {
+          TAG: "UnsupportedChannel",
+          _0: "Push"
+        }
+      };
+  }
+}
+
+function provider(sender) {
+  return {
+    channels: channels(sender),
+    send: (recipient, message) => send(sender, recipient, message)
+  };
+}
+
+export {
+  log,
+  sent,
+  channels,
+  render,
+  send,
+  provider,
+}
+/* log Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -379,10 +379,7 @@ module Make = (
         // (DcbCommandTopicEntryPoint.mjs) route through `DcbTag.deriveEffectiveScope`
         // so the runtime decision query cannot drift from this scope — see
         // docs/analysis/dcb-runtime-scope-annotation-drift.md.
-        let {
-          crossPartitionTagKeys: effectiveCrossPartitionTagKeys,
-          tagKeysByEventType: effectiveTagKeysByEventType,
-        } = Reventless.DcbTag.deriveEffectiveScope(
+        let effective = Reventless.DcbTag.deriveEffectiveScope(
           stateChangeSlices->Array.map((module(Sc: StateChangeSlice.T)) => {
             Reventless.DcbTag.name: Sc.Spec.name,
             commandSchema: Sc.Spec.commandSchema->S.castToUnknown,
@@ -390,6 +387,26 @@ module Make = (
             eventSchema: Sc.Spec.eventSchema->S.castToUnknown,
           }),
         )
+        let effectiveCrossPartitionTagKeys = effective.crossPartitionTagKeys
+        let effectiveTagKeysByEventType = effective.tagKeysByEventType
+
+        // An ambiguity is a warning above because a boundary can fall back and
+        // lose nothing. Losing a cross-partition key is not that: the decision
+        // read for every slice that references another entity silently narrows to
+        // its own partition, so it decides against an empty history and rejects a
+        // command whose facts are sitting in the log. Nothing downstream fails —
+        // the wrong answer *is* the failure — so this is the only place it can be
+        // said, and it is said at error level naming the slice to fix.
+        if effective.droppedCrossPartitionTagKeys->Array.length > 0 {
+          log.error(
+            ~comp="Dcb_Builder",
+            `DCB scope degraded (${name}): cross-partition reads of [${effective.droppedCrossPartitionTagKeys->Array.join(
+                ", ",
+              )}] were derived but dropped — an ambiguous slice forced the boundary onto @crossPartition annotations that do not carry them. Slices referencing another entity by these keys will decide against an empty history and reject valid commands. Resolve: ${effective.ambiguities
+              ->Array.map(((slice, reason)) => `${slice} (${reason})`)
+              ->Array.join(" | ")}`,
+          )
+        }
 
         module DcbEventLog = DcbEventLog_Builder.Make(
           DcbEventLogStorage,

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -231,14 +231,17 @@ function Make(DcbEventLogStorage) {
       let scopeIssues = DcbValidation$Reventless.validateScopeVsInference(scopeAnnotations, inferred);
       scopeIssues.contradictions.forEach(e => log.warn("Dcb_Builder", undefined, `DCB scope contradiction (` + e.sliceName + `): ` + e.message));
       scopeIssues.redundancies.forEach(e => log.info("Dcb_Builder", undefined, `DCB scope (` + e.sliceName + `): ` + e.message));
-      let match = DcbTag$Reventless.deriveEffectiveScope(stateChangeSlices.map(Sc => ({
+      let effective = DcbTag$Reventless.deriveEffectiveScope(stateChangeSlices.map(Sc => ({
         name: Sc.Spec.name,
         commandSchema: Sc.Spec.commandSchema,
         consumedEventSchema: Sc.Spec.consumedEventSchema,
         eventSchema: Sc.Spec.eventSchema
       })));
-      let effectiveTagKeysByEventType = match.tagKeysByEventType;
-      let effectiveCrossPartitionTagKeys = match.crossPartitionTagKeys;
+      let effectiveCrossPartitionTagKeys = effective.crossPartitionTagKeys;
+      let effectiveTagKeysByEventType = effective.tagKeysByEventType;
+      if (effective.droppedCrossPartitionTagKeys.length !== 0) {
+        log.error("Dcb_Builder", undefined, `DCB scope degraded (` + name + `): cross-partition reads of [` + effective.droppedCrossPartitionTagKeys.join(", ") + `] were derived but dropped — an ambiguous slice forced the boundary onto @crossPartition annotations that do not carry them. Slices referencing another entity by these keys will decide against an empty history and reject valid commands. Resolve: ` + effective.ambiguities.map(param => param[0] + ` (` + param[1] + `)`).join(" | "));
+      }
       let DcbEventLog = DcbEventLog_Builder$ReventlessCore.Make(DcbEventLogStorage)(DcbEventTopicPublisher);
       let dcbEventLog = DcbEventLog.make(name, indexes$1, partitionTag, effectiveCrossPartitionTagKeys, opts);
       Stdlib_Option.forEach(HooksConfig.hooks.onDcbEventLogCreated, hook => hook(dcbEventLog));

package/src/plugin/component/Plugin_Structure.res

@@ -117,7 +117,7 @@ let checkRetiredValue = (~entityName: string, stateSchema: S.t<unknown>): retire
           ->Option.map(f => ` (that is "${f}")`)
           ->Option.getOr(
             " (it declares none)",
-          )}. A retirement state no command's @transition can name loses the command filtering the state form exists for.`,
+          )}. A retirement state no command's declared edge can name loses the command filtering the state form exists for.`,
       )
     }
     let declared = switch stateSchema {
@@ -179,8 +179,9 @@ let reportRetiredStates = (
   }
 }
 
-// The states a record's lifecycle field can hold — the field `@transition` is
-// written in terms of. `None`: no lifecycle; `Some([])`: one with no cases.
+// The states a record's lifecycle field can hold — the field a command's
+// declared edge is written in terms of. `None`: no lifecycle; `Some([])`: one
+// with no cases.
 let lifecycleStatesFromStateSchema = (
   ~entityName: string,
   stateSchema: S.t<unknown>,
@@ -373,18 +374,17 @@ let reportTranslationTables = (
   }
 }
 
-// A command's declared edge names states belonging to another component's enum.
-// From `@transition` the PPX only ever sees names, so a misspelling compiles clean
-// and produces a command legal in a state no row is in. Both sides are in hand
-// here. A state the linked views do not declare raises (this runs at assembly,
+// A command's declared edge names states belonging to another component's enum,
+// and nothing forces a spec to pick the one its linked view declares. Both sides
+// are in hand here. A state the linked views do not declare raises (this runs at assembly,
 // never in a Lambda, so that is a failed deploy); no resolvable view only warns.
 // Checked against the UNION of the linked views: a slice feeding two is not
 // claiming which one.
 //
-// A `commandTransition` switch comes through the same `commandDef` fields and is
-// checked the same way. The compiler has already resolved its constructors, so
-// what survives to here is naming the wrong enum rather than misspelling one —
-// which this catches for the same reason and with the same message.
+// The compiler has already resolved the switch's constructors, so what survives
+// to here is a component naming the wrong lifecycle enum rather than misspelling
+// a state — the half of the check `lifecycleState` cannot make, since nothing
+// forces a spec to pick its linked view's enum.
 let checkDeclaredTransitions = (
   ~pluginName: string,
   ~writables: array<Reventless.Plugin.writableDef>,
@@ -714,9 +714,8 @@ let toCommandDef = (
   // component-level shortcut would gate `AddProduct` and `PlaceOrder` alike.
   ~commandAuthorization: unknown => Reventless.Authorization.permission,
   // The spec's `command => Transition.t<_>`, evaluated per variant the same way
-  // `commandAuthorization` is. It wins over the `@transition` metadata where it
-  // declares an edge, and stands aside where it says `Unrestricted` — which is
-  // what the PPX injects for a spec that never wrote the switch.
+  // `commandAuthorization` is, and the only declaration of an edge there is —
+  // the PPX injects `Unrestricted` for a spec that writes no switch.
   //
   // Read at `t<string>` because this is the erasure boundary: the spec declares
   // its edges over the linked view's own lifecycle enum, whose arms are
@@ -740,34 +739,15 @@ let toCommandDef = (
       Reventless.DcbTag.isVariantPayloadBearing(parentSchema, variantName)
         ? {"TAG": variantName}->Obj.magic
         : variantName->Obj.magic
-    // The spec's own switch, which is the only form that can speak for a
-    // constructor the host did not declare: `@transition` lowers to a dict on
-    // the parent union, and a variant spread splices members, so a spliced
-    // command reaches the metadata below carrying nothing.
-    let declared = commandTransition(syntheticCommand)
-    // An edge is ONE declaration, so the two fields are chosen together. Taking
-    // them separately would let `Guards(…)` — which positively claims the
-    // command moves the row nowhere — inherit a target from an annotation it
-    // was written to replace.
-    //
-    // The `@transition` metadata is per-variant but attached by the PPX to the
-    // *parent* schema as one dict. It is consulted only where the switch
-    // declares no edge at all: a spec that never wrote one answers
-    // `Unrestricted` for every command, which is how the annotation stays in
-    // charge for the hosts that still use it.
+    // The spec's own switch, which is exhaustive — so it also speaks for a
+    // constructor the host did not declare but spliced from a trait.
     //
+    // An edge is ONE declaration, so the two fields are read off it together.
     // `targetState: None` ⇒ AutoUI's board resolver falls back to its name-stem
     // heuristic.
-    let (allowedStates, targetState) = switch declared {
-    | Unrestricted => (
-        ApiAllowedStatesHelpers.getAllowedStates(parentSchema, ~variantName),
-        ApiTargetStateHelpers.getTargetState(parentSchema, ~variantName),
-      )
-    | _ => (
-        Reventless.Transition.allowedStates(declared),
-        Reventless.Transition.targetState(declared),
-      )
-    }
+    let declared = commandTransition(syntheticCommand)
+    let allowedStates = Reventless.Transition.allowedStates(declared)
+    let targetState = Reventless.Transition.targetState(declared)
     // API-exposed iff the whole command isn't @noApi and this variant
     // isn't in its @noApi-variants set — mirrors the API-generation filter
     // (Plugin_Helpers / PluginBaseFragment). Drives the event-graph API badge.

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

@@ -25,8 +25,6 @@ import * as StateAnnotations$Reventless from "@reventlessdev/reventless-spec/src
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
 import * as SuryToJsonSchema$ReventlessCore from "../../components/Api/SuryToJsonSchema.res.mjs";
 import * as Capability_Inference$ReventlessCore from "./Capability_Inference.res.mjs";
-import * as ApiTargetStateHelpers$ReventlessCore from "../../components/Api/ApiTargetStateHelpers.res.mjs";
-import * as ApiAllowedStatesHelpers$ReventlessCore from "../../components/Api/ApiAllowedStatesHelpers.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../../components/Api/GraphQL_FragmentGenerator.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
@@ -122,7 +120,7 @@ function checkRetiredValue(entityName, stateSchema) {
   let named = values.join(", ");
   let lifecycle = lifecycleFieldFromStateSchema(entityName, 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 @transition can name loses the command filtering the state form exists for.`);
+    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.`);
   }
   let declared;
   declared = stateSchema.type === "object" ? Stdlib_Option.getOr(Stdlib_Option.map(stateSchema.properties[field], schema => {
@@ -602,14 +600,8 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
         TAG: variantName
       }) : variantName;
     let declared = commandTransition(syntheticCommand);
-    let match$1;
-    match$1 = typeof declared !== "object" ? [
-        ApiAllowedStatesHelpers$ReventlessCore.getAllowedStates(parentSchema, variantName),
-        ApiTargetStateHelpers$ReventlessCore.getTargetState(parentSchema, variantName)
-      ] : [
-        Transition$Reventless.allowedStates(declared),
-        Transition$Reventless.targetState(declared)
-      ];
+    let allowedStates = Transition$Reventless.allowedStates(declared);
+    let targetState = Transition$Reventless.targetState(declared);
     let apiExposed = false;
     if (!ApiNoApiHelpers$ReventlessCore.isNoApi(parentSchema)) {
       let excluded = ApiNoApiHelpers$ReventlessCore.getExcludedVariants(parentSchema);
@@ -626,8 +618,8 @@ function toCommandDef(isAggregate, mutationFieldFor, parentSchema, commandAuthor
       aggregateIdField: match[1],
       mutationField: mutationField,
       references: references,
-      allowedStates: match$1[0],
-      targetState: match$1[1],
+      allowedStates: allowedStates,
+      targetState: targetState,
       apiExposed: apiExposed,
       requiredAccess: requiredAccess,
       ownerField: Owner$Reventless.fieldNamesOfProperties(properties)[0]

package/src/plugin/lifecycle/PluginSpec.res

@@ -2,8 +2,9 @@
 
 open Reventless.Plugin
 
-// Alias, not `open`: the PPX strips `@transition` before the typechecker, so the
-// state constructors never reach it and an `open` would warn as unused.
+// Alias, not `open`: the lifecycle states are named qualified in
+// `commandTransition` below, and an `open` would pull the whole view's namespace
+// in for four constructors.
 module Plugins = PluginsReadModelSpec
 
 // The Plugin aggregate is keyed by plugin **name** (not name@version). One
@@ -15,10 +16,7 @@ module Plugins = PluginsReadModelSpec
 // more same-shaped ones, so the `pluginDefinition` pair must lead (DZakh/sury#392).
 @schema
 type command =
-  // The handshake brings the version's row into being, so it runs from no state
-  // — `decide` accepts it against an unknown version and against every status
-  // but `Connected`, where it is a definition refresh rather than a move.
-  | @noApi @transition(() => Plugins.Connected) Connect(pluginDefinition)
+  | @noApi Connect(pluginDefinition)
   // Records a protocol-version incompatibility without changing connection state.
   | @noApi ReportIncompatibility(pluginDefinition)
   | @noApi Heartbeat(version)
@@ -26,28 +24,20 @@ type command =
   // re-run for an already-connected version so its definition is refreshed on the
   // row — unlike Heartbeat, which no-ops a connected keep-alive.
   | @noApi Redetect(version)
-  // A heartbeat timing out is the only way a row reaches `Disconnected`, and
-  // `decide` moves the row for exactly one status — anything else is a stray
-  // disconnect it tolerates without emitting.
-  | @noApi @transition(([Plugins.Connected]) => Plugins.Disconnected) Disconnect(version)
+  | @noApi Disconnect(version)
   // Admin lifecycle commands — API-exposed (auto-derived admin mutations,
   // Cognito group-gated). `version` selects which known version to act on.
-  // The `@transition` edges must agree with `decide` below; `Platform_Admin_Structure`
-  // reads them off this schema rather than restating them.
   //
   // Inline records, unlike the `@noApi` commands above, and the difference is the
   // API. A positional payload publishes its argument as `_0`, which names nothing:
   // a caller cannot match it against a field it holds, and a coercion failure says
   // `Variable '_0'` rather than what was missing. These three are the ones a person
   // calls, so their argument carries its own name.
-  | @transition(([Plugins.Inactive, Plugins.Retired]) => Plugins.Connected)
-  Activate({version: version})
-  | @transition(([Plugins.Connected, Plugins.Disconnected]) => Plugins.Inactive)
-  Deactivate({version: version})
+  | Activate({version: version})
+  | Deactivate({version: version})
   // Manual admin retirement of a specific version (archive). Distinct from the
   // automatic `Superseded` transition (which is decided, not commanded).
-  | @transition(([Plugins.Connected, Plugins.Disconnected, Plugins.Inactive]) => Plugins.Retired)
-  Retire({version: version})
+  | Retire({version: version})
 
 // Carries both the superseded and the superseding version's full definition —
 // a deterministic trigger for version-to-version schema/data migrations
@@ -91,3 +81,28 @@ type error =
   | AlreadyConnected
   | IsDisconnected
   | IsInactive
+
+// The edges must agree with `decide`; `Platform_Admin_Structure` reads them off
+// the assembled structure rather than restating them.
+type lifecycleState = Plugins.status
+
+let commandTransition = (command: command): Reventless.Transition.t<lifecycleState> => {
+  open Reventless.Transition
+  switch command {
+  // The handshake brings the version's row into being, so it runs from no state
+  // — `decide` accepts it against an unknown version and against every status
+  // but `Connected`, where it is a definition refresh rather than a move.
+  | Connect(_) => Creates(Plugins.Connected)
+  // Neither records a move: an incompatibility is noted beside the row, and a
+  // heartbeat or a re-detect refreshes one that is already where it belongs.
+  | ReportIncompatibility(_) | Heartbeat(_) | Redetect(_) => Unrestricted
+  // A heartbeat timing out is the only way a row reaches `Disconnected`, and
+  // `decide` moves the row for exactly one status — anything else is a stray
+  // disconnect it tolerates without emitting.
+  | Disconnect(_) => Moves([Plugins.Connected], Plugins.Disconnected)
+  | Activate(_) => Moves([Plugins.Inactive, Plugins.Retired], Plugins.Connected)
+  | Deactivate(_) => Moves([Plugins.Connected, Plugins.Disconnected], Plugins.Inactive)
+  | Retire(_) =>
+    Moves([Plugins.Connected, Plugins.Disconnected, Plugins.Inactive], Plugins.Retired)
+  }
+}

package/src/plugin/lifecycle/PluginSpec.res.mjs

@@ -92,6 +92,52 @@ let errorSchema = Sury.union([
   Sury.literal("IsInactive")
 ]);
 
+function commandTransition(command) {
+  switch (command.TAG) {
+    case "Connect" :
+      return {
+        TAG: "Creates",
+        _0: "Connected"
+      };
+    case "Disconnect" :
+      return {
+        TAG: "Moves",
+        _0: ["Connected"],
+        _1: "Disconnected"
+      };
+    case "Activate" :
+      return {
+        TAG: "Moves",
+        _0: [
+          "Inactive",
+          "Retired"
+        ],
+        _1: "Connected"
+      };
+    case "Deactivate" :
+      return {
+        TAG: "Moves",
+        _0: [
+          "Connected",
+          "Disconnected"
+        ],
+        _1: "Inactive"
+      };
+    case "Retire" :
+      return {
+        TAG: "Moves",
+        _0: [
+          "Connected",
+          "Disconnected",
+          "Inactive"
+        ],
+        _1: "Retired"
+      };
+    default:
+      return "Unrestricted";
+  }
+}
+
 let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
   "Connect",
   "ReportIncompatibility",
@@ -100,66 +146,10 @@ let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, [
   "Disconnect"
 ]);
 
-let commandSchema$2 = Api$ReventlessInfra.markAllowedStates(commandSchema$1, [
-  [
-    "Disconnect",
-    ["Connected"]
-  ],
-  [
-    "Activate",
-    [
-      "Inactive",
-      "Retired"
-    ]
-  ],
-  [
-    "Deactivate",
-    [
-      "Connected",
-      "Disconnected"
-    ]
-  ],
-  [
-    "Retire",
-    [
-      "Connected",
-      "Disconnected",
-      "Inactive"
-    ]
-  ]
-]);
-
-let commandSchema$3 = Api$ReventlessInfra.markTargetState(commandSchema$2, [
-  [
-    "Connect",
-    "Connected"
-  ],
-  [
-    "Disconnect",
-    "Disconnected"
-  ],
-  [
-    "Activate",
-    "Connected"
-  ],
-  [
-    "Deactivate",
-    "Inactive"
-  ],
-  [
-    "Retire",
-    "Retired"
-  ]
-]);
-
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Unrestricted";
-}
-
 let traits = [];
 
 let name = "Plugin";
@@ -177,10 +167,10 @@ export {
   versionSupersededDataSchema,
   eventSchema,
   errorSchema,
-  commandSchema$3 as commandSchema,
+  commandTransition,
+  commandSchema$1 as commandSchema,
   moduleUrl,
   commandAuthorization,
-  commandTransition,
   traits,
 }
 /* commandSchema Not a pure module */

package/tests/plugin/PluginStructureTest.res

@@ -304,11 +304,11 @@ describe("lifecycle topology", () => {
 })
 
 describe("commandTransition — the edge as a switch", () => {
-  // The seam a variant spread needs. `@transition` lowers to a dict on the
-  // parent union keyed by variant name, and a spread splices members, so a
-  // command a host did not declare cannot be annotated at all. A switch over the
-  // command reaches every constructor, spliced or not, and the compiler makes
-  // it exhaustive.
+  // The seam a variant spread needs. The removed attribute lowered to a dict on
+  // the parent union keyed by variant name, and a spread splices members, so a
+  // command a host did not declare could not be annotated at all. A switch over
+  // the command reaches every constructor, spliced or not, and the compiler
+  // makes it exhaustive.
   let structure = Plugin_Structure.make(
     ~name="TransitionSwitchPlugin",
     ~stateChangeSlices=[module(PsTransitionSwitchSlice)],
@@ -325,21 +325,15 @@ describe("commandTransition — the edge as a switch", () => {
   })
 
   testSync("a guard declares its from-set and no target", () => {
-    // The same positive claim the one-sided `@transition` makes: legal in these
-    // states, and it moves the row nowhere.
+    // A positive claim rather than an omission: legal in these states, and it
+    // moves the row nowhere. Distinguishable on the wire from both fields being
+    // None, and consumers are expected to honour it.
     expect((
       byName("Rebook")->Option.flatMap(c => c.allowedStates),
       byName("Rebook")->Option.flatMap(c => c.targetState),
     ))->toEqual((Some(["Booked"]), None))
   })
 
-  testSync("the switch wins over an @transition on the same command", () => {
-    // `Rebook` carries both, and they disagree on purpose: the attribute says
-    // Draft. Two sources of truth need a stated winner, and it is the one the
-    // compiler checked.
-    expect(byName("Rebook")->Option.flatMap(c => c.allowedStates))->toEqual(Some(["Booked"]))
-  })
-
   testSync("Unrestricted declares nothing, leaving the command unconstrained", () => {
     // Distinct from a from-set naming every state, which says the same thing to
     // a menu and something different to a reader.
@@ -384,12 +378,14 @@ describe("traitDeclarations — a graft leaves a trace", () => {
   })
 })
 
-describe("@transition cross-check", () => {
+describe("declared-edge cross-check", () => {
   // The exit criterion: a state no linked view declares stops the build, and the
   // message says which command, which state, and what it was checked against.
   // `DispatchShipment` produces `ShipmentDispatched`, which the `Shipments` view
   // consumes — so the two are linked, the view's lifecycle is in hand, and
-  // "Dispatchd" has somewhere to be wrong.
+  // "Dispatchd" has somewhere to be wrong. It compiles because the switch names
+  // the slice's OWN enum: the typechecker cannot see that the wrong lifecycle
+  // was picked, and this is the check that can.
   let buildBad = () =>
     try {
       Plugin_Structure.make(
@@ -504,11 +500,10 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ))->toEqual((Some(true), Some(false)))
     })
 
-    testSync("ShipOrder: @transition's target flows through the PPX to commandDef.targetState", () => {
-      // End-to-end: the reventless-ppx @transition annotation → markTargetState
-      // metadata → ApiTargetStateHelpers.getTargetState → commandDef. The
-      // un-annotated CancelShipment carries None (resolver falls back to
-      // name-stem).
+    testSync("ShipOrder: the switch's target flows through to commandDef.targetState", () => {
+      // End-to-end: the spec's `commandTransition`, evaluated per constructor
+      // against a synthetic command → commandDef. `CancelShipment` answers
+      // `Unrestricted` and carries None (resolver falls back to name-stem).
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       let byName = name => shipOrder.commands->Array.find(c => c.name == name)
       expect((
@@ -517,10 +512,10 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       ))->toEqual((Some("Shipped"), None))
     })
 
-    testSync("ShipOrder: @transition's from-set flows through to commandDef.allowedStates", () => {
-      // The other half of the same annotation, which the removed pair spelled
-      // separately: one attribute now fills both fields, so a command that
-      // declares a target cannot end up without the states it may run from.
+    testSync("ShipOrder: the switch's from-set flows through to commandDef.allowedStates", () => {
+      // The other half of the same declaration. An edge is one value, so a
+      // command that declares a target cannot end up without the states it may
+      // run from — the two fields are read off it together.
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       let byName = name => shipOrder.commands->Array.find(c => c.name == name)
       expect((

package/tests/plugin/PluginStructureTest.res.mjs

@@ -602,9 +602,6 @@ globalThis.describe("commandTransition — the edge as a switch", () => {
       undefined
     ]);
   });
-  globalThis.test("the switch wins over an @transition on the same command", () => {
-    globalThis.expect(Stdlib_Option.flatMap(byName("Rebook"), c => c.allowedStates)).toEqual(["Booked"]);
-  });
   globalThis.test("Unrestricted declares nothing, leaving the command unconstrained", () => {
     globalThis.expect([
       Stdlib_Option.flatMap(byName("Abandon"), c => c.allowedStates),
@@ -646,7 +643,7 @@ globalThis.describe("traitDeclarations — a graft leaves a trace", () => {
   });
 });
 
-globalThis.describe("@transition cross-check", () => {
+globalThis.describe("declared-edge cross-check", () => {
   let buildBad = () => {
     try {
       Plugin_Structure$ReventlessCore.make("TransitionPlugin", undefined, undefined, [PsShipmentsViewSlice], [PsDispatchShipmentSlice], undefined, undefined, undefined, undefined, undefined, undefined);
@@ -759,7 +756,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         false
       ]);
     });
-    globalThis.test("ShipOrder: @transition's target flows through the PPX to commandDef.targetState", () => {
+    globalThis.test("ShipOrder: the switch's target flows through to commandDef.targetState", () => {
       let shipOrder = structure.stateChangeSlices[1];
       let byName = name => shipOrder.commands.find(c => c.name === name);
       globalThis.expect([
@@ -770,7 +767,7 @@ globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
         undefined
       ]);
     });
-    globalThis.test("ShipOrder: @transition's from-set flows through to commandDef.allowedStates", () => {
+    globalThis.test("ShipOrder: the switch's from-set flows through to commandDef.allowedStates", () => {
       let shipOrder = structure.stateChangeSlices[1];
       let byName = name => shipOrder.commands.find(c => c.name === name);
       globalThis.expect([

package/tests/plugin/StateChangeSlice/PsDispatchShipment.res

@@ -1,15 +1,16 @@
-// Test fixture spec for the @transition cross-check — the failing case.
+// Test fixture spec for the declared-edge cross-check — the failing case.
 //
-// `Dispatchd` is a deliberate typo. It compiles: the PPX strips the attribute
-// before the typechecker sees it, so a misspelled state is a well-formed string
-// all the way down. That is exactly the hole the structure-side check closes,
-// and a fixture that could not compile would not demonstrate it.
+// The switch names constructors of THIS file's own enum, and `Dispatchd` is a
+// real case of it, so the compiler is satisfied. The linked `Shipments` view
+// declares `Booked | Dispatched`, and nothing forces a spec to pick its linked
+// view's enum — which is the hole the structure-side check closes, and the half
+// the typechecker cannot reach.
 
 @@reventless.spec("DispatchShipment")
 
 type shipmentStatus =
   | Booked
-  | Dispatched
+  | Dispatchd
 
 @schema
 type consumedEvent = ShipmentBooked({shipmentId: string})
@@ -20,7 +21,7 @@ type state = bool
 let initialState = false
 
 @schema
-type command = @transition(([Booked]) => Dispatchd) DispatchShipment({shipmentId: string})
+type command = DispatchShipment({shipmentId: string})
 
 @schema
 type error = ShipmentNotFound
@@ -29,3 +30,12 @@ type error = ShipmentNotFound
 type event = ShipmentDispatched({shipmentId: string})
 
 let decide = (_state, _command): result<array<event>, error> => Ok([])
+
+type lifecycleState = shipmentStatus
+
+let commandTransition = (command: command): Reventless.Transition.t<lifecycleState> => {
+  open Reventless.Transition
+  switch command {
+  | DispatchShipment(_) => Moves([Booked], Dispatchd)
+  }
+}

package/tests/plugin/StateChangeSlice/PsDispatchShipment.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
   TAG: "ShipmentBooked",
@@ -32,24 +31,18 @@ function decide(_state, _command) {
   };
 }
 
-let commandSchema$1 = Api$ReventlessInfra.markAllowedStates(commandSchema, [[
-    "DispatchShipment",
-    ["Booked"]
-  ]]);
-
-let commandSchema$2 = Api$ReventlessInfra.markTargetState(commandSchema$1, [[
-    "DispatchShipment",
-    "Dispatchd"
-  ]]);
+function commandTransition(command) {
+  return {
+    TAG: "Moves",
+    _0: ["Booked"],
+    _1: "Dispatchd"
+  };
+}
 
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Unrestricted";
-}
-
 let traits = [];
 
 let name = "DispatchShipment";
@@ -68,14 +61,14 @@ export {
   consumedEventSchema,
   evolve,
   initialState,
+  commandSchema,
   errorSchema,
   eventSchema,
   decide,
-  commandSchema$2 as commandSchema,
+  commandTransition,
   moduleUrl,
   commandAuthorization,
   readConsistency,
-  commandTransition,
   traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsShipOrder.res

@@ -13,27 +13,21 @@ type consumedEvent = OrderPlaced | OrderShipped | OrderCancelled
 
 let evolve = (_state, _event) => true
 
-// CancelShipment is payload-less — it compiles to a bare string literal, so it
-// exercises toCommandDef's payload-less branch (still surfaced in `commands`).
-// It is also `@noApi` (internal/admin only): a two-variant slice with exactly
-// one API-exposed command, which is the case that used to leak the exposed
-// command's slice mutation field onto the non-exposed variant.
-// The lifecycle this slice's commands move a shipment through. The PPX strips
-// @transition before the typechecker sees it, so this enum is not what makes the
-// reference below valid — the structure-side check against the linked view is.
-// It is here because a state is a constructor, and naming one in a string is a
-// reference nothing can check at any layer.
+// The lifecycle this slice's commands move a shipment through. Declared here
+// rather than on a linked view because this fixture's plugin has none: the
+// structure-side check warns instead of failing when a component's views declare
+// no lifecycle, and that is the path this exercises.
 type shipmentStatus = Placed | Shipped | Cancelled
 
 // CancelShipment is payload-less — it compiles to a bare string literal, so it
 // exercises toCommandDef's payload-less branch (still surfaced in `commands`).
 // It is also `@noApi` (internal/admin only): a two-variant slice with exactly
 // one API-exposed command, which is the case that used to leak the exposed
-// command's slice mutation field onto the non-exposed variant. It carries no
-// @transition, which is the un-annotated case the resolver still guesses for.
+// command's slice mutation field onto the non-exposed variant. It declares no
+// edge, which is the case the board resolver still guesses for.
 @schema
 type command =
-  | @transition(([Placed]) => Shipped) ShipOrder({orderId: string})
+  | ShipOrder({orderId: string})
   | @noApi CancelShipment
 
 // Two variants, one payload-less and one carrying a field — the same two branches
@@ -47,3 +41,13 @@ type error = OrderNotFound | NotShippable({reason: string})
 type event = OrderShipped({orderId: string}) | ShipmentVoided
 
 let decide = (_state, _command): result<array<event>, error> => Ok([])
+
+type lifecycleState = shipmentStatus
+
+let commandTransition = (command: command): Reventless.Transition.t<lifecycleState> => {
+  open Reventless.Transition
+  switch command {
+  | ShipOrder(_) => Moves([Placed], Shipped)
+  | CancelShipment => Unrestricted
+  }
+}

package/tests/plugin/StateChangeSlice/PsShipOrder.res.mjs

@@ -45,26 +45,24 @@ function decide(_state, _command) {
   };
 }
 
-let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["CancelShipment"]);
-
-let commandSchema$2 = Api$ReventlessInfra.markAllowedStates(commandSchema$1, [[
-    "ShipOrder",
-    ["Placed"]
-  ]]);
+function commandTransition(command) {
+  if (typeof command !== "object") {
+    return "Unrestricted";
+  } else {
+    return {
+      TAG: "Moves",
+      _0: ["Placed"],
+      _1: "Shipped"
+    };
+  }
+}
 
-let commandSchema$3 = Api$ReventlessInfra.markTargetState(commandSchema$2, [[
-    "ShipOrder",
-    "Shipped"
-  ]]);
+let commandSchema$1 = Api$ReventlessInfra.markNoApiVariants(commandSchema, ["CancelShipment"]);
 
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
 
-function commandTransition(param) {
-  return "Unrestricted";
-}
-
 let traits = [];
 
 let name = "ShipOrder";
@@ -86,11 +84,11 @@ export {
   errorSchema,
   eventSchema,
   decide,
-  commandSchema$3 as commandSchema,
+  commandTransition,
+  commandSchema$1 as commandSchema,
   moduleUrl,
   commandAuthorization,
   readConsistency,
-  commandTransition,
   traits,
 }
 /* consumedEventSchema Not a pure module */

package/tests/plugin/StateChangeSlice/PsTransitionSwitch.res

@@ -1,18 +1,13 @@
-// Test fixture spec for `commandTransition` — the edge declared as a switch
-// rather than as an attribute.
+// Test fixture spec for `commandTransition` — the three shapes of a declared
+// edge, in one command type:
 //
-// Three cases in one command type:
-//
-//   `Book`     declares only through the switch, which is the case
-//              `@transition` cannot serve for a spliced constructor.
-//   `Rebook`   carries BOTH. The switch says `Booked`, the attribute says
-//              `Draft`; the switch is what must reach the commandDef, because
-//              two sources of truth need a stated winner.
-//   `Abandon`  declares nothing in either, and must stay unconstrained.
+//   `Book`     moves the row: a from-set and a target.
+//   `Rebook`   guards only: a from-set and no target, which is the positive
+//              claim that the command moves the row nowhere.
+//   `Abandon`  declares nothing, and must stay unconstrained.
 //
 // The states go in as constructors of this file's own enum, so the compiler
-// resolves them. `@transition` on `Rebook` cannot — it is stripped before the
-// typechecker runs, which is why `PsDispatchShipment` can carry a typo at all.
+// resolves them.
 
 @@reventless.spec("TransitionSwitch")
 
@@ -29,7 +24,7 @@ let initialState = false
 @schema
 type command =
   | Book({bookingId: string})
-  | @transition(([Draft]) => Draft) Rebook({bookingId: string})
+  | Rebook({bookingId: string})
   | Abandon({bookingId: string})
 
 @schema

package/tests/plugin/StateChangeSlice/PsTransitionSwitch.res.mjs

@@ -2,7 +2,6 @@
 
 import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
-import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 
 let consumedEventSchema = Sury.$schema(s => ({
   TAG: "BookingDrafted",
@@ -72,16 +71,6 @@ let traits = [{
     posture: "SelfContained"
   }];
 
-let commandSchema$1 = Api$ReventlessInfra.markAllowedStates(commandSchema, [[
-    "Rebook",
-    ["Draft"]
-  ]]);
-
-let commandSchema$2 = Api$ReventlessInfra.markTargetState(commandSchema$1, [[
-    "Rebook",
-    "Draft"
-  ]]);
-
 function commandAuthorization(param) {
   return "AllowAuthenticated";
 }
@@ -102,12 +91,12 @@ export {
   consumedEventSchema,
   evolve,
   initialState,
+  commandSchema,
   errorSchema,
   eventSchema,
   decide,
   commandTransition,
   traits,
-  commandSchema$2 as commandSchema,
   moduleUrl,
   commandAuthorization,
   readConsistency,

package/tests/plugin/StateViewSlice/PsShipmentsView.res

@@ -1,4 +1,4 @@
-// Test fixture spec for the @transition cross-check.
+// Test fixture spec for the declared-edge cross-check.
 // A view that declares a lifecycle, so a command's declared states have
 // something to be checked against. `PsOrdersView` deliberately declares none —
 // the two together cover both the checked and the unvalidated path.

package/src/components/Api/ApiAllowedStatesHelpers.res

@@ -1,18 +0,0 @@
-// Read per-variant `allowedStates` metadata that the reventless-ppx
-// an `@transition` from-set attaches to a command schema. Consumed by
-// `Plugin_Structure.toCommandDef` when building the `commandDef` records that
-// land in `Platform_ComponentDefinitions` so AutoUI can filter the per-row command
-// menu by the row's status.
-
-open ReventlessInfra.Api
-
-/** Returns the allowed-state list for a given command-variant name, or None
-    when the variant declares no `@transition` (the command shows on every row). */
-let getAllowedStates = (
-  commandSchema: S.t<unknown>,
-  ~variantName: string,
-): option<array<string>> =>
-  switch commandSchema->S.Metadata.get(~id=allowedStatesId) {
-  | None => None
-  | Some(entries) => entries->Dict.get(variantName)
-  }

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

@@ -1,16 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Sury from "sury";
-import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
-
-function getAllowedStates(commandSchema, variantName) {
-  let entries = Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.allowedStatesId);
-  if (entries !== undefined) {
-    return entries[variantName];
-  }
-}
-
-export {
-  getAllowedStates,
-}
-/* sury Not a pure module */

package/src/components/Api/ApiTargetStateHelpers.res

@@ -1,21 +0,0 @@
-// Read per-variant `targetState` metadata that the reventless-ppx
-// an `@transition` target attaches to a command schema. Consumed by
-// `Plugin_Structure.toCommandDef` when building the `commandDef` records that
-// land in `Platform_ComponentDefinitions`, so AutoUI's board drag resolver can
-// move a row by a *declared* transition instead of a name-stem guess. Mirrors
-// `ApiAllowedStatesHelpers.getAllowedStates`.
-
-open ReventlessInfra.Api
-
-/** Returns the declared target state for a given command-variant name, or None
-    when the variant declares no target — either because it carries no
-    `@transition` at all, or because it declares a from-set only, which is a
-    command saying it does not move the row. */
-let getTargetState = (
-  commandSchema: S.t<unknown>,
-  ~variantName: string,
-): option<string> =>
-  switch commandSchema->S.Metadata.get(~id=targetStateId) {
-  | None => None
-  | Some(entries) => entries->Dict.get(variantName)
-  }

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

@@ -1,16 +0,0 @@
-// Generated by ReScript, PLEASE EDIT WITH CARE
-
-import * as Sury from "sury";
-import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
-
-function getTargetState(commandSchema, variantName) {
-  let entries = Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.targetStateId);
-  if (entries !== undefined) {
-    return entries[variantName];
-  }
-}
-
-export {
-  getTargetState,
-}
-/* sury Not a pure module */