@reventlessdev/reventless-spec 3.0.0-alpha.116 → 3.0.0-alpha.118

package/src/semantic/Media_Ref.res

@@ -0,0 +1,33 @@
+// The grammar `ImageRef` and `FileRef` share. They differ in what the value
+// depicts, not in how a reference to it is written, so the rule lives once here
+// rather than twice with a chance to disagree.
+
+/** Is this an absolute web address? Schemes fold case per RFC 3986. */
+let hasWebScheme = (raw: string): bool => {
+  let lower = String.toLowerCase(raw)
+  String.startsWith(lower, "http://") || String.startsWith(lower, "https://")
+}
+
+/**
+Validate a reference to a resource the platform does not own: an `http`/`https`
+URL, or an origin-relative path. `~what` names the kind in the rejection so the
+message reads as the field's own.
+
+An origin-relative path is admitted because a value may legitimately have been
+minted by this platform earlier and simply not be declared as stored here —
+refusing it would make the unowned types unable to hold their own history.
+*/
+let check = (~what: string, raw: string): result<string, string> =>
+  if raw === "" {
+    Error(`expected a ${what} reference, got an empty string`)
+  } else if hasWebScheme(raw) {
+    Ok(raw)
+  } else if String.startsWith(raw, "/") && !String.startsWith(raw, "//") {
+    Ok(raw)
+  } else {
+    Error(
+      `expected an http:// or https:// address, or an origin-relative path, got ${Semantic.showString(
+          raw,
+        )}. A data: URI is not a ${what} reference — it inlines the bytes into the event log, permanently.`,
+    )
+  }

package/src/semantic/Media_Ref.res.mjs

@@ -0,0 +1,37 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+
+function hasWebScheme(raw) {
+  let lower = raw.toLowerCase();
+  if (lower.startsWith("http://")) {
+    return true;
+  } else {
+    return lower.startsWith("https://");
+  }
+}
+
+function check(what, raw) {
+  if (raw === "") {
+    return {
+      TAG: "Error",
+      _0: `expected a ` + what + ` reference, got an empty string`
+    };
+  } else if (hasWebScheme(raw) || raw.startsWith("/") && !raw.startsWith("//")) {
+    return {
+      TAG: "Ok",
+      _0: raw
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: `expected an http:// or https:// address, or an origin-relative path, got ` + Semantic$Reventless.showString(raw) + `. A data: URI is not a ` + what + ` reference — it inlines the bytes into the event log, permanently.`
+    };
+  }
+}
+
+export {
+  hasWebScheme,
+  check,
+}
+/* Semantic-Reventless Not a pure module */

package/src/semantic/Money.res

@@ -79,11 +79,13 @@ let validateAmount = (amount: float): result<float, string> =>
     `Cannot access 'v0' before initialization`). Refining the field is both the
     honest placement and the one that works. */
 let amountSchema: S.t<float> =
-  S.float->S.refine(s => amount =>
-    switch validateAmount(amount) {
-    | Ok(_) => ()
-    | Error(why) => s.fail(why)
-    }
+  S.float->S.refine(
+    amount =>
+      switch validateAmount(amount) {
+      | Ok(_) => true
+      | Error(_) => false
+      },
+    ~error="expected a monetary amount",
   )
 
 @schema

package/src/semantic/Money.res.mjs

@@ -1,6 +1,7 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_Result from "@rescript/runtime/lib/es6/Stdlib_Result.js";
 import * as Currency$Reventless from "./Currency.res.mjs";
@@ -27,16 +28,12 @@ function validateAmount(amount) {
   }
 }
 
-let amountSchema = S.refine(S.float, s => (amount => {
-  let why = validateAmount(amount);
-  if (why.TAG === "Ok") {
-    return;
-  } else {
-    return s.fail(why._0, undefined);
-  }
-}));
+let amountSchema = S.refine(Sury.float, amount => {
+  let match = validateAmount(amount);
+  return match.TAG === "Ok";
+}, "expected a monetary amount", undefined);
 
