@reventlessdev/reventless-spec 3.0.0-alpha.127 → 3.0.0-alpha.129

package/src/components/Plugin.res.mjs

@@ -49,26 +49,18 @@ let apiTargetSchema = Sury.union([
 
 let apiSchemaFragmentOffloadSchema = Offload$Reventless.optionSchema(undefined, "pluginApiFragments", undefined, apiSchemaFragmentSchema);
 
-let dcbEventLogOptionSchema = Sury.$nullAsOption(dcbEventLogDefinitionSchema);
-
-let stringOptionSchema = Sury.$nullAsOption(Sury.string);
-
-let stringArrayOptionSchema = Sury.$nullAsOption(Sury.array(Sury.string));
-
-let boolOptionSchema = Sury.$nullAsOption(Sury.bool);
-
 let panelManifestEntrySchema = Sury.$schema(s => ({
   fragmentId: s.m(Sury.string),
   title: s.m(Sury.string),
   description: s.m(Sury.string),
   positions: s.m(Sury.array(Sury.string)),
-  requiredAccess: s.m(stringOptionSchema)
+  requiredAccess: s.m(Sury.$option(Sury.string))
 }));
 
 let menuEntrySchema = Sury.$schema(s => ({
   label: s.m(Sury.string),
-  icon: s.m(stringOptionSchema),
-  group: s.m(stringOptionSchema),
+  icon: s.m(Sury.$option(Sury.string)),
+  group: s.m(Sury.$option(Sury.string)),
   sortOrder: s.m(Sury.int)
 }));
 
@@ -76,7 +68,7 @@ let pageManifestEntrySchema = Sury.$schema(s => ({
   fragmentId: s.m(Sury.string),
   title: s.m(Sury.string),
   menuEntry: s.m(menuEntrySchema),
-  requiredAccess: s.m(stringOptionSchema)
+  requiredAccess: s.m(Sury.$option(Sury.string))
 }));
 
 let uiFragmentManifestSchema = Sury.$schema(s => ({
@@ -85,7 +77,7 @@ let uiFragmentManifestSchema = Sury.$schema(s => ({
   pages: s.m(Sury.array(pageManifestEntrySchema))
 }));
 
-let uiFragmentManifestOptionSchema = Sury.$nullAsOption(uiFragmentManifestSchema);
+let uiFragmentManifestOptionSchema = Sury.$option(uiFragmentManifestSchema);
 
 let commandLevelSchema = Sury.union([
   Sury.literal("Collection"),
@@ -95,21 +87,21 @@ let commandLevelSchema = Sury.union([
 let fieldReferenceSchema = Sury.$schema(s => ({
   fieldName: s.m(Sury.string),
   entity: s.m(Sury.string),
-  plugin: s.m(stringOptionSchema)
+  plugin: s.m(Sury.$option(Sury.string))
 }));
 
 let commandDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   schema: s.m(Sury.string),
   level: s.m(commandLevelSchema),
-  aggregateIdField: s.m(stringOptionSchema),
+  aggregateIdField: s.m(Sury.$option(Sury.string)),
   mutationField: s.m(Sury.string),
   references: s.m(Sury.array(fieldReferenceSchema)),
-  allowedStates: s.m(stringArrayOptionSchema),
-  targetState: s.m(stringOptionSchema),
-  apiExposed: s.m(boolOptionSchema),
-  requiredAccess: s.m(stringArrayOptionSchema),
-  ownerField: s.m(stringOptionSchema)
+  allowedStates: s.m(Sury.$option(Sury.array(Sury.string))),
+  targetState: s.m(Sury.$option(Sury.string)),
+  apiExposed: s.m(Sury.$option(Sury.bool)),
+  requiredAccess: s.m(Sury.$option(Sury.array(Sury.string))),
+  ownerField: s.m(Sury.$option(Sury.string))
 }));
 
 let queryableDefSchema = Sury.$schema(s => ({
@@ -120,18 +112,18 @@ let queryableDefSchema = Sury.$schema(s => ({
   linkedWriteSide: s.m(Sury.array(Sury.string)),
   labelField: s.m(Sury.string),
   searchableFields: s.m(Sury.array(Sury.string)),
-  labelFieldSource: s.m(stringOptionSchema),
-  lifecycleField: s.m(stringOptionSchema),
-  ownerField: s.m(stringOptionSchema),
-  retiredField: s.m(stringOptionSchema),
-  retiredValues: s.m(stringArrayOptionSchema),
-  namedWhenRetired: s.m(boolOptionSchema),
-  visibility: s.m(stringOptionSchema),
-  chapter: s.m(stringOptionSchema),
-  singleQueryField: s.m(stringOptionSchema),
-  idField: s.m(stringOptionSchema),
-  idFieldSource: s.m(stringOptionSchema),
-  requiredAccess: s.m(stringArrayOptionSchema)
+  labelFieldSource: s.m(Sury.$option(Sury.string)),
+  lifecycleField: s.m(Sury.$option(Sury.string)),
+  ownerField: s.m(Sury.$option(Sury.string)),
+  retiredField: s.m(Sury.$option(Sury.string)),
+  retiredValues: s.m(Sury.$option(Sury.array(Sury.string))),
+  namedWhenRetired: s.m(Sury.$option(Sury.bool)),
+  visibility: s.m(Sury.$option(Sury.string)),
+  chapter: s.m(Sury.$option(Sury.string)),
+  singleQueryField: s.m(Sury.$option(Sury.string)),
+  idField: s.m(Sury.$option(Sury.string)),
+  idFieldSource: s.m(Sury.$option(Sury.string)),
+  requiredAccess: s.m(Sury.$option(Sury.array(Sury.string)))
 }));
 
 let eventDefSchema = Sury.$schema(s => ({
@@ -152,10 +144,10 @@ let writableDefSchema = Sury.$schema(s => ({
   producedEventTypes: s.m(Sury.array(Sury.string)),
   consumedEventTypes: s.m(Sury.array(Sury.string)),
   linkedViews: s.m(Sury.array(Sury.string)),
-  consistencyRead: s.m(stringOptionSchema),
+  consistencyRead: s.m(Sury.$option(Sury.string)),
   events: s.m(Sury.array(eventDefSchema)),
   errors: s.m(Sury.array(errorDefSchema)),
-  chapter: s.m(stringOptionSchema)
+  chapter: s.m(Sury.$option(Sury.string))
 }));
 
 let automationSliceDefSchema = Sury.$schema(s => ({
@@ -163,24 +155,25 @@ let automationSliceDefSchema = Sury.$schema(s => ({
   consumedEventTypes: s.m(Sury.array(Sury.string)),
   producedCommandTypes: s.m(Sury.array(Sury.string)),
   targetName: s.m(Sury.string),
-  chapter: s.m(stringOptionSchema)
+  chapter: s.m(Sury.$option(Sury.string))
 }));
 
 let outboundTranslationSliceDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   consumedEventTypes: s.m(Sury.array(Sury.string)),
   inboundCommandTypes: s.m(Sury.array(Sury.string)),
-  targetName: s.m(stringOptionSchema),
-  externalSystem: s.m(stringOptionSchema),
-  chapter: s.m(stringOptionSchema)
+  targetName: s.m(Sury.$option(Sury.string)),
+  externalSystem: s.m(Sury.$option(Sury.string)),
+  chapter: s.m(Sury.$option(Sury.string)),
+  consumedSources: s.m(Sury.$option(Sury.array(Sury.string)))
 }));
 
 let inboundTranslationSliceDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   commandTypes: s.m(Sury.array(Sury.string)),
   targetName: s.m(Sury.string),
-  externalSystem: s.m(stringOptionSchema),
-  chapter: s.m(stringOptionSchema)
+  externalSystem: s.m(Sury.$option(Sury.string)),
+  chapter: s.m(Sury.$option(Sury.string))
 }));
 
 let publishedEventDefSchema = Sury.$schema(s => ({
@@ -188,65 +181,51 @@ let publishedEventDefSchema = Sury.$schema(s => ({
   fromEventTypes: s.m(Sury.array(Sury.string))
 }));
 
-let publishedEventDefArrayOptionSchema = Sury.$nullAsOption(Sury.array(publishedEventDefSchema));
-
 let acceptedCommandDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   toCommandTypes: s.m(Sury.array(Sury.string))
 }));
 
-let acceptedCommandDefArrayOptionSchema = Sury.$nullAsOption(Sury.array(acceptedCommandDefSchema));
-
 let handledEventDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   toCommandTypes: s.m(Sury.array(Sury.string))
 }));
 
-let handledEventDefArrayOptionSchema = Sury.$nullAsOption(Sury.array(handledEventDefSchema));
-
 let issuedCommandDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   fromEventTypes: s.m(Sury.array(Sury.string))
 }));
 
-let issuedCommandDefArrayOptionSchema = Sury.$nullAsOption(Sury.array(issuedCommandDefSchema));
-
 let extensionDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   delegateNames: s.m(Sury.array(Sury.string)),
   eventTypes: s.m(Sury.array(Sury.string)),
   commandTypes: s.m(Sury.array(Sury.string)),
-  handledEvents: s.m(handledEventDefArrayOptionSchema),
-  issuedCommands: s.m(issuedCommandDefArrayOptionSchema)
+  handledEvents: s.m(Sury.$option(Sury.array(handledEventDefSchema))),
+  issuedCommands: s.m(Sury.$option(Sury.array(issuedCommandDefSchema)))
 }));
 
 let extensionPointDefSchema = Sury.$schema(s => ({
   name: s.m(Sury.string),
   delegateNames: s.m(Sury.array(Sury.string)),
   sourceEventTypes: s.m(Sury.array(Sury.string)),
-  commandTypes: s.m(stringArrayOptionSchema),
-  publishedEvents: s.m(publishedEventDefArrayOptionSchema),
-  acceptedCommands: s.m(acceptedCommandDefArrayOptionSchema)
+  commandTypes: s.m(Sury.$option(Sury.array(Sury.string))),
+  publishedEvents: s.m(Sury.$option(Sury.array(publishedEventDefSchema))),
+  acceptedCommands: s.m(Sury.$option(Sury.array(acceptedCommandDefSchema)))
 }));
 
