@reventlessdev/reventless-core 3.0.0-alpha.134

package/tests/plugin/PluginStructureTest.res.mjs

@@ -0,0 +1,388 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_JSON from "@rescript/runtime/lib/es6/Stdlib_JSON.js";
+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 PsShipOrder$ReventlessCore from "./StateChangeSlice/PsShipOrder.res.mjs";
+import * as PsOrdersView$ReventlessCore from "./StateViewSlice/PsOrdersView.res.mjs";
+import * as PsPlaceOrder$ReventlessCore from "./StateChangeSlice/PsPlaceOrder.res.mjs";
+import * as PsAnnotatedView$ReventlessCore from "./StateViewSlice/PsAnnotatedView.res.mjs";
+import * as PsCustomersView$ReventlessCore from "./StateViewSlice/PsCustomersView.res.mjs";
+import * as Plugin_Structure$ReventlessCore from "../../src/plugin/component/Plugin_Structure.res.mjs";
+import * as PsAvailableProductsView$ReventlessCore from "./StateViewSlice/PsAvailableProductsView.res.mjs";
+
+let Behavior = {
+  initialState: false,
+  evolve: PsPlaceOrder$ReventlessCore.evolve,
+  decide: PsPlaceOrder$ReventlessCore.decide,
+  moduleUrl: PsPlaceOrder$ReventlessCore.moduleUrl
+};
+
+function make(param, param$1, param$2, param$3, param$4) {
+  return 0;
+}
+
+let PsPlaceOrderSlice_Spec = {
+  name: PsPlaceOrder$ReventlessCore.name,
+  moduleUrl: PsPlaceOrder$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsPlaceOrder$ReventlessCore.consumedEventSchema,
+  errorSchema: PsPlaceOrder$ReventlessCore.errorSchema,
+  eventSchema: PsPlaceOrder$ReventlessCore.eventSchema,
+  commandSchema: PsPlaceOrder$ReventlessCore.commandSchema,
+  commandAuthorization: PsPlaceOrder$ReventlessCore.commandAuthorization,
+  readConsistency: PsPlaceOrder$ReventlessCore.readConsistency
+};
+
+let PsPlaceOrderSlice = {
+  Spec: PsPlaceOrderSlice_Spec,
+  Behavior: Behavior,
+  isAsync: false,
+  make: make
+};
+
+let Behavior$1 = {
+  initialState: false,
+  evolve: PsShipOrder$ReventlessCore.evolve,
+  decide: PsShipOrder$ReventlessCore.decide,
+  moduleUrl: PsShipOrder$ReventlessCore.moduleUrl
+};
+
+function make$1(param, param$1, param$2, param$3, param$4) {
+  return 0;
+}
+
+let PsShipOrderSlice_Spec = {
+  name: PsShipOrder$ReventlessCore.name,
+  moduleUrl: PsShipOrder$ReventlessCore.moduleUrl,
+  Id: Id$Reventless.$$String,
+  consumedEventSchema: PsShipOrder$ReventlessCore.consumedEventSchema,
+  errorSchema: PsShipOrder$ReventlessCore.errorSchema,
+  eventSchema: PsShipOrder$ReventlessCore.eventSchema,
+  commandSchema: PsShipOrder$ReventlessCore.commandSchema,
+  commandAuthorization: PsShipOrder$ReventlessCore.commandAuthorization,
+  readConsistency: PsShipOrder$ReventlessCore.readConsistency
+};
+
+let PsShipOrderSlice = {
+  Spec: PsShipOrderSlice_Spec,
+  Behavior: Behavior$1,
+  isAsync: false,
+  make: make$1
+};
+
+let Projection = {
+  project: PsOrdersView$ReventlessCore.project,
+  moduleUrl: PsOrdersView$ReventlessCore.moduleUrl
+};
+
+function make$2(param, param$1) {
+  return 0;
+}
+
+let PsOrdersViewSlice_Spec = {
+  name: PsOrdersView$ReventlessCore.name,
+  moduleUrl: PsOrdersView$ReventlessCore.moduleUrl,
+  stateSchema: PsOrdersView$ReventlessCore.stateSchema,
+  consumedEventSchema: PsOrdersView$ReventlessCore.consumedEventSchema,
+  config: PsOrdersView$ReventlessCore.config,
+  subIdConfig: undefined,
+  authorization: PsOrdersView$ReventlessCore.authorization,
+  visibility: PsOrdersView$ReventlessCore.visibility
+};
+
+let PsOrdersViewSlice = {
+  Spec: PsOrdersViewSlice_Spec,
+  Projection: Projection,
+  make: make$2
+};
+
+let Projection$1 = {
+  project: PsAvailableProductsView$ReventlessCore.project,
+  moduleUrl: PsAvailableProductsView$ReventlessCore.moduleUrl
+};
+
+function make$3(param, param$1) {
+  return 0;
+}
+
+let PsAvailableProductsViewSlice_Spec = {
+  name: PsAvailableProductsView$ReventlessCore.name,
+  moduleUrl: PsAvailableProductsView$ReventlessCore.moduleUrl,
+  stateSchema: PsAvailableProductsView$ReventlessCore.stateSchema,
+  consumedEventSchema: PsAvailableProductsView$ReventlessCore.consumedEventSchema,
+  config: PsAvailableProductsView$ReventlessCore.config,
+  subIdConfig: undefined,
+  authorization: PsAvailableProductsView$ReventlessCore.authorization,
+  visibility: PsAvailableProductsView$ReventlessCore.visibility
+};
+
+let PsAvailableProductsViewSlice = {
+  Spec: PsAvailableProductsViewSlice_Spec,
+  Projection: Projection$1,
+  make: make$3
+};
+
+let Projection$2 = {
+  project: PsCustomersView$ReventlessCore.project,
+  moduleUrl: PsCustomersView$ReventlessCore.moduleUrl
+};
+
+function make$4(param, param$1) {
+  return 0;
+}
+
+let PsCustomersViewSlice_Spec = {
+  name: PsCustomersView$ReventlessCore.name,
+  moduleUrl: PsCustomersView$ReventlessCore.moduleUrl,
+  stateSchema: PsCustomersView$ReventlessCore.stateSchema,
+  consumedEventSchema: PsCustomersView$ReventlessCore.consumedEventSchema,
+  config: PsCustomersView$ReventlessCore.config,
+  subIdConfig: undefined,
+  authorization: PsCustomersView$ReventlessCore.authorization,
+  visibility: PsCustomersView$ReventlessCore.visibility
+};
+
+let PsCustomersViewSlice = {
+  Spec: PsCustomersViewSlice_Spec,
+  Projection: Projection$2,
+  make: make$4
+};
+
+let Projection$3 = {
+  project: PsAnnotatedView$ReventlessCore.project,
+  moduleUrl: PsAnnotatedView$ReventlessCore.moduleUrl
+};
+
+function make$5(param, param$1) {
+  return 0;
+}
+
+let PsAnnotatedViewSlice_Spec = {
+  name: PsAnnotatedView$ReventlessCore.name,
+  moduleUrl: PsAnnotatedView$ReventlessCore.moduleUrl,
+  stateSchema: PsAnnotatedView$ReventlessCore.stateSchema,
+  consumedEventSchema: PsAnnotatedView$ReventlessCore.consumedEventSchema,
+  config: PsAnnotatedView$ReventlessCore.config,
+  subIdConfig: PsAnnotatedView$ReventlessCore.subIdConfig,
+  authorization: PsAnnotatedView$ReventlessCore.authorization,
+  visibility: PsAnnotatedView$ReventlessCore.visibility
+};
+
+let PsAnnotatedViewSlice = {
+  Spec: PsAnnotatedViewSlice_Spec,
+  Projection: Projection$3,
+  make: make$5
+};
+
+let structure = Plugin_Structure$ReventlessCore.make("TestPlugin", undefined, undefined, [
+  PsOrdersViewSlice,
+  PsAvailableProductsViewSlice,
+  PsCustomersViewSlice,
+  PsAnnotatedViewSlice
+], [
+  PsPlaceOrderSlice,
+  PsShipOrderSlice
+], undefined, undefined, undefined, undefined, undefined);
+
+globalThis.describe("Plugin_Structure.make — Phase 2 graph fields", () => {
+  globalThis.describe("stateChangeSlices", () => {
+    globalThis.test("produces two SCS entries in declaration order", () => {
+      globalThis.expect(structure.stateChangeSlices.length).toBe(2);
+    });
+    globalThis.test("PlaceOrder: producedEventTypes contains OrderPlaced (qualified)", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.producedEventTypes).toEqual(["TestPlugin.OrderPlaced"]);
+    });
+    globalThis.test("PlaceOrder: consumedEventTypes contains CatalogProductSynced qualified (payload-less variants excluded)", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.consumedEventTypes).toEqual(["TestPlugin.CatalogProductSynced"]);
+    });
+    globalThis.test("PlaceOrder: linkedViews contains Orders (consumes its OrderPlaced)", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.linkedViews).toEqual(["Orders"]);
+    });
+    globalThis.test("PlaceOrder: consistencyRead is AvailableProducts (only SVS consuming CatalogProductSynced)", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      globalThis.expect(placeOrder.consistencyRead).toEqual("AvailableProducts");
+    });
+    globalThis.test("PlaceOrder command: level Collection (creation command), aggregateIdField orderId for UUID injection", () => {
+      let placeOrder = structure.stateChangeSlices[0];
+      let cmd = placeOrder.commands[0];
+      globalThis.expect([
+        cmd.level,
+        cmd.aggregateIdField
+      ]).toEqual([
+        "Collection",
+        "orderId"
+      ]);
+    });
+    globalThis.test("ShipOrder: producedEventTypes contains OrderShipped (qualified)", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.producedEventTypes).toEqual(["TestPlugin.OrderShipped"]);
+    });
+    globalThis.test("ShipOrder: consumedEventTypes is empty (all consumed events are payload-less literals)", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.consumedEventTypes).toEqual([]);
+    });
+    globalThis.test("ShipOrder: linkedViews contains Orders (consumes its OrderShipped)", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.linkedViews).toEqual(["Orders"]);
+    });
+    globalThis.test("ShipOrder: consistencyRead is None (empty consumedEventTypes cannot overlap any SVS)", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.consistencyRead).toEqual(undefined);
+    });
+    globalThis.test("ShipOrder command: level Instance, aggregateIdField orderId", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      let cmd = shipOrder.commands[0];
+      globalThis.expect([
+        cmd.level,
+        cmd.aggregateIdField
+      ]).toEqual([
+        "Instance",
+        "orderId"
+      ]);
+    });
+    globalThis.test("ShipOrder: payload-less command CancelShipment is surfaced in commands", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.commands.map(c => c.name)).toEqual([
+        "ShipOrder",
+        "CancelShipment"
+      ]);
+    });
+    globalThis.test("ShipOrder: payload-less event ShipmentVoided is surfaced in events", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.events.map(e => e.name)).toEqual([
+        "OrderShipped",
+        "ShipmentVoided"
+      ]);
+    });
+    globalThis.test("ShipOrder: producedEventTypes still excludes the payload-less ShipmentVoided (DCB filter intact)", () => {
+      let shipOrder = structure.stateChangeSlices[1];
+      globalThis.expect(shipOrder.producedEventTypes).toEqual(["TestPlugin.OrderShipped"]);
+    });
+  });
+  globalThis.describe("stateViewSlices", () => {
+    globalThis.test("produces four SVS entries in declaration order", () => {
+      globalThis.expect(structure.stateViewSlices.length).toBe(4);
+    });
+    globalThis.test("OrdersView: consumedEventTypes contains the three order events (qualified)", () => {
+      let ordersView = structure.stateViewSlices[0];
+      globalThis.expect(ordersView.consumedEventTypes).toEqual([
+        "TestPlugin.OrderPlaced",
+        "TestPlugin.OrderShipped",
+        "TestPlugin.OrderCancelled"
+      ]);
+    });
+    globalThis.test("OrdersView: linkedWriteSide contains both SCS producing order events", () => {
+      let ordersView = structure.stateViewSlices[0];
+      globalThis.expect(ordersView.linkedWriteSide).toEqual([
+        "PlaceOrder",
+        "ShipOrder"
+      ]);
+    });
+    globalThis.test("AvailableProductsView: consumedEventTypes contains catalog events (qualified)", () => {
+      let apv = structure.stateViewSlices[1];
+      globalThis.expect(apv.consumedEventTypes).toEqual([
+        "TestPlugin.CatalogProductSynced",
+        "TestPlugin.CatalogProductPriceChanged"
+      ]);
+    });
+    globalThis.test("AvailableProductsView: linkedWriteSide is empty (no SCS produces these events)", () => {
+      let apv = structure.stateViewSlices[1];
+      globalThis.expect(apv.linkedWriteSide).toEqual([]);
+    });
+  });
+  globalThis.describe("labelField / searchableFields", () => {
+    globalThis.test("OrdersView: no @displayName → first non-`*Id` string field wins (customerName)", () => {
+      let ordersView = structure.stateViewSlices[0];
+      globalThis.expect([
+        ordersView.labelField,
+        ordersView.searchableFields
+      ]).toEqual([
+        "customerName",
+        ["customerName"]
+      ]);
+    });
+    globalThis.test("AvailableProductsView: no @displayName → first non-`*Id` string field wins (name)", () => {
+      let apv = structure.stateViewSlices[1];
+      globalThis.expect([
+        apv.labelField,
+        apv.searchableFields
+      ]).toEqual([
+        "name",
+        ["name"]
+      ]);
+    });
+    globalThis.test("Customers: composite @displayName → labelField=displayName, searchableFields=raw source fields in declaration order", () => {
+      let customers = structure.stateViewSlices[2];
+      globalThis.expect([
+        customers.labelField,
+        customers.searchableFields
+      ]).toEqual([
+        "displayName",
+        [
+          "firstName",
+          "lastName"
+        ]
+      ]);
+    });
+  });
+  globalThis.describe("queryableDef.schema propagates x-reventless-* annotations", () => {
+    let getProperty = (json, key) => {
+      let obj = Stdlib_JSON.Decode.object(json);
+      if (obj !== undefined) {
+        return obj[key];
+      }
+    };
+    let getPropertyOf = (json, fieldName) => {
+      let props = getProperty(json, "properties");
+      if (props === undefined) {
+        return;
+      }
+      let obj = Stdlib_JSON.Decode.object(props);
+      if (obj !== undefined) {
+        return obj[fieldName];
+      }
+    };
+    let annotatedSchema = JSON.parse(structure.stateViewSlices[3].schema);
+    globalThis.test("itemId carries x-reventless-id", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "itemId"), s => getProperty(s, "x-reventless-id")), Stdlib_JSON.Decode.bool)).toBe(true);
+    });
+    globalThis.test("version carries x-reventless-subId", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "version"), s => getProperty(s, "x-reventless-subId")), Stdlib_JSON.Decode.bool)).toBe(true);
+    });
+    globalThis.test("ownerId carries x-reventless-index = byOwner", () => {
+      globalThis.expect(Stdlib_Option.flatMap(Stdlib_Option.flatMap(getPropertyOf(annotatedSchema, "ownerId"), s => getProperty(s, "x-reventless-index")), Stdlib_JSON.Decode.string)).toBe("byOwner");
+    });
+    globalThis.test("unannotated field 'name' has no x-reventless-* keys", () => {
+      let nameField = getPropertyOf(annotatedSchema, "name");
+      globalThis.expect([
+        Stdlib_Option.flatMap(nameField, s => getProperty(s, "x-reventless-id")),
+        Stdlib_Option.flatMap(nameField, s => getProperty(s, "x-reventless-subId")),
+        Stdlib_Option.flatMap(nameField, s => getProperty(s, "x-reventless-index"))
+      ]).toEqual([
+        undefined,
+        undefined,
+        undefined
+      ]);
+    });
+    globalThis.test("unannotated state-view slice (Orders) emits no x-reventless-* keys", () => {
+      let ordersSchema = JSON.parse(structure.stateViewSlices[0].schema);
+      let orderIdField = getPropertyOf(ordersSchema, "orderId");
+      globalThis.expect(Stdlib_Option.flatMap(orderIdField, s => getProperty(s, "x-reventless-id"))).toBe(undefined);
+    });
+  });
+});
+
+export {
+  PsPlaceOrderSlice,
+  PsShipOrderSlice,
+  PsOrdersViewSlice,
+  PsAvailableProductsViewSlice,
+  PsCustomersViewSlice,
+  PsAnnotatedViewSlice,
+  structure,
+}
+/* structure Not a pure module */

