@reventlessdev/reventless-aws 3.0.0-alpha.328 → 3.0.0-alpha.329

package/CHANGELOG.md

@@ -3,6 +3,13 @@
 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.329 (2026-08-27)
+
+### Bug Fixes
+
+* **aws:** report why the manifest bake is waiting, and what a pass proved ([7ba2a04](https://github.com/ReventlessDev/reventless-core/commit/7ba2a04c7dfa88bc10ca4336f9298f5fee1eb763))
+
+
 # 3.0.0-alpha.328 (2026-08-27)
 
 **Note:** Version bump only for package @reventlessdev/reventless-aws

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-aws",
-  "version": "3.0.0-alpha.328",
+  "version": "3.0.0-alpha.329",
   "description": "AWS adapters for Reventless",
   "license": "Apache-2.0",
   "bin": {
@@ -15,18 +15,18 @@
     "@aws-sdk/s3-request-presigner": "3.970.0",
     "sury": "11.0.0-rc.2",
     "uuid": "^13.0.0",
+    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.13",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.10",
-    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-effect": "0.1.0-alpha.32",
-    "@reventlessdev/rescript-aws-sdk": "3.0.0-alpha.13",
+    "@reventlessdev/rescript-node": "2.0.0-alpha.8",
     "@reventlessdev/rescript-pulumi-aws": "3.0.0-alpha.6",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.19",
-    "@reventlessdev/reventless-core": "3.0.0-alpha.251",
     "@reventlessdev/rescript-uuid": "2.0.0-alpha.0",
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.152",
     "@reventlessdev/reventless-interop": "3.0.0-alpha.34",
     "@reventlessdev/reventless-spec": "3.0.0-alpha.124",
-    "@reventlessdev/reventless-postgres": "3.0.0-alpha.115",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.152"
+    "@reventlessdev/reventless-core": "3.0.0-alpha.251",
+    "@reventlessdev/reventless-postgres": "3.0.0-alpha.115"
   },
   "devDependencies": {
     "rescript": "12.3.0",

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res

@@ -440,6 +440,15 @@ let bakeExpectations = (event: JSON.t): dict<string> =>
     ->Dict.fromArray
   )
 
+// The instant this deploy began, when the caller names one. Optional because the
+// key comparison stands without it; what it adds is telling a matching key that
+// was re-registered apart from one that merely never changed.
+let bakeSince = (event: JSON.t): option<string> =>
+  event
+  ->JSON.Decode.object
+  ->Option.flatMap(o => o->Dict.get("since"))
+  ->Option.flatMap(JSON.Decode.string)
+
 // The offload key a scanned row carries. None for a structure held inline, which
 // on a deployed platform means the row predates offloading — it cannot match an
 // expectation, and saying so beats baking it.
@@ -452,19 +461,143 @@ let structureRefKey = (item: dict<JSON.t>): option<string> =>
   ->Option.flatMap(r => r->Dict.get("key"))
   ->Option.flatMap(JSON.Decode.string)
 
+// When the projection last wrote this row. Every status-moving event stamps the
+// producing message's time onto `statusChange`, and a Connect carrying a changed
+// definition re-emits VersionConnected — so this advances exactly when the
+// registration chain completes, and stays put when it does not.
+let rowWrittenAt = (item: dict<JSON.t>): option<string> =>
+  item
+  ->Dict.get("statusChange")
+  ->Option.flatMap(JSON.Decode.object)
+  ->Option.flatMap(o => o->Dict.get("at"))
+  ->Option.flatMap(JSON.Decode.string)
+
+// Parsed rather than compared as strings: an offset-bearing ISO timestamp on
+// either side orders wrongly lexically. An unreadable date answers false, so it
+// reports a plugin as still pending rather than baking on a stamp nobody read.
+let notBefore = (~at: string, ~since: string): bool => {
+  let a = Date.fromString(at)->Date.getTime
+  let s = Date.fromString(since)->Date.getTime
+  !Float.isNaN(a) && !Float.isNaN(s) && a >= s
+}
+
+/** What the Plugin read model says about one plugin the bake is waiting on.
+
+    Distinct outcomes rather than a boolean because a bake that reported only
+    "pending" left every one of these to be told apart by reading the read model
+    out of band, with credentials the deploy pipeline does not surface. */
+type registrationState =
+  /** Key agrees, row written by this deploy: the chain ran, and this is the evidence. */
+  | Registered
+  /** Key agrees, nothing re-registered — a correct pass that proves nothing. */
+  | Unchanged
+  /** Key agrees, and no deploy instant to tell the two above apart. */
+  | Matched
+  /** No Connected row carries a structure. The scan filters on Connected, so a
+      version that dropped out mid-deploy leaves nothing to converge against. */
+  | Missing
+  /** Row holds another key and predates this deploy — the case retrying is for. */
+  | Behind
+  /** Row written by this deploy and still holding another key. Retrying cannot fix it. */
+  | Diverged
+
+type registration = {
+  plugin: string,
+  expected: string,
+  found: option<string>,
+  writtenAt: option<string>,
+  state: registrationState,
+}
+
+let classify = (
+  ~expected: string,
+  ~found: option<string>,
+  ~writtenAt: option<string>,
+  ~since: option<string>,
+): registrationState => {
+  let fresh = switch (since, writtenAt) {
+  | (Some(since), Some(at)) => Some(notBefore(~at, ~since))
+  | _ => None
+  }
+  switch found {
+  | None => Missing
+  | Some(key) if key == expected =>
+    switch fresh {
+    | None => Matched
+    | Some(true) => Registered
+    | Some(false) => Unchanged
+    }
+  | Some(_) => fresh == Some(true) ? Diverged : Behind
+  }
+}
+
 // Compared against the collapsed latest version per plugin, the same view the
 // bake itself takes — an older version's row lingering on the table is not the
 // registration anyone is waiting for.
-let pendingRegistrations = (items: array<dict<JSON.t>>, ~expect: dict<string>): array<string> => {
+let registrations = (
+  items: array<dict<JSON.t>>,
+  ~expect: dict<string>,
+  ~since: option<string>,
+): array<registration> => {
   let current =
     Platform_AdminScan_Ops.latestByName(
       items,
       ~nameVersionOf=item => item->str("name"),
-      ~toEntry=(item, ~name) => item->structureRefKey->Option.map(key => (name, key)),
+      ~toEntry=(item, ~name) =>
+        item->structureRefKey->Option.map(key => (name, (key, item->rowWrittenAt))),
     )->Dict.fromArray
   expect
   ->Dict.toArray
-  ->Array.filterMap(((plugin, key)) => current->Dict.get(plugin) == Some(key) ? None : Some(plugin))
+  ->Array.map(((plugin, expected)) => {
+    let row = current->Dict.get(plugin)
+    let found = row->Option.map(((key, _)) => key)
+    let writtenAt = row->Option.flatMap(((_, at)) => at)
+    {plugin, expected, found, writtenAt, state: classify(~expected, ~found, ~writtenAt, ~since)}
+  })
+}
+
+let isPending = (r: registration): bool =>
+  switch r.state {
+  | Missing | Behind | Diverged => true
+  | Registered | Unchanged | Matched => false
+  }
+
+let stateName = (s: registrationState): string =>
+  switch s {
+  | Registered => "registered"
+  | Unchanged => "unchanged"
+  | Matched => "matched"
+  | Missing => "missing"
+  | Behind => "behind"
+  | Diverged => "diverged"
+  }
+
+// Both halves of the comparison and the date on the row, which is what separates
+// the causes on sight. `found` and `writtenAt` travel as null rather than being
+// omitted, so the line printed for a plugin with no row has a column for them too.
+let encodeRegistration = (r: registration): JSON.t =>
+  Dict.fromArray([
+    ("plugin", JSON.Encode.string(r.plugin)),
+    ("state", JSON.Encode.string(r.state->stateName)),
+    ("expected", JSON.Encode.string(r.expected)),
+    ("found", r.found->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+    ("writtenAt", r.writtenAt->Option.mapOr(JSON.Encode.null, JSON.Encode.string)),
+  ])->JSON.Encode.object
+
+// What a green bake actually proved. Without the counts it says "nothing needed to
+// converge" as often as it says "convergence works", and the two read identically
+// — so this path can be broken across any number of green deploys and surface on
+// the first one that changes a structure, maximally far from what broke it.
+let encodeSummary = (rs: array<registration>): JSON.t => {
+  let count = f => rs->Array.filter(f)->Array.length
+  Dict.fromArray([
+    ("summary", JSON.Encode.bool(true)),
+    ("plugins", JSON.Encode.int(rs->Array.length)),
+    ("registered", JSON.Encode.int(count(r => r.state == Registered))),
+    ("unchanged", JSON.Encode.int(count(r => r.state == Unchanged))),
+    ("matched", JSON.Encode.int(count(r => r.state == Matched))),
+    ("registrations", rs->Array.map(encodeRegistration)->JSON.Encode.array),
+  ])->JSON.Encode.object
 }
 
 // Every failure mode here is the deployment's own mistake — a name matching no
@@ -561,7 +694,12 @@ let handler = async (event: JSON.t): array<JSON.t> => {
     | Some(target) =>
       // Checked on the raw rows: the refs are what the deploy can predict, and a
       // row that is behind should not have its structure fetched at all.
-      switch pendingRegistrations(rawItems, ~expect=bakeExpectations(event)) {
+      let regs = registrations(
+        rawItems,
+        ~expect=bakeExpectations(event),
+        ~since=bakeSince(event),
+      )
+      switch regs->Array.filter(isPending) {
       | [] =>
         // The built-in admin entry is deliberately absent: it never enters the
         // Plugin read model, and the in-memory bake curates the composed plugins
@@ -571,14 +709,22 @@ let handler = async (event: JSON.t): array<JSON.t> => {
           ~nameVersionOf=item => item->str("name"),
           ~toEntry=structureOf,
         )
-        await runBake(~target, ~structures)
+        let written = await runBake(~target, ~structures)
+        // Appended rather than merged into a file's report: the caller reads
+        // `[0]` to decide whether anything was written, and that stays the first
+        // file. What the summary adds is orthogonal to the files — it says what
+        // the convergence check proved, not what the bake wrote.
+        Array.concat(written, [encodeSummary(regs)])
       | pending =>
         // Not an error — the deploy just has not finished arriving. Reported so the
-        // caller can invoke again rather than bake the previous deployment.
+        // caller can invoke again rather than bake the previous deployment, and
+        // reported with both keys and the row's date so that when it never does
+        // arrive, the job says which of the causes it was.
         [
           Dict.fromArray([
             ("baked", JSON.Encode.bool(false)),
-            ("pending", pending->Array.map(JSON.Encode.string)->JSON.Encode.array),
+            ("pending", pending->Array.map(r => JSON.Encode.string(r.plugin))->JSON.Encode.array),
+            ("registrations", regs->Array.map(encodeRegistration)->JSON.Encode.array),
           ])->JSON.Encode.object,
         ]
       }

package/src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs

@@ -365,25 +365,158 @@ function bakeExpectations(event) {
   })));
 }
 
+function bakeSince(event) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_JSON.Decode.object(event), o => o["since"]), Stdlib_JSON.Decode.string);
+}
+
 function structureRefKey(item) {
   return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(item["structure"], Stdlib_JSON.Decode.object), o => o[Offload$Reventless.sentinelKey]), Stdlib_JSON.Decode.object), r => r["key"]), Stdlib_JSON.Decode.string);
 }
 
