@reventlessdev/reventless-infra 3.0.0-alpha.152 → 3.0.0-alpha.154

package/CHANGELOG.md

@@ -3,6 +3,27 @@
 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.154 (2026-09-01)
+
+**Note:** Version bump only for package @reventlessdev/reventless-infra
+
+
+
+
+
+# 3.0.0-alpha.153 (2026-09-01)
+
+### Bug Fixes
+
+* **api:** [@no](https://github.com/no)Api was lost when a command variant was spliced into another type ([00403fb](https://github.com/ReventlessDev/reventless-core/commit/00403fb4b8873a68a69558829e598339a5012833))
+* **capabilities:** a plugin's geocoding need was declared nowhere and failed silently ([67917dd](https://github.com/ReventlessDev/reventless-core/commit/67917dd504b43fa78b7c6a51644c9eae656b7f6b))
+### Features
+
+* **capabilities:** a plugin can send a message without naming a provider ([b001a1e](https://github.com/ReventlessDev/reventless-core/commit/b001a1e9361a0f4d0affe228cb4c08c38a5a995e))
+* **spec:** a command declares its lifecycle edge as a value ([40eee9f](https://github.com/ReventlessDev/reventless-core/commit/40eee9f7723dc05e418be680528f01967d074da4))
+* **spec:** a graft leaves a trace the deployed plugin can read ([c08ff6c](https://github.com/ReventlessDev/reventless-core/commit/c08ff6c0f6177d58603e7ae1e5cec392d9bac16a))
+
+
 # 3.0.0-alpha.152 (2026-08-27)
 
 * feat(spec)!: reflect the command direction across a port, both halves ([f2fe258](https://github.com/ReventlessDev/reventless-core/commit/f2fe258d195b74f4a61488edee305665341020ea))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-infra",
-  "version": "3.0.0-alpha.152",
+  "version": "3.0.0-alpha.154",
   "description": "Infrastructure types for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -17,9 +17,9 @@
     "sury-ppx": "11.0.0-rc.2",
     "uuid": "^13.0.0",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.124"
+    "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.126"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/components/Api.res

@@ -7,37 +7,76 @@ let noApiId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(~namespace="api", ~name=
 let noApiVariantsId: S.Metadata.Id.t<Set.t<string>> =
   S.Metadata.Id.make(~namespace="api", ~name="noApiVariants")
 
-/** Internal sury metadata ID storing per-variant allowed-state lists for AutoUI command filtering.
-    Maps variant name → set of status values under which the command is meaningful. */
-let allowedStatesId: S.Metadata.Id.t<dict<array<string>>> =
-  S.Metadata.Id.make(~namespace="api", ~name="allowedStates")
+/** The same exclusion, carried by the excluded *member* rather than by the union
+    it sits in — so it survives a variant spread.
 
-/** Internal sury metadata ID storing per-variant target-state values for AutoUI board
-    transitions. Maps variant name → the single status the command's handler writes. */
-let targetStateId: S.Metadata.Id.t<dict<string>> =
-  S.Metadata.Id.make(~namespace="api", ~name="targetState")
+    A spread splices members: the generated code concatenates the source union's
+    `anyOf` into the target's. Metadata on the source *union* is not part of that,
+    so an exclusion recorded only there vanishes on the way into the host, and the
+    host publishes a command its author marked internal. A mark on the member
+    travels, because the member is what is spliced — the host's union holds the
+    same schema object. */
+let noApiVariantId: S.Metadata.Id.t<bool> =
+  S.Metadata.Id.make(~namespace="api", ~name="noApiVariant")
 
 /** PPX helper: attaches the noApi flag to a command schema. Called by generated code. */
 let markNoApi = (schema: S.t<'a>): S.t<'a> =>
   schema->S.Metadata.set(~id=noApiId, true)
 
-/** PPX helper: attaches variant-level exclusions to a command schema. Called by generated code. */
-let markNoApiVariants = (schema: S.t<'a>, variants: array<string>): S.t<'a> =>
-  schema->S.Metadata.set(~id=noApiVariantsId, Set.fromArray(variants))
-
-/** PPX helper: attaches per-variant allowedStates to a command schema. Called by generated code
-    emitted from the from-set of an @transition attribute. Each entry is (variantName, allowedStateNames). */
-let markAllowedStates = (
-  schema: S.t<'a>,
-  entries: array<(string, array<string>)>,
-): S.t<'a> => schema->S.Metadata.set(~id=allowedStatesId, Dict.fromArray(entries))
-
-/** PPX helper: attaches per-variant targetState to a command schema. Called by generated code
-    emitted from the target of an @transition attribute. Each entry is (variantName, targetStateName). */
-let markTargetState = (
-  schema: S.t<'a>,
-  entries: array<(string, string)>,
-): S.t<'a> => schema->S.Metadata.set(~id=targetStateId, Dict.fromArray(entries))
+/** The constructor a union member stands for: the `TAG` literal of a
+    payload-bearing variant, or the bare literal a payload-less one compiles to. */
+let variantNameOf = (member: S.t<unknown>): option<string> =>
+  switch member {
+  | Object({properties}) =>
+    properties
+    ->Dict.get("TAG")
+    ->Option.flatMap(tag =>
+      switch tag {
+      | String({const: ?Some(name)}) => Some(name)
+      | _ => None
+      }
+    )
+  | String({const: ?Some(name)}) => Some(name)
+  | _ => None
+  }
+
+/**
+PPX helper: attaches variant-level exclusions to a command schema. Called by
+generated code.
+
+Recorded twice, on purpose. The set on the union is what every reader has always
+consulted; the per-member mark is what survives being spliced into another type.
+Writing only the second would break any reader holding a union whose members it
+did not build, and writing only the first is the defect this exists to close.
+
+The union is rebuilt from the marked members because sury metadata is immutable —
+setting it returns a new schema, so the members the original union holds would
+otherwise still be the unmarked ones. Sound here because the PPX calls this
+*first*, directly on the freshly built union, before any other metadata is
+attached: there is nothing on the parent yet to lose. A schema that is not a
+union, or that names no excluded variant, is left structurally untouched.
+*/
+let markNoApiVariants = (schema: S.t<'a>, variants: array<string>): S.t<'a> => {
+  let excluded = Set.fromArray(variants)
+  let marked = switch (variants, schema->S.castToUnknown) {
+  | ([], _) => schema
+  | (_, AnyOf({anyOf})) =>
+    anyOf
+    ->Array.map(member =>
+      switch variantNameOf(member) {
+      | Some(name) if excluded->Set.has(name) => member->S.Metadata.set(~id=noApiVariantId, true)
+      | _ => member
+      }
+    )
+    ->S.union
+    // The rebuilt union describes the same values as the one handed in — same
+    // members, same order, only metadata added. `S.union` cannot express that in
+    // the type, so the equivalence is carried here rather than by the compiler.
+    ->(Obj.magic: S.t<unknown> => S.t<'a>)
+  | (_, _) => schema
+  }
+  marked->S.Metadata.set(~id=noApiVariantsId, excluded)
+}
 
 /** Type alias for schema fragments (re-exports Plugin.apiSchemaFragment). */
 type schemaFragment = Reventless.Plugin.apiSchemaFragment

package/src/components/Api.res.mjs

@@ -1,39 +1,61 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as Sury from "sury";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 
 let noApiId = Sury.$Metadata_Id_make("api", "noApi");
 
 let noApiVariantsId = Sury.$Metadata_Id_make("api", "noApiVariants");
 
-let allowedStatesId = Sury.$Metadata_Id_make("api", "allowedStates");
-
-let targetStateId = Sury.$Metadata_Id_make("api", "targetState");
+let noApiVariantId = Sury.$Metadata_Id_make("api", "noApiVariant");
 
 function markNoApi(schema) {
   return Sury.$Metadata_set(schema, noApiId, true);
 }
 
-function markNoApiVariants(schema, variants) {
-  return Sury.$Metadata_set(schema, noApiVariantsId, new Set(variants));
+function variantNameOf(member) {
+  switch (member.type) {
+    case "string" :
+      let name = member.const;
+      if (name !== undefined) {
+        return name;
+      } else {
+        return;
+      }
+    case "object" :
+      return Stdlib_Option.flatMap(member.properties["TAG"], tag => {
+        if (tag.type !== "string") {
+          return;
+        }
+        let name = tag.const;
+        if (name !== undefined) {
+          return name;
+        }
+      });
+    default:
+      return;
+  }
 }
 
-function markAllowedStates(schema, entries) {
-  return Sury.$Metadata_set(schema, allowedStatesId, Object.fromEntries(entries));
-}
-
-function markTargetState(schema, entries) {
-  return Sury.$Metadata_set(schema, targetStateId, Object.fromEntries(entries));
+function markNoApiVariants(schema, variants) {
+  let excluded = new Set(variants);
+  let marked = variants.length !== 0 && schema.type === "anyOf" ? Sury.union(schema.anyOf.map(member => {
+      let name = variantNameOf(member);
+      if (name !== undefined && excluded.has(name)) {
+        return Sury.$Metadata_set(member, noApiVariantId, true);
+      } else {
+        return member;
+      }
+    })) : schema;
+  return Sury.$Metadata_set(marked, noApiVariantsId, excluded);
 }
 
 export {
   noApiId,
   noApiVariantsId,
-  allowedStatesId,
-  targetStateId,
+  noApiVariantId,
   markNoApi,
+  variantNameOf,
   markNoApiVariants,
-  markAllowedStates,
-  markTargetState,
 }
 /* noApiId Not a pure module */

package/src/types/ExtensionMapping.res

@@ -147,6 +147,9 @@ module NoDelegate = {
   let moduleUrl: string = %raw(`import.meta.url`)
   let commandAuthorization = (_: command): Reventless.Authorization.permission =>
     AllowAuthenticated
+  type lifecycleState = unit
+  let commandTransition = (_: command): Reventless.Transition.t<lifecycleState> => Unrestricted
+  let traits: array<Reventless.Trait.t> = []
 }
 
 

package/src/types/ExtensionMapping.res.mjs

@@ -32,6 +32,12 @@ function commandAuthorization() {
   return "AllowAuthenticated";
 }
 
+function commandTransition() {
+  return "Unrestricted";
+}
+
+let traits = [];
+
 let NoDelegate = {
   name: "NoDelegate",
   Id: Id,
@@ -39,7 +45,9 @@ let NoDelegate = {
   errorSchema: errorSchema,
   commandSchema: commandSchema,
   moduleUrl: moduleUrl,
-  commandAuthorization: commandAuthorization
+  commandAuthorization: commandAuthorization,
+  commandTransition: commandTransition,
+  traits: traits
 };
 
 function Make(MappingImpl) {

package/src/types/Platform.res

@@ -109,6 +109,7 @@ store, and reaching another plugin's store is the qualified form.
 type capability =
   | ObjectStore({plugin: string, store: string})
   | Geocoding
+  | Messaging
 
 // A provisioned geocoding place index, as returned by the framework's geocoding
 // capability helper. A record rather than a bare name so the handle can grow
@@ -181,6 +182,20 @@ type bakedManifest = {
 
 type geocoderIndex = {indexName: Pulumi.Input.t<string>}
 
+/**
+A provisioned messaging sender, as returned by the framework's messaging
+capability helper.
+
+`emailSender` is the verified address messages are sent *from* — a provider-side
+identity, not something an application picks per message, which is why it is a
+deploy-time handle rather than a field on `Messaging.message`. Absent when the
+deployment provisions no email channel.
+
+The channel set is derived from which senders are present rather than declared
+beside them, so a handle carrying no sender at all cannot claim a channel.
+*/
+type messagingSender = {emailSender?: Pulumi.Input.t<string>}
+
 // Options for the shell's map view mode. Written to config.json flat, beside
 // `viewModes`, because that is where the shell reads them; carried on the arm
 // here so a style set with the map off is unrepresentable.
@@ -426,6 +441,12 @@ module type T = {
     // on the platform API — and exports the index name for the unattended slice
     // path. Unset ⇒ no resolver, no export. In-memory platforms ignore this.
     geocoderPlaceIndex?: geocoderIndex,
+    // Optional messaging sender. When set, the deploy exports the verified
+    // sender address for the unattended slice path and grants those Lambdas the
+    // right to send from it. No client door — a browser has no business sending
+    // from the deployment's identity. Unset ⇒ no export, no grant. In-memory
+    // platforms ignore this.
+    messagingSender?: messagingSender,
     // Optional object store for direct-to-store uploads. When set, the deploy
     // provisions a presign service against it, threads that service's URL into
     // config.json as `uploadEndpoint`, and serves the store read-only from the

package/src/types/PluginExtensionPointSpec.res.mjs

@@ -175,6 +175,14 @@ let requiredStoreDeclarationSchema = Plugin$Reventless.requiredStoreDeclarationS
 
 let requiredStoreDeclarationArrayOptionSchema = Plugin$Reventless.requiredStoreDeclarationArrayOptionSchema;
 
+let requiredCapabilityDeclarationSchema = Plugin$Reventless.requiredCapabilityDeclarationSchema;
+
+let requiredCapabilityDeclarationArrayOptionSchema = Plugin$Reventless.requiredCapabilityDeclarationArrayOptionSchema;
+
+let traitDeclarationSchema = Plugin$Reventless.traitDeclarationSchema;
+
+let traitDeclarationArrayOptionSchema = Plugin$Reventless.traitDeclarationArrayOptionSchema;
+
 let pluginStructureSchema = Plugin$Reventless.pluginStructureSchema;
 
 let pluginStructureOffloadSchema = Plugin$Reventless.pluginStructureOffloadSchema;
@@ -225,6 +233,10 @@ export {
   extensionPointDefArrayOptionSchema,
   requiredStoreDeclarationSchema,
   requiredStoreDeclarationArrayOptionSchema,
+  requiredCapabilityDeclarationSchema,
+  requiredCapabilityDeclarationArrayOptionSchema,
+  traitDeclarationSchema,
+  traitDeclarationArrayOptionSchema,
   pluginStructureSchema,
   pluginStructureOffloadSchema,
   pluginDefinitionSchema,