@reventlessdev/reventless-core 3.0.0-alpha.239 → 3.0.0-alpha.241

package/src/admin/Platform_Admin_Structure.res

@@ -7,9 +7,11 @@
 // never seeds them into pluginStructuresStore — so the host shell's Auto UI
 // has no metadata for the admin plugin and renders nothing for it.
 //
-// This module produces an equivalent structure by hand using the same field
-// naming conventions (Api_Naming.adminField) and the mutation arg schemas
-// from PluginBaseFragment.
+// This module assembles the equivalent structure from `PluginSpec` /
+// `PluginsReadModelSpec` directly, through the same module-level extractors
+// `make` uses for every ordinary plugin. It cannot call `make` itself — the
+// platform has no `module(Aggregate.T)` to hand it at structure-assembly time —
+// but the extractors take schemas, which is all this needs.
 
 open Reventless.Plugin
 
@@ -17,86 +19,31 @@ let pluginId = "Platform"
 
 let pluginName = pluginId
 
-let encodeSchema = (schema: S.t<unknown>): string =>
-  schema->SuryToJsonSchema.deriveObjectSchema->JSON.stringify
+let commandSchema = PluginSpec.commandSchema->S.castToUnknown
 
-// Strip the named fields from a derived JSON schema's `properties` map and
-// `required` list. Used so Plugin read model metadata announced via
-// `Platform_ComponentDefinitions` matches the SDL — fields excluded from the GraphQL
-// schema in `PluginBaseFragment` must also disappear from the schema string
-// AutoUI consumes, or list-view queries will reference non-existent fields.
-let encodeSchemaExcluding = (schema: S.t<unknown>, ~excludeFields: array<string>): string => {
-  let derived = schema->SuryToJsonSchema.deriveObjectSchema
-  switch derived->JSON.Decode.object {
-  | None => derived->JSON.stringify
-  | Some(obj) =>
-    switch obj->Dict.get("properties")->Option.flatMap(JSON.Decode.object) {
-    | None => derived->JSON.stringify
-    | Some(props) =>
-      excludeFields->Array.forEach(f => props->Dict.delete(f))
-      obj->Dict.set("properties", props->JSON.Encode.object)
-      switch obj->Dict.get("required")->Option.flatMap(JSON.Decode.array) {
-      | None => ()
-      | Some(req) =>
-        let filtered =
-          req
-          ->Array.filterMap(JSON.Decode.string)
-          ->Array.filter(name => !(excludeFields->Array.includes(name)))
-          ->Array.map(JSON.Encode.string)
-          ->JSON.Encode.array
-        obj->Dict.set("required", filtered)
-      }
-      obj->JSON.Encode.object->JSON.stringify
-    }
-  }
-}
-
-// Args schema for the synthetic Auto UI metadata. Activate/Deactivate are payload-less
-// `PluginSpec.command` variants on the wire — the auto-resolver flow injects `id: ID!`.
-// Keep a local schema here so Auto UI's command-form metadata stays accurate.
-@schema
-type idArgs = {id: @s.matches(Reventless.DcbTag.string) string}
-
-// `aggregateIdField: Some("id")` pre-fills the form's `id` input from the
-// selected list row. The auto-codegen path would emit this for any
-// Instance-level command whose schema has a DCB-tagged id field; the
-// hand-rolled definitions below have to mirror that.
-
-// `allowedStates` mirrors the PluginBehavior accept/reject branches: Activate
-// is meaningful only on Inactive plugins; Deactivate is meaningful on
-// Connected or Disconnected ones. Strings here must match the variant
-// constructor names that PluginsReadModelSpec.status serialises to.
-let activateCommand: commandDef = {
-  name: "Activate",
-  schema: idArgsSchema->S.castToUnknown->encodeSchema,
-  level: Instance,
-  aggregateIdField: Some("id"),
-  mutationField: Api_Naming.adminField(~name="Plugin_Activate"),
-  references: [],
-  allowedStates: Some(["Inactive"]),
-  targetState: None,
-  apiExposed: Some(true),
-  requiredAccess: None,
-  ownerField: None,
-}
-
-let deactivateCommand: commandDef = {
-  name: "Deactivate",
-  schema: idArgsSchema->S.castToUnknown->encodeSchema,
-  level: Instance,
-  aggregateIdField: Some("id"),
-  mutationField: Api_Naming.adminField(~name="Plugin_Deactivate"),
-  references: [],
-  allowedStates: Some(["Connected", "Disconnected"]),
-  targetState: None,
-  apiExposed: Some(true),
-  requiredAccess: None,
-  ownerField: None,
-}
+// Every variant of `PluginSpec.command`, walked by the same `extractCommandDefs`
+// an ordinary aggregate goes through. The hand-written alternative described the
+// arguments with a local `{id}` schema while the generated SDL declared
+// `Platform_Plugin_Activate(_0: String!, id: ID!)`, so AutoUI built a mutation
+// missing a required argument and every admin row action was rejected before it
+// reached the aggregate. Deriving from `commandSchema` — the same schema the SDL
+// is generated from — cannot reproduce that class of fault.
+//
+// `mutationFieldFor` is composed the way `PluginBaseFragment` composes the field
+// it generates, so the two cannot name it differently. The `@noApi` protocol
+// variants come back too, carrying `apiExposed: false` and the empty
+// `mutationField` sentinel: metadata about an edge, not a way to invoke it.
+let pluginCommands: array<commandDef> = Plugin_Structure.extractCommandDefs(
+  ~isAggregate=true,
+  ~mutationFieldFor=variantName =>
+    Api_Naming.adminField(~name=PluginSpec.name ++ "_" ++ variantName),
+  ~commandAuthorization=PluginSpec.commandAuthorization->Obj.magic,
+  commandSchema,
+)
 
 let pluginAggregate: writableDef = {
   name: "Plugin",
-  commands: [activateCommand, deactivateCommand],
+  commands: pluginCommands,
   producedEventTypes: [],
   consumedEventTypes: [],
   linkedViews: ["Plugins"],
@@ -109,40 +56,13 @@ let pluginAggregate: writableDef = {
   chapter: None,
 }
 
-let pluginReadModel: queryableDef = {
-  name: "Plugins",
-  queryField: Api_Naming.adminField(~name="Plugins"),
-  schema: PluginsReadModelSpec.stateSchema
-  ->S.castToUnknown
-  ->encodeSchemaExcluding(~excludeFields=PluginBaseFragment.pluginUIOnlyExcludeFields),
-  consumedEventTypes: [],
-  linkedWriteSide: ["Plugin"],
-  labelField: "name",
-  searchableFields: ["name"],
-  // Hand-rolled rather than resolved, but the rung is the same one
-  // `labelFieldsFromStateSchema` would report for a field literally named `name`.
-  labelFieldSource: Some("convention"),
-  // The published wire name stays `status` — it is what the SDL declares and what
-  // stored rows carry. Only the key naming it moved.
-  lifecycleField: Some("status"),
-  visibility: None,
-  chapter: None,
-  // The admin fragment hand-declares its query names rather than deriving them from
-  // the read-model name, so the singular is taken from the same call
-  // `PluginBaseFragment.queryNames.singleFieldName` makes — not singularised here.
-  singleQueryField: Some(Api_Naming.adminField(~name="Plugin")),
-  // No key field to name: the row id is `name@version` (`Plugin.makeId`), and the
-  // state carries the two halves separately rather than the composed key. `None`
-  // is the honest answer — the same one the resolver ladder reaches for a state
-  // with no `*Id` field.
-  idField: None,
-  idFieldSource: None,
-  requiredAccess: None,
-  ownerField: None,
-  retiredField: None,
-  retiredValues: None,
-  namedWhenRetired: None,
-}
+let pluginReadModel: queryableDef = Plugin_Structure.queryableDefFromSpec(
+  ~plugin=pluginId,
+  ~name=PluginsReadModelSpec.name,
+  ~stateSchema=PluginsReadModelSpec.stateSchema->S.castToUnknown,
+  ~authorization=PluginsReadModelSpec.authorization,
+  ~linkedWriteSide=["Plugin"],
+)
 
 let structure: pluginStructure = {
   readModels: [pluginReadModel],
@@ -157,3 +77,28 @@ let structure: pluginStructure = {
   requiredStores: None,
   requiredStoreDeclarations: None,
 }
+
+/** The definition the platform's own EventCollector ships as its
+    `pluginDefinition.json` asset, and hands to `Platform_Admin_Callback`.
+
+    The admin IS the Plugin extension point, so it never travels the connect
+    handshake and every field here is a placeholder. The asset is still read back
+    on the same path as every other plugin's, so it is declared as a value and
+    encoded through `pluginDefinitionSchema` at both sites rather than written out
+    as JSON: the hand-written twin that used to live in the AWS builder predated
+    `dcbEventLog` and `kind` and silently stopped matching the schema, which only
+    surfaced once the read side decoded instead of casting. */
+let internalPluginDefinition: pluginDefinition = {
+  id: pluginId ++ "@INTERNAL",
+  name: pluginId,
+  version: "INTERNAL",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "NOT-SET",
+  extensionProtocols: [],
+  apiSchemaFragment: None,
+  apiTarget: None,
+  structure: None,
+  dcbEventLog: None,
+  kind: Domain,
+}

package/src/admin/Platform_Admin_Structure.res.mjs

@@ -1,107 +1,13 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
-import * as Stdlib_Dict from "@rescript/runtime/lib/es6/Stdlib_Dict.js";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
-import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
-import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
-import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Api_Naming$ReventlessCore from "../components/Api/Api_Naming.res.mjs";
 import * as PluginSpec$ReventlessCore from "../plugin/lifecycle/PluginSpec.res.mjs";
 import * as Plugin_Structure$ReventlessCore from "../plugin/component/Plugin_Structure.res.mjs";
-import * as SuryToJsonSchema$ReventlessCore from "../components/Api/SuryToJsonSchema.res.mjs";
-import * as PluginBaseFragment$ReventlessCore from "../plugin/api/PluginBaseFragment.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "../plugin/lifecycle/PluginsReadModelSpec.res.mjs";
 
 let pluginId = "Platform";
 
-function encodeSchema(schema) {
-  return JSON.stringify(SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema));
-}
-
-function encodeSchemaExcluding(schema, excludeFields) {
-  let derived = SuryToJsonSchema$ReventlessCore.deriveObjectSchema(schema);
-  let obj = Stdlib_JSON.Decode.object(derived);
-  if (obj === undefined) {
-    return JSON.stringify(derived);
-  }
-  let props = Stdlib_Option.flatMap(obj["properties"], Stdlib_JSON.Decode.object);
-  if (props === undefined) {
-    return JSON.stringify(derived);
-  }
-  excludeFields.forEach(f => Stdlib_Dict.$$delete(props, f));
-  obj["properties"] = props;
-  let req = Stdlib_Option.flatMap(obj["required"], Stdlib_JSON.Decode.array);
-  if (req !== undefined) {
-    let filtered = Stdlib_Array.filterMap(req, Stdlib_JSON.Decode.string).filter(name => !excludeFields.includes(name)).map(prim => prim);
-    obj["required"] = filtered;
-  }
-  return JSON.stringify(obj);
-}
-
-let idArgsSchema = S.schema(s => ({
-  id: s.m(DcbTag$Reventless.string)
-}));
-
-let activateCommand_schema = encodeSchema(idArgsSchema);
-
-let activateCommand_aggregateIdField = "id";
-
-let activateCommand_mutationField = Api_Naming$ReventlessCore.adminField("Plugin_Activate");
-
-let activateCommand_references = [];
-
-let activateCommand_allowedStates = ["Inactive"];
-
-let activateCommand_apiExposed = true;
-
-let activateCommand = {
-  name: "Activate",
-  schema: activateCommand_schema,
-  level: "Instance",
-  aggregateIdField: activateCommand_aggregateIdField,
-  mutationField: activateCommand_mutationField,
-  references: activateCommand_references,
-  allowedStates: activateCommand_allowedStates,
-  targetState: undefined,
-  apiExposed: activateCommand_apiExposed,
-  requiredAccess: undefined,
-  ownerField: undefined
-};
-
-let deactivateCommand_schema = encodeSchema(idArgsSchema);
-
-let deactivateCommand_aggregateIdField = "id";
-
-let deactivateCommand_mutationField = Api_Naming$ReventlessCore.adminField("Plugin_Deactivate");
-
-let deactivateCommand_references = [];
-
-let deactivateCommand_allowedStates = [
-  "Connected",
-  "Disconnected"
-];
-
-let deactivateCommand_apiExposed = true;
-
-let deactivateCommand = {
-  name: "Deactivate",
-  schema: deactivateCommand_schema,
-  level: "Instance",
-  aggregateIdField: deactivateCommand_aggregateIdField,
-  mutationField: deactivateCommand_mutationField,
-  references: deactivateCommand_references,
-  allowedStates: deactivateCommand_allowedStates,
-  targetState: undefined,
-  apiExposed: deactivateCommand_apiExposed,
-  requiredAccess: undefined,
-  ownerField: undefined
-};
-
-let pluginAggregate_commands = [
-  activateCommand,
-  deactivateCommand
-];
+let pluginCommands = Plugin_Structure$ReventlessCore.extractCommandDefs(true, variantName => Api_Naming$ReventlessCore.adminField(PluginSpec$ReventlessCore.name + "_" + variantName), PluginSpec$ReventlessCore.commandAuthorization, PluginSpec$ReventlessCore.commandSchema);
 
 let pluginAggregate_producedEventTypes = [];
 
@@ -115,7 +21,7 @@ let pluginAggregate_errors = Plugin_Structure$ReventlessCore.extractErrorDefs(Pl
 
 let pluginAggregate = {
   name: "Plugin",
-  commands: pluginAggregate_commands,
+  commands: pluginCommands,
   producedEventTypes: pluginAggregate_producedEventTypes,
   consumedEventTypes: pluginAggregate_consumedEventTypes,
   linkedViews: pluginAggregate_linkedViews,
@@ -125,43 +31,7 @@ let pluginAggregate = {
   chapter: undefined
 };
 
-let pluginReadModel_queryField = Api_Naming$ReventlessCore.adminField("Plugins");
-
-let pluginReadModel_schema = encodeSchemaExcluding(PluginsReadModelSpec$ReventlessCore.stateSchema, PluginBaseFragment$ReventlessCore.pluginUIOnlyExcludeFields);
-
-let pluginReadModel_consumedEventTypes = [];
-
-let pluginReadModel_linkedWriteSide = ["Plugin"];
-
-let pluginReadModel_searchableFields = ["name"];
-
-let pluginReadModel_labelFieldSource = "convention";
-
-let pluginReadModel_lifecycleField = "status";
-
-let pluginReadModel_singleQueryField = Api_Naming$ReventlessCore.adminField("Plugin");
-
-let pluginReadModel = {
-  name: "Plugins",
-  queryField: pluginReadModel_queryField,
-  schema: pluginReadModel_schema,
-  consumedEventTypes: pluginReadModel_consumedEventTypes,
-  linkedWriteSide: pluginReadModel_linkedWriteSide,
-  labelField: "name",
-  searchableFields: pluginReadModel_searchableFields,
-  labelFieldSource: pluginReadModel_labelFieldSource,
-  lifecycleField: pluginReadModel_lifecycleField,
-  ownerField: undefined,
-  retiredField: undefined,
-  retiredValues: undefined,
-  namedWhenRetired: undefined,
-  visibility: undefined,
-  chapter: undefined,
-  singleQueryField: pluginReadModel_singleQueryField,
-  idField: undefined,
-  idFieldSource: undefined,
-  requiredAccess: undefined
-};
+let pluginReadModel = Plugin_Structure$ReventlessCore.queryableDefFromSpec(pluginId, PluginsReadModelSpec$ReventlessCore.name, PluginsReadModelSpec$ReventlessCore.stateSchema, PluginsReadModelSpec$ReventlessCore.authorization, undefined, undefined, ["Plugin"], undefined);
 
 let structure_readModels = [pluginReadModel];
 
@@ -193,18 +63,33 @@ let structure = {
   requiredStoreDeclarations: undefined
 };
 
+let internalPluginDefinition = {
+  id: pluginId + "@INTERNAL",
+  name: pluginId,
+  version: "INTERNAL",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "NOT-SET",
+  extensionProtocols: [],
+  apiSchemaFragment: undefined,
+  apiTarget: undefined,
+  structure: undefined,
+  dcbEventLog: undefined,
+  kind: "Domain"
+};
+
 let pluginName = pluginId;
 
+let commandSchema = PluginSpec$ReventlessCore.commandSchema;
+
 export {
   pluginId,
   pluginName,
-  encodeSchema,
-  encodeSchemaExcluding,
-  idArgsSchema,
-  activateCommand,
-  deactivateCommand,
+  commandSchema,
+  pluginCommands,
   pluginAggregate,
   pluginReadModel,
   structure,
+  internalPluginDefinition,
 }
-/* idArgsSchema Not a pure module */
+/* pluginCommands Not a pure module */

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

@@ -1,40 +1,40 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 
-let commandSchema = S.union([
-  S.schema(s => ({
+let commandSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "RegisterUiFragment",
     pluginId: s.m(DcbTag$Reventless.string),
     manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-    at: s.m(S.string)
+    at: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "DeregisterUiFragment",
     pluginId: s.m(DcbTag$Reventless.string)
   }))
 ]);
 
-let errorSchema = S.literal("RegistryError");
+let errorSchema = Sury.literal("RegistryError");
 
-let eventSchema = S.union([
-  S.schema(s => ({
+let eventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "UiFragmentRegistered",
     pluginId: s.m(DcbTag$Reventless.string),
     manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-    at: s.m(S.string)
+    at: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "UiFragmentUpdated",
     pluginId: s.m(DcbTag$Reventless.string),
     previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
     newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-    at: s.m(S.string)
+    at: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "UiFragmentDeregistered",
     pluginId: s.m(DcbTag$Reventless.string)
   }))

package/src/admin/UiFragmentRegistry/StateViewSlice/UiFragments.res.mjs

@@ -1,34 +1,34 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
 import * as ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
 
-let stateSchema = S.schema(s => ({
-  pluginId: s.m(S.string),
-  remoteEntryUrl: s.m(S.string),
-  panels: s.m(S.array(Plugin$Reventless.panelManifestEntrySchema)),
-  pages: s.m(S.array(Plugin$Reventless.pageManifestEntrySchema)),
-  registeredAt: s.m(S.string),
-  updatedAt: s.m(S.string)
+let stateSchema = Sury.$schema(s => ({
+  pluginId: s.m(Sury.string),
+  remoteEntryUrl: s.m(Sury.string),
+  panels: s.m(Sury.array(Plugin$Reventless.panelManifestEntrySchema)),
+  pages: s.m(Sury.array(Plugin$Reventless.pageManifestEntrySchema)),
+  registeredAt: s.m(Sury.string),
+  updatedAt: s.m(Sury.string)
 }));
 
-let consumedEventSchema = S.union([
-  S.schema(s => ({
+let consumedEventSchema = Sury.union([
+  Sury.$schema(s => ({
     TAG: "UiFragmentRegistered",
     pluginId: s.m(DcbTag$Reventless.string),
     manifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-    at: s.m(S.string)
+    at: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "UiFragmentUpdated",
     pluginId: s.m(DcbTag$Reventless.string),
     previousManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
     newManifest: s.m(Plugin$Reventless.uiFragmentManifestSchema),
-    at: s.m(S.string)
+    at: s.m(Sury.string)
   })),
-  S.schema(s => ({
+  Sury.$schema(s => ({
     TAG: "UiFragmentDeregistered",
     pluginId: s.m(DcbTag$Reventless.string)
   }))

package/src/components/Aggregate/Aggregate_Callback.res

@@ -153,7 +153,7 @@ module Make = (
   let encodeState = (state: Behavior.state): option<JSON.t> =>
     switch snapshotConfig {
     | Some({stateSchema}) =>
-      switch state->S.reverseConvertToJsonOrThrow(stateSchema) {
+      switch state->Reventless.Util_Sury.toJson(stateSchema) {
       | json => Some(json)
       | exception _ => None
       }
@@ -163,7 +163,7 @@ module Make = (
   let decodeState = (json: JSON.t): option<Behavior.state> =>
     switch snapshotConfig {
     | Some({stateSchema}) =>
-      switch json->S.parseJsonOrThrow(stateSchema) {
+      switch json->Reventless.Util_Sury.fromJson(stateSchema) {
       | state => Some(state)
       | exception _ => None
       }

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

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import HashObject from "hash-object";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
@@ -11,6 +10,7 @@ import * as Stream from "effect/Stream";
 import * as Stdlib_Promise from "@rescript/runtime/lib/es6/Stdlib_Promise.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Lru$ReventlessCore from "../../util/Lru.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Message$ReventlessCore from "../../Message.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
 import * as EffectLogger$ReventlessCore from "../../util/EffectLogger.res.mjs";
@@ -87,7 +87,7 @@ function Make(Spec) {
       }
       let json;
       try {
-        json = S.reverseConvertToJsonOrThrow(state, snapshotConfig.stateSchema);
+        json = Util_Sury$Reventless.toJson(state, snapshotConfig.stateSchema);
       } catch (exn) {
         return;
       }
@@ -99,7 +99,7 @@ function Make(Spec) {
       }
       let state;
       try {
-        state = S.parseJsonOrThrow(json, snapshotConfig.stateSchema);
+        state = Util_Sury$Reventless.fromJson(json, snapshotConfig.stateSchema);
       } catch (exn) {
         return;
       }
@@ -356,4 +356,4 @@ function Make(Spec) {
 export {
   Make,
 }
-/* S Not a pure module */
+/* hash-object Not a pure module */

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

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

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

@@ -1,19 +1,19 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Api$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/Api.res.mjs";
 
 function isNoApi(commandSchema) {
-  return Stdlib_Option.getOr(S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiId), false);
+  return Stdlib_Option.getOr(Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiId), false);
 }
 
 function getExcludedVariants(commandSchema) {
-  return S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  return Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
 }
 
 function filterNoApiVariants(fieldNames, commandSchema) {
-  let excluded = S.Metadata.get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
+  let excluded = Sury.$Metadata_get(commandSchema, Api$ReventlessInfra.noApiVariantsId);
   if (excluded !== undefined) {
     return fieldNames.filter(name => !excluded.has(name));
   } else {
@@ -26,4 +26,4 @@ export {
   getExcludedVariants,
   filterNoApiVariants,
 }
-/* S Not a pure module */
+/* sury Not a pure module */

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

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