-function pendingRegistrations(items, expect) {
+function rowWrittenAt(item) {
+  return Stdlib_Option.flatMap(Stdlib_Option.flatMap(Stdlib_Option.flatMap(item["statusChange"], Stdlib_JSON.Decode.object), o => o["at"]), Stdlib_JSON.Decode.string);
+}
+
+function notBefore(at, since) {
+  let a = new Date(at).getTime();
+  let s = new Date(since).getTime();
+  if (!Number.isNaN(a) && !Number.isNaN(s)) {
+    return a >= s;
+  } else {
+    return false;
+  }
+}
+
+function classify(expected, found, writtenAt, since) {
+  let fresh = since !== undefined && writtenAt !== undefined ? notBefore(writtenAt, since) : undefined;
+  if (found !== undefined) {
+    if (found === expected) {
+      if (fresh !== undefined) {
+        if (fresh) {
+          return "Registered";
+        } else {
+          return "Unchanged";
+        }
+      } else {
+        return "Matched";
+      }
+    } else if (Primitive_object.equal(fresh, true)) {
+      return "Diverged";
+    } else {
+      return "Behind";
+    }
+  } else {
+    return "Missing";
+  }
+}
+
+function registrations(items, expect, since) {
   let current = Object.fromEntries(Platform_AdminScan_Ops$ReventlessAws.latestByName(items, item => str(item, "name"), (item, name) => Stdlib_Option.map(structureRefKey(item), key => [
     name,
-    key
+    [
+      key,
+      rowWrittenAt(item)
+    ]
   ])));
-  return Stdlib_Array.filterMap(Object.entries(expect), param => {
+  return Object.entries(expect).map(param => {
+    let expected = param[1];
     let plugin = param[0];
-    if (Primitive_object.equal(current[plugin], param[1])) {
-      return;
-    } else {
-      return plugin;
-    }
+    let row = current[plugin];
+    let found = Stdlib_Option.map(row, param => param[0]);
+    let writtenAt = Stdlib_Option.flatMap(row, param => param[1]);
+    return {
+      plugin: plugin,
+      expected: expected,
+      found: found,
+      writtenAt: writtenAt,
+      state: classify(expected, found, writtenAt, since)
+    };
   });
 }
 
+function isPending(r) {
+  let match = r.state;
+  switch (match) {
+    case "Missing" :
+    case "Behind" :
+    case "Diverged" :
+      return true;
+    default:
+      return false;
+  }
+}
+
+function stateName(s) {
+  switch (s) {
+    case "Registered" :
+      return "registered";
+    case "Unchanged" :
+      return "unchanged";
+    case "Matched" :
+      return "matched";
+    case "Missing" :
+      return "missing";
+    case "Behind" :
+      return "behind";
+    case "Diverged" :
+      return "diverged";
+  }
+}
+
+function encodeRegistration(r) {
+  return Object.fromEntries([
+    [
+      "plugin",
+      r.plugin
+    ],
+    [
+      "state",
+      stateName(r.state)
+    ],
+    [
+      "expected",
+      r.expected
+    ],
+    [
+      "found",
+      Stdlib_Option.mapOr(r.found, null, prim => prim)
+    ],
+    [
+      "writtenAt",
+      Stdlib_Option.mapOr(r.writtenAt, null, prim => prim)
+    ]
+  ]);
+}
+
+function encodeSummary(rs) {
+  return Object.fromEntries([
+    [
+      "summary",
+      true
+    ],
+    [
+      "plugins",
+      rs.length
+    ],
+    [
+      "registered",
+      rs.filter(r => r.state === "Registered").length
+    ],
+    [
+      "unchanged",
+      rs.filter(r => r.state === "Unchanged").length
+    ],
+    [
+      "matched",
+      rs.filter(r => r.state === "Matched").length
+    ],
+    [
+      "registrations",
+      rs.map(encodeRegistration)
+    ]
+  ]);
+}
+
 async function runBake(target, structures) {
   let selections = bakeSelections();
   if (selections.length === 0) {
@@ -466,7 +599,8 @@ async function handler(event) {
     let fetch = Offload$Reventless.cachedFetch(key => S3$AwsSdk.GetObjectCommand.getString(bucket, key));
     let resolveAll = () => Promise.all(rawItems.map(item => resolveStructure(fetch, item)));
     if (bakeTarget !== undefined) {
-      let pending = pendingRegistrations(rawItems, bakeExpectations(event));
+      let regs = registrations(rawItems, bakeExpectations(event), bakeSince(event));
+      let pending = regs.filter(isPending);
       if (pending.length !== 0) {
         return [Object.fromEntries([
             [
@@ -475,12 +609,17 @@ async function handler(event) {
             ],
             [
               "pending",
-              pending.map(prim => prim)
+              pending.map(r => r.plugin)
+            ],
+            [
+              "registrations",
+              regs.map(encodeRegistration)
             ]
           ])];
       }
       let structures = Platform_AdminScan_Ops$ReventlessAws.latestByName(await resolveAll(), item => str(item, "name"), structureOf);
-      return await runBake(bakeTarget, structures);
+      let written = await runBake(bakeTarget, structures);
+      return written.concat([encodeSummary(regs)]);
     }
     let userEntries = Platform_AdminScan_Ops$ReventlessAws.latestByName(await resolveAll(), item => str(item, "name"), toEntry);
     return admin.concat(userEntries);
@@ -518,8 +657,16 @@ export {
   bakeJourneys,
   bakeTargetOf,
   bakeExpectations,
+  bakeSince,
   structureRefKey,
-  pendingRegistrations,
+  rowWrittenAt,
+  notBefore,
+  classify,
+  registrations,
+  isPending,
+  stateName,
+  encodeRegistration,
+  encodeSummary,
   runBake,
   handler,
 }

package/tests/BakeConvergenceTest.res

@@ -0,0 +1,209 @@
+// A plugin's structure CHANGES between two deploys and the bake is required to
+// converge.
+//
+// The rest of the bake's coverage cannot catch this class. An unchanged structure
+// converges trivially — the key already matches — so a test that never mutates the
+// structure passes against a completely broken re-detect → answer → project chain.
+// That is also how the chain can be broken across any number of green deploys and
+// surface on the first one that changes a structure.
+//
+// So this drives the chain a redeploy actually runs: the deploy hashes the
+// structure through the offload hook and exports the key, the SAME definition is
+// serialized into `pluginDefinition.json` and decoded back the way the
+// EventCollector decodes it at cold start, the Plugin aggregate decides on Redetect
+// and Connect, and the projection builds the row the bake scans.
+
+open JestGlobals
+
+// Mirrors the deploy-time hook in aws/src/Platform.res: content-addressed key, and
+// the key the stack exports as `pluginStructureRef` is the one the hook returned.
+let deployStructure = (
+  structure: Reventless.Plugin.pluginStructure,
+): (string, Reventless.Offload.payload<Reventless.Plugin.pluginStructure>) => {
+  let exported = ref("")
+  ReventlessCore.Plugin_Helpers.registerOffload((~store, ~bytes) => {
+    let hash = NodeCrypto.sha256Hex(bytes)
+    let key = "sha256/" ++ hash
+    if store == "pluginStructures" {
+      exported := key
+    }
+    {Reventless.Offload.store, key, hash, bytes: bytes->String.length}
+  })
+  let payload = ReventlessCore.Plugin_Helpers.offloadPayload(
+    structure,
+    ~schema=Reventless.Plugin.pluginStructureSchema,
+    ~store="pluginStructures",
+  )
+  ReventlessCore.Plugin_Helpers.clearOffload()
+  (exported.contents, payload)
+}
+
+let emptyStructure: Reventless.Plugin.pluginStructure = {
+  readModels: [],
+  stateViewSlices: [],
+  stateChangeSlices: [],
+  aggregates: [],
+  automationSlices: [],
+  outboundTranslationSlices: [],
+  inboundTranslationSlices: [],
+  extensions: [],
+  extensionPoints: None,
+  requiredStores: None,
+  requiredStoreDeclarations: None,
+}
+
+let definition = (~structure): Reventless.Plugin.pluginDefinition => {
+  id: "Ordering@1.0.0",
+  name: "Ordering",
+  version: "1.0.0",
+  extensionPoints: [],
+  extensions: [],
+  eventCollector: "arn:aws:sqs:eu-west-1:0:Ordering",
+  extensionProtocols: [],
+  apiSchemaFragment: None,
+  apiTarget: None,
+  structure: Some(structure),
+  dcbEventLog: None,
+  kind: Domain,
+}
+
+// What the deploy ships as `pluginDefinition.json` and the EventCollector decodes
+// at cold start. Round-tripped rather than handed over directly, because it is the
+// artifact the registration carries — a key that did not survive this encode is a
+// pair of hashes that can never converge.
+let shipped = (def: Reventless.Plugin.pluginDefinition): Reventless.Plugin.pluginDefinition =>
+  def
+  ->Reventless.Util_Sury.toJsonString(Reventless.Plugin.pluginDefinitionSchema)
+  ->Reventless.Util_Sury.fromJsonString(Reventless.Plugin.pluginDefinitionSchema)
+
+// The row the projection writes, as the bake's scan sees it: QueryDb marshals the
+// raw ReScript value, so the record's runtime shape IS the stored item.
+let row = (def: Reventless.Plugin.pluginDefinition, ~at: string): dict<JSON.t> =>
+  ReventlessCore.PluginsProjection.displayState(
+    def,
+    ReventlessCore.PluginsReadModelSpec.Connected,
+    {Reventless.Message.at, by: "deploy"},
+    [],
+  )
+  ->JSON.stringifyAny
+  ->Option.getOr("{}")
+  ->JSON.parseOrThrow
+  ->JSON.Decode.object
+  ->Option.getOr(Dict.make())
+
+let apply = (state, events) => events->Array.reduce(state, ReventlessCore.PluginBehavior.evolve)
+
+let connect = (state, def) =>
+  switch ReventlessCore.PluginBehavior.decide(state, ReventlessCore.PluginSpec.Connect(def)) {
+  | Ok(events) => events
+  | Error(_) => []
+  }
+
+let stateOf = (rows, ~expect, ~since) =>
+  Platform_ComponentDefinitions_Lambda_Ops.registrations(
+    rows,
+    ~expect=Dict.fromArray(expect),
+    ~since=Some(since),
+  )
+  ->Array.get(0)
+  ->Option.map(r => Platform_ComponentDefinitions_Lambda_Ops.stateName(r.state))
+
+let deployedAt = "2026-08-27T10:00:00Z"
+let beforeDeploy = "2026-08-27T09:00:00Z"
+let afterDeploy = "2026-08-27T10:05:00Z"
+
+describe("the bake converges when a plugin's structure changes", () => {
+  let (keyA, structureA) = deployStructure(emptyStructure)
+  let (keyB, structureB) = deployStructure({
+    ...emptyStructure,
+    requiredStores: Some(["Ordering.receipts"]),
+  })
+  let defA = definition(~structure=structureA)
+  let defB = definition(~structure=structureB)
+
+  // If this ever stops holding, the two keys can never converge and every retry is
+  // spent waiting for something that cannot happen.
+  testSync("a changed structure hashes to a different key", () =>
+    expect(keyA == keyB)->toBe(false)
+  )
+
+  // The invariant convergence rests on: the structure the deploy hashes and the
+  // structure the plugin's registration carries are the same bytes, because they
+  // are the same object — the runtime does not recompute it, it ships the
+  // deploy's reference and hands it back.
+  testSync("the key the deploy exported is the key the registration carries", () =>
+    expect(
+      Platform_ComponentDefinitions_Lambda_Ops.structureRefKey(
+        row(shipped(defB), ~at=afterDeploy),
+      ),
+    )->toEqual(Some(keyB))
+  )
+
+  testSync("before the redeploy's registration lands, the plugin reads as behind", () =>
+    expect(
+      stateOf(
+        [row(shipped(defA), ~at=beforeDeploy)],
+        ~expect=[("Ordering", keyB)],
+        ~since=deployedAt,
+      ),
+    )->toEqual(Some("behind"))
+  )
+
+  // The link the bake is actually waiting on: a Connect carrying a changed
+  // definition must re-emit VersionConnected. `decide` is idempotent on an
+  // unchanged one, so this is the step a broken chain silently skips.
+  testSync("a redeploy with a changed structure re-emits VersionConnected", () => {
+    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
+      ReventlessCore.PluginBehavior.initialState,
+      shipped(defA),
+    ))
+    expect(connect(connected, shipped(defB))->Array.length)->toBe(1)
+  })
+
+  testSync("once it lands, the plugin reads as registered by this deploy", () => {
+    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
+      ReventlessCore.PluginBehavior.initialState,
+      shipped(defA),
+    ))
+    let redeployed = connected->apply(connect(connected, shipped(defB)))
+    let def = switch redeployed.known->Dict.get("1.0.0") {
+    | Some({definition}) => definition
+    | None => shipped(defA)
+    }
+    expect(
+      stateOf([row(def, ~at=afterDeploy)], ~expect=[("Ordering", keyB)], ~since=deployedAt),
+    )->toEqual(Some("registered"))
+  })
+
+  // Defect 1, as a test: a plugin whose structure did not change never
+  // re-registers, so its row is never rewritten and it passes the check without
+  // exercising the chain at all. Correct, and no evidence — which is why the bake
+  // counts it apart from a plugin that did register.
+  testSync("an unchanged structure passes without re-registering", () => {
+    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
+      ReventlessCore.PluginBehavior.initialState,
+      shipped(defA),
+    ))
+    expect(connect(connected, shipped(defA)))->toEqual([])
+    expect(
+      stateOf(
+        [row(shipped(defA), ~at=beforeDeploy)],
+        ~expect=[("Ordering", keyA)],
+        ~since=deployedAt,
+      ),
+    )->toEqual(Some("unchanged"))
+  })
+
+  // Deploy-time re-detect is what starts the chain for an already-connected
+  // version; without it a redeploy of the same version never re-runs the handshake
+  // and the changed structure never reaches the read model.
+  testSync("a redeploy re-detects an already-connected version", () => {
+    let connected = ReventlessCore.PluginBehavior.initialState->apply(connect(
+      ReventlessCore.PluginBehavior.initialState,
+      shipped(defA),
+    ))
+    expect(
+      ReventlessCore.PluginBehavior.decide(connected, ReventlessCore.PluginSpec.Redetect("1.0.0")),
+    )->toEqual(Ok([ReventlessCore.PluginSpec.VersionDetected("1.0.0")]))
+  })
+})

package/tests/BakeConvergenceTest.res.mjs

@@ -0,0 +1,209 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as NodeCrypto from "@reventlessdev/rescript-node/src/NodeCrypto.res.mjs";
+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_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Plugin$Reventless from "@reventlessdev/reventless-spec/src/components/Plugin.res.mjs";
+import * as Util_Sury$Reventless from "@reventlessdev/reventless-spec/src/util/Util_Sury.res.mjs";
+import * as PluginBehavior$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginBehavior.res.mjs";
+import * as Plugin_Helpers$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/component/Plugin_Helpers.res.mjs";
+import * as PluginsProjection$ReventlessCore from "@reventlessdev/reventless-core/src/plugin/lifecycle/PluginsProjection.res.mjs";
+import * as Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws from "../src/adapter/Api/Platform_ComponentDefinitions_Lambda_Ops.res.mjs";
+
+function deployStructure(structure) {
+  let exported = {
+    contents: ""
+  };
+  Plugin_Helpers$ReventlessCore.registerOffload((store, bytes) => {
+    let hash = NodeCrypto.sha256Hex(bytes);
+    let key = "sha256/" + hash;
+    if (store === "pluginStructures") {
+      exported.contents = key;
+    }
+    return {
+      store: store,
+      key: key,
+      hash: hash,
+      bytes: bytes.length
+    };
+  });
+  let payload = Plugin_Helpers$ReventlessCore.offloadPayload(structure, Plugin$Reventless.pluginStructureSchema, "pluginStructures");
+  Plugin_Helpers$ReventlessCore.clearOffload();
+  return [
+    exported.contents,
+    payload
+  ];
+}
+
+let emptyStructure_readModels = [];
+
+let emptyStructure_stateViewSlices = [];
+
+let emptyStructure_stateChangeSlices = [];
+
+let emptyStructure_aggregates = [];
+
+let emptyStructure_automationSlices = [];
+
+let emptyStructure_outboundTranslationSlices = [];
+
+let emptyStructure_inboundTranslationSlices = [];
+
+let emptyStructure_extensions = [];
+
+let emptyStructure = {
+  readModels: emptyStructure_readModels,
+  stateViewSlices: emptyStructure_stateViewSlices,
+  stateChangeSlices: emptyStructure_stateChangeSlices,
+  aggregates: emptyStructure_aggregates,
+  automationSlices: emptyStructure_automationSlices,
+  outboundTranslationSlices: emptyStructure_outboundTranslationSlices,
+  inboundTranslationSlices: emptyStructure_inboundTranslationSlices,
+  extensions: emptyStructure_extensions,
+  extensionPoints: undefined,
+  requiredStores: undefined,
+  requiredStoreDeclarations: undefined
+};
+
+function definition(structure) {
+  return {
+    id: "Ordering@1.0.0",
+    name: "Ordering",
+    version: "1.0.0",
+    extensionPoints: [],
+    extensions: [],
+    eventCollector: "arn:aws:sqs:eu-west-1:0:Ordering",
+    extensionProtocols: [],
+    apiSchemaFragment: undefined,
+    apiTarget: undefined,
+    structure: structure,
+    dcbEventLog: undefined,
+    kind: "Domain"
+  };
+}
+
+function shipped(def) {
+  return Util_Sury$Reventless.fromJsonString(Util_Sury$Reventless.toJsonString(def, Plugin$Reventless.pluginDefinitionSchema, undefined), Plugin$Reventless.pluginDefinitionSchema);
+}
+
+function row(def, at) {
+  return Stdlib_Option.getOr(Stdlib_JSON.Decode.object(JSON.parse(Stdlib_Option.getOr(JSON.stringify(PluginsProjection$ReventlessCore.displayState(def, "Connected", {
+    at: at,
+    by: "deploy"
+  }, [])), "{}"))), {});
+}
+
+function apply(state, events) {
+  return Stdlib_Array.reduce(events, state, PluginBehavior$ReventlessCore.evolve);
+}
+
+function connect(state, def) {
+  let events = PluginBehavior$ReventlessCore.decide(state, {
+    TAG: "Connect",
+    _0: def
+  });
+  if (events.TAG === "Ok") {
+    return events._0;
+  } else {
+    return [];
+  }
+}
+
+function stateOf(rows, expect, since) {
+  return Stdlib_Option.map(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.registrations(rows, Object.fromEntries(expect), since)[0], r => Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.stateName(r.state));
+}
+
+let deployedAt = "2026-08-27T10:00:00Z";
+
+let beforeDeploy = "2026-08-27T09:00:00Z";
+
+let afterDeploy = "2026-08-27T10:05:00Z";
+
+globalThis.describe("the bake converges when a plugin's structure changes", () => {
+  let match = deployStructure(emptyStructure);
+  let keyA = match[0];
+  let match$1 = deployStructure({
+    readModels: emptyStructure_readModels,
+    stateViewSlices: emptyStructure_stateViewSlices,
+    stateChangeSlices: emptyStructure_stateChangeSlices,
+    aggregates: emptyStructure_aggregates,
+    automationSlices: emptyStructure_automationSlices,
+    outboundTranslationSlices: emptyStructure_outboundTranslationSlices,
+    inboundTranslationSlices: emptyStructure_inboundTranslationSlices,
+    extensions: emptyStructure_extensions,
+    extensionPoints: undefined,
+    requiredStores: ["Ordering.receipts"],
+    requiredStoreDeclarations: undefined
+  });
+  let keyB = match$1[0];
+  let defA = definition(match[1]);
+  let defB = definition(match$1[1]);
+  globalThis.test("a changed structure hashes to a different key", () => {
+    globalThis.expect(keyA === keyB).toBe(false);
+  });
+  globalThis.test("the key the deploy exported is the key the registration carries", () => {
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.structureRefKey(row(shipped(defB), afterDeploy))).toEqual(keyB);
+  });
+  globalThis.test("before the redeploy's registration lands, the plugin reads as behind", () => {
+    globalThis.expect(stateOf([row(shipped(defA), beforeDeploy)], [[
+        "Ordering",
+        keyB
+      ]], deployedAt)).toEqual("behind");
+  });
+  globalThis.test("a redeploy with a changed structure re-emits VersionConnected", () => {
+    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    globalThis.expect(connect(connected, shipped(defB)).length).toBe(1);
+  });
+  globalThis.test("once it lands, the plugin reads as registered by this deploy", () => {
+    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    let events$1 = connect(connected, shipped(defB));
+    let redeployed = Stdlib_Array.reduce(events$1, connected, PluginBehavior$ReventlessCore.evolve);
+    let match = redeployed.known["1.0.0"];
+    let def = match !== undefined ? match.definition : shipped(defA);
+    globalThis.expect(stateOf([row(def, afterDeploy)], [[
+        "Ordering",
+        keyB
+      ]], deployedAt)).toEqual("registered");
+  });
+  globalThis.test("an unchanged structure passes without re-registering", () => {
+    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    globalThis.expect(connect(connected, shipped(defA))).toEqual([]);
+    globalThis.expect(stateOf([row(shipped(defA), beforeDeploy)], [[
+        "Ordering",
+        keyA
+      ]], deployedAt)).toEqual("unchanged");
+  });
+  globalThis.test("a redeploy re-detects an already-connected version", () => {
+    let events = connect(PluginBehavior$ReventlessCore.initialState, shipped(defA));
+    let connected = Stdlib_Array.reduce(events, PluginBehavior$ReventlessCore.initialState, PluginBehavior$ReventlessCore.evolve);
+    globalThis.expect(PluginBehavior$ReventlessCore.decide(connected, {
+      TAG: "Redetect",
+      _0: "1.0.0"
+    })).toEqual({
+      TAG: "Ok",
+      _0: [{
+          TAG: "VersionDetected",
+          _0: "1.0.0"
+        }]
+    });
+  });
+});
+
+export {
+  deployStructure,
+  emptyStructure,
+  definition,
+  shipped,
+  row,
+  apply,
+  connect,
+  stateOf,
+  deployedAt,
+  beforeDeploy,
+  afterDeploy,
+}
+/*  Not a pure module */

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res

