@reventlessdev/reventless-spec 3.0.0-alpha.147 → 3.0.0-alpha.149

package/CHANGELOG.md

@@ -3,6 +3,20 @@
 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.149 (2026-09-25)
+
+### Bug Fixes
+
+* **spec:** the lifecycle harvest reads an app that installs at its root ([977b368](https://github.com/ReventlessDev/reventless-core/commit/977b3681c6acde78ae05b18ca72935c10e6a5154))
+
+
+# 3.0.0-alpha.148 (2026-09-25)
+
+### Bug Fixes
+
+* **spec:** a chapter that carries both keys backs neither ([cbd823e](https://github.com/ReventlessDev/reventless-core/commit/cbd823e4f87ddd5810debd929bb536b2003d0e4c))
+
+
 # 3.0.0-alpha.147 (2026-09-25)
 
 ### Bug Fixes

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@reventlessdev/reventless-spec",
-  "version": "3.0.0-alpha.147",
+  "version": "3.0.0-alpha.149",
   "description": "Specifications for Reventless",
   "license": "Apache-2.0",
   "bin": {

package/src/components/DcbValidation.res

@@ -497,7 +497,8 @@ Checks each `@partitionTag` against what inference derives with that hint remove
   fence and read scope would all follow the wrong key.
 - **Redundant** — inference reaches the same key unaided; the annotation can go.
 - **Override** — inference disagrees, but the slice's chapter backs the hint: every
-  id-carrying event written in the chapter carries the hinted key, and every foreign
+  id-carrying event written in the chapter carries the hinted key and not every one
+  carries the key inference chose, and every foreign
   event the slice reads by that key is written by a slice partitioned by it. Rule 1
   cannot tell an own key read back off a sibling's events from a reference
   (`ShipOrder` writing `{orderId, carrierBookingId}` and reading `OrderPlaced` has
@@ -519,11 +520,16 @@ let validatePartitionHintsVsInference = (
     shapes->Array.filter(p => p.produced->Array.some(e => e.eventType == eventType))
   // The chapter backs the hint, and what the slice reads by that key is its own
   // entity: each foreign arm carrying it comes from a slice partitioned by it.
-  let backedByChapter = (s: DcbScopeInference.sliceShape, hint, partitionBySlice) => {
+  // Backing means telling the keys apart: a chapter whose events all carry both the
+  // hinted key and inference's (one slice, one event with both ids) says nothing
+  // about which one the slice is about, so it backs neither.
+  let backedByChapter = (s: DcbScopeInference.sliceShape, hint, inferred, partitionBySlice) => {
     let chapterAgrees =
       s.chapter
       ->Option.flatMap(c => chapterKeys->Dict.get(c))
-      ->Option.mapOr(false, keys => keys->Array.includes(hint))
+      ->Option.mapOr(false, keys =>
+        keys->Array.includes(hint) && !(inferred->Array.some(k => keys->Array.includes(k)))
+      )
     let own = s.produced->Array.map(e => e.eventType)
     let readsOwnEntity =
       s.consumed
@@ -591,7 +597,7 @@ let validatePartitionHintsVsInference = (
             sliceName: s.sliceName,
             message: `@partitionTag ${hint} is what inference derives without it — the annotation is redundant and can be removed.`,
           })
-        | Some(inferred) if backedByChapter(s, hint, unaided.partitionBySlice) =>
+        | Some(inferred) if backedByChapter(s, hint, [inferred], unaided.partitionBySlice) =>
           overridden(s, hint, `it derives ${inferred}`)
         | Some(inferred) =>
           contradictions->Array.push({
@@ -602,7 +608,7 @@ let validatePartitionHintsVsInference = (
           let candidates = unaided.candidatesBySlice->Dict.get(s.sliceName)->Option.getOr([])
           if candidates->Array.includes(hint) {
             ()
-          } else if backedByChapter(s, hint, unaided.partitionBySlice) {
+          } else if backedByChapter(s, hint, candidates, unaided.partitionBySlice) {
             overridden(s, hint, `candidates: ${candidates->Array.join(", ")}`)
           } else {
             contradictions->Array.push({

package/src/components/DcbValidation.res.mjs

@@ -435,8 +435,14 @@ function validatePartitionHintsVsInference(shapes) {
   let overrides = [];
   let chapterKeys = DcbScopeInference$Reventless.chapterKeys(shapes);
   let producersOf = eventType => shapes.filter(p => p.produced.some(e => e.eventType === eventType));
-  let backedByChapter = (s, hint, partitionBySlice) => {
-    let chapterAgrees = Stdlib_Option.mapOr(Stdlib_Option.flatMap(s.chapter, c => chapterKeys[c]), false, keys => keys.includes(hint));
+  let backedByChapter = (s, hint, inferred, partitionBySlice) => {
+    let chapterAgrees = Stdlib_Option.mapOr(Stdlib_Option.flatMap(s.chapter, c => chapterKeys[c]), false, keys => {
+      if (keys.includes(hint)) {
+        return !inferred.some(k => keys.includes(k));
+      } else {
+        return false;
+      }
+    });
     let own = s.produced.map(e => e.eventType);
     let readsOwnEntity = s.consumed.filter(e => {
       if (own.includes(e.eventType)) {
@@ -504,7 +510,7 @@ function validatePartitionHintsVsInference(shapes) {
           message: `@partitionTag ` + hint + ` is what inference derives without it — the annotation is redundant and can be removed.`
         });
         return;
-      } else if (backedByChapter(s, hint, unaided.partitionBySlice)) {
+      } else if (backedByChapter(s, hint, [inferred], unaided.partitionBySlice)) {
         return overridden(s, hint, `it derives ` + inferred);
       } else {
         contradictions.push({
@@ -517,7 +523,7 @@ function validatePartitionHintsVsInference(shapes) {
     let candidates = Stdlib_Option.getOr(unaided.candidatesBySlice[s.sliceName], []);
     if (candidates.includes(hint)) {
       return;
-    } else if (backedByChapter(s, hint, unaided.partitionBySlice)) {
+    } else if (backedByChapter(s, hint, candidates, unaided.partitionBySlice)) {
       return overridden(s, hint, `candidates: ` + candidates.join(", "));
     } else {
       contradictions.push({

package/src/lifecycle/loadPluginStructure.mjs

@@ -18,13 +18,30 @@
 // schema describes the wire form, so validating an in-memory structure against
 // it fails on every optional that happens to be empty.
 import { existsSync } from "node:fs";
-import { join } from "node:path";
+import { dirname, join, resolve } from "node:path";
 
-const localPlatformPath = (pluginDir) =>
-  join(
-    pluginDir,
-    "node_modules/@reventlessdev/reventless-local/src/Platform.res.mjs",
-  );
+const localPlatformModule = "node_modules/@reventlessdev/reventless-local/src/Platform.res.mjs";
+
+/**
+ * Where the local platform is installed for this plugin: the nearest
+ * `node_modules` from the plugin directory up, the way Node resolves a package.
+ * A monorepo member has its own copy; an app that installs its dependencies at
+ * its root (`node-linker=hoisted`) has one only there. Walked rather than
+ * resolved through the package, so its `exports` map does not decide what can be
+ * reached.
+ *
+ * @returns {string | undefined}
+ */
+export const localPlatformPath = (pluginDir) => {
+  let dir = resolve(pluginDir);
+  for (;;) {
+    const candidate = join(dir, localPlatformModule);
+    if (existsSync(candidate)) return candidate;
+    const parent = dirname(dir);
+    if (parent === dir) return undefined;
+    dir = parent;
+  }
+};
 
 const pluginEntryPath = (pluginDir) => join(pluginDir, "src/Plugin.res.mjs");
 
@@ -40,10 +57,10 @@ export const loadPluginStructure = async (pluginDir) => {
       error: `no compiled plugin at ${entry} — build the plugin first`,
     };
   }
-  if (!existsSync(local)) {
+  if (local === undefined) {
     return {
       ok: false,
-      error: `no local platform installed at ${local}`,
+      error: `no local platform installed for ${pluginDir} — none in any node_modules from there up`,
     };
   }
   try {