package/tests/plugin/PluginVersionTest.res

@@ -0,0 +1,34 @@
+// Tests for Plugin.version / Plugin.compareVersions — the helpers the admin
+// manifest resolvers (Platform_ComponentDefinitions / Platform_UIFragments, both
+// the AWS Lambda and in-memory paths) use to collapse multiple Connected versions
+// of a plugin down to the single newest one. Without correct numeric ordering a
+// lingering older version surfaces a full duplicate set of AutoUI menu entries.
+
+open JestGlobals
+
+describe("Plugin.version", () => {
+  testSync("extracts the version segment from name@version", () => {
+    expect(Plugin.version("Catalog@0.10.0-alpha.73"))->toBe("0.10.0-alpha.73")
+  })
+  testSync("returns empty string when the id carries no @", () => {
+    expect(Plugin.version("Platform"))->toBe("")
+  })
+})
+
+describe("Plugin.compareVersions", () => {
+  testSync("equal versions compare as 0", () => {
+    expect(Plugin.compareVersions("0.10.0", "0.10.0"))->toBe(0)
+  })
+  testSync("higher patch is newer", () => {
+    expect(Plugin.compareVersions("0.10.1", "0.10.0"))->toBe(1)
+  })
+  testSync("lower minor is older", () => {
+    expect(Plugin.compareVersions("0.9.0", "0.10.0"))->toBe(-1)
+  })
+  testSync("orders prerelease counters numerically, not lexically", () => {
+    // The case naive string compare gets wrong: "alpha.9" > "alpha.73" lexically,
+    // but alpha.73 is the newer build.
+    expect(Plugin.compareVersions("0.10.0-alpha.9", "0.10.0-alpha.73"))->toBe(-1)
+    expect(Plugin.compareVersions("0.10.0-alpha.73", "0.10.0-alpha.7"))->toBe(1)
+  })
+})

