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

package/src/components/StateChangeSlice/StateChangeSlice_Callback.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -11,6 +10,7 @@ import * as Stream$1 from "effect/Stream";
 import * as DcbTag$Reventless from "@reventlessdev/reventless-spec/src/components/DcbTag.res.mjs";
 import * as Lru$ReventlessCore from "../../util/Lru.res.mjs";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.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 Metrics$ReventlessCore from "../../util/Metrics.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -186,7 +186,7 @@ function Make(Spec) {
               }
               let rawEvents = newEvents$1.map(e => {
                 let parentMeta = command$p.meta;
-                let json = S.reverseConvertToJsonOrThrow(e, Spec.eventSchema);
+                let json = Util_Sury$Reventless.toJson(e, Spec.eventSchema);
                 let match = Message$ReventlessCore.splitMessage(json);
                 let eventType = match[0];
                 let baseTags = DcbTag$Reventless.extractTagsExpanded(Spec.eventSchema, e);
@@ -272,7 +272,7 @@ function Make(Spec) {
               state,
               headPosition
             ]);
-            let errorJson = S.reverseConvertToJsonOrThrow(newEvents._0, Spec.errorSchema);
+            let errorJson = Util_Sury$Reventless.toJson(newEvents._0, Spec.errorSchema);
             let errorCode = Message$ReventlessCore.variantNameOfJson(errorJson);
             let match = Message$ReventlessCore.splitMessage(errorJson);
             let payloadDict = match[1];
@@ -321,4 +321,4 @@ function Make(Spec) {
 export {
   Make,
 }
-/* S Not a pure module */
+/* Stream Not a pure module */

package/src/components/StateViewSlice/StateViewSlice_Builder.res

@@ -103,7 +103,7 @@ module Make = (
                 // fall back defensively so a malformed envelope never drops the event.
                 let meta = switch envelopeDict->Dict.get("meta") {
                 | Some(m) =>
-                  switch m->S.parseJsonOrThrow(Message.metaSchema) {
+                  switch m->Reventless.Util_Sury.fromJson(Message.metaSchema) {
                   | parsed => parsed
                   | exception _ => Message.generateMeta(~service=Spec.name)
                   }

package/src/components/StateViewSlice/StateViewSlice_Builder.res.mjs

@@ -1,6 +1,5 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
 import * as Stream from "@reventlessdev/rescript-effect/src/Stream.res.mjs";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
@@ -12,6 +11,7 @@ import * as Effect from "effect/Effect";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as DcbDecode$Reventless from "@reventlessdev/reventless-spec/src/components/DcbDecode.res.mjs";
 import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+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 Component$ReventlessCore from "../Component.res.mjs";
 import * as LogFormat$ReventlessCore from "../../util/LogFormat.res.mjs";
@@ -87,7 +87,7 @@ function Make(RuntimeEnvironment) {
               let meta;
               if (m !== undefined) {
                 try {
-                  meta = S.parseJsonOrThrow(m, Message$ReventlessCore.metaSchema);
+                  meta = Util_Sury$Reventless.fromJson(m, Message$ReventlessCore.metaSchema);
                 } catch (exn) {
                   meta = Message$ReventlessCore.generateMeta(Spec.name, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
                 }
@@ -158,4 +158,4 @@ export {
   FrameworkProjection,
   Make,
 }
-/* S Not a pure module */
+/* Stream Not a pure module */

package/src/plugin/api/PluginBaseFragment.res

@@ -1,32 +1,5 @@
 open ReventlessInfra.Api
 
-let adminAuth: Reventless.ReadModel.authorization = {
-  tableName: "Plugin",
-  group: "Admin",
-}
-
-// Fields present on `PluginsReadModelSpec.state` for projection/storage purposes
-// but intentionally absent from the public GraphQL surface. Shared with
-// `Platform_Admin_Structure` so the schema announced via `Platform_ComponentDefinitions`
-// stays aligned with the SDL — otherwise AutoUI generates list-view queries
-// for fields the server doesn't expose and every Plugin row fails to load.
-let pluginExcludeFields: array<string> = [
-  "eventCollector",
-  "extensionPointNames",
-  "extensionNames",
-]
-
-// Additional fields the SDL exposes but the Plugin list view should NOT
-// surface — they're option-of-nested-object types (e.g. apiSchemaFragment,
-// structure) which AutoUI currently renders as scalar columns
-// and queries without a sub-selection, failing schema validation. Other
-// callers (host-shell's Platform_ComponentDefinitions) keep querying them via
-// dedicated fields and resolver paths.
-let pluginUIOnlyExcludeFields: array<string> = pluginExcludeFields->Array.concat([
-  "apiSchemaFragment",
-  "structure",
-])
-
 // Admin read-model query entries are generated from each spec the same way
 // ordinary read models are (Plugin_Builder.res): `subIdField` flows from the
 // spec's `subIdConfig` and `indexQueries` from `config.indexes`, so
@@ -57,8 +30,18 @@ let queryEntries: array<querySchemaEntry> = [
     listFieldName: Api_Naming.adminField(~name="Plugins"),
     returnTypeName: Api_Naming.adminField(~name="Plugin"),
     stateSchema: PluginsReadModelSpec.stateSchema->S.castToUnknown,
-    authorization: Some(adminAuth),
-    excludeFields: pluginExcludeFields,
+    // Read off the spec rather than restated. The hand-written
+    // `{tableName: "Plugin", group: "Admin"}` that used to sit here said the same
+    // thing as `Spec.authorization` in a different type, and the spec's default
+    // (`AllowAuthenticated`) disagreed with it — so the view's rule depended on
+    // which of the two a reader happened to find. The `tableName` half was never
+    // read: the entry path uses only the group, and the per-`@index` auth-table
+    // pipeline params come from `indexConfig.authorization`, which is untouched.
+    authorization: None,
+    permission: PluginsReadModelSpec.authorization,
+    // No `excludeFields`: the three fields this entry used to name are declared
+    // `@internal` on the spec, and `deriveObjectTypeWithNested` reads that off the
+    // schema itself.
     subIdField: ?PluginsReadModelSpec.subIdConfig->Option.map((c: Reventless.ReadModel.subIdConfig<_>) => c.subIdField),
     indexQueries: ?indexQueriesOfConfig(PluginsReadModelSpec.config),
   },

package/src/plugin/api/PluginBaseFragment.res.mjs

@@ -7,22 +7,6 @@ import * as PluginSpec$ReventlessCore from "../lifecycle/PluginSpec.res.mjs";
 import * as ApiNoApiHelpers$ReventlessCore from "../../components/Api/ApiNoApiHelpers.res.mjs";
 import * as PluginsReadModelSpec$ReventlessCore from "../lifecycle/PluginsReadModelSpec.res.mjs";
 
-let adminAuth = {
-  tableName: "Plugin",
-  group: "Admin"
-};
-
-let pluginExcludeFields = [
-  "eventCollector",
-  "extensionPointNames",
-  "extensionNames"
-];
-
-let pluginUIOnlyExcludeFields = pluginExcludeFields.concat([
-  "apiSchemaFragment",
-  "structure"
-]);
-
 function indexQueriesOfConfig(config) {
   if (config.indexes.length !== 0) {
     return config.indexes;
@@ -35,8 +19,8 @@ let queryEntries = [{
     returnTypeName: Api_Naming$ReventlessCore.adminField("Plugin"),
     stateSchema: PluginsReadModelSpec$ReventlessCore.stateSchema,
     specName: PluginsReadModelSpec$ReventlessCore.name,
-    authorization: adminAuth,
-    excludeFields: pluginExcludeFields,
+    authorization: undefined,
+    permission: PluginsReadModelSpec$ReventlessCore.authorization,
     subIdField: Stdlib_Option.map(undefined, c => c.subIdField),
     indexQueries: indexQueriesOfConfig(PluginsReadModelSpec$ReventlessCore.config)
   }];
@@ -53,11 +37,8 @@ let pluginAggregateMutationEntries = fieldNames.length === 0 ? [] : [{
     }];
 
 export {
-  adminAuth,
-  pluginExcludeFields,
-  pluginUIOnlyExcludeFields,
   indexQueriesOfConfig,
   queryEntries,
   pluginAggregateMutationEntries,
 }
-/* pluginUIOnlyExcludeFields Not a pure module */
+/* queryEntries Not a pure module */

package/src/plugin/component/Capability_Inference.res

@@ -55,7 +55,7 @@ let scanSchema = (~component: string, schema: S.t<unknown>): array<warning> => {
     | _ => []
     }
   switch schema {
-  | Union({anyOf}) => anyOf->Array.flatMap(fromVariant)
+  | AnyOf({anyOf}) => anyOf->Array.flatMap(fromVariant)
   | other => fromVariant(other)
   }
 }
@@ -66,3 +66,120 @@ let message = (w: warning): string =>
   `${w.component}.${w.field} looks like a stored-object reference but declares no store — ` ++
   `annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, ` ++
   `or rename the field if it holds an external URL. Heuristic matches are never provisioned.`
+
+// ── Near-duplicate stores ──────────────────────────────────────────────────
+//
+// Under name-derived stores a typo does not fail, it *provisions*: `productImage`
+// and `productImgae` both compile, both deploy, and objects split silently
+// across two buckets. Nothing else in the pipeline can see the mistake — both
+// are well-formed declarations — so the check has to live where every store a
+// plugin declares is visible at once.
+//
+// Unlike the heuristic lint above this is a hard failure, and it is meant to be:
+// a warning about infrastructure that was already created is a warning nobody
+// can act on cheaply. A pair that is genuinely two stores settles it by naming
+// one explicitly with `@storageRef("<store>")`.
+
+/** Two store declarations close enough that one is likely a typo for the other. */
+type collision = {
+  a: Reventless.Plugin.requiredStoreDeclaration,
+  b: Reventless.Plugin.requiredStoreDeclaration,
+}
+
+// Exactly the optimal-string-alignment distance ≤ 1: one insert, one delete, one
+// substitution, or one transposition. Written directly rather than as a general
+// distance because a transposition is the shape the motivating typo has
+// (`Images` → `Imgaes`), and a plain Levenshtein scores that 2 and misses it.
+let withinOneEdit = (a: string, b: string): bool => {
+  let (la, lb) = (String.length(a), String.length(b))
+  let charAt = (s, i) => String.charAt(s, i)
+  if la == lb {
+    let diffs = []
+    for i in 0 to la - 1 {
+      if charAt(a, i) != charAt(b, i) {
+        diffs->Array.push(i)
+      }
+    }
+    switch diffs {
+    | [] => true
+    | [_] => true
+    | [i, j] if j == i + 1 =>
+      charAt(a, i) == charAt(b, j) && charAt(a, j) == charAt(b, i)
+    | _ => false
+    }
+  } else if la - lb == 1 || lb - la == 1 {
+    // The longer string with one character removed must equal the shorter one.
+    let (long, short) = la > lb ? (a, b) : (b, a)
+    let rec scan = (~li, ~si, ~skipped) =>
+      if si >= String.length(short) {
+        true
+      } else if charAt(long, li) == charAt(short, si) {
+        scan(~li=li + 1, ~si=si + 1, ~skipped)
+      } else if skipped {
+        false
+      } else {
+        scan(~li=li + 1, ~si, ~skipped=true)
+      }
+    scan(~li=0, ~si=0, ~skipped=false)
+  } else {
+    false
+  }
+}
+
+/** Whether two store names are the same word in different number. Reached only
+    through an explicit `@storageRef` override — a derived name is already
+    pluralised through its singular stem, so two *derived* names cannot differ
+    this way. */
+let sameStem = (a: string, b: string): bool =>
+  Api_Naming.singularize(a) == Api_Naming.singularize(b)
+
+// The unqualified store name and its owning plugin, split off the qualified key
+// the declarations carry.
+let splitKey = (key: string): (string, string) =>
+  switch key->String.split(".") {
+  | [plugin, store] => (plugin, store)
+  | _ => ("", key)
+  }
+
+/**
+Pairs of declared stores that are probably one store misspelled twice.
+
+Compared within an owning plugin only: two plugins may legitimately hold stores
+whose names are one edit apart, and neither can be a typo for the other.
+*/
+let collisions = (
+  declarations: array<Reventless.Plugin.requiredStoreDeclaration>,
+): array<collision> => {
+  // One entry per store, keeping the first declaration site as the one the
+  // message names — several fields naming one store is ordinary, not a clash.
+  let byStore: dict<Reventless.Plugin.requiredStoreDeclaration> = Dict.make()
+  declarations->Array.forEach(d =>
+    switch byStore->Dict.get(d.store) {
+    | Some(_) => ()
+    | None => byStore->Dict.set(d.store, d)
+    }
+  )
+  let unique = byStore->Dict.valuesToArray
+  let found = []
+  for i in 0 to Array.length(unique) - 1 {
+    for j in i + 1 to Array.length(unique) - 1 {
+      let a = unique->Array.getUnsafe(i)
+      let b = unique->Array.getUnsafe(j)
+      let (pluginA, storeA) = splitKey(a.store)
+      let (pluginB, storeB) = splitKey(b.store)
+      if pluginA == pluginB && (withinOneEdit(storeA, storeB) || sameStem(storeA, storeB)) {
+        found->Array.push({a, b})->ignore
+      }
+    }
+  }
+  found
+}
+
+/** The failure text: name both stores and both declaration sites, so a pair that
+    is genuinely two stores is diagnosed in one reading. */
+let collisionMessage = (c: collision): string =>
+  `${c.a.store} (${c.a.component}.${c.a.field}) and ${c.b.store} ` ++
+  `(${c.b.component}.${c.b.field}) differ by one edit — one is probably a typo for ` ++
+  `the other, and both would be provisioned, splitting objects across two stores. ` ++
+  `Fix the field name, or name the store explicitly with \`@storageRef("<store>")\` ` ++
+  `if the two really are separate stores.`

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

@@ -3,6 +3,7 @@
 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 StorageRef$Reventless from "@reventlessdev/reventless-spec/src/semantic/StorageRef.res.mjs";
+import * as Api_Naming$ReventlessCore from "../../components/Api/Api_Naming.res.mjs";
 
 let refLikeNames = [
   "file",
@@ -56,7 +57,7 @@ function scanSchema(component, schema) {
       return [];
     }
   };
-  if (schema.type === "union") {
+  if (schema.type === "anyOf") {
     return schema.anyOf.flatMap(fromVariant);
   } else {
     return fromVariant(schema);
@@ -67,6 +68,127 @@ function message(w) {
   return w.component + `.` + w.field + ` looks like a stored-object reference but declares no store — annotate it \`@storageRef("<store>")\` so the deployment provisions the store it needs, or rename the field if it holds an external URL. Heuristic matches are never provisioned.`;
 }
 
+function withinOneEdit(a, b) {
+  let la = a.length;
+  let lb = b.length;
+  if (la === lb) {
+    let diffs = [];
+    for (let i = 0; i < la; ++i) {
+      if (a.charAt(i) !== b.charAt(i)) {
+        diffs.push(i);
+      }
+    }
+    let len = diffs.length;
+    if (len >= 3) {
+      return false;
+    }
+    switch (len) {
+      case 0 :
+      case 1 :
+        return true;
+      case 2 :
+        let i$1 = diffs[0];
+        let j = diffs[1];
+        if (j === (i$1 + 1 | 0) && a.charAt(i$1) === b.charAt(j)) {
+          return a.charAt(j) === b.charAt(i$1);
+        } else {
+          return false;
+        }
+    }
+  } else {
+    if ((la - lb | 0) !== 1 && (lb - la | 0) !== 1) {
+      return false;
+    }
+    let match = la > lb ? [
+        a,
+        b
+      ] : [
+        b,
+        a
+      ];
+    let short = match[1];
+    let long = match[0];
+    let _li = 0;
+    let _si = 0;
+    let _skipped = false;
+    while (true) {
+      let skipped = _skipped;
+      let si = _si;
+      let li = _li;
+      if (si >= short.length) {
+        return true;
+      }
+      if (long.charAt(li) === short.charAt(si)) {
+        _si = si + 1 | 0;
+        _li = li + 1 | 0;
+        continue;
+      }
+      if (skipped) {
+        return false;
+      }
+      _skipped = true;
+      _li = li + 1 | 0;
+      continue;
+    };
+  }
+}
+
+function sameStem(a, b) {
+  return Api_Naming$ReventlessCore.singularize(a) === Api_Naming$ReventlessCore.singularize(b);
+}
+
+function splitKey(key) {
+  let match = key.split(".");
+  if (match.length !== 2) {
+    return [
+      "",
+      key
+    ];
+  }
+  let plugin = match[0];
+  let store = match[1];
+  return [
+    plugin,
+    store
+  ];
+}
+
+function collisions(declarations) {
+  let byStore = {};
+  declarations.forEach(d => {
+    let match = byStore[d.store];
+    if (match !== undefined) {
+      return;
+    } else {
+      byStore[d.store] = d;
+      return;
+    }
+  });
+  let unique = Object.values(byStore);
+  let found = [];
+  for (let i = 0, i_finish = unique.length; i < i_finish; ++i) {
+    for (let j = i + 1 | 0, j_finish = unique.length; j < j_finish; ++j) {
+      let a = unique[i];
+      let b = unique[j];
+      let match = splitKey(a.store);
+      let storeA = match[1];
+      let match$1 = splitKey(b.store);
+      let storeB = match$1[1];
+      if (match[0] === match$1[0] && (withinOneEdit(storeA, storeB) || sameStem(storeA, storeB))) {
+        found.push({
+          a: a,
+          b: b
+        });
+      }
+    }
+  }
+  return found;
+}
+
+function collisionMessage(c) {
+  return c.a.store + ` (` + c.a.component + `.` + c.a.field + `) and ` + c.b.store + ` ` + (`(` + c.b.component + `.` + c.b.field + `) differ by one edit — one is probably a typo for `) + `the other, and both would be provisioned, splitting objects across two stores. Fix the field name, or name the store explicitly with \`@storageRef("<store>")\` if the two really are separate stores.`;
+}
+
 export {
   refLikeNames,
   refLikeSuffixes,
@@ -75,5 +197,10 @@ export {
   warningsFromProperties,
   scanSchema,
   message,
+  withinOneEdit,
+  sameStem,
+  splitKey,
+  collisions,
+  collisionMessage,
 }
 /* StorageRef-Reventless Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -687,7 +687,7 @@ module Make = (
               interstackAdminExtensionPoints
               ->Pulumi.StackReference.get(PluginExtensionPointSpec.name)
               ->Obj.magic: JSON.t
-            )->S.parseOrThrow(ReventlessInterop.ExtensionPoint.resolvedOutputsSchema)
+            )->S.parseOrThrow(~to=ReventlessInterop.ExtensionPoint.resolvedOutputsSchema)
             let pluginExtensionPointCommandTopicRemoteChannel = PluginExtensionPointRemoteChannel.make(
               pluginExtensionPointUnwrapped.commandTopic.resources->Array.map(
                 Adapter.fromInteropResolved,
@@ -1030,7 +1030,7 @@ module Make = (
       builderOutputs->Pulumi.Output.apply(outputs =>
         outputs
         ->toInteropMeta
-        ->S.reverseConvertToJsonOrThrow(ReventlessInterop.ExportMeta.schema)
+        ->Reventless.Util_Sury.toJson(ReventlessInterop.ExportMeta.schema)
       )
 
     Logger.currentPluginName := _prevPluginName

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

@@ -9,6 +9,7 @@ import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 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 Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
 import * as Logger$ReventlessCore from "../../util/Logger.res.mjs";
 import * as Plugin$ReventlessCore from "./Plugin.res.mjs";
 import * as StackReference$Pulumi from "@reventlessdev/rescript-pulumi-pulumi/src/StackReference.res.mjs";
@@ -648,7 +649,7 @@ function Make(Spec) {
           inboundTranslationSlices: pluginOutputs_inboundTranslationSlices
         };
         Component$ReventlessCore.setOutputs(extra, pluginOutputs);
-        Plugin_Helpers$ReventlessCore.interopMetaOutput.contents = builderOutputs.apply(outputs => S.reverseConvertToJsonOrThrow(Plugin_Helpers$ReventlessCore.toInteropMeta(outputs), ExportMeta$ReventlessInterop.schema));
+        Plugin_Helpers$ReventlessCore.interopMetaOutput.contents = builderOutputs.apply(outputs => Util_Sury$Reventless.toJson(Plugin_Helpers$ReventlessCore.toInteropMeta(outputs), ExportMeta$ReventlessInterop.schema));
         Logger$ReventlessCore.currentPluginName.contents = _prevPluginName;
         return ResourceAttribution$ReventlessCore.restore(_prevAttribution);
       }, opts);

package/src/plugin/component/Plugin_Helpers.res

@@ -46,7 +46,7 @@ let getRemoteStorageResources = (pluginName, queryDbName) =>
           | Some(rawReadModel) =>
             try {
               let readModel =
-                rawReadModel->S.parseOrThrow(ReventlessInterop.ReadModel.resolvedOutputsSchema)
+                rawReadModel->S.parseOrThrow(~to=ReventlessInterop.ReadModel.resolvedOutputsSchema)
               readModel.queryDb.resources->Adapter.fromInteropResources
             } catch {
             | exn =>
@@ -607,12 +607,12 @@ module MakeEventCollectorHelper = (
         ecResource.name->ComponentType.nameOpt(EventCollector.componentType)
       let pluginDefinitionJson =
         pluginDefinition
-        ->S.reverseConvertToJsonOrThrow(Reventless.Plugin.pluginDefinitionSchema)
+        ->Reventless.Util_Sury.toJson(Reventless.Plugin.pluginDefinitionSchema)
         ->JSON.stringify
         ->Pulumi.Output.make
       let uiFragmentsJson =
         uiFragments
-        ->S.reverseConvertToJsonOrThrow(Reventless.Plugin.uiFragmentManifestOptionSchema)
+        ->Reventless.Util_Sury.toJson(Reventless.Plugin.uiFragmentManifestOptionSchema)
         ->JSON.stringify
         ->Pulumi.Output.make
       let pluginExtensionPointCmdTopicUrl = switch pluginExtensionPointUnwrapped {
@@ -824,7 +824,7 @@ let offloadPayload = (value: 'a, ~schema: S.t<'a>, ~store: string): Reventless.O
   switch offloadHook.contents {
   | Some(hook) =>
     Reventless.Offload.Offloaded(
-      hook(~store, ~bytes=value->S.reverseConvertToJsonStringOrThrow(schema)),
+      hook(~store, ~bytes=value->Reventless.Util_Sury.toJsonString(schema)),
     )
   | None => Reventless.Offload.Inline(value)
   }
@@ -1250,7 +1250,7 @@ let serializePlainDictExport = (
     ->toResolved
     ->Pulumi.Output.apply(resolved => (
       name,
-      resolved->S.reverseConvertToJsonOrThrow(schema),
+      resolved->Reventless.Util_Sury.toJson(schema),
     ))
   )
   ->Pulumi.Output.all
@@ -1269,7 +1269,7 @@ let serializeDictExport = (
       ->toResolved
       ->Pulumi.Output.apply(resolved => (
         name,
-        resolved->S.reverseConvertToJsonOrThrow(schema),
+        resolved->Reventless.Util_Sury.toJson(schema),
       ))
     )
     ->Pulumi.Output.all
@@ -1285,7 +1285,7 @@ let serializeTasksOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Output.t<JSO
       task
       ->Task.toResolvedOutputs
       ->Pulumi.Output.apply(resolved =>
-        resolved->S.reverseConvertToJsonOrThrow(ReventlessInterop.Task.resolvedOutputsSchema)
+        resolved->Reventless.Util_Sury.toJson(ReventlessInterop.Task.resolvedOutputsSchema)
       )
     )
     ->Pulumi.Output.all
@@ -1310,7 +1310,7 @@ let serializeEventMappersOutputs = (pluginOutputs: Plugin.outputs): Pulumi.Outpu
           ->EventMapper.toResolvedOutputs
           ->Pulumi.Output.apply(resolved =>
             Some(
-              resolved->S.reverseConvertToJsonOrThrow(
+              resolved->Reventless.Util_Sury.toJson(
                 ReventlessInterop.EventMapper.resolvedOutputsSchema,
               ),
             )
@@ -1350,7 +1350,7 @@ let exportPlatformOutputs = (
         ->ExtensionPoint.toResolvedOutputs
         ->Pulumi.Output.apply(resolved => (
           ep.name,
-          resolved->S.reverseConvertToJsonOrThrow(
+          resolved->Reventless.Util_Sury.toJson(
             ReventlessInterop.ExtensionPoint.resolvedOutputsSchema,
           ),
         ))
@@ -1392,7 +1392,7 @@ let exportPlatformOutputs = (
       dcbOutputs
       ->DcbEventLog.toResolvedOutputs
       ->Pulumi.Output.apply(resolved =>
-        resolved->S.reverseConvertToJsonOrThrow(
+        resolved->Reventless.Util_Sury.toJson(
           ReventlessInterop.DcbEventLog.resolvedOutputsSchema,
         )
       ),
@@ -1545,7 +1545,7 @@ let exportPluginOutputs = (pluginOutputs: Plugin.outputs) => {
         dcbOutputs
         ->DcbEventLog.toResolvedOutputs
         ->Pulumi.Output.apply(resolved =>
-          resolved->S.reverseConvertToJsonOrThrow(
+          resolved->Reventless.Util_Sury.toJson(
             ReventlessInterop.DcbEventLog.resolvedOutputsSchema,
           )
         )