@reventlessdev/reventless-core 3.0.0-alpha.153 → 3.0.0-alpha.155

package/CHANGELOG.md

@@ -3,6 +3,23 @@
 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.155 (2026-07-11)
+
+### Bug Fixes
+
+* **build:** mark tests as dev-only sources so dependents don't compile them ([28b3b1c](https://github.com/ReventlessDev/reventless-core/commit/28b3b1ccfeaafc1d7050a86ce2362f32e4299187))
+
+
+# 3.0.0-alpha.154 (2026-07-11)
+
+### Bug Fixes
+
+* **plugin-lifecycle:** heal message decode of definitions persisted before a schema field existed ([6bb3e72](https://github.com/ReventlessDev/reventless-core/commit/6bb3e7259ad606a0f77fb670bcfc680256592003))
+### Features
+
+* **monitoring:** deploy-time Monitoring hook seam for provisioned execution units ([30f1c23](https://github.com/ReventlessDev/reventless-core/commit/30f1c23ba118805dae83af9115341f4aff6db92b))
+
+
 # 3.0.0-alpha.153 (2026-07-10)
 
 ### Features

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-core",
-  "version": "3.0.0-alpha.153",
+  "version": "3.0.0-alpha.155",
   "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-effect": "0.1.0-alpha.25",
+    "@reventlessdev/rescript-effect": "0.1.0-alpha.26",
     "@reventlessdev/rescript-fast-csv": "1.2.0-alpha.11",
     "@reventlessdev/rescript-hash-object": "1.2.0-alpha.10",
-    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-jest": "1.0.0-alpha.6",
+    "@reventlessdev/rescript-node-streams": "1.1.0-alpha.10",
     "@reventlessdev/rescript-pulumi-pulumi": "2.3.0-alpha.14",
     "@reventlessdev/rescript-ssh2": "1.1.0-alpha.11",
     "@reventlessdev/rescript-uuid": "1.1.0-alpha.14",
-    "@reventlessdev/reventless-infra": "3.0.0-alpha.94",
-    "@reventlessdev/reventless-interop": "3.0.0-alpha.24",
-    "@reventlessdev/reventless-spec": "3.0.0-alpha.72"
+    "@reventlessdev/reventless-infra": "3.0.0-alpha.96",
+    "@reventlessdev/reventless-interop": "3.0.0-alpha.25",
+    "@reventlessdev/reventless-spec": "3.0.0-alpha.74"
   },
   "devDependencies": {
     "rescript": "^12.3.0",

package/rescript.json

@@ -19,7 +19,8 @@
     },
     {
       "dir": "tests",
-      "subdirs": true
+      "subdirs": true,
+      "type": "dev"
     }
   ],
   "dependencies": [

package/src/Message.res

@@ -64,10 +64,16 @@ let toCommandSchema' = (idSchema, commandSchema) =>
     })
   )
 
+// Schema-migration-on-read: reuse the tolerant parse from `Reventless.Message`
+// (`parseJsonTolerant` / `fillMissingDefaults`, included above) so a message persisted
+// before a nested `@schema` field existed still decodes instead of bricking the
+// aggregate's log replay. These two entry points thread the memoized envelope schema;
+// `Reventless.Message.decode` (the other central decoder) is tolerant at the source.
+// See docs/plans/platform-infrastructure-in-plugin-list.md (durable fix option 2).
 let decodeEvent' = (json, idSchema, eventSchema) =>