package/tests/plugin/PluginVersionTest.res.mjs

@@ -0,0 +1,30 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Plugin$ReventlessCore from "../../src/plugin/component/Plugin.res.mjs";
+
+globalThis.describe("Plugin.version", () => {
+  globalThis.test("extracts the version segment from name@version", () => {
+    globalThis.expect(Plugin$ReventlessCore.version("Catalog@0.10.0-alpha.73")).toBe("0.10.0-alpha.73");
+  });
+  globalThis.test("returns empty string when the id carries no @", () => {
+    globalThis.expect(Plugin$ReventlessCore.version("Platform")).toBe("");
+  });
+});
+
+globalThis.describe("Plugin.compareVersions", () => {
+  globalThis.test("equal versions compare as 0", () => {
+    globalThis.expect(Plugin$ReventlessCore.compareVersions("0.10.0", "0.10.0")).toBe(0);
+  });
+  globalThis.test("higher patch is newer", () => {
+    globalThis.expect(Plugin$ReventlessCore.compareVersions("0.10.1", "0.10.0")).toBe(1);
+  });
+  globalThis.test("lower minor is older", () => {
+    globalThis.expect(Plugin$ReventlessCore.compareVersions("0.9.0", "0.10.0")).toBe(-1);
+  });
+  globalThis.test("orders prerelease counters numerically, not lexically", () => {
+    globalThis.expect(Plugin$ReventlessCore.compareVersions("0.10.0-alpha.9", "0.10.0-alpha.73")).toBe(-1);
+    globalThis.expect(Plugin$ReventlessCore.compareVersions("0.10.0-alpha.73", "0.10.0-alpha.7")).toBe(1);
+  });
+});
+
+/*  Not a pure module */

