@reventlessdev/reventless-spec 3.0.0-alpha.100

package/src/semantic/Offload.res

@@ -0,0 +1,294 @@
+/**
+A field whose large value lives in a content-addressed object store, carried by
+reference — or inline when it is small enough not to be worth a round trip.
+
+## Sibling of `StorageRef`, not the same thing
+
+`StorageRef` and `Offload` are two members of one family: both say "this field's
+value lives in an object store", both declare that store through the shared
+`Semantic.StoredIn` marker, and both are produced by a **client** that uploads
+the bytes before the command is issued — never by the framework inside `decide`.
+They differ in what the field carries:
+
+- `@storageRef` is always a reference (an origin-relative path a store minted),
+  and the reference *is* the value the reader sees (a URL it renders).
+- `@offload` is an **inline-or-reference** value. Below a size threshold the
+  value stays embedded; above it the client stores the bytes under a
+  content-addressed key and the field carries `Offloaded{store, key, hash, bytes}`.
+  A reader resolves either arm back to the value.
+
+Content addressing (the key is the SHA-256 of the bytes) makes the store write
+idempotent and deduplicating: the same value stored twice lands on the same key,
+so identical payloads across versions or tenants hold one object, not many.
+
+## The backward-compatible wire form
+
+Every event already in history stored the value **inline and unwrapped** — a
+plain record, with no variant tag. So the codec here must decode those bytes
+unchanged, which rules out sury's default tagged-union encoding (`{TAG, _0}`).
+
+Instead the codec is *untagged* and sniffs a reserved sentinel key:
+
+- an `Offloaded` value encodes as `{"$offload": {store, key, hash, bytes}}`;
+- an `Inline` value encodes as the raw value, exactly as before.
+
+On decode, a JSON object carrying the `$offload` key is an `Offloaded`; anything
+else is decoded as the inner value into `Inline`. A record field name can never
+be `$offload` (identifiers cannot start with `$`), so a legacy inline payload can
+never be mistaken for a reference, and vice versa — no migration, and a
+pre-change fixture decodes as `Inline` untouched.
+
+@example
+```rescript
+// an event/command field, optional and offloadable to the "pluginStructures" store
+structure: @s.matches(Offload.optionSchema(~store="pluginStructures", pluginStructureSchema))
+  option<Offload.payload<pluginStructure>>
+```
+*/
+
+/** The reference an offloaded value carries: which store holds it, the
+    content-addressed key, the content hash (== the key's basis), and the byte
+    length. `hash` is redundant with `key` today (`key` is `sha256/<hash>`) but
+    named so a reader can verify integrity without parsing the key. */
+@schema
+type offloadedRef = {
+  store: string,
+  key: string,
+  hash: string,
+  bytes: int,
+}
+
+/** A field's value: embedded, or a reference to bytes the client stored. */
+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. */
+let sentinelKey = "$offload"
+
+/**
+The untagged inline-or-reference codec for a field of inner type `'a`.
+
+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.
+*/
+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")
+      },
+  })
+  // 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")
+      },
+  })
+  S.union([offloadedArm, inlineArm])
+}
+
+/**
+The codec plus the `StoredIn` marker declaring which store the field's references
+live in, for a **non-optional** field. `plugin` is absent for the declaring
+plugin's own store; qualify as `"<plugin>.<store>"` to point at another's.
+
+Prefer the `@offload("<store>")` ppx shorthand over calling this by hand.
+*/
+let forStore = (
+  ~plugin: option<string>=?,
+  ~store: string,
+  ~threshold: option<int>=?,
+  inner: S.t<'a>,
+): S.t<payload<'a>> =>
+  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
+`Semantic.get` reads it first.
+*/
+let optionSchema = (
+  ~plugin: option<string>=?,
+  ~store: string,
+  ~threshold: option<int>=?,
+  inner: S.t<'a>,
+): S.t<option<payload<'a>>> =>
+  _jsNullable(schema(inner), ())->Semantic.mark(
+    ~id=Semantic.Id.offload,
+    ~payload=StoredIn({plugin, store, threshold}),
+  )
+
+/** Serialize a payload to its **untagged** wire JSON: `Inline` becomes the bare
+    inner value's JSON, `Offloaded` becomes `{"$offload": {...}}`. Used where a
+    payload must be stored as a plain JSON blob rather than the ReScript variant —
+    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))
+
+/** 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
+    caller that only ever sees inline values (a test, or a path where offloading
+    is not yet wired) uses this. */
+let getInline = (payload: payload<'a>): option<'a> =>
+  switch payload {
+  | Inline(value) => Some(value)
+  | Offloaded(_) => None
+  }
+
+// ── Client helpers ─────────────────────────────────────────────────────────
+//
+// The producer/reader surface that makes offloading easy for a client to drive.
+// Both take their store I/O as injected transports so this module stays pure
+// and provider-agnostic: a browser passes a presigned PUT / fetch, the Node seed
+// passes a direct SDK call, a test passes an in-memory map. The plugin's own
+// deploy-time producer is the exception — it offloads Pulumi-natively (declares a
+// content-addressed object resource) rather than through `prepare`, because its
+// value is a `Pulumi.Output` and a resource cannot be created inside `.apply`.
+
+/**
+Decide inline-or-offloaded for one value and, when it is large, upload it.
+
+Serializes `value` with `schema`; if the JSON is below `threshold` it stays
+`Inline` (no round trip). Otherwise it is hashed, uploaded under the
+content-addressed key `sha256/<hash>`, and returned as `Offloaded`. Because the
+key is the content hash, re-uploading identical bytes writes the same object —
+idempotent, and the source of cross-version/cross-client dedupe.
+
+`~hash` and `~upload` are injected so this stays provider-agnostic; `~hash` must
+be a stable content hash (the same bytes must always hash the same). Size is the
+JSON string's length in characters — a close proxy for byte length on the
+mostly-ASCII JSON these payloads are, and only ever used for the threshold cut.
+*/
+let prepare = (
+  value: 'a,
+  ~schema: S.t<'a>,
+  ~store: string,
+  ~threshold: int,
+  ~hash: string => string,
+  ~upload: (~key: string, ~bytes: string) => promise<unit>,
+): promise<payload<'a>> => {
+  let bytes = value->S.reverseConvertToJsonStringOrThrow(schema)
+  if bytes->String.length < threshold {
+    Promise.resolve(Inline(value))
+  } else {
+    let digest = hash(bytes)
+    let key = "sha256/" ++ digest
+    upload(~key, ~bytes)->Promise.then(() =>
+      Promise.resolve(Offloaded({store, key, hash: digest, bytes: bytes->String.length}))
+    )
+  }
+}
+
+/**
+Resolve a payload back to its value: `Inline` directly, `Offloaded` by fetching
+the object's bytes (via the injected `~fetch`) and decoding with `schema`.
+
+Offloaded objects are written by current code, so their bytes decode strictly —
+unlike the inline arm of the wire codec, which heals older event payloads.
+*/
+let resolve = (payload: payload<'a>, ~schema: S.t<'a>, ~fetch: string => promise<string>): promise<
+  'a,
+> =>
+  switch payload {
+  | Inline(value) => Promise.resolve(value)
+  | Offloaded({key}) =>
+    fetch(key)->Promise.then(bytes => Promise.resolve(bytes->S.parseJsonStringOrThrow(schema)))
+  }
+
+/**
+Wrap a `~fetch` so each content-addressed key is fetched at most once per process.
+
+Keys are immutable (they are content hashes), so a fetched object can be cached
+forever — every replay/projection that references the same hash reuses it, and
+concurrent resolves of the same key share the one in-flight promise.
+*/
+let cachedFetch = (fetch: string => promise<string>): (string => promise<string>) => {
+  let cache: dict<promise<string>> = Dict.make()
+  key =>
+    switch cache->Dict.get(key) {
+    | Some(inflight) => inflight
+    | None =>
+      let inflight = fetch(key)
+      cache->Dict.set(key, inflight)
+      inflight
+    }
+}
+
+/** The store an `@offload` field declares, if any — the read side of the marker,
+    used by provisioning to know the field requires this store to exist. Distinct
+    from `StorageRef.getStore` by the semantic id, so the two families stay
+    separable (offload objects are content-addressed and durable up front; they
+    must not be swept by the pending-upload claimer). */
+let getStore = (schema: S.t<'a>): option<Semantic.storeTarget> =>
+  switch Semantic.get(schema) {
+  | Some({id, payload: StoredIn(target)}) if id == Semantic.Id.offload => Some(target)
+  | _ => None
+  }
+
+/** The framework-default inline-vs-offloaded byte cut, used when neither the field
+    marker nor the platform declares one. Retuning any level is safe: both arms of
+    the codec read back to identical bytes, so the threshold only decides how
+    *future* values are split — no wire change, no re-encoding, existing events
+    stay valid. */
+let defaultThreshold = 8192
+
+/** The per-field threshold an `@offload` field declares, if any — the top of the
+    precedence chain (`@offload({..., threshold})`). `None` when the field left it
+    unset, which defers to the platform default and then {!defaultThreshold}. */
+let getThreshold = (schema: S.t<'a>): option<int> =>
+  switch Semantic.get(schema) {
+  | Some({id, payload: StoredIn({threshold})}) if id == Semantic.Id.offload => threshold
+  | _ => None
+  }
+
+/**
+The effective threshold for a field, resolving the precedence chain most-specific
+first: the per-field `@offload({threshold})` (read from the field's schema), then
+the platform config default (`~platformDefault`, e.g. `MakeWithConfig`'s
+`offloadThreshold`), then {!defaultThreshold}.
+
+A client drives an offloadable field by reading its field schema, calling this to
+get the cut, and passing the result as {!prepare}'s `~threshold`. `prepare` stays
+threshold-explicit (it holds the *value* schema, not the field schema that carries
+the marker), so this is the seam that turns the declaration into a number.
+*/
+let effectiveThreshold = (schema: S.t<'a>, ~platformDefault: option<int>=?, ()): int =>
+  switch getThreshold(schema) {
+  | Some(t) => t
+  | None => platformDefault->Option.getOr(defaultThreshold)
+  }

package/src/semantic/Offload.res.mjs

@@ -0,0 +1,191 @@
+// 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 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";
+
+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)
+}));
+
+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 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);
+      }
+    }
+  }));
+  return S.union([
+    offloadedArm,
+    inlineArm
+  ]);
+}
+
+function forStore(plugin, store, threshold, inner) {
+  return Semantic$Reventless.mark(schema(inner), Semantic$Reventless.Id.offload, {
+    TAG: "StoredIn",
+    _0: {
+      plugin: plugin,
+      store: store,
+      threshold: threshold
+    }
+  });
+}
+
+function optionSchema(plugin, store, threshold, inner) {
+  return Semantic$Reventless.mark(SuryResMjs.js_nullable(schema(inner)), Semantic$Reventless.Id.offload, {
+    TAG: "StoredIn",
+    _0: {
+      plugin: plugin,
+      store: store,
+      threshold: threshold
+    }
+  });
+}
+
+function toJson(inner, payload) {
+  return S.reverseConvertToJsonOrThrow(payload, schema(inner));
+}
+
+function getInline(payload) {
+  if (payload.TAG === "Inline") {
+    return Primitive_option.some(payload._0);
+  }
+}
+
+function prepare(value, schema, store, threshold, hash, upload) {
+  let bytes = S.reverseConvertToJsonStringOrThrow(value, schema, undefined);
+  if (bytes.length < threshold) {
+    return Promise.resolve({
+      TAG: "Inline",
+      _0: value
+    });
+  }
+  let digest = hash(bytes);
+  let key = "sha256/" + digest;
+  return upload(key, bytes).then(() => Promise.resolve({
+    TAG: "Offloaded",
+    _0: {
+      store: store,
+      key: key,
+      hash: digest,
+      bytes: bytes.length
+    }
+  }));
+}
+
+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)));
+  }
+}
+
+function cachedFetch(fetch) {
+  let cache = {};
+  return key => {
+    let inflight = cache[key];
+    if (inflight !== undefined) {
+      return inflight;
+    }
+    let inflight$1 = fetch(key);
+    cache[key] = inflight$1;
+    return inflight$1;
+  };
+}
+
+function getStore(schema) {
+  let match = Semantic$Reventless.get(schema);
+  if (match === undefined) {
+    return;
+  }
+  let target = match.payload;
+  if (typeof target !== "object" || target.TAG === "ReferenceTo" || match.id !== Semantic$Reventless.Id.offload) {
+    return;
+  } else {
+    return target._0;
+  }
+}
+
+function getThreshold(schema) {
+  let match = Semantic$Reventless.get(schema);
+  if (match === undefined) {
+    return;
+  }
+  let match$1 = match.payload;
+  if (typeof match$1 !== "object" || match$1.TAG === "ReferenceTo" || match.id !== Semantic$Reventless.Id.offload) {
+    return;
+  } else {
+    return match$1._0.threshold;
+  }
+}
+
+function effectiveThreshold(schema, platformDefault, param) {
+  let t = getThreshold(schema);
+  if (t !== undefined) {
+    return t;
+  } else {
+    return Stdlib_Option.getOr(platformDefault, 8192);
+  }
+}
+
+let defaultThreshold = 8192;
+
+export {
+  offloadedRefSchema,
+  sentinelKey,
+  schema,
+  forStore,
+  optionSchema,
+  toJson,
+  getInline,
+  prepare,
+  resolve,
+  cachedFetch,
+  getStore,
+  defaultThreshold,
+  getThreshold,
+  effectiveThreshold,
+}
+/* offloadedRefSchema Not a pure module */

