@reventlessdev/reventless-core 3.0.0-alpha.179 → 3.0.0-alpha.181

package/tests/message/MetaEnvelopeTest.res.mjs

@@ -0,0 +1,188 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+
+globalThis.describe("Message.meta optional fields:", () => {
+  globalThis.test("generateMeta() with no ~ip/~user omits those keys from JSON", () => {
+    let meta = Message$ReventlessCore.generateMeta("svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let json = S.reverseConvertToJsonOrThrow(meta, Message$ReventlessCore.metaSchema);
+    let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(json), undefined);
+    globalThis.expect(obj["ip"]).toEqual(undefined);
+    globalThis.expect(obj["user"]).toEqual(undefined);
+    globalThis.expect(obj["causationId"]).toEqual(undefined);
+    globalThis.expect(obj["traceparent"]).toEqual(undefined);
+    globalThis.expect(obj["schemaVersion"]).toEqual(undefined);
+    globalThis.expect(obj["headers"]).toEqual(undefined);
+    globalThis.expect(Stdlib_Option.isSome(obj["service"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isSome(obj["time"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isSome(obj["msgId"])).toBe(true);
+    globalThis.expect(Stdlib_Option.isSome(obj["correlationId"])).toBe(true);
+  });
+  globalThis.test("generateMeta() correlationId defaults to msgId", () => {
+    let meta = Message$ReventlessCore.generateMeta("svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    globalThis.expect(meta.correlationId).toBe(meta.msgId);
+  });
+  globalThis.test("generateMeta(~user=alice) round-trips Some(alice)", () => {
+    let meta = Message$ReventlessCore.generateMeta("svc", undefined, "alice", undefined, undefined, undefined, undefined, undefined);
+    let json = S.reverseConvertToJsonOrThrow(meta, Message$ReventlessCore.metaSchema);
+    let decoded = S.parseJsonOrThrow(json, Message$ReventlessCore.metaSchema);
+    globalThis.expect(decoded.user).toEqual("alice");
+  });
+  globalThis.test("all new optional fields round-trip when set", () => {
+    let headers = Object.fromEntries([
+      [
+        "tenantId",
+        "t1"
+      ],
+      [
+        "feature.x",
+        "on"
+      ]
+    ]);
+    let meta = Message$ReventlessCore.generateMeta("svc", "10.0.0.1", "bob", "parent-msg-id", "00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01", "root-msg-id", "1.2.0", headers);
+    let json = S.reverseConvertToJsonOrThrow(meta, Message$ReventlessCore.metaSchema);
+    let decoded = S.parseJsonOrThrow(json, Message$ReventlessCore.metaSchema);
+    globalThis.expect(decoded.ip).toEqual("10.0.0.1");
+    globalThis.expect(decoded.user).toEqual("bob");
+    globalThis.expect(decoded.causationId).toEqual("parent-msg-id");
+    globalThis.expect(decoded.traceparent).toEqual("00-0af7651916cd43dd8448eb211c80319c-b7ad6b7169203331-01");
+    globalThis.expect(decoded.correlationId).toBe("root-msg-id");
+    globalThis.expect(decoded.schemaVersion).toEqual("1.2.0");
+    globalThis.expect(Stdlib_Option.getOr(decoded.headers, {})["tenantId"]).toEqual("t1");
+  });
+});
+
+globalThis.describe("Message.deriveMeta:", () => {
+  globalThis.test("emits a new msgId distinct from the parent", () => {
+    let parent = Message$ReventlessCore.generateMeta("svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let child = Message$ReventlessCore.deriveMeta(parent, undefined);
+    globalThis.expect(child.msgId === parent.msgId).toBe(false);
+  });
+  globalThis.test("sets causationId = parent.msgId", () => {
+    let parent = Message$ReventlessCore.generateMeta("svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let child = Message$ReventlessCore.deriveMeta(parent, undefined);
+    globalThis.expect(child.causationId).toEqual(parent.msgId);
+  });
+  globalThis.test("inherits correlationId (chain-root id stays stable)", () => {
+    let root = Message$ReventlessCore.generateMeta("svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let mid = Message$ReventlessCore.deriveMeta(root, undefined);
+    let leaf = Message$ReventlessCore.deriveMeta(mid, undefined);
+    globalThis.expect(mid.correlationId).toBe(root.correlationId);
+    globalThis.expect(leaf.correlationId).toBe(root.correlationId);
+    globalThis.expect(leaf.causationId).toEqual(mid.msgId);
+  });
+  globalThis.test("inherits ip/user/traceparent/schemaVersion/headers from parent", () => {
+    let parent = Message$ReventlessCore.generateMeta("svc", "10.0.0.1", "alice", undefined, "tp", undefined, "1", Object.fromEntries([[
+        "k",
+        "v"
+      ]]));
+    let child = Message$ReventlessCore.deriveMeta(parent, undefined);
+    globalThis.expect(child.ip).toEqual("10.0.0.1");
+    globalThis.expect(child.user).toEqual("alice");
+    globalThis.expect(child.traceparent).toEqual("tp");
+    globalThis.expect(child.schemaVersion).toEqual("1");
+    globalThis.expect(Stdlib_Option.getOr(child.headers, {})["k"]).toEqual("v");
+  });
+  globalThis.test("~service overrides parent's service; defaults to parent's service", () => {
+    let parent = Message$ReventlessCore.generateMeta("parent-svc", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let inherited = Message$ReventlessCore.deriveMeta(parent, undefined);
+    let overridden = Message$ReventlessCore.deriveMeta(parent, "child-svc");
+    globalThis.expect(inherited.service).toBe("parent-svc");
+    globalThis.expect(overridden.service).toBe("child-svc");
+  });
+});
+
+globalThis.describe("StoredEvent encode/decode round-trip:", () => {
+  globalThis.test("aggregate-style record (no tags) round-trips through the flat-dict bridge", () => {
+    let meta = Message$ReventlessCore.generateMeta("catalog", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let stored_data = Object.fromEntries([
+      [
+        "itemId",
+        "agg-1"
+      ],
+      [
+        "name",
+        "Widget"
+      ]
+    ]);
+    let stored = {
+      id: "agg-1",
+      position: "000000001",
+      event: "ItemCreated",
+      data: stored_data,
+      meta: meta,
+      recordedAt: "2026-05-13T10:00:00.000Z"
+    };
+    let flat = Message$ReventlessCore.storedEventToFlatJson(stored, S.string);
+    let roundTrip = Message$ReventlessCore.flatJsonToStoredEvent(flat, S.string);
+    globalThis.expect(roundTrip.id).toBe("agg-1");
+    globalThis.expect(roundTrip.position).toBe("000000001");
+    globalThis.expect(roundTrip.event).toBe("ItemCreated");
+    globalThis.expect(roundTrip.recordedAt).toBe("2026-05-13T10:00:00.000Z");
+    globalThis.expect(roundTrip.meta.msgId).toBe(meta.msgId);
+    globalThis.expect(roundTrip.meta.correlationId).toBe(meta.correlationId);
+    globalThis.expect(roundTrip.tags).toEqual(undefined);
+  });
+  globalThis.test("DCB-style record (with tags) round-trips and preserves the tag list", () => {
+    let meta = Message$ReventlessCore.generateMeta("catalog", undefined, undefined, "cmd-1", undefined, undefined, undefined, undefined);
+    let stored_data = Object.fromEntries([[
+        "productId",
+        "p-1"
+      ]]);
+    let stored_tags = [
+      {
+        key: "productId",
+        value: "p-1"
+      },
+      {
+        key: "categoryId",
+        value: "c-1"
+      }
+    ];
+    let stored = {
+      id: "productId:p-1",
+      position: "1736782800000-abc-uuid",
+      event: "ProductAdded",
+      data: stored_data,
+      meta: meta,
+      recordedAt: "2026-05-13T10:00:00.000Z",
+      tags: stored_tags
+    };
+    let flat = Message$ReventlessCore.storedEventToFlatJson(stored, S.string);
+    let roundTrip = Message$ReventlessCore.flatJsonToStoredEvent(flat, S.string);
+    globalThis.expect(roundTrip.id).toBe("productId:p-1");
+    globalThis.expect(roundTrip.position).toBe("1736782800000-abc-uuid");
+    globalThis.expect(roundTrip.event).toBe("ProductAdded");
+    globalThis.expect(roundTrip.meta.causationId).toEqual("cmd-1");
+    let tags = Stdlib_Option.getOrThrow(roundTrip.tags, undefined);
+    globalThis.expect(tags.length).toBe(2);
+    let first = tags[0];
+    globalThis.expect(first.key).toBe("productId");
+    globalThis.expect(first.value).toBe("p-1");
+  });
+  globalThis.test("meta is flattened to top-level keys in the on-disk JSON (DynamoDB GSI projectability)", () => {
+    let meta = Message$ReventlessCore.generateMeta("catalog", undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+    let stored_data = {};
+    let stored = {
+      id: "agg-1",
+      position: "000000001",
+      event: "ItemCreated",
+      data: stored_data,
+      meta: meta,
+      recordedAt: "2026-05-13T10:00:00.000Z"
+    };
+    let flat = Message$ReventlessCore.storedEventToFlatJson(stored, S.string);
+    let obj = Stdlib_Option.getOrThrow(Stdlib_JSON.Decode.object(flat), undefined);
+    globalThis.expect(obj["meta"]).toEqual(undefined);
+    globalThis.expect(obj["service"]).toEqual("catalog");
+    globalThis.expect(Stdlib_Option.isSome(obj["msgId"])).toBe(true);
+    globalThis.expect(obj["position"]).toEqual("000000001");
+    globalThis.expect(obj["event"]).toEqual("ItemCreated");
+    globalThis.expect(obj["recordedAt"]).toEqual("2026-05-13T10:00:00.000Z");
+  });
+});
+
+/*  Not a pure module */

package/tests/plugin/HeartbeatDisconnectGraceTest.res.mjs

@@ -0,0 +1,91 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Array from "@rescript/runtime/lib/es6/Stdlib_Array.js";
+import * as Message$ReventlessCore from "../../src/Message.res.mjs";
+import * as PluginExtensionPoint_Plugin$ReventlessCore from "../../src/plugin/connect/PluginExtensionPoint_Plugin.res.mjs";
+
+let TestMapping = PluginExtensionPoint_Plugin$ReventlessCore.Make({
+  runtimeOps: undefined,
+  environment: "test",
+  updateApiSchema: undefined,
+  manageSubscriptions: undefined
+});
+
+function graceFromActions(actions) {
+  return Stdlib_Array.findMap(actions, action => {
+    if (action.TAG === "PublishCommand") {
+      return;
+    }
+    let match = action._1;
+    if (match.TAG === "CreateDisconnectSchedule") {
+      return match._1;
+    }
+  });
+}
+
+let meta = Message$ReventlessCore.generateMeta("test", undefined, "test", undefined, undefined, undefined, undefined, undefined);
+
+globalThis.describe("disconnectGrace", () => {
+  globalThis.test("scales with the interval (5→7, 10→15, 60→90)", () => {
+    globalThis.expect(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(5)).toBe(7);
+    globalThis.expect(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(10)).toBe(15);
+    globalThis.expect(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(60)).toBe(90);
+  });
+  globalThis.test("always leaves at least a full interval of headroom past one beat", () => {
+    [
+      1,
+      2,
+      5,
+      10,
+      30,
+      60,
+      120
+    ].forEach(interval => {
+      let grace = PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(interval);
+      globalThis.expect(grace > interval).toBe(true);
+      globalThis.expect(grace >= (interval + 2 | 0)).toBe(true);
+    });
+  });
+  globalThis.test("a 60-min cadence gets far more than the old fixed +2 grace", () => {
+    globalThis.expect(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(60) > 62).toBe(true);
+  });
+});
+
+globalThis.describe("PluginExtensionPoint mapping arms the disconnect schedule from the beat interval", () => {
+  globalThis.test("Heartbeat(interval) → CreateDisconnectSchedule(_, disconnectGrace(interval))", () => {
+    [
+      5,
+      10,
+      60
+    ].forEach(interval => {
+      let actions = TestMapping.PluginMapping.mapIncomingCommand("Test@1", {
+        TAG: "Heartbeat",
+        _0: interval
+      }, meta);
+      globalThis.expect(graceFromActions(actions)).toEqual(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(interval));
+    });
+  });
+  globalThis.test("RedetectPlugin(interval) arms the same interval-derived grace as a heartbeat", () => {
+    [
+      5,
+      10,
+      60
+    ].forEach(interval => {
+      let actions = TestMapping.PluginMapping.mapIncomingCommand("Test@1", {
+        TAG: "RedetectPlugin",
+        _0: interval
+      }, meta);
+      globalThis.expect(graceFromActions(actions)).toEqual(PluginExtensionPoint_Plugin$ReventlessCore.disconnectGrace(interval));
+    });
+  });
+});
+
+let PluginExtensionPointSpec;
+
+export {
+  PluginExtensionPointSpec,
+  TestMapping,
+  graceFromActions,
+  meta,
+}
+/* TestMapping Not a pure module */

package/tests/plugin/ManifestVisibilityTest.res.mjs

@@ -0,0 +1,215 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Id$Reventless from "@reventlessdev/reventless-spec/src/types/Id.res.mjs";
+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 ReadModel$Reventless from "@reventlessdev/reventless-spec/src/components/ReadModel.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+
+let name = "PublicView";
+
+let moduleUrl = "";
+
+let stateSchema = S.schema(s => ({
+  id: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let config = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let PublicSpec = {
+  Id: undefined,
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let name$1 = "InternalView";
+
+let moduleUrl$1 = "";
+
+let stateSchema$1 = S.schema(s => ({
+  id: s.m(S.string),
+  name: s.m(S.string)
+}));
+
+let config$1 = ReadModel$Reventless.config(undefined, undefined, undefined);
+
+let InternalSpec = {
+  Id: undefined,
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  visibility: "Internal",
+  authorization: "AllowAuthenticated"
+};
+
+let sourceNames = [];
+
+let consumedEventNames = ["OrderPlaced"];
+
+function make(param, param$1, param$2, param$3, param$4) {
+  return 0;
+}
+
+function outputs(param) {
+  return 0;
+}
+
+function operations(param) {
+  return 0;
+}
+
+function finish() {
+  
+}
+
+let PublicReadModel_Spec = {
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name,
+  moduleUrl: moduleUrl,
+  stateSchema: stateSchema,
+  config: config,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Public"
+};
+
+let PublicReadModel = {
+  Spec: PublicReadModel_Spec,
+  sourceNames: sourceNames,
+  consumedEventNames: consumedEventNames,
+  make: make,
+  outputs: outputs,
+  operations: operations,
+  finish: finish
+};
+
+let sourceNames$1 = [];
+
+let consumedEventNames$1 = [];
+
+function make$1(param, param$1, param$2, param$3, param$4) {
+  return 0;
+}
+
+function outputs$1(param) {
+  return 0;
+}
+
+function operations$1(param) {
+  return 0;
+}
+
+function finish$1() {
+  
+}
+
+let InternalReadModel_Spec = {
+  Id: {
+    schema: Id$Reventless.StringPure.schema,
+    make: prim => prim,
+    makeFromString: prim => prim,
+    toString: prim => prim,
+    cmp: Id$Reventless.StringPure.cmp
+  },
+  name: name$1,
+  moduleUrl: moduleUrl$1,
+  stateSchema: stateSchema$1,
+  config: config$1,
+  subIdConfig: undefined,
+  authorization: "AllowAuthenticated",
+  visibility: "Internal"
+};
+
+let InternalReadModel = {
+  Spec: InternalReadModel_Spec,
+  sourceNames: sourceNames$1,
+  consumedEventNames: consumedEventNames$1,
+  make: make$1,
+  outputs: outputs$1,
+  operations: operations$1,
+  finish: finish$1
+};
+
+function isVisible(R) {
+  let match = R.Spec.visibility;
+  return match === "Public";
+}
+
+let readModels = [
+  PublicReadModel,
+  InternalReadModel
+];
+
+globalThis.describe("ReadModel visibility filter", () => {
+  globalThis.test("PPX defaults visibility to Public when no attribute is present", () => {
+    globalThis.expect("Public").toEqual("Public");
+  });
+  globalThis.test("Internal spec retains Internal value", () => {
+    globalThis.expect("Internal").toEqual("Internal");
+  });
+  globalThis.test("filter predicate excludes Internal", () => {
+    let visible = readModels.filter(isVisible);
+    globalThis.expect(visible.length).toBe(1);
+  });
+  globalThis.test("filter predicate retains Public name", () => {
+    let visible = readModels.filter(isVisible);
+    let first = visible[0];
+    globalThis.expect(first.Spec.name).toEqual("PublicView");
+  });
+  globalThis.test("unfiltered list still contains both entries (no over-filtering)", () => {
+    globalThis.expect(readModels.length).toBe(2);
+  });
+});
+
+globalThis.describe("Plugin_Structure.make — visibility tagging", () => {
+  let structure = Plugin_Structure$ReventlessCore.make("VisibilityPlugin", undefined, readModels, undefined, undefined, undefined, undefined, undefined, undefined, undefined, undefined);
+  globalThis.test("readModels carries both Public and Internal entries", () => {
+    globalThis.expect(structure.readModels.length).toBe(2);
+  });
+  globalThis.test("the Public entry is tagged visibility = None", () => {
+    let $$public = structure.readModels.find(d => d.name === "PublicView");
+    globalThis.expect(Stdlib_Option.map($$public, d => d.visibility)).toEqual(Primitive_option.some(undefined));
+  });
+  globalThis.test("the Internal entry is carried and tagged visibility = Some(\"Internal\")", () => {
+    let internal = structure.readModels.find(d => d.name === "InternalView");
+    globalThis.expect(Stdlib_Option.map(internal, d => d.visibility)).toEqual("Internal");
+  });
+  globalThis.test("a read model's mapping-consumed events surface as qualified consumedEventTypes", () => {
+    let $$public = structure.readModels.find(d => d.name === "PublicView");
+    globalThis.expect(Stdlib_Option.map($$public, d => d.consumedEventTypes)).toEqual(["VisibilityPlugin.OrderPlaced"]);
+  });
+  globalThis.test("aggregates / stateViewSlices stay empty when none are passed (sanity)", () => {
+    globalThis.expect([
+      structure.aggregates.length,
+      structure.stateViewSlices.length
+    ]).toEqual([
+      0,
+      0
+    ]);
+  });
+});
+
+export {
+  PublicSpec,
+  InternalSpec,
+  PublicReadModel,
+  InternalReadModel,
+  isVisible,
+  readModels,
+}
+/* stateSchema Not a pure module */

package/tests/plugin/PluginSpecExperiment.res.mjs

@@ -0,0 +1,31 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+
+S.enableJson();
+
+let recordSchema = S.schema(s => ({
+  a: s.m(S.meta(S.string, {
+    description: "aaa"
+  })),
+  b: s.m(S.string)
+}));
+
+let variantSchema = S.union([
+  S.schema(s => ({
+    TAG: "Q",
+    _0: s.m(S.int)
+  })),
+  S.literal("X"),
+  S.literal("Y")
+]);
+
+console.log("Record:", JSON.stringify(S.toJSONSchema(recordSchema), undefined, 2));
+
+console.log("Variant:", JSON.stringify(S.toJSONSchema(variantSchema), undefined, 2));
+
+export {
+  recordSchema,
+  variantSchema,
+}
+/*  Not a pure module */

package/tests/plugin/PluginStructureTest.res

@@ -159,6 +159,41 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       expect(shipOrder.commands->Array.map(c => c.name))->toEqual(["ShipOrder", "CancelShipment"])
     })
 
+    testSync("ShipOrder: the @noApi CancelShipment is tagged apiExposed=false; ShipOrder stays exposed", () => {
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let byName = name => shipOrder.commands->Array.find(c => c.name == name)
+      expect((
+        byName("ShipOrder")->Option.flatMap(c => c.apiExposed),
+        byName("CancelShipment")->Option.flatMap(c => c.apiExposed),
+      ))->toEqual((Some(true), Some(false)))
+    })
+
+    testSync("ShipOrder: @targetState(\"Shipped\") flows through the PPX to commandDef.targetState", () => {
+      // End-to-end: the reventless-ppx @targetState annotation → markTargetState
+      // metadata → ApiTargetStateHelpers.getTargetState → commandDef. The
+      // un-annotated CancelShipment carries None (resolver falls back to
+      // name-stem).
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let byName = name => shipOrder.commands->Array.find(c => c.name == name)
+      expect((
+        byName("ShipOrder")->Option.flatMap(c => c.targetState),
+        byName("CancelShipment")->Option.flatMap(c => c.targetState),
+      ))->toEqual((Some("Shipped"), None))
+    })
+
+    testSync("ShipOrder: the @noApi variant carries no callable mutation field (no sibling leak)", () => {
+      // Regression: for a single-exposed-command slice, `mutationFieldFor`
+      // resolves every variant — including the @noApi one — to the slice's one
+      // mutation field. The non-exposed variant must not carry that sibling
+      // field; it emits an empty sentinel instead, while the exposed command
+      // keeps a real, non-empty field.
+      let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
+      let byName = name => shipOrder.commands->Array.find(c => c.name == name)
+      let shipField = byName("ShipOrder")->Option.map(c => c.mutationField)->Option.getOr("")
+      let cancelField = byName("CancelShipment")->Option.map(c => c.mutationField)->Option.getOr("x")
+      expect((shipField->String.length > 0, cancelField))->toEqual((true, ""))
+    })
+
     testSync("ShipOrder: payload-less event ShipmentVoided is surfaced in events", () => {
       let shipOrder = structure.stateChangeSlices->Array.getUnsafe(1)
       expect(shipOrder.events->Array.map(e => e.name))->toEqual(["OrderShipped", "ShipmentVoided"])
@@ -278,6 +313,26 @@ describe("Plugin_Structure.make — Phase 2 graph fields", () => {
       )->toBe(Some("byOwner"))
     })
 
+    testSync("@semantic(\"currency\") flows through the PPX to x-reventless-semantic", () => {
+      expect(
+        annotatedSchema
+        ->getPropertyOf("total")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-semantic"))
+        ->Option.flatMap(JSON.Decode.string),
+      )->toBe(Some("currency"))
+    })
+
+    testSync("@metric flows through the PPX to x-reventless-metric {aggregate,label}", () => {
+      let metricObj =
+        annotatedSchema
+        ->getPropertyOf("total")
+        ->Option.flatMap(s => getProperty(s, "x-reventless-metric"))
+      expect((
+        metricObj->Option.flatMap(m => getProperty(m, "aggregate"))->Option.flatMap(JSON.Decode.string),
+        metricObj->Option.flatMap(m => getProperty(m, "label"))->Option.flatMap(JSON.Decode.string),
+      ))->toEqual((Some("sum"), Some("Revenue")))
+    })
+
     testSync("unannotated field 'name' has no x-reventless-* keys", () => {
       let nameField = annotatedSchema->getPropertyOf("name")
       expect((