package/tests/plugin/SchemaWalkerTest.res

@@ -0,0 +1,115 @@
+open JestGlobals
+
+S.enableJson()
+
+@schema
+type simpleRecord = {
+  label: string,
+  count: int,
+  rating?: float,
+}
+
+@schema
+type simpleVariant =
+  | Added({id: string, name: string})
+  | Renamed({id: string, newName: string})
+  | Removed
+
+describe("SchemaWalker:", () => {
+  describe("record schema", () => {
+    let result = SchemaWalker.walk("SimpleRecord", simpleRecordSchema)
+
+    testSync("kind is record", () => expect(result.kind)->toBe("record"))
+    testSync("constructors is absent", () => expect(result.constructors)->toEqual(None))
+
+    testSync("fields are sorted alphabetically", () => {
+      let names = result.fields->Array.map(f => f.name)
+      expect(names)->toEqual(["count", "label", "rating"])
+    })
+
+    testSync("required string field", () => {
+      let f = result.fields->Array.getUnsafe(1)
+      expect((f.typeDescription, f.isRequired))->toEqual(("string", true))
+    })
+
+    testSync("required int field typeDescription is number", () => {
+      let f = result.fields->Array.getUnsafe(0)
+      expect((f.typeDescription, f.isRequired))->toEqual(("number", true))
+    })
+
+    testSync("optional float field", () => {
+      let f = result.fields->Array.getUnsafe(2)
+      expect((f.typeDescription, f.isRequired))->toEqual(("option<number>", false))
+    })
+
+    testSync("structuralHash is non-empty", () =>
+      expect(result.structuralHash->String.length > 0)->toBe(true)
+    )
+  })
+
+  describe("variant schema", () => {
+    let result = SchemaWalker.walk("SimpleVariant", simpleVariantSchema)
+
+    testSync("kind is variant", () => expect(result.kind)->toBe("variant"))
+    testSync("fields array is empty", () => expect(result.fields)->toEqual([]))
+
+    testSync("payload-less constructor Removed is excluded", () => {
+      let ctors = result.constructors->Option.getOr([])
+      let names = ctors->Array.map(c => c.name)->Array.toSorted(String.compare)
+      expect(names)->toEqual(["Added", "Renamed"])
+    })
+
+    testSync("Added constructor has sorted fields", () => {
+      let ctors = result.constructors->Option.getOr([])
+      let added = ctors->Array.find(c => c.name == "Added")->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
+      expect(added.fields->Array.map(f => f.name))->toEqual(["id", "name"])
+    })
+
+    testSync("Renamed constructor has sorted fields", () => {
+      let ctors = result.constructors->Option.getOr([])
+      let renamed = ctors->Array.find(c => c.name == "Renamed")->Option.getOr({Plugin_BuiltHook.name: "", fields: []})
+      expect(renamed.fields->Array.map(f => f.name))->toEqual(["id", "newName"])
+    })
+
+    testSync("structuralHash is non-empty", () =>
+      expect(result.structuralHash->String.length > 0)->toBe(true)
+    )
+  })
+
+  describe("hash properties", () => {
+    testSync("same schema produces identical hash on repeated calls", () => {
+      let h1 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
+      let h2 = SchemaWalker.walk("X", simpleRecordSchema).structuralHash
+      expect(h1)->toBe(h2)
+    })
+
+    testSync("typeName does not affect structuralHash", () => {
+      let h1 = SchemaWalker.walk("TypeA", simpleRecordSchema).structuralHash
+      let h2 = SchemaWalker.walk("TypeB", simpleRecordSchema).structuralHash
+      expect(h1)->toBe(h2)
+    })
+
+    testSync("structurally distinct schemas produce different hashes", () => {
+      let h1 = SchemaWalker.walk("R", simpleRecordSchema).structuralHash
+      let h2 = SchemaWalker.walk("V", simpleVariantSchema).structuralHash
+      expect(h1 == h2)->toBe(false)
+    })
+  })
+
+  describe("scalar / unsupported schema", () => {
+    testSync("plain string schema → kind unknown", () => {
+      let result = SchemaWalker.walk("Scalar", S.string)
+      expect(result.kind)->toBe("unknown")
+    })
+
+    testSync("plain string schema → empty fields", () => {
+      let result = SchemaWalker.walk("Scalar", S.string)
+      expect(result.fields)->toEqual([])
+    })
+
+    testSync("plain string schema → empty structuralHash", () => {
+      let result = SchemaWalker.walk("Scalar", S.string)
+      expect(result.structuralHash)->toBe("")
+    })
+  })
+})