@@ -355,8 +355,8 @@ describe("bakeJourney", () => {
 // The bake reads a read model the deploy updates asynchronously, so "is this the
 // deployment I was asked to bake" is a question it has to be able to answer. The
 // answer is an equality check against the key each plugin stack just wrote.
-describe("pendingRegistrations", () => {
-  let row = (~name, ~key=?, ()) => {
+describe("registrations", () => {
+  let row = (~name, ~key=?, ~at=?, ()) => {
     let item = Dict.fromArray([("name", JSON.Encode.string(name))])
     key->Option.forEach(k =>
       item->Dict.set(
@@ -364,15 +364,29 @@ describe("pendingRegistrations", () => {
         JSON.parseOrThrow(`{"$offload": {"store": "pluginStructures", "key": "${k}"}}`),
       )
     )
+    at->Option.forEach(t =>
+      item->Dict.set("statusChange", JSON.parseOrThrow(`{"at": "${t}", "by": "deploy"}`))
+    )
     item
   }
 
-  let pending = (rows, expect) =>
-    Platform_ComponentDefinitions_Lambda_Ops.pendingRegistrations(
+  let regs = (rows, expect, ~since=?) =>
+    Platform_ComponentDefinitions_Lambda_Ops.registrations(
       rows,
       ~expect=Dict.fromArray(expect),
+      ~since,
     )
 
+  let pending = (rows, expect) =>
+    regs(rows, expect)
+    ->Array.filter(Platform_ComponentDefinitions_Lambda_Ops.isPending)
+    ->Array.map(r => r.plugin)
+
+  let stateOf = (rows, expect, ~since=?) =>
+    regs(rows, expect, ~since?)
+    ->Array.get(0)
+    ->Option.map(r => Platform_ComponentDefinitions_Lambda_Ops.stateName(r.state))
+
   testSync("nothing is pending when every row carries the key the deploy wrote", () =>
     expect(
       pending(
@@ -412,6 +426,111 @@ describe("pendingRegistrations", () => {
       )->Dict.get("Ordering"),
     )->toEqual(Some("sha256/b"))
   )
+
+  testSync("reads the deploy instant off the invocation payload", () =>
+    expect(
+      Platform_ComponentDefinitions_Lambda_Ops.bakeSince(
+        JSON.parseOrThrow(`{"bake": true, "since": "2026-08-27T10:00:00Z"}`),
+      ),
+    )->toEqual(Some("2026-08-27T10:00:00Z"))
+  )
+
+  // Both halves of the comparison and the row's date, which is the whole point:
+  // the failure used to report a name and nothing else, and the four causes it
+  // could have had were told apart by reading the read model out of band.
+  testSync("reports the expected key, the found key and when the row was written", () => {
+    let r = regs(
+      [row(~name="Ordering", ~key="sha256/old", ~at="2026-08-27T09:00:00Z", ())],
+      [("Ordering", "sha256/new")],
+    )->Array.get(0)
+    expect((
+      r->Option.map(r => r.expected),
+      r->Option.flatMap(r => r.found),
+      r->Option.flatMap(r => r.writtenAt),
+    ))->toEqual((Some("sha256/new"), Some("sha256/old"), Some("2026-08-27T09:00:00Z")))
+  })
+
+  describe("dated against the deploy", () => {
+    let since = "2026-08-27T10:00:00Z"
+    let before = "2026-08-27T09:00:00Z"
+    let after = "2026-08-27T10:05:00Z"
+
+    // The distinction §4 exists for: this plugin proves the chain works.
+    testSync("a matching key on a row this deploy wrote is registered", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/a", ~at=after, ())],
+          [("Ordering", "sha256/a")],
+          ~since,
+        ),
+      )->toEqual(Some("registered"))
+    )
+
+    // Correct, and vacuous — an unchanged structure converges against a
+    // completely broken chain, which is why it is not counted as evidence.
+    testSync("a matching key on a row that predates the deploy is unchanged", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/a", ~at=before, ())],
+          [("Ordering", "sha256/a")],
+          ~since,
+        ),
+      )->toEqual(Some("unchanged"))
+    )
+
+    testSync("a matching key with no deploy instant to date it against is matched", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/a", ~at=after, ())],
+          [("Ordering", "sha256/a")],
+        ),
+      )->toEqual(Some("matched"))
+    )
+
+    // Retrying is for this one.
+    testSync("a stale row that predates the deploy is behind", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/old", ~at=before, ())],
+          [("Ordering", "sha256/new")],
+          ~since,
+        ),
+      )->toEqual(Some("behind"))
+    )
+
+    // And never for this one: the plugin answered during this deploy and produced
+    // a structure other than the one the deploy hashed, so the keys cannot
+    // converge and every remaining attempt is spent on something that cannot happen.
+    testSync("a stale row this deploy wrote is diverged", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/other", ~at=after, ())],
+          [("Ordering", "sha256/new")],
+          ~since,
+        ),
+      )->toEqual(Some("diverged"))
+    )
+
+    // The scan filters on Connected, so a version that dropped out mid-deploy
+    // leaves no row to compare against — indistinguishable, before this, from a
+    // projection that had merely not landed yet, and waited on for the full
+    // retry budget either way.
+    testSync("no Connected row at all is missing, not behind", () =>
+      expect(stateOf([], [("Ordering", "sha256/new")], ~since))->toEqual(Some("missing"))
+    )
+
+    // An unparseable stamp must not read as fresh: reporting `registered` off a
+    // date nobody could read would credit the chain for work it may not have done.
+    testSync("an unreadable row date does not count as written by this deploy", () =>
+      expect(
+        stateOf(
+          [row(~name="Ordering", ~key="sha256/a", ~at="not-a-date", ())],
+          [("Ordering", "sha256/a")],
+          ~since,
+        ),
+      )->toEqual(Some("unchanged"))
+    )
+  })
 })
 
 describe("resolveStructure", () => {

package/tests/Platform_ComponentDefinitions_Lambda_OpsTest.res.mjs

@@ -221,8 +221,8 @@ globalThis.describe("bakeJourney", () => {
   });
 });
 