package/src/semantic/Percent.res

@@ -0,0 +1,53 @@
+/**
+Marks a `float` field as a percentage, expressed **0–100**.
+
+## Why 0–100 and not 0–1
+
+Both conventions are defensible in the abstract, so the tie is broken by the
+consumer that already exists: the dashboard gauges a field with this semantic
+against fixed bounds of 0 and 100, and formats `42.0` as `"42%"`. Under a 0–1
+convention every value would render as a rounding error near zero — a gauge
+pinned at empty and a label reading `"0.42%"`.
+
+That failure is quiet, and it is quiet in the worst way: the numbers are
+*present* and *wrong*, and the layer at fault is not the one showing the symptom.
+Agreeing with the renderer costs nothing; disagreeing costs an afternoon.
+
+A fraction is still perfectly good arithmetic — it just multiplies by 100 before
+it becomes this type.
+
+## The grammar
+
+A finite number in `[0, 100]`. Fractions are allowed: `99.95` is a percentage.
+
+@example
+```rescript
+@schema type state = {
+  productId: string,
+  taxRate: @s.matches(Reventless.Percent.schema) float,
+}
+```
+*/
+
+/** The percentage's representation. Transparent `float`: the marker refines an
+    existing numeric field rather than replacing it, so nothing stored changes. */
+type t = float
+
+external unsafe: float => t = "%identity"
+external toFloat: t => float = "%identity"
+
+/** Validate a number as a percentage, saying why when it is not one. */
+let fromFloat = (raw: float): result<t, string> =>
+  if !Float.isFinite(raw) {
+    Error(`a percentage must be a finite number, got ${Float.toString(raw)}`)
+  } else if raw < 0.0 || raw > 100.0 {
+    Error(
+      `a percentage runs from 0 to 100, got ${Float.toString(raw)}. ` ++
+      `This scale is 0–100, not 0–1 — a fraction multiplies by 100 first.`,
+    )
+  } else {
+    Ok(raw)
+  }
+
+/** The sury schema for a percentage field. Use with `@s.matches(Reventless.Percent.schema)`. */
+let schema: S.t<t> = S.float->Semantic.refined(~id=Semantic.Id.percent, ~check=fromFloat)