-let schema = S.schema(s => ({
+let schema = Sury.$schema(s => ({
   amount: s.m(amountSchema),
   currency: s.m(Currency$Reventless.schema)
 }));

package/src/semantic/Offload.res

@@ -63,17 +63,6 @@ type payload<'a> =
   | Inline('a)
   | Offloaded(offloadedRef)
 
-/** `nullableAsOption` emits `T | undefined | null`, which fails
-    `jsonableValidation` inside an event union; `js_nullable` emits `T | null`,
-    which is JSON-safe there. Same reason `Plugin.res` reaches for it. */
-@module("sury/src/Sury.res.mjs")
-external _jsNullable: (S.t<'a>, unit) => S.t<option<'a>> = "js_nullable"
-
-/** The codec builds on `S.json`, which sury 11 gates behind an explicit enable.
-    Doing it here (at module load, before any `schema` call) makes the primitive
-    self-contained: importing `Offload` is enough, no consumer has to remember. */
-S.enableJson()
-
 /** The object key under which an `Offloaded` value hides. Reserved: no ReScript
     record field encodes to a key starting with `$`, so it cannot collide with an
     inline payload's own fields. */
@@ -86,37 +75,30 @@ Parameterised by the inner value's schema because the `Inline` arm round-trips
 through it. The `Offloaded` arm round-trips through `offloadedRefSchema` under the
 sentinel key. See the module doc for why this is untagged.
 */
+// Both arms are *declared* (`S.object` / `S.shape`) rather than hand-written as
+// `S.transform` pairs, and that is load-bearing, not a style choice. A transform
+// arm is opaque: sury cannot see what it accepts, so it must offer every value to
+// the arm's own serializer and let it reject. Two things follow, both of which bit
+// this codec on 11.0.0-rc.0 and neither of which the type checker can see:
+//
+//   - an absent optional value reaches the arms as a raw `undefined`, and the first
+//     serializer to read its payload dereferences it — an uncatchable `TypeError`;
+//   - a json-typed arm cannot chain into a non-JSON target, so encoding an
+//     `Offloaded` value to `S.jsonString` fails where encoding it to `S.json` works.
+//
+// A declared arm has neither problem: sury derives both directions from the shape,
+// discriminates on it, and never runs user code to find out. One transform arm is
+// enough to bring both failures back, so keep every arm declarative.
 let schema = (inner: S.t<'a>): S.t<payload<'a>> => {
-  // Offloaded arm: recognised by the reserved sentinel key, strict, and tried
-  // first so an offloaded value is never mistaken for an inline one. The ref is
-  // a fixed new shape that needs no healing, so a direct json-transform is fine.
-  let offloadedArm = S.json->S.transform(s => {
-    parser: json =>
-      switch json->JSON.Decode.object->Option.flatMap(dict => dict->Dict.get(sentinelKey)) {
-      | Some(refJson) => Offloaded(refJson->S.parseJsonOrThrow(offloadedRefSchema))
-      | None => s.fail("not an offloaded reference")
-      },
-    serializer: payload =>
-      switch payload {
-      | Offloaded(ref) =>
-        Dict.fromArray([(sentinelKey, ref->S.reverseConvertToJsonOrThrow(offloadedRefSchema))])
-        ->JSON.Encode.object
-      | Inline(_) => s.fail("not an offloaded reference")
-      },
-  })
+  // Offloaded arm: an object carrying the reserved sentinel key, tried first so an
+  // offloaded value is never mistaken for an inline one.
+  let offloadedArm = S.object(s => Offloaded(s.field(sentinelKey, offloadedRefSchema)))
   // Inline arm: the inner schema applied through sury's own pipeline, so it
   // inherits whatever tolerance the surrounding decode uses — the lifecycle
   // Message decoder heals older payloads with missing fields. This is why the
   // codec is a union rather than one json-transform with a nested
   // parseJsonOrThrow: a nested parse runs strict and breaks the frozen corpus.
-  let inlineArm = inner->S.transform(s => {
-    parser: value => Inline(value),
-    serializer: payload =>
-      switch payload {
-      | Inline(value) => value
-      | Offloaded(_) => s.fail("not an inline value")
-      },
-  })
+  let inlineArm = inner->S.shape(value => Inline(value))
   S.union([offloadedArm, inlineArm])
 }
 
@@ -136,10 +118,14 @@ let forStore = (
   schema(inner)->Semantic.mark(~id=Semantic.Id.offload, ~payload=StoredIn({plugin, store, threshold}))
 
 /**
-The codec wrapped for an **optional** field (`js_nullable`), plus the `StoredIn`
-marker. This is the common case: offloadable fields are usually optional (absent
-for older protocol versions, say). The marker sits on the outer schema, where
+The codec wrapped for an **optional** field, plus the `StoredIn` marker. This is
+the common case: offloadable fields are usually optional (absent for older
+protocol versions, say). The marker sits on the outer schema, where
 `Semantic.get` reads it first.
+
+`nullAsOption` keeps the wire form `T | null` — byte-identical to every stored
+message — and makes the union advertise `has.null`, which is what
+`Message.fillMissingDefaults` reads to heal an absent field to `None` on replay.
 */
 let optionSchema = (
   ~plugin: option<string>=?,
@@ -147,7 +133,7 @@ let optionSchema = (
   ~threshold: option<int>=?,
   inner: S.t<'a>,
 ): S.t<option<payload<'a>>> =>
-  _jsNullable(schema(inner), ())->Semantic.mark(
+  S.nullAsOption(schema(inner))->Semantic.mark(
     ~id=Semantic.Id.offload,
     ~payload=StoredIn({plugin, store, threshold}),
   )
@@ -158,7 +144,7 @@ let optionSchema = (
     e.g. the plugin read model, whose DynamoDB write path marshals the raw value
     and would otherwise persist the variant's runtime `{TAG, _0}` shape. */
 let toJson = (inner: S.t<'a>, payload: payload<'a>): JSON.t =>
-  payload->S.reverseConvertToJsonOrThrow(schema(inner))
+  payload->Util_Sury.toJson(schema(inner))
 
 /** The inline value, if this payload is `Inline`. `None` for `Offloaded` — a
     caller that must handle both arms uses `resolve` (async, fetches the ref); a
@@ -202,7 +188,7 @@ let prepare = (
   ~hash: string => string,
   ~upload: (~key: string, ~bytes: string) => promise<unit>,
 ): promise<payload<'a>> => {
-  let bytes = value->S.reverseConvertToJsonStringOrThrow(schema)
+  let bytes = value->Util_Sury.toJsonString(schema)
   if bytes->String.length < threshold {
     Promise.resolve(Inline(value))
   } else {
@@ -227,7 +213,7 @@ let resolve = (payload: payload<'a>, ~schema: S.t<'a>, ~fetch: string => promise
   switch payload {
   | Inline(value) => Promise.resolve(value)
   | Offloaded({key}) =>
-    fetch(key)->Promise.then(bytes => Promise.resolve(bytes->S.parseJsonStringOrThrow(schema)))
+    fetch(key)->Promise.then(bytes => Promise.resolve(bytes->Util_Sury.fromJsonString(schema)))
   }
 
 /**

package/src/semantic/Offload.res.mjs

@@ -1,61 +1,30 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
-import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Sury from "sury";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
 import * as Semantic$Reventless from "./Semantic.res.mjs";
-import * as SuryResMjs from "sury/src/Sury.res.mjs";
+import * as Util_Sury$Reventless from "../util/Util_Sury.res.mjs";
 
-let offloadedRefSchema = S.schema(s => ({
-  store: s.m(S.string),
-  key: s.m(S.string),
-  hash: s.m(S.string),
-  bytes: s.m(S.int)
+let offloadedRefSchema = Sury.$schema(s => ({
+  store: s.m(Sury.string),
+  key: s.m(Sury.string),
+  hash: s.m(Sury.string),
+  bytes: s.m(Sury.int)
 }));
 
-S.enableJson();
-
 let sentinelKey = "$offload";
 
 function schema(inner) {
-  let offloadedArm = S.transform(S.json, s => ({
-    p: json => {
-      let refJson = Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(json), dict => dict[sentinelKey]);
-      if (refJson !== undefined) {
-        return {
-          TAG: "Offloaded",
-          _0: S.parseJsonOrThrow(refJson, offloadedRefSchema)
-        };
-      } else {
-        return s.fail("not an offloaded reference", undefined);
-      }
-    },
-    s: payload => {
-      if (payload.TAG === "Inline") {
-        return s.fail("not an offloaded reference", undefined);
-      } else {
-        return Object.fromEntries([[
-            sentinelKey,
-            S.reverseConvertToJsonOrThrow(payload._0, offloadedRefSchema)
-          ]]);
-      }
-    }
+  let offloadedArm = Sury.object(s => ({
+    TAG: "Offloaded",
+    _0: s.f(sentinelKey, offloadedRefSchema)
   }));
-  let inlineArm = S.transform(inner, s => ({
-    p: value => ({
-      TAG: "Inline",
-      _0: value
-    }),
-    s: payload => {
-      if (payload.TAG === "Inline") {
-        return payload._0;
-      } else {
-        return s.fail("not an inline value", undefined);
-      }
-    }
+  let inlineArm = Sury.shape(inner, value => ({
+    TAG: "Inline",
+    _0: value
   }));
-  return S.union([
+  return Sury.union([
     offloadedArm,
     inlineArm
   ]);
@@ -73,7 +42,7 @@ function forStore(plugin, store, threshold, inner) {
 }
 
 function optionSchema(plugin, store, threshold, inner) {
-  return Semantic$Reventless.mark(SuryResMjs.js_nullable(schema(inner)), Semantic$Reventless.Id.offload, {
+  return Semantic$Reventless.mark(Sury.$nullAsOption(schema(inner)), Semantic$Reventless.Id.offload, {
     TAG: "StoredIn",
     _0: {
       plugin: plugin,
@@ -84,7 +53,7 @@ function optionSchema(plugin, store, threshold, inner) {
 }
 
 function toJson(inner, payload) {
-  return S.reverseConvertToJsonOrThrow(payload, schema(inner));
+  return Util_Sury$Reventless.toJson(payload, schema(inner));
 }
 
 function getInline(payload) {
@@ -94,7 +63,7 @@ function getInline(payload) {
 }
 
 function prepare(value, schema, store, threshold, hash, upload) {
-  let bytes = S.reverseConvertToJsonStringOrThrow(value, schema, undefined);
+  let bytes = Util_Sury$Reventless.toJsonString(value, schema, undefined);
   if (bytes.length < threshold) {
     return Promise.resolve({
       TAG: "Inline",
@@ -118,7 +87,7 @@ function resolve(payload, schema, fetch) {
   if (payload.TAG === "Inline") {
     return Promise.resolve(payload._0);
   } else {
-    return fetch(payload._0.key).then(bytes => Promise.resolve(S.parseJsonStringOrThrow(bytes, schema)));
+    return fetch(payload._0.key).then(bytes => Promise.resolve(Util_Sury$Reventless.fromJsonString(bytes, schema)));
   }
 }
 

package/src/semantic/Percent.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Semantic$Reventless from "./Semantic.res.mjs";
 
 function fromFloat(raw) {
@@ -24,7 +24,7 @@ function fromFloat(raw) {
   }
 }
 
-let schema = Semantic$Reventless.refined(S.float, Semantic$Reventless.Id.percent, fromFloat);
+let schema = Semantic$Reventless.refined(Sury.float, Semantic$Reventless.Id.percent, fromFloat);
 
 export {
   fromFloat,

package/src/semantic/Phone.res.mjs

@@ -1,6 +1,6 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
-import * as S from "sury/src/S.res.mjs";
+import * as Sury from "sury";
 import * as Semantic$Reventless from "./Semantic.res.mjs";
 
 let e164 = /^\+[1-9]\d{0,14}$/;
@@ -19,7 +19,7 @@ function fromString(raw) {
   }
 }
 
-let schema = Semantic$Reventless.refined(S.string, Semantic$Reventless.Id.phone, fromString);
+let schema = Semantic$Reventless.refined(Sury.string, Semantic$Reventless.Id.phone, fromString);
 
 export {
   e164,

package/src/semantic/Semantic.res

@@ -57,6 +57,18 @@ module Id = {
   // value rather than an always-a-ref path string.
   let offload = "offload"
 
+  // The uploadable family: the same `StoredIn` declaration as `storageRef`,
+  // plus a statement about what the value *is*, so one declaration picks both a
+  // renderer and an upload endpoint. The store is derived from the field name by
+  // the ppx rather than written on the type.
+  let uploadableImage = "uploadableImage"
+  let uploadableFile = "uploadableFile"
+
+  // The same content facts with no store attached, for values the platform
+  // reads but does not own. Nothing is provisioned for these.
+  let imageRef = "imageRef"
+  let fileRef = "fileRef"
+
   // The branded scalars. Each refines a `string` or a number without changing
   // its shape, so a field gains one of these without anything stored changing.
   let email = "email"
@@ -102,13 +114,19 @@ hand-rolling a second check beside it. Deriving it here makes that structural:
 there is one place a grammar can be written, so there is nowhere for a second
 one to drift.
 */
+// sury's refiner is a predicate with a fixed message, so the per-value reason
+// `check` returns is not threaded into the schema error; call the scalar's own
+// `fromString`/`fromFloat` directly when the caller needs to report which rule
+// the value broke.
 let refined = (base: S.t<'a>, ~id: string, ~check: 'a => result<'a, string>): S.t<'a> =>
   base
-  ->S.refine(s => value =>
-    switch check(value) {
-    | Ok(_) => ()
-    | Error(why) => s.fail(why)
-    }
+  ->S.refine(
+    value =>
+      switch check(value) {
+      | Ok(_) => true
+      | Error(_) => false
+      },
+    ~error=`expected a valid ${id}`,
   )
   ->mark(~id)
 
@@ -131,7 +149,7 @@ that could stand for the whole.
 */
 let unwrapOptional = (schema: S.t<unknown>): option<S.t<unknown>> =>
   switch schema {
-  | Union({anyOf}) =>
+  | AnyOf({anyOf}) =>
     switch anyOf->Array.filter(v =>
       switch v {
       | Null(_) | Undefined(_) => false

package/src/semantic/Semantic.res.mjs

@@ -1,6 +1,7 @@
 // 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";
 
 let Id = {
@@ -8,6 +9,10 @@ let Id = {
   reference: "reference",
   storageRef: "storageRef",
   offload: "offload",
+  uploadableImage: "uploadableImage",
+  uploadableFile: "uploadableFile",
+  imageRef: "imageRef",
+  fileRef: "fileRef",
   email: "email",
   phone: "phone",
   url: "url",
@@ -20,25 +25,21 @@ let Id = {
   geoPoint: "geoPoint"
 };
 
-let semanticId = S.Metadata.Id.make("reventless", "semantic");
+let semanticId = Sury.$Metadata_Id_make("reventless", "semantic");
 
 function mark(schema, id, payloadOpt) {
   let payload = payloadOpt !== undefined ? payloadOpt : "Plain";
-  return S.Metadata.set(schema, semanticId, {
+  return Sury.$Metadata_set(schema, semanticId, {
     id: id,
     payload: payload
   });
 }
 
 function refined(base, id, check) {
-  return mark(S.refine(base, s => (value => {
-    let why = check(value);
-    if (why.TAG === "Ok") {
-      return;
-    } else {
-      return s.fail(why._0, undefined);
-    }
-  })), id, undefined);
+  return mark(S.refine(base, value => {
+    let match = check(value);
+    return match.TAG === "Ok";
+  }, `expected a valid ` + id, undefined), id, undefined);
 }
 
 function showString(raw) {
@@ -46,7 +47,7 @@ function showString(raw) {
 }
 
 function unwrapOptional(schema) {
-  if (schema.type !== "union") {
+  if (schema.type !== "anyOf") {
     return;
   }
   let match = schema.anyOf.filter(v => {
@@ -66,7 +67,7 @@ function unwrapOptional(schema) {
 }
 
 function getFrom(schema) {
-  let found = S.Metadata.get(schema, semanticId);
+  let found = Sury.$Metadata_get(schema, semanticId);
   if (found !== undefined) {
     return found;
   } else {

package/src/semantic/StorageRef.res

@@ -89,6 +89,35 @@ let fromString = (raw: string): result<t, string> =>
     }
   }
 
+/**
+The refinement a ref-holding field validates against, carrying no semantic yet.
+The `Uploadable*` types re-label this rather than restating the grammar, so a
+re-labelling cannot validate differently from what it re-labels.
+*/
+// The empty string is admitted as the "no object" sentinel. The fields this
+// marks are non-optional today, and a producer with nothing to reference —
+// a supplier feed carrying no image, say — already writes `""` to mean
+// absence. Rejecting it here would break a legitimate existing value and
+// force an event-schema change, which this marker exists to avoid: it
+// refines an existing `string` field without altering what is stored.
+//
+// Note this is a strictly weaker guarantee than `fromString`, which stays
+// exact. Making these fields properly optional would let the sentinel go.
+//
+// sury's refiner is a predicate with a fixed message, so the per-value reason
+// `fromString` returns is not threaded through; call `fromString` directly
+// when the caller needs to report which rule the value broke.
+let refinement: S.t<t> =
+  S.string->S.refine(
+    value =>
+      value === "" ||
+        switch fromString(value) {
+        | Ok(_) => true
+        | Error(_) => false
+        },
+    ~error=`expected an origin-relative storage ref: "/" followed by a prefix and an object path, or "" for no object`,
+  )
+
 /**
 The sury schema for a field holding a ref into a named store.
 
@@ -96,25 +125,10 @@ Prefer the `@storageRef("<store>")` ppx shorthand over writing this by hand.
 Qualify the store as `"<plugin>.<store>"` to point at another plugin's store.
 */
 let forStore = (~plugin: option<string>=?, ~store: string): S.t<t> =>
-  S.string
-  ->S.refine(s => value =>
-    // The empty string is admitted as the "no object" sentinel. The fields this
-    // marks are non-optional today, and a producer with nothing to reference —
-    // a supplier feed carrying no image, say — already writes `""` to mean
-    // absence. Rejecting it here would break a legitimate existing value and
-    // force an event-schema change, which this marker exists to avoid: it
-    // refines an existing `string` field without altering what is stored.
-    //
-    // Note this is a strictly weaker guarantee than `fromString`, which stays
-    // exact. Making these fields properly optional would let the sentinel go.
-    if value !== "" {
-      switch fromString(value) {
-      | Ok(_) => ()
-      | Error(why) => s.fail(why)
-      }
-    }
+  refinement->Semantic.mark(
+    ~id=Semantic.Id.storageRef,
+    ~payload=StoredIn({plugin, store, threshold: None}),
   )
-  ->Semantic.mark(~id=Semantic.Id.storageRef, ~payload=StoredIn({plugin, store, threshold: None}))
 
 /** The store a field's schema declares its refs live in, if any. */
 let getStore = (schema: S.t<'a>): option<Semantic.storeTarget> =>
@@ -152,7 +166,7 @@ let getFieldStore = (schema: S.t<'a>): option<(Semantic.storeTarget, arity)> =>
       // and a tuple's positional schemas in `items`; read both so the marker is
       // found wherever the element sits.
       switch items->Array.get(0) {
-      | Some({schema: itemSchema}) => getStore(itemSchema)
+      | Some(itemSchema) => getStore(itemSchema)
       | None =>
         switch additionalItems {
         | Schema(itemSchema) => getStore(itemSchema)

package/src/semantic/StorageRef.res.mjs

@@ -1,6 +1,7 @@
 // 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 Semantic$Reventless from "./Semantic.res.mjs";
 
@@ -44,18 +45,16 @@ function fromString(raw) {
   }
 }
 
+let refinement = S.refine(Sury.string, value => {
+  if (value === "") {
+    return true;
+  }
+  let match = fromString(value);
+  return match.TAG === "Ok";
+}, `expected an origin-relative storage ref: "/" followed by a prefix and an object path, or "" for no object`, undefined);
+
 function forStore(plugin, store) {
-  return Semantic$Reventless.mark(S.refine(S.string, s => (value => {
-    if (value === "") {
-      return;
-    }
-    let why = fromString(value);
-    if (why.TAG === "Ok") {
-      return;
-    } else {
-      return s.fail(why._0, undefined);
-    }
-  })), Semantic$Reventless.Id.storageRef, {
+  return Semantic$Reventless.mark(refinement, Semantic$Reventless.Id.storageRef, {
     TAG: "StoredIn",
     _0: {
       plugin: plugin,
@@ -90,9 +89,9 @@ function getFieldStore(schema) {
     return;
   }
   let additionalItems = schema.additionalItems;
-  let match = schema.items[0];
+  let itemSchema = schema.items[0];
   let tmp;
-  tmp = match !== undefined ? getStore(match.schema) : (
+  tmp = itemSchema !== undefined ? getStore(itemSchema) : (
       additionalItems === "strip" || additionalItems === "strict" ? undefined : getStore(additionalItems)
     );
   return Stdlib_Option.map(tmp, target => [
@@ -104,8 +103,9 @@ function getFieldStore(schema) {
 export {
   segmentIsSafe,
   fromString,
+  refinement,
   forStore,
   getStore,
   getFieldStore,
 }
-/* S Not a pure module */
+/* refinement Not a pure module */