-  json->S.parseJsonOrThrow(toEventSchema'(idSchema, eventSchema))
+  json->parseJsonTolerant(toEventSchema'(idSchema, eventSchema))
 let decodeCommand' = (json, idSchema, commandSchema) =>
-  json->S.parseJsonOrThrow(toCommandSchema'(idSchema, commandSchema))
+  json->parseJsonTolerant(toCommandSchema'(idSchema, commandSchema))
 
 let encodeEvent' = (event', idSchema, eventSchema) =>
   event'->S.reverseConvertToJsonOrThrow(toEventSchema'(idSchema, eventSchema))

package/src/Message.res.mjs

@@ -44,11 +44,11 @@ function toCommandSchema$p(idSchema, commandSchema) {
 }
 
 function decodeEvent$p(json, idSchema, eventSchema) {
-  return S.parseJsonOrThrow(json, toEventSchema$p(idSchema, eventSchema));
+  return Message$Reventless.parseJsonTolerant(json, toEventSchema$p(idSchema, eventSchema));
 }
 
 function decodeCommand$p(json, idSchema, commandSchema) {
-  return S.parseJsonOrThrow(json, toCommandSchema$p(idSchema, commandSchema));
+  return Message$Reventless.parseJsonTolerant(json, toCommandSchema$p(idSchema, commandSchema));
 }
 
 function encodeEvent$p(event$p, idSchema, eventSchema) {
@@ -384,6 +384,10 @@ let statusChangeSchema = Message$Reventless.statusChangeSchema;
 
 let commandJsonSchema = Message$Reventless.commandJsonSchema;
 
+let fillMissingDefaults = Message$Reventless.fillMissingDefaults;
+
+let parseJsonTolerant = Message$Reventless.parseJsonTolerant;
+
 let decode = Message$Reventless.decode;
 
 let encode = Message$Reventless.encode;
@@ -397,6 +401,8 @@ export {
   contextSchema,
   statusChangeSchema,
   commandJsonSchema,
+  fillMissingDefaults,
+  parseJsonTolerant,
   decode,
   encode,
   InvalidEvent,

package/src/adapter/Monitoring/Monitoring.res

@@ -0,0 +1,96 @@
+/**
+Deploy-time inventory hook: every runtime backend announces the execution units
+it provisions so an extension can attach provider-native monitoring to each.
+
+No-op by default. Zero behavioral change unless an extension registers a backend
+via `use` before the platform/plugin build. The seam fires once per unit at
+provisioning time (inside the deploy program) — never at invocation, and it runs
+no code in production. Monitoring/alerting itself is deliberately NOT a framework
+concern; this only exposes the choke point through which the framework says
+"I just provisioned an execution unit" and leaves what to do about it to the
+listener.
+
+See `docs/plans/monitoring-hook-seam.md`.
+*/
+
+/**
+The ROLE of a provisioned execution unit, not its mechanism. What "failure"
+means for a unit is provider-specific (a Lambda `Errors` metric vs. container
+restarts vs. NATS redeliveries) and belongs in the extension's per-provider
+`Backend`; core only says *that* a unit exists and *what role* it plays, which is
+what keeps the contract stable across runtimes. `Other(string)` is the escape
+hatch for support units and future roles (same pattern as the protocol's
+`OtherKind`).
+*/
+type unitKind =
+  | /** aggregates, state-change slices, extension points — failure = writes
+       rejected/dropped (the silent-freeze class) */
+  CommandHandler
+  | /** state-view slices, read models — failure = silently stale reads */
+  Projection
+  | /** automation slices, side-effect handlers, translations — failure = missed
+       side effects at boundaries */
+  Reactor
+  | /** cross-plugin/admin event ingestion — failure = event flow between plugins
+       stops */
+  EventCollector
+  | /** scheduled task runners */
+  Task
+  | /** heartbeat/keep-alive — failure = lifecycle detection AND any staleness
+       watchdog go blind (monitoring's own pulse) */
+  Scheduler
+  | /** receives messages that exhausted processing */
+  DeadLetterSink
+  | /** support units (counters, change-feed relays, migration runners, query
+       resolvers, …) — providers pass their name */
+  Other(string)
+
+/**
+A monitoring backend, registered by an extension (a deploy program) before the
+platform builds. `onProvisioned` is called once per execution unit.
+
+`~name` is the unit's STATIC logical name — the string the builder passed to its
+provisioning call. A Pulumi-based backend derives logical resource names from it
+(alarm/rule resource names must be stable and known at graph-construction time).
+`~component` is the deploy-time `Adapter.resource`; its fields are `Output`s
+(physical, suffix-bearing — right for a metric dimension like a CloudWatch
+FunctionName or a PrometheusRule deployment selector, but unusable as a logical
+resource name). Because `onProvisioned` fires during resource creation inside the
+deploy program, a Pulumi-based backend can create monitoring resources in the
+same stack, parented naturally.
+*/
+module type Backend = {
+  let onProvisioned: (
+    ~kind: unitKind,
+    ~name: string,
+    ~component: ReventlessInfra.Adapter.resource,
+  ) => unit
+}
+
+/** Default backend: does nothing. Active unless an extension calls `use`. */
+module Noop: Backend = {
+  let onProvisioned = (~kind as _, ~name as _, ~component as _) => ()
+}
+
+let backend: ref<module(Backend)> = ref(module(Noop: Backend))
+
+/**
+Register the monitoring backend. Must run before the platform/plugin build in the
+deploy program (plain statement order — the registry is consulted lazily at each
+provisioning site). Called once, by the extension, first.
+*/
+let use = (b: module(Backend)) => backend := b
+
+/**
+Announce a provisioned execution unit to the registered backend. Called by
+runtime backends at their provisioning sites (once per unit). No-op until an
+extension registers a backend.
+*/
+let notify = (
+  ~kind: unitKind,
+  ~name: string,
+  ~component: ReventlessInfra.Adapter.resource,
+) => {
+  module B = unpack(backend.contents)
+  B.onProvisioned(~kind, ~name, ~component)
+}

package/src/adapter/Monitoring/Monitoring.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function onProvisioned(param, param$1, param$2) {
+  
+}
+
+let Noop = {
+  onProvisioned: onProvisioned
+};
+
+let backend = {
+  contents: Noop
+};
+
+function use(b) {
+  backend.contents = b;
+}
+
+function notify(kind, name, component) {
+  let B = backend.contents;
+  B.onProvisioned(kind, name, component);
+}
+
+export {
+  Noop,
+  backend,
+  use,
+  notify,
+}
+/* No side effect */

package/tests/adapter/MonitoringTest.res

@@ -0,0 +1,53 @@
+open JestGlobals
+
+// The registry only forwards `~component`; it never reads its fields. A
+// structural stand-in keeps @pulumi/pulumi (whose Output.make would build a real
+// resource) out of the Jest run — its ESM entry can't be imported under Jest.
+let stubResource: ReventlessInfra.Adapter.resource = %raw(`{}`)
+
+describe("Monitoring", () => {
+  testSync("Noop default: notify is silent and does not throw", () => {
+    // No backend registered — the default Noop backend swallows the call.
+    Monitoring.notify(~kind=CommandHandler, ~name="before", ~component=stubResource)
+    expect(true)->toBe(true)
+  })
+
+  testSync("use registers a backend that receives every notify, role and name", () => {
+    let recorded: array<(Monitoring.unitKind, string)> = []
+    module Recorder: Monitoring.Backend = {
+      let onProvisioned = (~kind, ~name, ~component as _) => recorded->Array.push((kind, name))
+    }
+    Monitoring.use(module(Recorder: Monitoring.Backend))
+
+    Monitoring.notify(~kind=CommandHandler, ~name="AllAggregatesCmdHandler", ~component=stubResource)
+    Monitoring.notify(~kind=Projection, ~name="AllStateViewSlices", ~component=stubResource)
+    Monitoring.notify(~kind=DeadLetterSink, ~name="DeadLetterQueue", ~component=stubResource)
+    Monitoring.notify(~kind=Other("Counter"), ~name="ProductCounter", ~component=stubResource)
+
+    expect(recorded)->toEqual([
+      (Monitoring.CommandHandler, "AllAggregatesCmdHandler"),
+      (Monitoring.Projection, "AllStateViewSlices"),
+      (Monitoring.DeadLetterSink, "DeadLetterQueue"),
+      (Monitoring.Other("Counter"), "ProductCounter"),
+    ])
+
+    // Restore the default so registry state doesn't leak to other cases.
+    Monitoring.use(module(Monitoring.Noop))
+  })
+
+  testSync("notify forwards the static name and component resource to the backend", () => {
+    let seen: ref<option<(string, ReventlessInfra.Adapter.resource)>> = ref(None)
+    module Capture: Monitoring.Backend = {
+      let onProvisioned = (~kind as _, ~name, ~component) => seen := Some((name, component))
+    }
+    Monitoring.use(module(Capture: Monitoring.Backend))
+
+    Monitoring.notify(~kind=Scheduler, ~name="HeartbeatUnit", ~component=stubResource)
+    switch seen.contents {
+    | Some((name, _component)) => expect(name)->toBe("HeartbeatUnit")
+    | None => expect("no notify received")->toBe("a notify")
+    }
+
+    Monitoring.use(module(Monitoring.Noop))
+  })
+})

package/tests/adapter/MonitoringTest.res.mjs

@@ -0,0 +1,82 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Monitoring$ReventlessCore from "../../src/adapter/Monitoring/Monitoring.res.mjs";
+
+let stubResource = {};
+
+globalThis.describe("Monitoring", () => {
+  globalThis.test("Noop default: notify is silent and does not throw", () => {
+    Monitoring$ReventlessCore.notify("CommandHandler", "before", stubResource);
+    globalThis.expect(true).toBe(true);
+  });
+  globalThis.test("use registers a backend that receives every notify, role and name", () => {
+    let recorded = [];
+    let onProvisioned = (kind, name, param) => {
+      recorded.push([
+        kind,
+        name
+      ]);
+    };
+    let Recorder = {
+      onProvisioned: onProvisioned
+    };
+    Monitoring$ReventlessCore.use(Recorder);
+    Monitoring$ReventlessCore.notify("CommandHandler", "AllAggregatesCmdHandler", stubResource);
+    Monitoring$ReventlessCore.notify("Projection", "AllStateViewSlices", stubResource);
+    Monitoring$ReventlessCore.notify("DeadLetterSink", "DeadLetterQueue", stubResource);
+    Monitoring$ReventlessCore.notify({
+      TAG: "Other",
+      _0: "Counter"
+    }, "ProductCounter", stubResource);
+    globalThis.expect(recorded).toEqual([
+      [
+        "CommandHandler",
+        "AllAggregatesCmdHandler"
+      ],
+      [
+        "Projection",
+        "AllStateViewSlices"
+      ],
+      [
+        "DeadLetterSink",
+        "DeadLetterQueue"
+      ],
+      [
+        {
+          TAG: "Other",
+          _0: "Counter"
+        },
+        "ProductCounter"
+      ]
+    ]);
+    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+  });
+  globalThis.test("notify forwards the static name and component resource to the backend", () => {
+    let seen = {
+      contents: undefined
+    };
+    let onProvisioned = (param, name, component) => {
+      seen.contents = [
+        name,
+        component
+      ];
+    };
+    let Capture = {
+      onProvisioned: onProvisioned
+    };
+    Monitoring$ReventlessCore.use(Capture);
+    Monitoring$ReventlessCore.notify("Scheduler", "HeartbeatUnit", stubResource);
+    let match = seen.contents;
+    if (match !== undefined) {
+      globalThis.expect(match[0]).toBe("HeartbeatUnit");
+    } else {
+      globalThis.expect("no notify received").toBe("a notify");
+    }
+    Monitoring$ReventlessCore.use(Monitoring$ReventlessCore.Noop);
+  });
+});
+
+export {
+  stubResource,
+}
+/*  Not a pure module */

package/tests/message/MessageTest.res

@@ -93,4 +93,150 @@ describe("Message should", () => {
 
     expect(eventId)->toBe("testId")
   })
+
+  // Schema-migration-on-read: a VersionConnected event persisted before `kind` (and
+  // before later pluginStructure fields like `events`/`chapter`) existed must still
+  // decode — otherwise the one stale event bricks the whole lifecycle aggregate. See
+  // docs/plans/platform-infrastructure-in-plugin-list.md (durable fix option 2).
+  testSync("tolerantly decode a VersionConnected persisted before kind/structure fields existed", () => {
+    open PluginSpec
+    let def: Reventless.Plugin.pluginDefinition = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: None,
+      apiTarget: None,
+      uiFragments: None,
+      structure: Some({
+        readModels: [],
+        stateViewSlices: [],
+        stateChangeSlices: [],
+        aggregates: [
+          {
+            name: "Order",
+            commands: [],
+            producedEventTypes: [],
+            consumedEventTypes: [],
+            linkedViews: [],
+            consistencyRead: None,
+            events: [],
+            chapter: None,
+          },
+        ],
+        automationSlices: [],
+        outboundTranslationSlices: [],
+        inboundTranslationSlices: [],
+        extensions: [],
+        extensionPoints: None,
+      }),
+      dcbEventLog: None,
+      kind: Domain,
+    }
+    let event' = {
+      id: "id",
+      meta: {
+        service: "svc",
+        time: "t",
+        ip: "ip",
+        user: "u",
+        msgId: "m",
+        correlationId: "c",
+      },
+      event: VersionConnected(def),
+    }
+    let json = event'->Message.encodeEvent'(S.string, PluginSpec.eventSchema)
+
+    // Simulate the persisted JSON as written before these fields existed: drop the
+    // mandatory enum `kind`, a top-level `T | null` field, and two nested writableDef
+    // fields (a mandatory array + a `T | null`).
+    let oldJson =
+      %raw(`function(j){
+        var c = JSON.parse(JSON.stringify(j));
+        var d = c.event._0;
+        delete d.kind;
+        delete d.apiSchemaFragment;
+        var agg = d.structure.aggregates[0];
+        delete agg.events;
+        delete agg.chapter;
+        return c;
+      }`)(json)
+
+    // Strict decode must reject the stale JSON — the tolerance is what saves it.
+    let strictThrew = switch oldJson->S.parseJsonOrThrow(
+      Message.toEventSchema'(S.string, PluginSpec.eventSchema),
+    ) {
+    | _ => false
+    | exception _ => true
+    }
+    expect(strictThrew)->toBe(true)
+
+    // Tolerant decode heals: kind -> Domain (first variant), missing array -> [],
+    // missing `T | null` fields -> None.
+    let decoded = oldJson->Message.decodeEvent'(S.string, PluginSpec.eventSchema)
+    switch decoded.event {
+    | VersionConnected(d) =>
+      expect(
+        switch d.kind {
+        | Domain => "Domain"
+        | _ => "other"
+        },
+      )->toBe("Domain")
+      expect(d.apiSchemaFragment->Option.isNone)->toBe(true)
+      let structure: Reventless.Plugin.pluginStructure = d.structure->Option.getOrThrow
+      let agg = structure.aggregates->Array.getUnsafe(0)
+      expect(agg.events->Array.length)->toBe(0)
+      expect(agg.chapter->Option.isNone)->toBe(true)
+    | _ => expect("wrong-variant")->toBe("VersionConnected")
+    }
+  })
+
+  // The exact aggregate-replay path: EventLog_Operations.decodeEvent reassembles the
+  // event variant and calls `Message.decode(Spec.eventSchema)`. This is what actually
+  // bricked in production, so assert `Message.decode` itself heals a stale def.
+  testSync("Message.decode heals a VersionConnected variant missing kind (the replay path)", () => {
+    open PluginSpec
+    let def: Reventless.Plugin.pluginDefinition = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: None,
+      apiTarget: None,
+      uiFragments: None,
+      structure: None,
+      dcbEventLog: None,
+      kind: Domain,
+    }
+    let variantJson = VersionConnected(def)->Message.encode(PluginSpec.eventSchema)
+    let staleJson =
+      %raw(`function(j){ var c = JSON.parse(JSON.stringify(j)); delete c._0.kind; return c; }`)(
+        variantJson,
+      )
+
+    // Strict decode of the stale variant throws (reproduces the production brick).
+    let strictThrew = switch staleJson->S.parseJsonOrThrow(PluginSpec.eventSchema) {
+    | _ => false
+    | exception _ => true
+    }
+    expect(strictThrew)->toBe(true)
+
+    // The replay decoder heals kind -> Domain.
+    switch staleJson->Message.decode(PluginSpec.eventSchema) {
+    | VersionConnected(d) =>
+      expect(
+        switch d.kind {
+        | Domain => "Domain"
+        | _ => "other"
+        },
+      )->toBe("Domain")
+    | _ => expect("wrong-variant")->toBe("VersionConnected")
+    }
+  })
 })