package/src/semantic/Percent.res.mjs

@@ -0,0 +1,33 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+
+function fromFloat(raw) {
+  if (isFinite(raw)) {
+    if (raw < 0.0 || raw > 100.0) {
+      return {
+        TAG: "Error",
+        _0: `a percentage runs from 0 to 100, got ` + raw.toString() + `. This scale is 0–100, not 0–1 — a fraction multiplies by 100 first.`
+      };
+    } else {
+      return {
+        TAG: "Ok",
+        _0: raw
+      };
+    }
+  } else {
+    return {
+      TAG: "Error",
+      _0: `a percentage must be a finite number, got ` + raw.toString()
+    };
+  }
+}
+
+let schema = Semantic$Reventless.refined(S.float, Semantic$Reventless.Id.percent, fromFloat);
+
+export {
+  fromFloat,
+  schema,
+}
+/* schema Not a pure module */

package/src/semantic/Phone.res

@@ -0,0 +1,55 @@
+/**
+Marks a `string` field as a phone number in E.164 form.
+
+## Why E.164, and only E.164
+
+A phone number written the way a person says it out loud — `(030) 12 34 56`,
+`+49 30 123456`, `0049-30-123456` — is three different strings for one number,
+so a log full of them cannot be searched, deduplicated or dialled reliably. E.164
+is the one form that is unambiguous internationally, and it is the form the
+`tel:` link this field renders as actually wants.
+
+That makes this the one branded scalar that is likely to *reject* input a form
+would otherwise have accepted, and it should: the alternative is storing an
+un-dialable string permanently. Normalising a local number into E.164 needs a
+default country the framework does not know, so that belongs to the caller,
+before the command.
+
+## The grammar
+
+`+`, then a country digit 1–9, then up to 14 more digits — at most 15 in total,
+which is the E.164 limit. No spaces, no punctuation, no leading zero after the
+`+`.
+
+@example
+```rescript
+@schema type command =
+  | SetContactPhone({
+      customerId: @s.matches(DcbTag.string) string,
+      phone: @s.matches(Reventless.Phone.schema) string,
+    })
+```
+*/
+
+/** The number's representation. Transparent `string`; see `Email.t`. */
+type t = string
+
+external unsafe: string => t = "%identity"
+external toString: t => string = "%identity"
+
+let e164 = /^\+[1-9]\d{0,14}$/
+
+/** Validate a raw string as an E.164 number, saying why when it is not one. */
+let fromString = (raw: string): result<t, string> =>
+  if e164->RegExp.test(raw) {
+    Ok(raw)
+  } else {
+    Error(
+      `expected a phone number in E.164 form — "+" then up to 15 digits, as in "+4930123456" — got ${Semantic.showString(
+          raw,
+        )}. Spaces, dashes and brackets are not part of the stored form.`,
+    )
+  }
+
+/** The sury schema for a phone field. Use with `@s.matches(Reventless.Phone.schema)`. */
+let schema: S.t<t> = S.string->Semantic.refined(~id=Semantic.Id.phone, ~check=fromString)

package/src/semantic/Phone.res.mjs

@@ -0,0 +1,29 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Semantic$Reventless from "./Semantic.res.mjs";
+
+let e164 = /^\+[1-9]\d{0,14}$/;
+
+function fromString(raw) {
+  if (e164.test(raw)) {
+    return {
+      TAG: "Ok",
+      _0: raw
+    };
+  } else {
+    return {
+      TAG: "Error",
+      _0: `expected a phone number in E.164 form — "+" then up to 15 digits, as in "+4930123456" — got ` + Semantic$Reventless.showString(raw) + `. Spaces, dashes and brackets are not part of the stored form.`
+    };
+  }
+}
+
+let schema = Semantic$Reventless.refined(S.string, Semantic$Reventless.Id.phone, fromString);
+
+export {
+  e164,
+  fromString,
+  schema,
+}
+/* schema Not a pure module */