-let extensionPointDefArrayOptionSchema = Sury.$nullAsOption(Sury.array(extensionPointDefSchema));
-
 let requiredStoreDeclarationSchema = Sury.$schema(s => ({
   store: s.m(Sury.string),
   component: s.m(Sury.string),
   field: s.m(Sury.string),
-  annotation: s.m(stringOptionSchema)
+  annotation: s.m(Sury.$option(Sury.string))
 }));
 
-let requiredStoreDeclarationArrayOptionSchema = Sury.$nullAsOption(Sury.array(requiredStoreDeclarationSchema));
-
 let requiredCapabilityDeclarationSchema = Sury.$schema(s => ({
   capability: s.m(Sury.string),
   component: s.m(Sury.string)
 }));
 
-let requiredCapabilityDeclarationArrayOptionSchema = Sury.$nullAsOption(Sury.array(requiredCapabilityDeclarationSchema));
-
 let traitDeclarationSchema = Sury.$schema(s => ({
   trait: s.m(Sury.string),
   version: s.m(Sury.string),
@@ -254,8 +233,6 @@ let traitDeclarationSchema = Sury.$schema(s => ({
   component: s.m(Sury.string)
 }));
 
-let traitDeclarationArrayOptionSchema = Sury.$nullAsOption(Sury.array(traitDeclarationSchema));
-
 let pluginStructureSchema = Sury.$schema(s => ({
   readModels: s.m(Sury.array(queryableDefSchema)),
   stateViewSlices: s.m(Sury.array(queryableDefSchema)),
@@ -265,11 +242,11 @@ let pluginStructureSchema = Sury.$schema(s => ({
   outboundTranslationSlices: s.m(Sury.array(outboundTranslationSliceDefSchema)),
   inboundTranslationSlices: s.m(Sury.array(inboundTranslationSliceDefSchema)),
   extensions: s.m(Sury.array(extensionDefSchema)),
-  extensionPoints: s.m(extensionPointDefArrayOptionSchema),
-  requiredStores: s.m(stringArrayOptionSchema),
-  requiredStoreDeclarations: s.m(requiredStoreDeclarationArrayOptionSchema),
-  requiredCapabilities: s.m(requiredCapabilityDeclarationArrayOptionSchema),
-  traitDeclarations: s.m(traitDeclarationArrayOptionSchema)
+  extensionPoints: s.m(Sury.$option(Sury.array(extensionPointDefSchema))),
+  requiredStores: s.m(Sury.$option(Sury.array(Sury.string))),
+  requiredStoreDeclarations: s.m(Sury.$option(Sury.array(requiredStoreDeclarationSchema))),
+  requiredCapabilities: s.m(Sury.$option(Sury.array(requiredCapabilityDeclarationSchema))),
+  traitDeclarations: s.m(Sury.$option(Sury.array(traitDeclarationSchema)))
 }));
 
 let pluginStructureOffloadSchema = Offload$Reventless.optionSchema(undefined, "pluginStructures", undefined, pluginStructureSchema);
@@ -283,9 +260,9 @@ let pluginDefinitionSchema = Sury.$schema(s => ({
   eventCollector: s.m(Sury.string),
   extensionProtocols: s.m(Sury.array(extensionProtocolSchema)),
   apiSchemaFragment: s.m(apiSchemaFragmentOffloadSchema),
-  apiTarget: s.m(stringOptionSchema),
+  apiTarget: s.m(Sury.$option(Sury.string)),
   structure: s.m(pluginStructureOffloadSchema),
-  dcbEventLog: s.m(dcbEventLogOptionSchema),
+  dcbEventLog: s.m(Sury.$option(dcbEventLogDefinitionSchema)),
   kind: s.m(pluginKindSchema)
 }));
 
@@ -300,10 +277,6 @@ export {
   apiSchemaFragmentSchema,
   apiTargetSchema,
   apiSchemaFragmentOffloadSchema,
-  dcbEventLogOptionSchema,
-  stringOptionSchema,
-  stringArrayOptionSchema,
-  boolOptionSchema,
   panelManifestEntrySchema,
   menuEntrySchema,
   pageManifestEntrySchema,
@@ -320,22 +293,14 @@ export {
   outboundTranslationSliceDefSchema,
   inboundTranslationSliceDefSchema,
   publishedEventDefSchema,
-  publishedEventDefArrayOptionSchema,
   acceptedCommandDefSchema,
-  acceptedCommandDefArrayOptionSchema,
   handledEventDefSchema,
-  handledEventDefArrayOptionSchema,
   issuedCommandDefSchema,
-  issuedCommandDefArrayOptionSchema,
   extensionDefSchema,
   extensionPointDefSchema,
-  extensionPointDefArrayOptionSchema,
   requiredStoreDeclarationSchema,
-  requiredStoreDeclarationArrayOptionSchema,
   requiredCapabilityDeclarationSchema,
-  requiredCapabilityDeclarationArrayOptionSchema,
   traitDeclarationSchema,
-  traitDeclarationArrayOptionSchema,
   pluginStructureSchema,
   pluginStructureOffloadSchema,
   pluginDefinitionSchema,

package/src/components/Sensitive.res

@@ -0,0 +1,137 @@
+/**
+Marks a field whose value must not be rendered into content a person receives.
+
+`@sensitive` is a *position*, not a type: it says "whatever this field holds, do
+not put it in an outbound message". What the field **is** — an email, a token, a
+reference — is declared separately, exactly as owning and tagging are separate
+facts about one field.
+
+It is declared where the field is declared, and read by anything that composes
+text somebody will read. That is the whole reason it lives here rather than
+beside whichever consumer happens to need it first: a marking that exists in one
+consumer is a marking the rest of the system cannot honour, and the domain model
+is the only place that knows which values are sensitive.
+
+## Absent means "not stated", not "safe"
+
+A reader that misses the marker leaks the value, so the failure is *open* — the
+same shape as `Owner`, and the reason `isFieldSensitive` follows the wrappers
+rather than leaving each consumer to unwrap for itself.
+
+## Some fields need no annotation
+
+A field whose semantic already says it is a contact detail is sensitive without
+anybody writing it down — see `impliedBySemantic`. The annotation is for the
+values a type cannot betray: a token, a note, a reference somebody chose.
+
+`@sensitive` is the authoring form and is sugar over the constructors below, the
+way `@owner` is sugar over `Owner`'s. Write `@s.matches(Sensitive.mark(…))` by
+hand where the ppx shorthand cannot reach — a file with no `@@reventless.spec`
+annotation, or a field whose type is neither `string` nor `option<string>`.
+
+@example
+```rescript
+@schema type event =
+  PasswordReset({
+    @owner customerId: string,
+    @sensitive resetToken: string,
+  })
+```
+*/
+let sensitiveId: S.Metadata.Id.t<bool> = S.Metadata.Id.make(
+  ~namespace="reventless",
+  ~name="sensitive",
+)
+
+/**
+Layers the marker onto a schema that already says something else.
+
+Sensitivity is independent of everything else a field declares — it may equally
+be a DCB tag, an owner, or a reference — but a field carries at most one
+`@s.matches`, so this composes by *wrapping* what the field already resolved to
+rather than replacing it. Replacing would silently drop the field's tag, and a
+dropped tag is a decision read that quietly misses events.
+*/
+let mark = (schema: S.t<'a>): S.t<'a> => schema->S.Metadata.set(~id=sensitiveId, true)
+
+/** A string field that must not be rendered outbound. */
+let string: S.t<string> = S.string->mark
+
+/**
+An `option<string>` field that must not be rendered outbound.
+
+Needed because `@s.matches` on an explicitly-`option`-typed field must supply the
+whole field schema, wrapper included. The `f?: string` form needs nothing extra:
+sury wraps the annotated inner schema itself, and `isFieldSensitive` looks
+through that wrapper either way.
+*/
+let optionString: S.t<option<string>> = S.option(string)
+
+/** Whether this exact schema carries the marker. Does not look through wrappers. */
+let isSensitive = (schema: S.t<unknown>): bool =>
+  S.Metadata.get(schema, ~id=sensitiveId)->Option.getOr(false)
+
+/**
+Whether a *field* is sensitive, wherever inside the field's type the marker sits.
+
+An optional field keeps its marker inside the union wrapper, so a walk reading
+only the outer schema answers `false` for `token?: string` — and here that means
+the value is rendered into a message rather than withheld. Object properties are
+deliberately not followed, for the same reason `Owner` does not follow them: a
+marker on a nested record's field belongs to that field, and attributing it to
+the enclosing one would withhold a whole record because one leaf is private.
+*/
+let isFieldSensitive = (schema: S.t<unknown>): bool =>
+  isSensitive(schema) ||
+    switch schema->Semantic.unwrapOptional {
+    | Some(inner) => isSensitive(inner)
+    | None => false
+    }
+
+/**
+The sensitive fields declared on an object schema, in declaration order.
+
+Threaded to the JSON-Schema walk the way `Owner.fieldNames` is, and for the same
+reason: the IR is shape-driven and sensitivity is not a shape — the field stays a
+plain string either way. Reading it off the sury schema here also keeps it
+available on command and event variants, which carry no annotation spec.
+*/
+let fieldNamesOfProperties = (properties: dict<S.t<unknown>>): array<string> =>
+  properties
+  ->Dict.toArray
+  ->Array.filterMap(((propName, propSchema)) =>
+    isFieldSensitive(propSchema) ? Some(propName) : None
+  )
+
+let fieldNames = (schema: S.t<unknown>): array<string> =>
+  switch schema {
+  | Object({properties}) => fieldNamesOfProperties(properties)
+  | _ => []
+  }
+
+/**
+The sensitive fields of one constructor of a command or event union.
+
+The form a renderer actually needs: it composes text about **one** occurrence, so
+only that variant's fields have anything to say. `OrderPlaced` and
+`PasswordReset` live in the same union and know nothing about each other's
+fields — resolving by TAG here rather than at the call site is what stops a
+template from consulting the wrong arm.
+
+Answers `[]` for an unknown tag and for a payload-less variant, both of which
+mean the same thing to a caller: nothing on this event is withheld.
+*/
+let variantFieldNames = (schema: S.t<unknown>, ~variant: string): array<string> =>
+  schema->Semantic.unionVariant(~variant)->Option.mapOr([], fieldNames)
+
+/**
+The semantics that are sensitive without an annotation.
+
+A contact detail is one whether or not anybody remembered to mark it, so the
+rule is stated once here rather than left to each consumer to remember. Kept
+deliberately short: it holds only the semantics whose *whole meaning* is "how to
+reach a particular person". A postal address or a display name can be sensitive
+in context, and context is exactly what an annotation is for.
+*/
+let impliedBySemantic = (semanticId: string): bool =>
+  semanticId === Semantic.Id.email || semanticId === Semantic.Id.phone

package/src/components/Sensitive.res.mjs

@@ -0,0 +1,74 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Sury from "sury";
+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 Semantic$Reventless from "../semantic/Semantic.res.mjs";
+
+let sensitiveId = Sury.$Metadata_Id_make("reventless", "sensitive");
+
+function mark(schema) {
+  return Sury.$Metadata_set(schema, sensitiveId, true);
+}
+
+let string = Sury.$Metadata_set(Sury.string, sensitiveId, true);
+
+let optionString = Sury.$option(string);
+
+function isSensitive(schema) {
+  return Stdlib_Option.getOr(Sury.$Metadata_get(schema, sensitiveId), false);
+}
+
+function isFieldSensitive(schema) {
+  if (isSensitive(schema)) {
+    return true;
+  }
+  let inner = Semantic$Reventless.unwrapOptional(schema);
+  if (inner !== undefined) {
+    return isSensitive(inner);
+  } else {
+    return false;
+  }
+}
+
+function fieldNamesOfProperties(properties) {
+  return Stdlib_Array.filterMap(Object.entries(properties), param => {
+    if (isFieldSensitive(param[1])) {
+      return param[0];
+    }
+  });
+}
+
+function fieldNames(schema) {
+  if (schema.type === "object") {
+    return fieldNamesOfProperties(schema.properties);
+  } else {
+    return [];
+  }
+}
+
+function variantFieldNames(schema, variant) {
+  return Stdlib_Option.mapOr(Semantic$Reventless.unionVariant(schema, variant), [], fieldNames);
+}
+
+function impliedBySemantic(semanticId) {
+  if (semanticId === Semantic$Reventless.Id.email) {
+    return true;
+  } else {
+    return semanticId === Semantic$Reventless.Id.phone;
+  }
+}
+
+export {
+  sensitiveId,
+  mark,
+  string,
+  optionString,
+  isSensitive,
+  isFieldSensitive,
+  fieldNamesOfProperties,
+  fieldNames,
+  variantFieldNames,
+  impliedBySemantic,
+}
+/* sensitiveId Not a pure module */

package/src/generator/GraftTrait.res

@@ -55,7 +55,7 @@ let parseFlags = (args: array<string>): dict<JSON.t> => {
     switch args->Array.get(i) {
     | None => ()
     | Some(arg) if arg->String.startsWith("--") =>
-      let key = arg->String.sliceToEnd(~start=2)
+      let key = arg->String.slice(~start=2, ~end=arg->String.length)
       switch args->Array.get(i + 1) {
       | Some(value) if !(value->String.startsWith("--")) =>
         out->Dict.set(key, JSON.Encode.string(value))
@@ -107,14 +107,14 @@ let arrayFieldNames = (schema: S.t<unknown>): array<string> =>
 // ── Entry point ──────────────────────────────────────────────────────────────
 
 let main = async () => {
-  let argv = NodeProcess.argv->Array.sliceToEnd(~start=2)
+  let argv = NodeProcess.argv->Array.slice(~start=2, ~end=NodeProcess.argv->Array.length)
   switch argv->Array.get(0) {
   | None | Some("") | Some("--help") | Some("-h") => {
       Console.log(usage)
       NodeProcess.exit(argv->Array.length == 0 ? 1 : 0)
     }
   | Some(traitPackage) => {
-      let flags = parseFlags(argv->Array.sliceToEnd(~start=1))
+      let flags = parseFlags(argv->Array.slice(~start=1, ~end=argv->Array.length))
       let stringFlag = key => flags->Dict.get(key)->Option.flatMap(JSON.Decode.string)
       let into = stringFlag("into")
       let tests = stringFlag("tests")
@@ -136,7 +136,8 @@ let main = async () => {
             ->String.replace("trait-", "")
             ->String.split("-")
             ->Array.map(part =>
-              part->String.charAt(0)->String.toUpperCase ++ part->String.sliceToEnd(~start=1)
+              part->String.charAt(0)->String.toUpperCase ++
+                part->String.slice(~start=1, ~end=part->String.length)
             )
             ->Array.join("") ++ "_Scaffold"
           let specifier = `${traitPackage}/src/${scaffoldModule}.res.mjs`

package/src/generator/GraftTrait.res.mjs

@@ -36,7 +36,7 @@ function parseFlags(args) {
         return;
       }
       if (arg.startsWith("--")) {
-        let key = arg.slice(2);
+        let key = arg.slice(2, arg.length);
         let value = args[i + 1 | 0];
         if (value !== undefined && !value.startsWith("--")) {
           out[key] = value;
@@ -83,7 +83,7 @@ function arrayFieldNames(schema) {
 }
 
 async function main() {
-  let argv = process.argv.slice(2);
+  let argv = process.argv.slice(2, process.argv.length);
   let traitPackage = argv[0];
   if (traitPackage !== undefined) {
     switch (traitPackage) {
@@ -92,7 +92,7 @@ async function main() {
       case "-h" :
         break;
       default:
-        let flags = parseFlags(argv.slice(1));
+        let flags = parseFlags(argv.slice(1, argv.length));
         let stringFlag = key => Stdlib_Option.flatMap(flags[key], Stdlib_JSON.Decode.string);
         let into = stringFlag("into");
         let tests = stringFlag("tests");
@@ -103,7 +103,7 @@ async function main() {
         if (tests === undefined) {
           return fail("--into and --tests are both required.\n\n" + usage);
         }
-        let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1)).join("") + "_Scaffold";
+        let scaffoldModule = Stdlib_Option.getOr(Stdlib_Array.last(traitPackage.split("/")), "").replace("trait-", "").split("-").map(part => part.charAt(0).toUpperCase() + part.slice(1, part.length)).join("") + "_Scaffold";
         let specifier = traitPackage + `/src/` + scaffoldModule + `.res.mjs`;
         let modulePath;
         try {

package/src/semantic/Bytes.res

@@ -1,26 +1,9 @@
 /**
-Marks a numeric field as a count of bytes.
+Marks a numeric field as a count of bytes: finite, whole, zero or greater.
 
-## Why `float` and not `int`
-
-A byte count is a whole number and cannot be negative, so `int` is the type it
-wants to be. It is the wrong one here anyway: ReScript's `int` is int32, and
-sury enforces that, so an `int` byte count silently caps at 2,147,483,647 — just
-under 2 GiB. A type whose stated job is file sizes cannot stop at 2 GB.
-
-`float` is a JS number, exact for every integer up to 2^53 — nine petabytes,
-which is enough. The discreteness `int` would have given for free is recovered
-by checking it: the grammar below rejects a fractional byte count, so the type
-still means what `int` meant, minus the ceiling.
-
-The wire is unaffected either way — both are JSON numbers — so this is a source
-choice, not a format one. A field genuinely bounded below 2 GiB can still be
-declared `int` and left unmarked; this type is for the ones that are not.
-
-## The grammar
-
-A finite, whole number, zero or greater. Zero is a real byte count — an empty
-object — so it is accepted.
+`float` rather than `int` because ReScript's `int` is int32, which caps a byte
+count just under 2 GiB; wholeness is recovered by the grammar below. The wire is
+a JSON number either way.
 
 @example
 ```rescript
@@ -52,3 +35,20 @@ let fromFloat = (raw: float): result<t, string> =>
 
 /** The sury schema for a byte-count field. Use with `@s.matches(Reventless.Bytes.schema)`. */
 let schema: S.t<t> = S.float->Semantic.refined(~id=Semantic.Id.bytes, ~check=fromFloat)
+
+/** Binary, because a byte count is what a filesystem reports. */
+let step = 1024.0
+let units = ["B", "KB", "MB", "GB", "TB", "PB"]
+
+/** The count as text — `"512 B"`, `"1.5 KB"`, `"2 MB"`. Locale-independent, the
+    way `Money.format` is, so one value reads the same everywhere. */
+let format = (b: t): string => {
+  let last = Array.length(units) - 1
+  let rec reduce = (value: float, index: int): (float, string) =>
+    value < step || index >= last
+      ? (value, units->Array.getUnsafe(index))
+      : reduce(value /. step, index + 1)
+  let (value, unit) = reduce(b, 0)
+  // One decimal, and only when it says something: 2097152 is "2 MB", not "2.0 MB".
+  Float.toString(Math.round(value *. 10.0) /. 10.0) ++ " " ++ unit
+}

package/src/semantic/Bytes.res.mjs

@@ -31,8 +31,43 @@ function fromFloat(raw) {
 
 let schema = Semantic$Reventless.refined(Sury.float, Semantic$Reventless.Id.bytes, fromFloat);
 
+let units = [
+  "B",
+  "KB",
+  "MB",
+  "GB",
+  "TB",
+  "PB"
+];
+
+function format(b) {
+  let last = units.length - 1 | 0;
+  let reduce = (_value, _index) => {
+    while (true) {
+      let index = _index;
+      let value = _value;
+      if (value < 1024.0 || index >= last) {
+        return [
+          value,
+          units[index]
+        ];
+      }
+      _index = index + 1 | 0;
+      _value = value / 1024.0;
+      continue;
+    };
+  };
+  let match = reduce(b, 0);
+  return (Math.round(match[0] * 10.0) / 10.0).toString() + " " + match[1];
+}
+
+let step = 1024.0;
+
 export {
   fromFloat,
   schema,
+  step,
+  units,
+  format,
 }
 /* schema Not a pure module */