@reventlessdev/reventless-core 3.0.0-alpha.212 → 3.0.0-alpha.213

package/CHANGELOG.md

@@ -3,6 +3,18 @@
 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.213 (2026-08-05)
+
+### Bug Fixes
+
+* **core:** describe slice TODO items by their own schema in the API ([d863056](https://github.com/ReventlessDev/reventless-core/commit/d863056ba734ba3dc76721c32bfb766d777ceb9a))
+### Features
+
+* **core:** cap rendered values in command, event and action logs ([8e07752](https://github.com/ReventlessDev/reventless-core/commit/8e077527ad3c8258582951544ee53d2722876191))
+* **local:** offload large pluginDefinition fields to the object store ([84c5fab](https://github.com/ReventlessDev/reventless-core/commit/84c5fab339856b5d64f0c05110b1fa7f38646f5e))
+* **local:** scoped seed:reset for the local platform ([a4dd003](https://github.com/ReventlessDev/reventless-core/commit/a4dd0033b7d01be23be91bac3f01d38ebeab7d45))
+
+
 # 3.0.0-alpha.212 (2026-08-04)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.212",
+  "version": "3.0.0-alpha.213",
   "description": "Core package for Reventless framework",
   "license": "Apache-2.0",
   "jest": {
@@ -28,17 +28,17 @@
   "dependencies": {
     "sury": "11.0.0-alpha.4",
     "uuid": "^13.0.0",
-    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.1",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.1",
+    "@reventlessdev/rescript-fast-csv": "2.0.0-alpha.2",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
+    "@reventlessdev/rescript-hash-object": "1.2.0-alpha.14",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.2",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.18",
-    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.1",
-    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.126",
+    "@reventlessdev/rescript-ssh2": "2.0.0-alpha.2",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.30",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.100"
+    "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.127",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.101"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/Projection.res

@@ -126,9 +126,12 @@ let applyChanges = async (
 }
 
 // Best-effort: a state that can't be JSON-serialized (e.g. carries a function)
-// must not crash the projection just to produce a debug line.
+// must not crash the projection just to produce a debug line. Capped at the
+// shared log budget — an action line names which row changed, and a read model
+// holding a large field (a plugin structure, an inline offload payload) would
+// otherwise print the whole row twice, once per side of the `=>`.
 let stateToString: 'a => string = state =>
-  state->JSON.stringifyAny->Option.getOr("<unserializable>")
+  state->JSON.stringifyAny->Option.getOr("<unserializable>")->LogFormat.truncate
 let statesToString: array<'a> => string = states =>
   states->Array.map(stateToString)->Array.joinUnsafe(", ")
 

package/src/Projection.res.mjs

@@ -16,6 +16,7 @@ import * as DisplayName$Reventless from "@reventlessdev/reventless-spec/src/comp
 import * as Message$ReventlessCore from "./Message.res.mjs";
 import * as QueryDb$ReventlessCore from "./components/QueryDb/QueryDb.res.mjs";
 import * as QueryDb$ReventlessInfra from "@reventlessdev/reventless-infra/src/components/QueryDb.res.mjs";
+import * as LogFormat$ReventlessCore from "./util/LogFormat.res.mjs";
 
 let log = Logger$ReventlessCore.fromEnv();
 
@@ -195,7 +196,7 @@ async function applyChanges(action, id, beforeStates, afterStates, param, param$
 }
 
 function stateToString(state) {
-  return Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>");
+  return LogFormat$ReventlessCore.truncate(Stdlib_Option.getOr(JSON.stringify(state), "<unserializable>"));
 }
 
 function statesToString(states) {

package/src/components/AutomationSlice/AutomationSlice_Callback.res

@@ -31,6 +31,36 @@ type todoRow = {
   retryCount: int,
 }
 
+/** The item schema seen through the `JSON.t` the row actually stores.
+
+    `item` holds `Spec.todoItemSchema`-encoded JSON, so the item schema already
+    describes the stored value exactly — only the ReScript types disagree. */
+external itemAsJson: S.t<'item> => S.t<JSON.t> = "%identity"
+
+/**
+The row schema as the API describes it: `item` carried by the slice's own item
+schema instead of as opaque JSON.
+
+`todoRowSchema` types `item` as `JSON.t`, which the schema→GraphQL IR can only
+classify as `Unknown` — and `Unknown` renders as `String!`. The field then
+serves a stored object through a String, which fails at execution ("String
+cannot represent value: { … }") the moment a client selects it. Describing the
+item shape gives the field a real object type instead.
+
+Shape only: never encode or parse a row with this. The runtime field is `JSON.t`
+and the identity cast above would have `S.parseOrThrow` hand back an item where
+the row's own code expects JSON.
+*/
+let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
+  S.schema(s => {
+    item: s.matches(itemSchema->itemAsJson),
+    status: s.matches(todoStatusSchema),
+    createdAt: s.matches(S.string),
+    processedAt: ?s.matches(S.option(S.string)),
+    completedAt: ?s.matches(S.option(S.string)),
+    retryCount: s.matches(S.int),
+  })
+
 /**
 The runtime protocol between a built callback and whoever drives it — the same
 arrangement as `OutboundTranslationSlice_Callback`, and for the same reason. The

package/src/components/AutomationSlice/AutomationSlice_Callback.res.mjs

@@ -30,6 +30,17 @@ let todoRowSchema = S.schema(s => ({
   retryCount: s.m(S.int)
 }));
 
+function todoRowSchemaFor(itemSchema) {
+  return S.schema(s => ({
+    item: s.m(itemSchema),
+    status: s.m(todoStatusSchema),
+    createdAt: s.m(S.string),
+    processedAt: s.m(S.option(S.string)),
+    completedAt: s.m(S.option(S.string)),
+    retryCount: s.m(S.int)
+  }));
+}
+
 function Make(Spec) {
   return Automation => {
     let todoItems = {};
@@ -184,6 +195,7 @@ function Make(Spec) {
 export {
   todoStatusSchema,
   todoRowSchema,
+  todoRowSchemaFor,
   Make,
 }
 /*  Not a pure module */

package/src/components/Dcb/Dcb_Builder.res

@@ -1009,7 +1009,9 @@ module Make = (
             ReventlessInfra.Api.singleFieldName: qn.singleFieldName,
             listFieldName: qn.listFieldName,
             returnTypeName: qn.returnTypeName,
-            stateSchema: AutomationSlice_Callback.todoRowSchema->S.castToUnknown,
+            stateSchema: AutomationSlice_Callback.todoRowSchemaFor(
+              A.Spec.todoItemSchema,
+            )->S.castToUnknown,
             authorization: None,
             connectionSpec: true,
           }
@@ -1023,7 +1025,9 @@ module Make = (
             ReventlessInfra.Api.singleFieldName: qn.singleFieldName,
             listFieldName: qn.listFieldName,
             returnTypeName: qn.returnTypeName,
-            stateSchema: OutboundTranslationSlice_Callback.todoRowSchema->S.castToUnknown,
+            stateSchema: OutboundTranslationSlice_Callback.todoRowSchemaFor(
+              O.Spec.outboundItemSchema,
+            )->S.castToUnknown,
             authorization: None,
             connectionSpec: true,
           }

package/src/components/Dcb/Dcb_Builder.res.mjs

@@ -531,7 +531,7 @@ function Make(DcbEventLogStorage) {
           singleFieldName: qn.singleFieldName,
           listFieldName: qn.listFieldName,
           returnTypeName: qn.returnTypeName,
-          stateSchema: AutomationSlice_Callback$ReventlessCore.todoRowSchema,
+          stateSchema: AutomationSlice_Callback$ReventlessCore.todoRowSchemaFor(A.Spec.todoItemSchema),
           authorization: undefined,
           connectionSpec: true
         };
@@ -542,7 +542,7 @@ function Make(DcbEventLogStorage) {
           singleFieldName: qn.singleFieldName,
           listFieldName: qn.listFieldName,
           returnTypeName: qn.returnTypeName,
-          stateSchema: OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchema,
+          stateSchema: OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchemaFor(O.Spec.outboundItemSchema),
           authorization: undefined,
           connectionSpec: true
         };

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res

@@ -22,6 +22,38 @@ type todoRow = {
   lastError?: string,
 }
 
+/** The item schema seen through the `JSON.t` the row actually stores.
+
+    `item` holds `Spec.outboundItemSchema`-encoded JSON, so the item schema
+    already describes the stored value exactly — only the ReScript types
+    disagree. */
+external itemAsJson: S.t<'item> => S.t<JSON.t> = "%identity"
+
+/**
+The row schema as the API describes it: `item` carried by the slice's own item
+schema instead of as opaque JSON.
+
+`todoRowSchema` types `item` as `JSON.t`, which the schema→GraphQL IR can only
+classify as `Unknown` — and `Unknown` renders as `String!`. The field then
+serves a stored object through a String, which fails at execution ("String
+cannot represent value: { … }") the moment a client selects it. Describing the
+item shape gives the field a real object type instead.
+
+Shape only: never encode or parse a row with this. The runtime field is `JSON.t`
+and the identity cast above would have `S.parseOrThrow` hand back an item where
+the row's own code expects JSON.
+*/
+let todoRowSchemaFor = (itemSchema: S.t<'item>): S.t<todoRow> =>
+  S.schema(s => {
+    item: s.matches(itemSchema->itemAsJson),
+    status: s.matches(todoStatusSchema),
+    createdAt: s.matches(S.string),
+    processedAt: ?s.matches(S.option(S.string)),
+    completedAt: ?s.matches(S.option(S.string)),
+    retryCount: s.matches(S.int),
+    lastError: ?s.matches(S.option(S.string)),
+  })
+
 /**
 The runtime protocol between a built callback and whoever drives it.
 

package/src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs

@@ -29,6 +29,18 @@ let todoRowSchema = S.schema(s => ({
   lastError: s.m(S.option(S.string))
 }));
 
+function todoRowSchemaFor(itemSchema) {
+  return S.schema(s => ({
+    item: s.m(itemSchema),
+    status: s.m(todoStatusSchema),
+    createdAt: s.m(S.string),
+    processedAt: s.m(S.option(S.string)),
+    completedAt: s.m(S.option(S.string)),
+    retryCount: s.m(S.int),
+    lastError: s.m(S.option(S.string))
+  }));
+}
+
 function Make(Spec) {
   return Translation => {
     let todoItems = {};
@@ -168,6 +180,7 @@ function Make(Spec) {
 export {
   todoStatusSchema,
   todoRowSchema,
+  todoRowSchemaFor,
   Make,
 }
 /*  Not a pure module */

package/src/plugin/component/Plugin_Builder.res

@@ -621,20 +621,13 @@ module Make = (
 
       // Offload the two large pluginDefinition fields at deploy time when a
       // provider offers an object store (AWS writes a content-addressed object
-      // and returns a reference); unset locally, so they stay Inline. Computed
-      // HERE, at graph-construction time — both values are concrete and the hook
-      // (which creates the object resource) MUST run outside the Pulumi.Output.apply
-      // below: a resource cannot be created inside .apply, and an apply callback is
-      // skipped entirely on `pulumi preview` when its inputs are still unknown.
+      // and returns a reference). Computed HERE, at graph-construction time —
+      // both values are concrete and the hook (which creates the object resource)
+      // MUST run outside the Pulumi.Output.apply below: a resource cannot be
+      // created inside .apply, and an apply callback is skipped entirely on
+      // `pulumi preview` when its inputs are still unknown.
       // Unconditional: these fields are always large enough to be worth offloading.
-      let toPayload = (value, ~schema, ~store) =>
-        switch Plugin_Helpers.offloadHook.contents {
-        | Some(hook) =>
-          Reventless.Offload.Offloaded(
-            hook(~store, ~bytes=value->S.reverseConvertToJsonStringOrThrow(schema)),
-          )
-        | None => Reventless.Offload.Inline(value)
-        }
+      let toPayload = Plugin_Helpers.offloadPayload
       let apiSchemaFragmentPayload = toPayload(
         apiSchemaFragment,
         ~schema=Reventless.Plugin.apiSchemaFragmentSchema,

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

@@ -425,22 +425,8 @@ function Make(Spec) {
         });
         let pushSchema = Spec.hooks.preResolversSchemaHook;
         let schemaPushed = pushSchema !== undefined ? pushSchema(extra$1, version, apiSchemaFragment) : Pulumi.output();
-        let toPayload = (value, schema, store) => {
-          let hook = Plugin_Helpers$ReventlessCore.offloadHook.contents;
-          if (hook !== undefined) {
-            return {
-              TAG: "Offloaded",
-              _0: hook(store, S.reverseConvertToJsonStringOrThrow(value, schema, undefined))
-            };
-          } else {
-            return {
-              TAG: "Inline",
-              _0: value
-            };
-          }
-        };
-        let apiSchemaFragmentPayload = toPayload(apiSchemaFragment, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments");
-        let structurePayload = Stdlib_Option.map(pluginStructure, s => toPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures"));
+        let apiSchemaFragmentPayload = Plugin_Helpers$ReventlessCore.offloadPayload(apiSchemaFragment, Plugin$Reventless.apiSchemaFragmentSchema, "pluginApiFragments");
+        let structurePayload = Stdlib_Option.map(pluginStructure, s => Plugin_Helpers$ReventlessCore.offloadPayload(s, Plugin$Reventless.pluginStructureSchema, "pluginStructures"));
         let builderOutputs = Pulumi.all([
           Pulumi.all([
             interstackAdminExtensionPoints,

package/src/plugin/component/Plugin_Helpers.res

@@ -788,9 +788,10 @@ let clearOnPluginDeployed = () => {
 // ---------------------------------------------------------------------------
 // Deploy-time offload hook — content-addresses a large pluginDefinition field
 // to an object store and returns the reference. Set by a provider that can
-// write objects (AWS creates a BucketObject); unset on the local platform, so
-// the fields stay Inline. `bytes` is the already-serialized JSON of the value;
-// the provider hashes it, stores it at `sha256/<hash>`, and returns the ref.
+// write objects (AWS creates a BucketObject, local writes to its process-local
+// object store); when unset the fields stay Inline. `bytes` is the
+// already-serialized JSON of the value; the provider hashes it, stores it at
+// `sha256/<hash>`, and returns the ref.
 // Fired synchronously at graph-construction time (the value is concrete and a
 // resource cannot be created inside a Pulumi.Output.apply).
 // ---------------------------------------------------------------------------
@@ -806,6 +807,23 @@ let clearOffload = () => {
   offloadHook.contents = None
 }
 
+/**
+Carry a large `pluginDefinition` field by reference when a provider registered an
+offload hook, inline otherwise.
+
+One implementation for both construction sites — `Plugin_Builder`'s deploy-time
+definition and the local platform's synthetic one — so a provider that offloads
+cannot end up offloading through one path and inlining through the other.
+*/
+let offloadPayload = (value: 'a, ~schema: S.t<'a>, ~store: string): Reventless.Offload.payload<'a> =>
+  switch offloadHook.contents {
+  | Some(hook) =>
+    Reventless.Offload.Offloaded(
+      hook(~store, ~bytes=value->S.reverseConvertToJsonStringOrThrow(schema)),
+    )
+  | None => Reventless.Offload.Inline(value)
+  }
+
 // ---------------------------------------------------------------------------
 // Platform-deployed hook — fires after deployPlatform / makePlatform
 // completes, providing platform-level metadata with resolved values.

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

@@ -430,6 +430,21 @@ function clearOffload() {
   offloadHook.contents = undefined;
 }
 
+function offloadPayload(value, schema, store) {
+  let hook = offloadHook.contents;
+  if (hook !== undefined) {
+    return {
+      TAG: "Offloaded",
+      _0: hook(store, S.reverseConvertToJsonStringOrThrow(value, schema, undefined))
+    };
+  } else {
+    return {
+      TAG: "Inline",
+      _0: value
+    };
+  }
+}
+
 let onPlatformDeployedHook = {
   contents: undefined
 };
@@ -1030,6 +1045,7 @@ export {
   offloadHook,
   registerOffload,
   clearOffload,
+  offloadPayload,
   onPlatformDeployedHook,
   lastPlatformDeployedInfo,
   registerOnPlatformDeployed,

package/src/util/LogFormat.res

@@ -28,6 +28,41 @@
 // styling primitive through `LogFormat.bold` rather than the spec namespace.
 let bold = Reventless.AnsiStyle.bold
 
+// ─── Value truncation ────────────────────────────────────────────────────────
+
+@val external logEnv: dict<string> = "process.env"
+
+/**
+Per-value character budget for rendered payloads, before the rest is elided.
+
+A detail line exists to say *which* command or event this is, not to reproduce
+it: a single field can be arbitrarily large (a plugin structure, a pasted
+document, an inline offload payload), and one of those turns a log into
+something no one reads. Truncation is per value rather than per line so a large
+field costs its neighbours nothing — the small fields that identify the message
+stay visible next to it.
+
+`REVENTLESS_LOG_MAX_VALUE` overrides the budget; `0` disables truncation for a
+session that genuinely needs the whole payload.
+*/
+let maxValueChars =
+  logEnv
+  ->Dict.get("REVENTLESS_LOG_MAX_VALUE")
+  ->Option.flatMap(v => Int.fromString(v))
+  ->Option.getOr(512)
+
+/** `s` capped at `maxValueChars`, with what was dropped named rather than
+    silently missing — a truncated line must not read like a complete one. */
+let truncate = (s: string): string => {
+  let len = s->String.length
+  if maxValueChars <= 0 || len <= maxValueChars {
+    s
+  } else {
+    `${s->String.slice(~start=0, ~end=maxValueChars)}…(+${(len - maxValueChars)
+      ->Int.toString} chars)`
+  }
+}
+
 // ─── Commands ────────────────────────────────────────────────────────────────
 
 // "Add"  (bold)
@@ -46,6 +81,16 @@ let cmdSummary = (msg: Message.commandJson): string =>
 let cmdSummaries = (msgs: array<Message.commandJson>): string =>
   `[${msgs->Array.map(cmdSummary)->Array.join(",")}]`
 
+/**
+`JSON.stringify` is typed as total but returns `undefined` — not a string — for
+the one value `JSON.t` cannot represent: the `undefined` a ReScript record's
+*absent* optional field leaves behind as an own property of the JS object. Read
+the result as nullable so an absent field is dropped instead of reaching a
+string function as `undefined`. An explicit `null` still stringifies to `"null"`
+and keeps printing.
+*/
+external stringifiedOrAbsent: string => Nullable.t<string> = "%identity"
+
 // Strip TAG from a variant JSON, return remaining fields as a compact string.
 // {"TAG":"Add","name":"Cat 1"} → {name:"Cat 1"}
 // "Add" (bare string variant) → ""
@@ -56,7 +101,13 @@ let variantFields = (json: JSON.t): string =>
       dict
       ->Dict.toArray
       ->Array.filter(((k, _)) => k != "TAG")
-      ->Array.map(((k, v)) => `${k}:${v->JSON.stringify}`)
+      ->Array.filterMap(((k, v)) =>
+        v
+        ->JSON.stringify
+        ->stringifiedOrAbsent
+        ->Nullable.toOption
+        ->Option.map(s => `${k}:${s->truncate}`)
+      )
       ->Array.join(",")
     fields == "" ? "" : `, {${fields}}`
   | _ => ""

package/src/util/LogFormat.res.mjs

@@ -1,11 +1,25 @@
 // Generated by ReScript, PLEASE EDIT WITH CARE
 
+import * as Stdlib_Int from "@rescript/runtime/lib/es6/Stdlib_Int.js";
 import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
 import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.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 AnsiStyle$Reventless from "@reventlessdev/reventless-spec/src/AnsiStyle.res.mjs";
 import * as Message$ReventlessCore from "../Message.res.mjs";
 
+let maxValueChars = Stdlib_Option.getOr(Stdlib_Option.flatMap(process.env["REVENTLESS_LOG_MAX_VALUE"], v => Stdlib_Int.fromString(v, undefined)), 512);
+
+function truncate(s) {
+  let len = s.length;
+  if (maxValueChars <= 0 || len <= maxValueChars) {
+    return s;
+  } else {
+    return s.slice(0, maxValueChars) + `…(+` + (len - maxValueChars | 0).toString() + ` chars)`;
+  }
+}
+
 function cmdName(msg) {
   return AnsiStyle$Reventless.bold(Message$ReventlessCore.variantNameOfJson(msg.commandJson));
 }
@@ -26,7 +40,10 @@ function variantFields(json) {
   if (typeof json !== "object" || json === null || Array.isArray(json)) {
     return "";
   }
-  let fields = Object.entries(json).filter(param => param[0] !== "TAG").map(param => param[0] + `:` + JSON.stringify(param[1])).join(",");
+  let fields = Stdlib_Array.filterMap(Object.entries(json).filter(param => param[0] !== "TAG"), param => {
+    let k = param[0];
+    return Stdlib_Option.map(Primitive_option.fromNullable(JSON.stringify(param[1])), s => k + `:` + truncate(s));
+  }).join(",");
   if (fields === "") {
     return "";
   } else {
@@ -220,6 +237,8 @@ let fmtActions = actionNames;
 
 export {
   bold,
+  maxValueChars,
+  truncate,
   cmdName,
   cmdNames,
   cmdSummary,
@@ -254,4 +273,4 @@ export {
   fmtAction,
   fmtActions,
 }
-/* Stdlib_JsExn Not a pure module */
+/* maxValueChars Not a pure module */

package/src/util/StoreLayout.res

@@ -0,0 +1,38 @@
+// Where a declared object store's keys are rooted.
+//
+// Lives in core beside StorePrefixCollision, and for the same reason: the rule
+// is about a namespace, not about a cloud. The deployed platform roots an S3
+// store's keys here, the local platform roots its filesystem store's keys here,
+// and a reset attributes an object to the plugin that declared its store by
+// reading the prefix back off the key. Three readers of one rule — so it is one
+// function, not three strings that happen to agree today.
+//
+// Qualifying by plugin is what makes the prefix an identity rather than a label:
+// two plugins may both declare a store called `images`, and only the qualified
+// form keeps their objects apart (which is the collision StorePrefixCollision
+// refuses when it cannot).
+
+/** The prefix a store's object keys are rooted at: `{plugin}/{store}`.
+
+    A stored ref is independent of whether the store got its own bucket or a
+    prefix inside a shared one — refs live in an append-only log, so one that
+    encoded its physical layout would be unrewritable and environment-specific. */
+let keyPrefixFor = (~plugin: string, ~store: string): string => `${plugin}/${store}`
+
+/** The same prefix from the qualified `{plugin}.{store}` key that a
+    `pluginStructure.requiredStores` entry carries and that the `Upload_Presign`
+    mutation's `store` argument names.
+
+    Splits on the FIRST `.` — a store name may contain dots, a plugin name may
+    not. An unqualified key (no `.`) is returned as-is rather than guessed at:
+    it is not a `{plugin}.{store}` and inventing a plugin for it would attribute
+    objects to a plugin that never declared them. */
+let prefixOfQualified = (qualified: string): string =>
+  switch qualified->String.indexOfOpt(".") {
+  | Some(i) =>
+    keyPrefixFor(
+      ~plugin=qualified->String.slice(~start=0, ~end=i),
+      ~store=qualified->String.slice(~start=i + 1, ~end=qualified->String.length),
+    )
+  | None => qualified
+  }

package/src/util/StoreLayout.res.mjs

@@ -0,0 +1,22 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_String from "@rescript/runtime/lib/es6/Stdlib_String.js";
+
+function keyPrefixFor(plugin, store) {
+  return plugin + `/` + store;
+}
+
+function prefixOfQualified(qualified) {
+  let i = Stdlib_String.indexOfOpt(qualified, ".");
+  if (i !== undefined) {
+    return keyPrefixFor(qualified.slice(0, i), qualified.slice(i + 1 | 0, qualified.length));
+  } else {
+    return qualified;
+  }
+}
+
+export {
+  keyPrefixFor,
+  prefixOfQualified,
+}
+/* No side effect */

package/tests/api/GraphQL_FragmentGeneratorTest.res

@@ -47,3 +47,43 @@ describe("GraphQL_FragmentGenerator.generate mutation id injection", () => {
     expect(field->String.includes("id: ID!, orderId"))->toBe(true)
   })
 })
+
+// A slice TODO row stores its work item as `JSON.t`, which the IR can only call
+// `Unknown` — and `Unknown` renders as `String!`. Serving a stored object
+// through a String field fails at execution ("String cannot represent value:
+// { … }") as soon as a client selects it, so `Dcb_Builder` describes the row
+// with `todoRowSchemaFor` and the item's own schema instead.
+module GeocodeItem = {
+  @schema
+  type outboundItem = {customerId: string, address: string}
+}
+
+let typeDefFor = (fragment, needle) =>
+  GraphQL_Stitcher.decode(fragment).types->Array.find(t => t->String.includes(needle))
+
+describe("GraphQL_FragmentGenerator slice TODO rows", () => {
+  testSync("item carries the slice's item type, not String", () => {
+    let fragment = GraphQL_FragmentGenerator.generate(
+      ~mutationEntries=[],
+      ~queryEntries=[
+        {
+          ReventlessInfra.Api.singleFieldName: "Ordering_GeocodeCustomerAddressTodo",
+          listFieldName: "Ordering_GeocodeCustomerAddressTodos",
+          returnTypeName: "Ordering_GeocodeCustomerAddressTodo",
+          stateSchema: OutboundTranslationSlice_Callback.todoRowSchemaFor(
+            GeocodeItem.outboundItemSchema,
+          )->S.castToUnknown,
+          authorization: None,
+          connectionSpec: true,
+        },
+      ],
+    )
+    let row = typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodo ")->Option.getOr("")
+    expect(row->String.includes("item: Ordering_GeocodeCustomerAddressTodoItem!"))->toBe(true)
+
+    let item =
+      typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodoItem ")->Option.getOr("")
+    expect(item->String.includes("customerId: ID!"))->toBe(true)
+    expect(item->String.includes("address: String!"))->toBe(true)
+  })
+})

package/tests/api/GraphQL_FragmentGeneratorTest.res.mjs

@@ -4,6 +4,7 @@ import * as S from "sury/src/S.res.mjs";
 import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
 import * as GraphQL_Stitcher$ReventlessCore from "../../src/components/Api/GraphQL_Stitcher.res.mjs";
 import * as GraphQL_FragmentGenerator$ReventlessCore from "../../src/components/Api/GraphQL_FragmentGenerator.res.mjs";
+import * as OutboundTranslationSlice_Callback$ReventlessCore from "../../src/components/OutboundTranslationSlice/OutboundTranslationSlice_Callback.res.mjs";
 
 let commandSchema = S.union([
   S.schema(s => ({
@@ -50,8 +51,42 @@ globalThis.describe("GraphQL_FragmentGenerator.generate mutation id injection",
   });
 });
 
+let outboundItemSchema = S.schema(s => ({
+  customerId: s.m(S.string),
+  address: s.m(S.string)
+}));
+
+let GeocodeItem = {
+  outboundItemSchema: outboundItemSchema,
+  externalSystem: undefined
+};
+
+function typeDefFor(fragment, needle) {
+  return GraphQL_Stitcher$ReventlessCore.decode(fragment).types.find(t => t.includes(needle));
+}
+
+globalThis.describe("GraphQL_FragmentGenerator slice TODO rows", () => {
+  globalThis.test("item carries the slice's item type, not String", () => {
+    let fragment = GraphQL_FragmentGenerator$ReventlessCore.generate([], [{
+        singleFieldName: "Ordering_GeocodeCustomerAddressTodo",
+        listFieldName: "Ordering_GeocodeCustomerAddressTodos",
+        returnTypeName: "Ordering_GeocodeCustomerAddressTodo",
+        stateSchema: OutboundTranslationSlice_Callback$ReventlessCore.todoRowSchemaFor(outboundItemSchema),
+        authorization: undefined,
+        connectionSpec: true
+      }]);
+    let row = Stdlib_Option.getOr(typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodo "), "");
+    globalThis.expect(row.includes("item: Ordering_GeocodeCustomerAddressTodoItem!")).toBe(true);
+    let item = Stdlib_Option.getOr(typeDefFor(fragment, "type Ordering_GeocodeCustomerAddressTodoItem "), "");
+    globalThis.expect(item.includes("customerId: ID!")).toBe(true);
+    globalThis.expect(item.includes("address: String!")).toBe(true);
+  });
+});
+
 export {
   OrderSliceCmd,
   mutationFor,
+  GeocodeItem,
+  typeDefFor,
 }
 /* commandSchema Not a pure module */

package/tests/logger/LogFormatTest.res

@@ -127,6 +127,48 @@ describe("LogFormat", () => {
       },
     )
   })
+
+  // A ReScript record's absent optional field survives encoding as an own
+  // property whose value is `undefined` — the one thing `JSON.t` cannot hold and
+  // `JSON.stringify` answers with `undefined` instead of a string. Rendering a
+  // command carrying one must not reach a string function with that `undefined`:
+  // `variantFields` runs inside the CommandGenerator's log tap, so a throw there
+  // takes the command down with it and the slice never sees it.
+  describe("variantFields", () => {
+    module OptionalFieldCmd = {
+      @schema
+      type command = AddProduct({productId: string, name: string, imageUrl?: string})
+    }
+
+    testSync("omits an absent optional field", () => {
+      let json =
+        OptionalFieldCmd.AddProduct({productId: "prd-1", name: "Cirrus"})
+        ->Message.encode(OptionalFieldCmd.commandSchema)
+      expect(variantFields(json))->toEqual(`, {productId:"prd-1",name:"Cirrus"}`)
+    })
+
+    testSync("keeps a present optional field", () => {
+      let json =
+        OptionalFieldCmd.AddProduct({productId: "prd-1", name: "Cirrus", imageUrl: "/u/a.png"})
+        ->Message.encode(OptionalFieldCmd.commandSchema)
+      expect(variantFields(json))->toEqual(
+        `, {productId:"prd-1",name:"Cirrus",imageUrl:"/u/a.png"}`,
+      )
+    })
+
+    testSync("elides a value past the budget rather than dropping it", () => {
+      let long = String.repeat("x", maxValueChars + 20)
+      let json =
+        OptionalFieldCmd.AddProduct({productId: "prd-1", name: long})
+        ->Message.encode(OptionalFieldCmd.commandSchema)
+      let rendered = variantFields(json)
+      expect(rendered->String.includes("…(+22 chars)"))->toBe(true)
+      // The oversized value is capped, not the line: the neighbouring field that
+      // says which product this is stays intact.
+      expect(rendered->String.includes(long))->toBe(false)
+      expect(rendered->String.includes(`productId:"prd-1"`))->toBe(true)
+    })
+  })
 })
 
 // ─── JSON sink (non-TTY collector: CloudWatch / Datadog / …) ─────────────────

package/tests/logger/LogFormatTest.res.mjs

@@ -124,6 +124,43 @@ globalThis.describe("LogFormat", () => {
       globalThis.expect(msg).toEqual(`\x1b[1mVersionDetected\x1b[0m(testId): {"event":{"TAG":"VersionDetected","_0":"0.0.0"},"meta":{"service":"testService","time":"testTime","ip":"testIp","user":"testUser","msgId":"testMsgId","correlationId":"testCorrelationId"},"id":"testId"}`);
     });
   });
+  globalThis.describe("variantFields", () => {
+    let commandSchema = S.schema(s => ({
+      TAG: "AddProduct",
+      productId: s.m(S.string),
+      name: s.m(S.string),
+      imageUrl: s.m(S.option(S.string))
+    }));
+    globalThis.test("omits an absent optional field", () => {
+      let json = Message$ReventlessCore.encode({
+        TAG: "AddProduct",
+        productId: "prd-1",
+        name: "Cirrus"
+      }, commandSchema);
+      globalThis.expect(LogFormat$ReventlessCore.variantFields(json)).toEqual(`, {productId:"prd-1",name:"Cirrus"}`);
+    });
+    globalThis.test("keeps a present optional field", () => {
+      let json = Message$ReventlessCore.encode({
+        TAG: "AddProduct",
+        productId: "prd-1",
+        name: "Cirrus",
+        imageUrl: "/u/a.png"
+      }, commandSchema);
+      globalThis.expect(LogFormat$ReventlessCore.variantFields(json)).toEqual(`, {productId:"prd-1",name:"Cirrus",imageUrl:"/u/a.png"}`);
+    });
+    globalThis.test("elides a value past the budget rather than dropping it", () => {
+      let long = "x".repeat(LogFormat$ReventlessCore.maxValueChars + 20 | 0);
+      let json = Message$ReventlessCore.encode({
+        TAG: "AddProduct",
+        productId: "prd-1",
+        name: long
+      }, commandSchema);
+      let rendered = LogFormat$ReventlessCore.variantFields(json);
+      globalThis.expect(rendered.includes("…(+22 chars)")).toBe(true);
+      globalThis.expect(rendered.includes(long)).toBe(false);
+      globalThis.expect(rendered.includes(`productId:"prd-1"`)).toBe(true);
+    });
+  });
 });
 
 function hasAnsi(s) {