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

package/CHANGELOG.md

@@ -3,6 +3,46 @@
 All notable changes to this project will be documented in this file.
 See [Conventional Commits](https://conventionalcommits.org) for commit guidelines.
 
+# 3.0.0-alpha.129 (2026-09-04)
+
+### Bug Fixes
+
+* **logging:** let a runtime declare whether a person reads its logs ([df7a6cb](https://github.com/ReventlessDev/reventless-core/commit/df7a6cbdff62b856ea6b9d1f169b913563ba13a1))
+* feat(spec)!: one optional encoding on the wire, with no annotation ([320f91d](https://github.com/ReventlessDev/reventless-core/commit/320f91daa8bd90812a6e82069e7a1cb473041930))
+
+### BREAKING CHANGES
+
+* the two encodings cannot read each other. Stored
+pluginDefinition / pluginStructure payloads and already-deployed plugins must
+go — wipe the platform scope (SEED_RESET_SCOPE=platform), quiesce, and
+redeploy the fleet from one commit. Domain plugin data is untouched.
+
+Two guards had to learn the new shape, both of which defined "optional" as
+has.null and so mistook an omitted key for something to invent:
+
+- Message.fillMissingDefaults reached `return undefined` only below two arms
+  that fire first — an enum's first const, and an object member filled with
+  zeros. Absent option<record> therefore healed to a zero-filled record, not
+  None: on the real schema, dcbEventLog became Some({name: "", eventTopicArn:
+  ""}), which manageSubscriptions would have read as a peer to subscribe to.
+  One line, mirroring the has.null guard, above both arms.
+- PluginDefinitionScalars' walker reported 16 optional fields as newly-added
+  bare required scalars. With both encodings understood, the golden list is
+  unchanged.
+
+The frozen lifecycle corpus holds five real payloads in the old encoding.
+Null-valued keys were stripped mechanically — the rewrite round-trips each
+file unchanged before editing, and a key-by-key diff shows null removals and
+nothing else. The README records it beside the account-id redaction and says
+why it is not a regeneration: no fixture was rebuilt from ReScript types, so
+every generation in its table is still pinned.
+
+check:graphql is unchanged, as expected: SchemaType.fromSury collapses Null
+and Undefined to the same Nullable, so the emitted schema never distinguished
+them.
+
+
+
 # 3.0.0-alpha.128 (2026-09-04)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.128",
+  "version": "3.0.0-alpha.129",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -24,7 +24,7 @@
     "sury": "11.0.0-rc.2",
     "sury-ppx": "11.0.0-rc.2",
     "yaml": "^2.8.3",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8"
+    "@reventlessdev/rescript-node": "2.0.0-alpha.9"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/AnsiStyle.res

@@ -11,14 +11,23 @@
 @val external _isTty: option<bool> = "process.stdout.isTTY"
 @val external _logFormat: option<string> = "process.env.REVENTLESS_LOG_FORMAT"
 
-// "json" | "text". Explicit REVENTLESS_LOG_FORMAT override always wins; otherwise
-// a TTY stdout ⇒ human-readable text, everything else (Lambda, Fargate, ECS,
-// Azure, GCP, Docker, CI runners, piped stdout) ⇒ structured JSON.
+// What this runtime is, for when stdout cannot say. A local dev platform's logs
+// are read by a person even when its stdout is a pipe — `concurrently`, `tsx
+// watch` and an IDE terminal all pipe — while a Lambda's are read by a collector
+// through a pipe that looks identical. TTY-ness is only a proxy for "a person is
+// reading this", and a pipe is exactly where the proxy fails, so a runtime that
+// knows which it is says so instead of being guessed at.
+let _default: ref<option<string>> = ref(None)
+
+// "json" | "text", in precedence order: an explicit REVENTLESS_LOG_FORMAT, then
+// what the runtime declared itself to be, then the TTY probe — a TTY stdout ⇒
+// text, everything else (Lambda, Fargate, ECS, Docker, CI) ⇒ structured JSON.
 let _resolveFormat = (): string =>
-  switch (_logFormat, _isTty) {
-  | (Some("json"), _) => "json"
-  | (Some("text"), _) => "text"
-  | (_, Some(true)) => "text"
+  switch (_logFormat, _default.contents, _isTty) {
+  | (Some("json"), _, _) => "json"
+  | (Some("text"), _, _) => "text"
+  | (_, Some(declared), _) => declared
+  | (_, None, Some(true)) => "text"
   | _ => "json"
   }
 
@@ -27,6 +36,21 @@ let _resolveFormat = (): string =>
 // keeps every log call off `process.env`.
 let _format = ref(_resolveFormat())
 
+/** Declares what this runtime is, for the pipe case the TTY probe gets wrong.
+    Call it at module init, before anything logs. An explicit
+    REVENTLESS_LOG_FORMAT still wins, so a developer can always ask for the other
+    one. A runtime that says nothing keeps the TTY behaviour. */
+let setDefaultFormat = (format: [#text | #json]) => {
+  _default :=
+    Some(
+      switch format {
+      | #text => "text"
+      | #json => "json"
+      },
+    )
+  _format := _resolveFormat()
+}
+
 /** Test-only: re-evaluate REVENTLESS_LOG_FORMAT / process.stdout.isTTY. */
 let reload = () => _format := _resolveFormat()
 

package/src/AnsiStyle.res.mjs

@@ -1,9 +1,14 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
 
+let _default = {
+  contents: undefined
+};
+
 function _resolveFormat() {
   let match = process.env.REVENTLESS_LOG_FORMAT;
-  let match$1 = process.stdout.isTTY;
+  let match$1 = _default.contents;
+  let match$2 = process.stdout.isTTY;
   if (match !== undefined) {
     switch (match) {
       case "json" :
@@ -12,7 +17,9 @@ function _resolveFormat() {
         return "text";
     }
   }
-  if (match$1 !== undefined && match$1) {
+  if (match$1 !== undefined) {
+    return match$1;
+  } else if (match$2 !== undefined && match$2) {
     return "text";
   } else {
     return "json";
@@ -23,6 +30,11 @@ let _format = {
   contents: _resolveFormat()
 };
 
+function setDefaultFormat(format) {
+  _default.contents = format === "text" ? "text" : "json";
+  _format.contents = _resolveFormat();
+}
+
 function reload() {
   _format.contents = _resolveFormat();
 }
@@ -44,8 +56,10 @@ function bold(s) {
 }
 
 export {
+  _default,
   _resolveFormat,
   _format,
+  setDefaultFormat,
   reload,
   isJsonSink,
   useAnsi,

package/src/components/Plugin.res

@@ -73,13 +73,13 @@ type apiSchemaFragment = {encoded: string, protocol: string}
 @schema
 type apiTarget = Domain | Platform
 
-// js_nullable (T | null) is the only optional that passes jsonableValidation inside
-// union variant payloads; nullableAsOption adds `undefined` and fails it.
+// Every optional below carries sury's default `option` encoding: the key is omitted,
+// never written as `null`. That is the shape the rest of the repo already uses
+// (`Message.meta`, `storedEvent.tags`), so there is one optional form on the wire and
+// nothing to annotate. The `T | null` these fields used to carry worked around a sury
+// bug — undefined failing jsonableValidation inside a union variant payload — fixed in
+// 11.0.0-alpha.11. `Offload` below is not an optional wrapper but an either-or codec.
 let apiSchemaFragmentOffloadSchema = Offload.optionSchema(~store="pluginApiFragments", apiSchemaFragmentSchema)
-let dcbEventLogOptionSchema = dcbEventLogDefinitionSchema->S.nullAsOption
-let stringOptionSchema = S.string->S.nullAsOption
-let stringArrayOptionSchema = S.array(S.string)->S.nullAsOption
-let boolOptionSchema = S.bool->S.nullAsOption
 
 // ── UI fragment manifest types ────────────────────────────────────────────────
 
@@ -89,14 +89,14 @@ type panelManifestEntry = {
   title: string,
   description: string,
   positions: array<string>,
-  requiredAccess: @s.matches(stringOptionSchema) option<string>,
+  requiredAccess: option<string>,
 }
 
 @schema
 type menuEntry = {
   label: string,
-  icon: @s.matches(stringOptionSchema) option<string>,
-  group: @s.matches(stringOptionSchema) option<string>,
+  icon: option<string>,
+  group: option<string>,
   sortOrder: int,
 }
 
@@ -105,7 +105,7 @@ type pageManifestEntry = {
   fragmentId: string,
   title: string,
   menuEntry: menuEntry,
-  requiredAccess: @s.matches(stringOptionSchema) option<string>,
+  requiredAccess: option<string>,
 }
 
 @schema
@@ -115,7 +115,7 @@ type uiFragmentManifest = {
   pages: array<pageManifestEntry>,
 }
 
-let uiFragmentManifestOptionSchema = uiFragmentManifestSchema->S.nullAsOption
+let uiFragmentManifestOptionSchema = S.option(uiFragmentManifestSchema)
 
 // ── Plugin structure types (component metadata for Auto UI and event graph) ──
 
@@ -126,7 +126,7 @@ type commandLevel = Collection | Instance
 type fieldReference = {
   fieldName: string,
   entity: string,
-  plugin: @s.matches(stringOptionSchema) option<string>,
+  plugin: option<string>,
 }
 
 @schema
@@ -134,23 +134,23 @@ type commandDef = {
   name: string,
   schema: string,
   level: commandLevel,
-  aggregateIdField: @s.matches(stringOptionSchema) option<string>,
+  aggregateIdField: option<string>,
   mutationField: string,
   references: array<fieldReference>,
   /** The declared *from* set — lifecycle states this command is meaningful in.
       `None` means always available; `Some([])` means never show. */
-  allowedStates: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  allowedStates: option<array<string>>,
   /** The declared *to* state this command's handler writes. `None` with a
       from-set present means the command does not move the row. */
-  targetState: @s.matches(stringOptionSchema) option<string>,
+  targetState: option<string>,
   /** Whether the variant is exposed in the generated API (non-`@noApi`). */
-  apiExposed: @s.matches(boolOptionSchema) option<bool>,
+  apiExposed: option<bool>,
   /** Access keys — any one of them — a caller needs to be *offered* this command.
       A hint derived from the server's rule, never the refusal itself. */
-  requiredAccess: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  requiredAccess: option<array<string>>,
   /** The `@owner` command field the server stamps with the caller's identity; a
       client omits it from a form, since whatever it collects is discarded. */
-  ownerField: @s.matches(stringOptionSchema) option<string>,
+  ownerField: option<string>,
 }
 
 @schema
@@ -168,41 +168,41 @@ type queryableDef = {
   searchableFields: array<string>,
   /** Which rung produced `labelField`, so a consumer can rank it against its own
       rule: `"annotation"` | `"convention"` | `"position"` | `"fallback"`. */
-  labelFieldSource: @s.matches(stringOptionSchema) option<string>,
+  labelFieldSource: option<string>,
   /** The state field holding the row's lifecycle, paired with
       `commandDef.allowedStates`. From `@lifecycle`, else an enum named `lifecycle`. */
-  lifecycleField: @s.matches(stringOptionSchema) option<string>,
+  lifecycleField: option<string>,
   /** The `@owner` state field. Reads of this view are narrowed server-side to a
       non-elevated caller's own rows. */
-  ownerField: @s.matches(stringOptionSchema) option<string>,
+  ownerField: option<string>,
   /** The `@retired` state field withdrawing a row from ordinary reads. From the
       annotation only — no fallback by name, since guessing hides data. */
-  retiredField: @s.matches(stringOptionSchema) option<string>,
+  retiredField: option<string>,
   /** The states a row is retired *in* (state form of `@retired`); `None` is the
       boolean form, where the excluded value is always `true`. */
-  retiredValues: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  retiredValues: option<array<string>>,
   /** Whether the view publishes the by-ids reference door that names a retired row
       to any caller holding a pointer (`@namedWhenRetired`). Never true without
       `retiredField`. */
-  namedWhenRetired: @s.matches(boolOptionSchema) option<bool>,
+  namedWhenRetired: option<bool>,
   /** `@@reventless.visibility`. `Some("Internal")` hides the component from AutoUI;
       it is still carried here for developer tooling. `None` means Public. */
-  visibility: @s.matches(stringOptionSchema) option<string>,
+  visibility: option<string>,
   /** Intra-plugin grouping band, the first non-kind path segment under `src/`.
       `None` renders flat. */
-  chapter: @s.matches(stringOptionSchema) option<string>,
+  chapter: option<string>,
   /** The singular counterpart of `queryField` (`Plugin_Order`), also the prefix of
       the generated input types. Not derivable without `Api_Naming.singularize`. */
-  singleQueryField: @s.matches(stringOptionSchema) option<string>,
+  singleQueryField: option<string>,
   /** The state field identifying a row, as opposed to a reference to another entity.
       `None` means unresolved — no key-derived filter or sort until `@id` is declared. */
-  idField: @s.matches(stringOptionSchema) option<string>,
+  idField: option<string>,
   /** Which rung produced `idField`, as `labelFieldSource` does: `"annotation"` |
       `"convention"` | `"sole"`. */
-  idFieldSource: @s.matches(stringOptionSchema) option<string>,
+  idFieldSource: option<string>,
   /** Access keys — any one of them — a caller needs to be *offered* this view. A
       denied read comes back empty rather than erroring, hence the hint. */
-  requiredAccess: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  requiredAccess: option<array<string>>,
 }
 
 /** One emitted event of a write side. `name` is the variant name, `schema` its
@@ -230,7 +230,7 @@ type writableDef = {
   producedEventTypes: array<string>,
   consumedEventTypes: array<string>,
   linkedViews: array<string>,
-  consistencyRead: @s.matches(stringOptionSchema) option<string>,
+  consistencyRead: option<string>,
   /** Emitted-event field schemas; `[]` when there are none. */
   events: array<eventDef>,
   /** Declared-error field schemas. Required, but a persisted structure predating a
@@ -238,7 +238,7 @@ type writableDef = {
       `[]` on read, and a new one must be added there too. */
   errors: array<errorDef>,
   /** Chapter grouping band — see `queryableDef.chapter`. */
-  chapter: @s.matches(stringOptionSchema) option<string>,
+  chapter: option<string>,
 }
 
 @schema
@@ -248,7 +248,7 @@ type automationSliceDef = {
   producedCommandTypes: array<string>,
   targetName: string,
   /** Chapter grouping band — see `queryableDef.chapter`. */
-  chapter: @s.matches(stringOptionSchema) option<string>,
+  chapter: option<string>,
 }
 
 @schema
@@ -256,11 +256,11 @@ type outboundTranslationSliceDef = {
   name: string,
   consumedEventTypes: array<string>,
   inboundCommandTypes: array<string>,
-  targetName: @s.matches(stringOptionSchema) option<string>,
+  targetName: option<string>,
   // Foreign system this slice publishes to — drives the external box (Event Graph).
-  externalSystem: @s.matches(stringOptionSchema) option<string>,
+  externalSystem: option<string>,
   /** Chapter grouping band — see `queryableDef.chapter`. */
-  chapter: @s.matches(stringOptionSchema) option<string>,
+  chapter: option<string>,
   /** The topics this slice subscribes to, as `Spec.sourceNames` declares them —
       an Aggregate's `Spec.name` or a DCB source name. `Some([])` is the declared
       default and means this plugin's own DCB log; `None` is an older structure
@@ -268,7 +268,7 @@ type outboundTranslationSliceDef = {
       which names event types and not where they came from — two topics carrying
       an event of the same name are indistinguishable there. Optional so an older
       reader ignores it. */
-  consumedSources: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  consumedSources: option<array<string>>,
 }
 
 @schema
@@ -277,9 +277,9 @@ type inboundTranslationSliceDef = {
   commandTypes: array<string>,
   targetName: string,
   // Foreign system this slice receives from — drives the external box (Event Graph).
-  externalSystem: @s.matches(stringOptionSchema) option<string>,
+  externalSystem: option<string>,
   /** Chapter grouping band — see `queryableDef.chapter`. */
-  chapter: @s.matches(stringOptionSchema) option<string>,
+  chapter: option<string>,
 }
 
 /** A published event of an extension point and the internal events producing it.
@@ -291,8 +291,6 @@ type publishedEventDef = {
   fromEventTypes: array<string>,
 }
 
-let publishedEventDefArrayOptionSchema = S.array(publishedEventDefSchema)->S.nullAsOption
-
 /** The command direction's producer half: a command an extension point takes and
     the delegate commands it routes to. `name` is EP-qualified, `toCommandTypes`
     plugin-qualified. */
@@ -302,8 +300,6 @@ type acceptedCommandDef = {
   toCommandTypes: array<string>,
 }
 
-let acceptedCommandDefArrayOptionSchema = S.array(acceptedCommandDefSchema)->S.nullAsOption
-
 /** The subscriber's half: a published event and the commands it routes to. A
     delegate command is plugin-qualified, one sent back to the EP is EP-qualified. */
 @schema
@@ -312,8 +308,6 @@ type handledEventDef = {
   toCommandTypes: array<string>,
 }
 
-let handledEventDefArrayOptionSchema = S.array(handledEventDefSchema)->S.nullAsOption
-
 /** The command direction's subscriber half: a command sent back to the port and
     the internal events producing it. `name` is EP-qualified, `fromEventTypes`
     plugin-qualified. */
@@ -323,21 +317,19 @@ type issuedCommandDef = {
   fromEventTypes: array<string>,
 }
 
-let issuedCommandDefArrayOptionSchema = S.array(issuedCommandDefSchema)->S.nullAsOption
-
 @schema
 type extensionDef = {
   name: string,
   delegateNames: array<string>,
   eventTypes: array<string>,
   commandTypes: array<string>,
-  /** Which published event routes to which commands. js_nullable like
+  /** Which published event routes to which commands. Optional like
       `extensionPointDef.commandTypes`; re-emit definitions persisted before it. */
-  handledEvents: @s.matches(handledEventDefArrayOptionSchema) option<array<handledEventDef>>,
+  handledEvents: option<array<handledEventDef>>,
   /** Which internal event sends which command back to the port. `None` means a
       definition persisted before the field, NOT an extension that issues nothing —
       a reader joining the two halves must keep them apart. */
-  issuedCommands: @s.matches(issuedCommandDefArrayOptionSchema) option<array<issuedCommandDef>>,
+  issuedCommands: option<array<issuedCommandDef>>,
 }
 
 /**
@@ -346,28 +338,21 @@ An extension point owned by a plugin, from the producer side.
 `sourceEventTypes` are the `Delegate`'s events feeding the published protocol,
 plugin-qualified to match `writableDef.producedEventTypes`. `commandTypes` is the
 EP's inbound protocol — None (read as []) for a `command = unit` EP, which routes
-nothing. js_nullable is the only JSON-safe optional here (this def is nested in the
-lifecycle Message union); definitions persisted before a field must be re-emitted.
+nothing. Definitions persisted before a field was added must be re-emitted.
 */
 @schema
 type extensionPointDef = {
   name: string,
   delegateNames: array<string>,
   sourceEventTypes: array<string>,
-  commandTypes: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  commandTypes: option<array<string>>,
   /** Which internal event becomes which published event. */
-  publishedEvents: @s.matches(publishedEventDefArrayOptionSchema)
-  option<array<publishedEventDef>>,
+  publishedEvents: option<array<publishedEventDef>>,
   /** Which arriving command becomes which delegate command. `None` means a
       definition persisted before the field, NOT a port that accepts nothing. */
-  acceptedCommands: @s.matches(acceptedCommandDefArrayOptionSchema)
-  option<array<acceptedCommandDef>>,
+  acceptedCommands: option<array<acceptedCommandDef>>,
 }
 
-// js_nullable creates `array | null` (not `| undefined`), which passes sury's
-// jsonableValidation inside the pluginStructure union variant payload.
-let extensionPointDefArrayOptionSchema = S.array(extensionPointDefSchema)->S.nullAsOption
-
 /**
 One field's store requirement, with its provenance.
 
@@ -382,12 +367,9 @@ type requiredStoreDeclaration = {
   store: string,
   component: string,
   field: string,
-  annotation: @s.matches(stringOptionSchema) option<string>,
+  annotation: option<string>,
 }
 
-let requiredStoreDeclarationArrayOptionSchema =
-  S.array(requiredStoreDeclarationSchema)->S.nullAsOption
-
 /**
 One component's capability requirement, with its provenance.
 
@@ -400,9 +382,6 @@ expressible as an annotation on one, which is why the need is declared.
 @schema
 type requiredCapabilityDeclaration = {capability: string, component: string}
 
-let requiredCapabilityDeclarationArrayOptionSchema =
-  S.array(requiredCapabilityDeclarationSchema)->S.nullAsOption
-
 /**
 One graft's provenance: which trait, at which version, on which component.
 
@@ -427,14 +406,13 @@ type traitDeclaration = {
   component: string,
 }
 
-let traitDeclarationArrayOptionSchema = S.array(traitDeclarationSchema)->S.nullAsOption
-
 /**
 Adding a field here? It must be a shape a stale event can be healed into — the
 lifecycle aggregate replays its own log before every decision, so one event that
-fails to decode freezes that plugin's registration. `Message.parseJsonTolerant`
-heals `T | null`, arrays, enums and nested objects; a bare scalar is fabricated
-and warned about. Prefer `js_nullable`. Regression suite:
+fails to decode freezes that plugin's registration. Make it `option`, which
+`Message.parseJsonTolerant` heals to `None` whatever the inner type is. A required
+array heals to `[]` and a required enum to its first variant; a required *scalar*
+is fabricated and warned about, so it is the one shape to avoid. Regression suite:
 `PluginLifecycleCorpusTest` — if it goes red, re-shape the field, not the fixtures.
 */
 @schema
@@ -449,27 +427,23 @@ type pluginStructure = {
   extensions: array<extensionDef>,
   // Extension points owned by this plugin (producer side). Optional so older
   // definitions still decode (absent → None, read as []).
-  extensionPoints: @s.matches(extensionPointDefArrayOptionSchema)
-  option<array<extensionPointDef>>,
+  extensionPoints: option<array<extensionPointDef>>,
   /** The object stores this plugin's fields declare they need, deduplicated and
       qualified as `{plugin}.{store}` even for the same-plugin case. */
-  requiredStores: @s.matches(stringArrayOptionSchema) option<array<string>>,
+  requiredStores: option<array<string>>,
   /** Provenance for `requiredStores`: one entry per declaring `(component, field)`.
       `requiredStores` is derived from it, so the two cannot disagree. */
-  requiredStoreDeclarations: @s.matches(requiredStoreDeclarationArrayOptionSchema)
-  option<array<requiredStoreDeclaration>>,
+  requiredStoreDeclarations: option<array<requiredStoreDeclaration>>,
   /** The platform capabilities this plugin's components declare they need, one
       entry per declaring component. Object stores are not here — a store need is
       a field's, and travels as `requiredStores`. Absent → None, read as []. */
-  requiredCapabilities: @s.matches(requiredCapabilityDeclarationArrayOptionSchema)
-  option<array<requiredCapabilityDeclaration>>,
+  requiredCapabilities: option<array<requiredCapabilityDeclaration>>,
   /** The domain traits grafted into this plugin, one entry per declaring
       component. Absent → None, read as []. The only signal a graft leaves that
       survives into a deployed plugin — every other one (the dependency, the
       variant spread, the rules alias, the conformance binding) is source-side.
       A claim about origin, never about behaviour: see `Trait`. */
-  traitDeclarations: @s.matches(traitDeclarationArrayOptionSchema)
-  option<array<traitDeclaration>>,
+  traitDeclarations: option<array<traitDeclaration>>,
 }
 
 let pluginStructureOffloadSchema = Offload.optionSchema(~store="pluginStructures", pluginStructureSchema)
@@ -496,15 +470,15 @@ type pluginDefinition = {
   apiSchemaFragment: @s.matches(apiSchemaFragmentOffloadSchema) option<Offload.payload<apiSchemaFragment>>,
   // Schema routing in split-API mode: None/"Domain" → DomainApi, Some("Platform") →
   // PlatformApi (and excluded from the DomainApi runtime schema).
-  apiTarget: @s.matches(stringOptionSchema) option<string>,
+  apiTarget: option<string>,
   // Component graph metadata, offloadable like apiSchemaFragment. Absent for older
   // protocol versions.
   structure: @s.matches(pluginStructureOffloadSchema) option<Offload.payload<pluginStructure>>,
   // EventTopic ARN of a bundled DcbEventLog, so the admin can subscribe peer
   // EventCollectors to it. None for plugins without one.
-  dcbEventLog: @s.matches(dcbEventLogOptionSchema) option<dcbEventLogDefinition>,
+  dcbEventLog: option<dcbEventLogDefinition>,
   // Mandatory; `Domain` is resolved as the default in Plugin_Builder. Payload-less
-  // variant → a bare JSON string, so JSON-safe without js_nullable.
+  // variant → a bare JSON string.
   kind: pluginKind,
 }
 

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,25 +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),
-  consumedSources: s.m(stringArrayOptionSchema)
+  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 => ({
@@ -189,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),
@@ -255,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)),
@@ -266,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);
@@ -284,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)
 }));
 
@@ -301,10 +277,6 @@ export {
   apiSchemaFragmentSchema,
   apiTargetSchema,
   apiSchemaFragmentOffloadSchema,
-  dcbEventLogOptionSchema,
-  stringOptionSchema,
-  stringArrayOptionSchema,
-  boolOptionSchema,
   panelManifestEntrySchema,
   menuEntrySchema,
   pageManifestEntrySchema,
@@ -321,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/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/types/Message.res

@@ -141,22 +141,23 @@ type commandJson = {
 
 // ── Schema-migration-on-read ──────────────────────────────────────────────────
 // Nested `@schema` types (notably `pluginDefinition`/`pluginStructure`) gain fields
-// over time — `kind`, `chapter`, `events`, `extensionPoints`, `apiExposed`, … Because
-// those types are JSON-encoded inside union-variant payloads, every optional field must
-// use the `js_nullable` (`T | null`) encoding: it is the only JSON-safe optional form,
-// since `S.option`/`nullableAsOption` carry `undefined`, which fails sury's
-// `jsonableValidation` inside a union variant. That encoding is *present-required on
-// decode*, so ONE message persisted before a field was added SuryError-bricks decode. For
-// an aggregate that rehydrates from its own event log (the Plugin lifecycle aggregate),
-// that single event then freezes EVERY later heartbeat/redetect/connect on that instance
-// — a silent lifecycle freeze with no error surfaced near the operator.
+// over time — `kind`, `chapter`, `events`, `extensionPoints`, `apiExposed`, … A field
+// that is not optional is *present-required on decode*, so ONE message persisted before
+// it was added SuryError-bricks decode. For an aggregate that rehydrates from its own
+// event log (the Plugin lifecycle aggregate), that single event then freezes EVERY later
+// heartbeat/redetect/connect on that instance — a silent lifecycle freeze with no error
+// surfaced near the operator.
 //
 // We heal on read. Strict decode stays the fast path (unchanged for every current
 // message); only when it throws do we schema-guide the raw JSON and retry once. The fill
 // walks the target sury schema and inserts, for any absent field, the value that field's
-// schema expects: `null` for a `T | null` union (→ `None`), `[]` for a missing array, the
+// schema expects: `null` for a `T | null` union (→ `None`), nothing at all for an
+// `option` (a union admitting `undefined` — also `None`), `[]` for a missing array, the
 // first variant of a mandatory enum (`kind` → `Domain`), a filled `{}` for a missing
-// nested object, and a zero value for a missing scalar. It descends only into values
+// nested object, and a zero value for a missing scalar. The `undefined` arm mirrors the
+// `null` one and must precede the enum/object guesses below it: an absent `option<enum>`
+// would otherwise heal to that enum's first variant and an absent `option<record>` to a
+// filled `{}`, turning `None` into a `Some` of an invented value. It descends only into values
 // actually present, matches tagged-union members by their `TAG` const, is purely additive
 // (clones via a JSON round-trip; never re-encodes through the schema), is idempotent on
 // valid data, and falls back to the ORIGINAL error when the fill doesn't resolve the
@@ -229,6 +230,7 @@ let fillMissingDefaults: (S.t<'a>, JSON.t, array<string>) => JSON.t = %raw(`func
         var has=schema.has||{};
         if(value===undefined){
           if(has.null) return null;
+          if(has.undefined) return undefined;
           var c=firstConst(schema.anyOf); if(c!==undefined) return c;
           var obj=(schema.anyOf||[]).find(function(s){return s.type==="object";}); if(obj) return fill(obj,{},path);
           return undefined;
@@ -273,7 +275,7 @@ let parseJsonTolerant = (json, schema) =>
             ->Int.toString} missing scalar field(s): ${scalarFills->Array.join(
               ", ",
             )}. A required scalar was added to a persisted type after this message was ` ++
-          `written; the value above is fabricated, not recovered. Prefer a js_nullable (T | null) field.`,
+          `written; the value above is fabricated, not recovered. Prefer an optional field.`,
         )
       }
       value

package/src/types/Message.res.mjs

@@ -87,6 +87,7 @@ let fillMissingDefaults = (function(schema, json, scalarFills){
         var has=schema.has||{};
         if(value===undefined){
           if(has.null) return null;
+          if(has.undefined) return undefined;
           var c=firstConst(schema.anyOf); if(c!==undefined) return c;
           var obj=(schema.anyOf||[]).find(function(s){return s.type==="object";}); if(obj) return fill(obj,{},path);
           return undefined;
@@ -126,7 +127,7 @@ function parseJsonTolerant(json, schema) {
       throw firstErr;
     }
     if (scalarFills.length !== 0) {
-      console.warn(`[reventless] decoded a stored message by inventing ` + scalarFills.length.toString() + ` missing scalar field(s): ` + scalarFills.join(", ") + `. A required scalar was added to a persisted type after this message was written; the value above is fabricated, not recovered. Prefer a js_nullable (T | null) field.`);
+      console.warn(`[reventless] decoded a stored message by inventing ` + scalarFills.length.toString() + ` missing scalar field(s): ` + scalarFills.join(", ") + `. A required scalar was added to a persisted type after this message was written; the value above is fabricated, not recovered. Prefer an optional field.`);
     }
     return value;
   }