-globalThis.describe("pendingRegistrations", () => {
-  let row = (name, key, param) => {
+globalThis.describe("registrations", () => {
+  let row = (name, key, at, param) => {
     let item = Object.fromEntries([[
         "name",
         name
@@ -230,14 +230,19 @@ globalThis.describe("pendingRegistrations", () => {
     Stdlib_Option.forEach(key, k => {
       item["structure"] = JSON.parse(`{"$offload": {"store": "pluginStructures", "key": "` + k + `"}}`);
     });
+    Stdlib_Option.forEach(at, t => {
+      item["statusChange"] = JSON.parse(`{"at": "` + t + `", "by": "deploy"}`);
+    });
     return item;
   };
+  let regs = (rows, expect, since) => Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.registrations(rows, Object.fromEntries(expect), since);
+  let pending = (rows, expect) => regs(rows, expect, undefined).filter(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.isPending).map(r => r.plugin);
+  let stateOf = (rows, expect, since) => Stdlib_Option.map(regs(rows, expect, since)[0], r => Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.stateName(r.state));
   globalThis.test("nothing is pending when every row carries the key the deploy wrote", () => {
-    let rows = [
-      row("Catalog", "sha256/a", undefined),
-      row("Ordering", "sha256/b", undefined)
-    ];
-    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([
+    globalThis.expect(pending([
+      row("Catalog", "sha256/a", undefined, undefined),
+      row("Ordering", "sha256/b", undefined, undefined)
+    ], [
       [
         "Catalog",
         "sha256/a"
@@ -246,14 +251,13 @@ globalThis.describe("pendingRegistrations", () => {
         "Ordering",
         "sha256/b"
       ]
-    ]))).toEqual([]);
+    ])).toEqual([]);
   });
   globalThis.test("names a plugin still carrying the previous structure", () => {
-    let rows = [
-      row("Catalog", "sha256/a", undefined),
-      row("Ordering", "sha256/old", undefined)
-    ];
-    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([
+    globalThis.expect(pending([
+      row("Catalog", "sha256/a", undefined, undefined),
+      row("Ordering", "sha256/old", undefined, undefined)
+    ], [
       [
         "Catalog",
         "sha256/a"
@@ -262,21 +266,85 @@ globalThis.describe("pendingRegistrations", () => {
         "Ordering",
         "sha256/new"
       ]
-    ]))).toEqual(["Ordering"]);
+    ])).toEqual(["Ordering"]);
   });
   globalThis.test("names a plugin with no row at all", () => {
-    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations([], Object.fromEntries([[
+    globalThis.expect(pending([], [[
         "Ordering",
         "sha256/new"
-      ]]))).toEqual(["Ordering"]);
+      ]])).toEqual(["Ordering"]);
   });
   globalThis.test("waits for nothing when the caller expects nothing", () => {
-    let rows = [row("Ordering", "sha256/old", undefined)];
-    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.pendingRegistrations(rows, Object.fromEntries([]))).toEqual([]);
+    globalThis.expect(pending([row("Ordering", "sha256/old", undefined, undefined)], [])).toEqual([]);
   });
   globalThis.test("reads the expectations off the invocation payload", () => {
     globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeExpectations(JSON.parse(`{"bake": true, "expect": {"Ordering": "sha256/b"}}`))["Ordering"]).toEqual("sha256/b");
   });
+  globalThis.test("reads the deploy instant off the invocation payload", () => {
+    globalThis.expect(Platform_ComponentDefinitions_Lambda_Ops$ReventlessAws.bakeSince(JSON.parse(`{"bake": true, "since": "2026-08-27T10:00:00Z"}`))).toEqual("2026-08-27T10:00:00Z");
+  });
+  globalThis.test("reports the expected key, the found key and when the row was written", () => {
+    let r = regs([row("Ordering", "sha256/old", "2026-08-27T09:00:00Z", undefined)], [[
+          "Ordering",
+          "sha256/new"
+        ]], undefined)[0];
+    globalThis.expect([
+      Stdlib_Option.map(r, r => r.expected),
+      Stdlib_Option.flatMap(r, r => r.found),
+      Stdlib_Option.flatMap(r, r => r.writtenAt)
+    ]).toEqual([
+      "sha256/new",
+      "sha256/old",
+      "2026-08-27T09:00:00Z"
+    ]);
+  });
+  globalThis.describe("dated against the deploy", () => {
+    let since = "2026-08-27T10:00:00Z";
+    let before = "2026-08-27T09:00:00Z";
+    let after = "2026-08-27T10:05:00Z";
+    globalThis.test("a matching key on a row this deploy wrote is registered", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/a", after, undefined)], [[
+          "Ordering",
+          "sha256/a"
+        ]], since)).toEqual("registered");
+    });
+    globalThis.test("a matching key on a row that predates the deploy is unchanged", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/a", before, undefined)], [[
+          "Ordering",
+          "sha256/a"
+        ]], since)).toEqual("unchanged");
+    });
+    globalThis.test("a matching key with no deploy instant to date it against is matched", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/a", after, undefined)], [[
+          "Ordering",
+          "sha256/a"
+        ]], undefined)).toEqual("matched");
+    });
+    globalThis.test("a stale row that predates the deploy is behind", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/old", before, undefined)], [[
+          "Ordering",
+          "sha256/new"
+        ]], since)).toEqual("behind");
+    });
+    globalThis.test("a stale row this deploy wrote is diverged", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/other", after, undefined)], [[
+          "Ordering",
+          "sha256/new"
+        ]], since)).toEqual("diverged");
+    });
+    globalThis.test("no Connected row at all is missing, not behind", () => {
+      globalThis.expect(stateOf([], [[
+          "Ordering",
+          "sha256/new"
+        ]], since)).toEqual("missing");
+    });
+    globalThis.test("an unreadable row date does not count as written by this deploy", () => {
+      globalThis.expect(stateOf([row("Ordering", "sha256/a", "not-a-date", undefined)], [[
+          "Ordering",
+          "sha256/a"
+        ]], since)).toEqual("unchanged");
+    });
+  });
 });
 
 globalThis.describe("resolveStructure", () => {