package/tests/message/MessageTest.res.mjs

@@ -89,6 +89,133 @@ globalThis.describe("Message should", () => {
     let eventId = Stdlib_Option.getOrThrow(Message$ReventlessCore.idOfEvent$pJson(eventJson$p), undefined);
     globalThis.expect(eventId).toBe("testId");
   });
+  globalThis.test("tolerantly decode a VersionConnected persisted before kind/structure fields existed", () => {
+    let def = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: undefined,
+      apiTarget: undefined,
+      uiFragments: undefined,
+      structure: {
+        readModels: [],
+        stateViewSlices: [],
+        stateChangeSlices: [],
+        aggregates: [{
+            name: "Order",
+            commands: [],
+            producedEventTypes: [],
+            consumedEventTypes: [],
+            linkedViews: [],
+            consistencyRead: undefined,
+            events: [],
+            chapter: undefined
+          }],
+        automationSlices: [],
+        outboundTranslationSlices: [],
+        inboundTranslationSlices: [],
+        extensions: [],
+        extensionPoints: undefined
+      },
+      dcbEventLog: undefined,
+      kind: "Domain"
+    };
+    let event$p_meta = {
+      service: "svc",
+      time: "t",
+      ip: "ip",
+      user: "u",
+      msgId: "m",
+      correlationId: "c"
+    };
+    let event$p_event = {
+      TAG: "VersionConnected",
+      _0: def
+    };
+    let event$p = {
+      id: "id",
+      meta: event$p_meta,
+      event: event$p_event
+    };
+    let json = Message$ReventlessCore.encodeEvent$p(event$p, S.string, PluginSpec$ReventlessCore.eventSchema);
+    let oldJson = (function(j){
+        var c = JSON.parse(JSON.stringify(j));
+        var d = c.event._0;
+        delete d.kind;
+        delete d.apiSchemaFragment;
+        var agg = d.structure.aggregates[0];
+        delete agg.events;
+        delete agg.chapter;
+        return c;
+      })(json);
+    let strictThrew;
+    try {
+      S.parseJsonOrThrow(oldJson, Message$ReventlessCore.toEventSchema$p(S.string, PluginSpec$ReventlessCore.eventSchema));
+      strictThrew = false;
+    } catch (exn) {
+      strictThrew = true;
+    }
+    globalThis.expect(strictThrew).toBe(true);
+    let decoded = Message$ReventlessCore.decodeEvent$p(oldJson, S.string, PluginSpec$ReventlessCore.eventSchema);
+    let d = decoded.event;
+    if (d.TAG === "VersionConnected") {
+      let d$1 = d._0;
+      let match = d$1.kind;
+      let tmp;
+      tmp = match === "Domain" ? "Domain" : "other";
+      globalThis.expect(tmp).toBe("Domain");
+      globalThis.expect(Stdlib_Option.isNone(d$1.apiSchemaFragment)).toBe(true);
+      let structure = Stdlib_Option.getOrThrow(d$1.structure, undefined);
+      let agg = structure.aggregates[0];
+      globalThis.expect(agg.events.length).toBe(0);
+      globalThis.expect(Stdlib_Option.isNone(agg.chapter)).toBe(true);
+      return;
+    }
+    globalThis.expect("wrong-variant").toBe("VersionConnected");
+  });
+  globalThis.test("Message.decode heals a VersionConnected variant missing kind (the replay path)", () => {
+    let def = {
+      id: "id",
+      name: "Ordering",
+      version: "1.0.0",
+      extensionPoints: [],
+      extensions: [],
+      eventCollector: "arn",
+      extensionProtocols: [],
+      apiSchemaFragment: undefined,
+      apiTarget: undefined,
+      uiFragments: undefined,
+      structure: undefined,
+      dcbEventLog: undefined,
+      kind: "Domain"
+    };
+    let variantJson = Message$ReventlessCore.encode({
+      TAG: "VersionConnected",
+      _0: def
+    }, PluginSpec$ReventlessCore.eventSchema);
+    let staleJson = (function(j){ var c = JSON.parse(JSON.stringify(j)); delete c._0.kind; return c; })(variantJson);
+    let strictThrew;
+    try {
+      S.parseJsonOrThrow(staleJson, PluginSpec$ReventlessCore.eventSchema);
+      strictThrew = false;
+    } catch (exn) {
+      strictThrew = true;
+    }
+    globalThis.expect(strictThrew).toBe(true);
+    let d = Message$ReventlessCore.decode(staleJson, PluginSpec$ReventlessCore.eventSchema);
+    if (d.TAG === "VersionConnected") {
+      let match = d._0.kind;
+      let tmp;
+      tmp = match === "Domain" ? "Domain" : "other";
+      globalThis.expect(tmp).toBe("Domain");
+      return;
+    }
+    globalThis.expect("wrong-variant").toBe("VersionConnected");
+  });
 });
 
 /*  Not a pure module */