From 1ef8fcc653b1e6bcfd01e5d1b35ad198e398ce10 Mon Sep 17 00:00:00 2001
From: Mohsen Zainalpour <zainalpour@gmail.com>
Date: Tue, 27 Oct 2026 08:37:48 -0400
Subject: [PATCH 1/3] chore(deps): bump rift engine to 0.24.0 and write
 behaviors the way it admits them

rift 0.24.0 aligns behaviors with Mountebank, and three shapes this SDK wrote
are now ignored or refused:
- a _behaviors object beside a response-level repeat is ignored whole
  (rift#1709). Reading an engine export (repeat + behaviors array) and writing
  it back produced exactly that, silently dropping every behavior. The block
  is now written as the array whenever a response-level repeat is present.
- an array element holding repeat is refused (rift#1582). In the array form
  the effective repeat now goes beside the response; this reverses #217's
  choice to keep it in the array for rift 0.17.0.
- an array element holding a list of copy/lookup is refused (rift#1639). A
  list is now written, and read, one item per element.

rift 0.24.0 also confines an admin-API imposter's lookup CSVs and require()
to --scripts-dir (rift#1617), refusing every lookup without one, so
SpawnOptions gains scriptsDir and the conformance spawn lane passes the
corpus root.
---
 docs/design/sdk-api.md                        |  6 +++
 pom.xml                                       |  2 +-
 rift-java-conformance/README.md               |  6 +--
 .../conformance/ConformanceTransport.java     |  6 ++-
 .../rift/conformance/LiveEngine.java          | 13 ++++++
 .../rift/conformance/LookupGrammarIT.java     |  7 ++--
 .../github/achirdlabs/rift/SpawnOptions.java  | 21 ++++++++++
 .../achirdlabs/rift/model/Behaviors.java      | 39 +++++++++++++++---
 .../achirdlabs/rift/model/Response.java       | 23 ++++++++---
 .../achirdlabs/rift/spawn/RiftProcess.java    |  4 ++
 .../rift/model/BehaviorRunOrderTest.java      | 14 ++++---
 .../rift/model/BehaviorsWriteFormTest.java    | 38 +++++++-----------
 .../rift/model/FaultScriptRepeatTest.java     |  5 ++-
 .../rift/model/ProxyInjectBehaviorsTest.java  |  6 +--
 .../rift/model/ResponseLevelRepeatTest.java   | 28 ++++++-------
 .../rift/spawn/SpawnScriptsDirTest.java       | 40 +++++++++++++++++++
 .../testcontainers/RiftContainerTest.java     |  6 +--
 17 files changed, 194 insertions(+), 70 deletions(-)
 create mode 100644 rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java

diff --git a/docs/design/sdk-api.md b/docs/design/sdk-api.md
index 2cceeeb..9eba1a6 100644
--- a/docs/design/sdk-api.md
+++ b/docs/design/sdk-api.md
@@ -564,6 +564,12 @@ public sealed interface BehaviorChain<S extends ResponseSpec & BehaviorChain<S>>
 // interchangeable, since rift 0.17.0 honours only the block one. When both are present both are
 // kept; `Behaviors.effectiveRepeat()` reports which applies. The DSL's `repeat(int)` emits the
 // block spelling.
+// From rift 0.24.0 the write follows what that engine admits: a `_behaviors` object beside a
+// response-level `repeat` is ignored (rift#1709), so the block is then written as the array; an
+// array element may not hold `repeat` (rift#1582, rift#1672), so in the array form the effective
+// `repeat` is written beside the response and any other is dropped; and an element may not hold a
+// list of `copy`/`lookup` (rift#1639), so a list is written one item per element and read back the
+// same way. This trades rift 0.17.0's block-only `repeat` for an imposter the pinned engine accepts.
 IsSpec templated()                                       // rename of template(); _rift.templated
 // declarative flow-state writes after the response (_rift.stateOps, rift >= 0.18.0; #227). Run in
 // chain order after templating and behaviors; engine-version gated at create/replaceAll.
diff --git a/pom.xml b/pom.xml
index 089485d..57e1916 100644
--- a/pom.xml
+++ b/pom.xml
@@ -44,7 +44,7 @@
     <maven.compiler.release>17</maven.compiler.release>
 
     <!-- Pinned Rift engine release the natives + version preflight track (no leading 'v'). -->
-    <rift.engine.version>0.23.0</rift.engine.version>
+    <rift.engine.version>0.24.0</rift.engine.version>
 
     <!-- rift-java-bom's resolve-through-bom invoker IT is self-validation, not a prerequisite for
          the BOM artifact. It runs at integration-test (before install) and needs network to resolve
diff --git a/rift-java-conformance/README.md b/rift-java-conformance/README.md
index 0dc7870..215f785 100644
--- a/rift-java-conformance/README.md
+++ b/rift-java-conformance/README.md
@@ -57,7 +57,7 @@ holding `manifest.json` and `corpus/`):
 ```bash
 # Download + extract the corpus for the pinned engine version, then:
 ./mvnw -pl rift-java-conformance -am test \
-  -Drift.corpus.root=/path/to/sdk-conformance-v0.23.0
+  -Drift.corpus.root=/path/to/sdk-conformance-v0.24.0
 ```
 
 Resolution order for the corpus: `-Drift.corpus.root` → `RIFT_CORPUS_ROOT` → `target/corpus`. When
@@ -69,7 +69,7 @@ cached on first use):
 
 ```bash
 RIFT_IT=1 ./mvnw -pl rift-java-conformance -am verify \
-  -Drift.corpus.root=/path/to/sdk-conformance-v0.23.0
+  -Drift.corpus.root=/path/to/sdk-conformance-v0.24.0
 ```
 
 On JDK 21 or 22+, `-am` also builds `rift-java-embedded` (or `-embedded-jdk21`), whose integration
@@ -80,7 +80,7 @@ Over the embedded transport (JDK 21 or 22+, with a `librift_ffi` for your platfo
 
 ```bash
 RIFT_IT=1 CONFORMANCE_TRANSPORT=EMBEDDED ./mvnw -pl rift-java-conformance -am verify \
-  -Drift.corpus.root=/path/to/sdk-conformance-v0.23.0 \
+  -Drift.corpus.root=/path/to/sdk-conformance-v0.24.0 \
   -Drift.ffi.lib=/path/to/librift_ffi-<platform>.<ext>
 ```
 
diff --git a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/ConformanceTransport.java b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/ConformanceTransport.java
index 62d569c..e42beb5 100644
--- a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/ConformanceTransport.java
+++ b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/ConformanceTransport.java
@@ -13,7 +13,10 @@
  */
 enum ConformanceTransport {
 
-    /** The engine as a spawned process; relative {@code data/} paths resolve via the working directory. */
+    /**
+     * The engine as a spawned process. Relative {@code data/} paths resolve against the corpus root,
+     * which is also the {@code --scripts-dir} a lookup's CSV must sit under from rift 0.24.0 (rift#1617).
+     */
     SPAWN {
         @Override
         boolean isAvailable() {
@@ -25,6 +28,7 @@ Rift engine(Corpus corpus) {
             return Rift.spawn(SpawnOptions.builder()
                     .version(corpus.engineVersion())
                     .workingDir(corpus.payloadRoot())
+                    .scriptsDir(corpus.payloadRoot())
                     .allowInjection(true)
                     .build());
         }
diff --git a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LiveEngine.java b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LiveEngine.java
index ed2e8d8..e7fe5e0 100644
--- a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LiveEngine.java
+++ b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LiveEngine.java
@@ -4,6 +4,7 @@
 import io.github.achirdlabs.rift.SpawnOptions;
 import org.junit.jupiter.api.DynamicTest;
 
+import java.nio.file.Path;
 import java.util.stream.Stream;
 
 import static org.junit.jupiter.api.Assumptions.assumeTrue;
@@ -33,6 +34,18 @@ static Rift engine() {
         };
     }
 
+    /**
+     * The engine for the selected lane, reading lookup CSVs and modules under {@code scriptsDir}. A
+     * spawned engine needs it as {@code --scripts-dir} from rift 0.24.0 (rift#1617); the embedded
+     * host calls are not confined, so that lane ignores it.
+     */
+    static Rift engine(Path scriptsDir) {
+        return switch (ConformanceTransport.selected()) {
+            case SPAWN -> Rift.spawn(SpawnOptions.builder().scriptsDir(scriptsDir).build());
+            case EMBEDDED -> Rift.embedded();
+        };
+    }
+
     /**
      * A claim that holds on every transport: gated only on the live-engine lane being enabled and
      * the selected one being startable here.
diff --git a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LookupGrammarIT.java b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LookupGrammarIT.java
index fae7b88..711a39a 100644
--- a/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LookupGrammarIT.java
+++ b/rift-java-conformance/src/test/java/io/github/achirdlabs/rift/conformance/LookupGrammarIT.java
@@ -34,9 +34,9 @@ class LookupGrammarIT {
     @TestFactory
     Stream<DynamicTest> indexDelimiterAndHeaderKeyResolveTheRow() {
         return gated("lookup keys on a regex capture group by index, reads a ';' CSV, and keys on a header", () -> {
-            Path csv = Files.createTempFile("rift-lookup-", ".csv");
-            Files.writeString(csv, "id;name\n7;seven\n42;forty-two\n");
-            try (Rift rift = engine()) {
+            Path dir = Files.createTempDirectory("rift-lookup-");
+            Path csv = Files.writeString(dir.resolve("tenants.csv"), "id;name\n7;seven\n42;forty-two\n");
+            try (Rift rift = engine(dir)) {
                 Imposter imp = rift.create(imposter("lookup")
                         .stub(onGet("/items/7/42").willReturn(ok().withTextBody("${row}[name]")
                                 .lookup(lookupKey("path").using(regex("/items/(\\d+)/(\\d+)")).index(2)
@@ -49,6 +49,7 @@ Stream<DynamicTest> indexDelimiterAndHeaderKeyResolveTheRow() {
                 assertEquals("seven", get(imp, "/tenant", "7"), "the key came from the X-Tenant header");
             } finally {
                 Files.deleteIfExists(csv);
+                Files.deleteIfExists(dir);
             }
         });
     }
diff --git a/rift-java-core/src/main/java/io/github/achirdlabs/rift/SpawnOptions.java b/rift-java-core/src/main/java/io/github/achirdlabs/rift/SpawnOptions.java
index 066f12a..ace897e 100644
--- a/rift-java-core/src/main/java/io/github/achirdlabs/rift/SpawnOptions.java
+++ b/rift-java-core/src/main/java/io/github/achirdlabs/rift/SpawnOptions.java
@@ -29,6 +29,7 @@ public final class SpawnOptions {
     private final String logLevel;
     private final Map<String, String> env;
     private final Optional<Path> workingDir;
+    private final Optional<Path> scriptsDir;
     private final Optional<URI> mirrorUrl;
     private final Duration startupTimeout;
     private final Duration shutdownTimeout;
@@ -51,6 +52,7 @@ private SpawnOptions(Builder b) {
         this.logLevel = b.logLevel;
         this.env = Map.copyOf(b.env);
         this.workingDir = b.workingDir;
+        this.scriptsDir = b.scriptsDir;
         this.mirrorUrl = b.mirrorUrl;
         this.startupTimeout = b.startupTimeout;
         this.shutdownTimeout = b.shutdownTimeout;
@@ -104,6 +106,11 @@ public Optional<Path> workingDir() {
         return workingDir;
     }
 
+    /** The engine's {@code --scripts-dir}, if set; see {@link Builder#scriptsDir(Path)}. */
+    public Optional<Path> scriptsDir() {
+        return scriptsDir;
+    }
+
     public Optional<URI> mirrorUrl() {
         return mirrorUrl;
     }
@@ -166,6 +173,7 @@ public static final class Builder {
         private String logLevel = "info";
         private final Map<String, String> env = new LinkedHashMap<>();
         private Optional<Path> workingDir = Optional.empty();
+        private Optional<Path> scriptsDir = Optional.empty();
         private Optional<URI> mirrorUrl = Optional.empty();
         private Duration startupTimeout = Duration.ofSeconds(15);
         private Duration shutdownTimeout = Duration.ofSeconds(5);
@@ -255,6 +263,19 @@ public Builder workingDir(Path workingDir) {
             return this;
         }
 
+        /**
+         * The engine's {@code --scripts-dir}: the only directory an imposter created through this
+         * client may read {@code lookup} CSV files, {@code require()} modules and {@code file:} scripts
+         * from. Unset by default. From rift 0.24.0 (rift#1611, rift#1617) an imposter written over the
+         * admin API reads none of these without it, and its {@code lookup} is refused with
+         * {@code 400}; a relative {@code lookup} path resolves against this directory, not
+         * {@link #workingDir(Path)}.
+         */
+        public Builder scriptsDir(Path scriptsDir) {
+            this.scriptsDir = Optional.of(Objects.requireNonNull(scriptsDir, "scriptsDir"));
+            return this;
+        }
+
         public Builder mirrorUrl(URI mirrorUrl) {
             this.mirrorUrl = Optional.of(Objects.requireNonNull(mirrorUrl, "mirrorUrl"));
             return this;
diff --git a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Behaviors.java b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Behaviors.java
index f38d159..a671550 100644
--- a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Behaviors.java
+++ b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Behaviors.java
@@ -59,6 +59,9 @@ public record Behaviors(List<Behavior> entries) {
      */
     private static final List<String> CANONICAL_ORDER = List.of("lookup", "copy", "shellTransform", "decorate");
 
+    /** The list-valued keys an array element holds one item of (rift#1639); shellTransform is already one step per command. */
+    private static final Set<String> SPLIT_IN_ARRAY_FORM = Set.of("copy", "lookup");
+
     /**
      * Reads the object form. An engine runs an object's transforming behaviors in {@link
      * #CANONICAL_ORDER} whatever order they were written in, so they are read in that order: the
@@ -90,6 +93,9 @@ static Behaviors read(JsonObject obj) {
      * The SDK writes one key per element, but the engine also accepts an element holding several
      * keys and runs them in its fixed object order ({@code wait, lookup, copy, shellTransform,
      * decorate}, then any other key alphabetically), so such an element is expanded in that order.
+     * A list-valued {@code copy} or {@code lookup} element, which an engine before 0.24.0 ran item by
+     * item, is read as one entry per item: that is what {@link #toJsonArray()} writes back, since
+     * rift 0.24.0 refuses the list there (rift#1639).
      */
     static Behaviors readArray(JsonArray arr) {
         List<Behavior> entries = new ArrayList<>();
@@ -101,11 +107,18 @@ static Behaviors readArray(JsonArray arr) {
             entry.fields().entrySet().stream()
                     .sorted(Comparator.comparingInt((Map.Entry<String, JsonValue> e) -> engineRank(e.getKey()))
                             .thenComparing(Map.Entry::getKey))
-                    .forEach(e -> entries.addAll(Behavior.readAll(e.getKey(), e.getValue())));
+                    .forEach(e -> entries.addAll(readElementKey(e.getKey(), e.getValue())));
         }
         return new Behaviors(entries);
     }
 
+    private static List<Behavior> readElementKey(String key, JsonValue value) {
+        if (SPLIT_IN_ARRAY_FORM.contains(key) && value instanceof JsonArray items && !items.items().isEmpty()) {
+            return items.items().stream().flatMap(item -> Behavior.readAll(key, item).stream()).toList();
+        }
+        return Behavior.readAll(key, value);
+    }
+
     /** A key's position in the engine's fixed object order; any other key sorts after, alphabetically. */
     private static int engineRank(String key) {
         if (key.equals("wait")) {
@@ -187,11 +200,27 @@ Behaviors withoutResponseLevelRepeat() {
         return block.size() == entries.size() ? this : new Behaviors(block);
     }
 
-    /** The array form: one single-key element per entry, in entry order. Never lossy. */
+    /** These entries minus every {@code repeat}: what an array-form block may hold. */
+    Behaviors withoutRepeats() {
+        return new Behaviors(entries.stream().filter(entry -> !(entry instanceof Behavior.Repeat)).toList());
+    }
+
+    /**
+     * The array form: one single-key element per entry, in entry order. Never lossy. A list-valued
+     * {@code copy} or {@code lookup} is written as one element per item, which runs the same: from
+     * rift 0.24.0 an element holding a list is refused, as in Mountebank (rift#1639).
+     */
     JsonArray toJsonArray() {
-        return new JsonArray(entries.stream()
-                .map(entry -> (JsonValue) JsonObject.builder().put(entry.key(), entry.value()).build())
-                .toList());
+        List<JsonValue> elements = new ArrayList<>();
+        for (Behavior entry : entries) {
+            JsonValue value = entry.value();
+            if (SPLIT_IN_ARRAY_FORM.contains(entry.key()) && value instanceof JsonArray items && !items.items().isEmpty()) {
+                items.items().forEach(item -> elements.add(JsonObject.builder().put(entry.key(), item).build()));
+            } else {
+                elements.add(JsonObject.builder().put(entry.key(), value).build());
+            }
+        }
+        return new JsonArray(elements);
     }
 
     public boolean isEmpty() {
diff --git a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
index ec21fba..11f6564 100644
--- a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
+++ b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
@@ -242,17 +242,28 @@ private static Behaviors readBehaviors(JsonObject obj) {
      * beside {@code is}, a block one inside the block — so a read followed by a write never moves
      * it. That matters because the two spellings are not interchangeable across engine versions:
      * rift 0.17.0 and earlier honour only the block one and silently ignore a response-level field.
+     *
+     * <p>Beside a response-level {@code repeat} the block is always the array: from rift 0.24.0 a
+     * {@code _behaviors} object next to a top-level {@code repeat} is ignored, as in Mountebank
+     * (rift#1709), while the array next to it runs. And the array never holds a {@code repeat}:
+     * rift 0.24.0 refuses a {@code {"repeat": n}} element and ignores one beside a behavior
+     * (rift#1582, rift#1672). So in the array form the effective {@code repeat} is written beside the
+     * response — a block one moves there when there is no response-level one — and any other is
+     * dropped, as no engine that runs the array form honours it.
      */
     private static void writeBehaviors(JsonObject.Builder builder, Behaviors behaviors) {
-        behaviors.responseLevelRepeat().ifPresent(repeat -> builder.put("repeat", repeat.value()));
+        Optional<Behavior.Repeat> responseLevelRepeat = behaviors.responseLevelRepeat();
         Behaviors block = behaviors.withoutResponseLevelRepeat();
-        if (block.isEmpty()) {
+        if (responseLevelRepeat.isEmpty() && !block.requiresArrayForm()) {
+            if (!block.isEmpty()) {
+                builder.put("_behaviors", block.toJsonValue());
+            }
             return;
         }
-        if (block.requiresArrayForm()) {
-            builder.put("behaviors", block.toJsonArray());
-        } else {
-            builder.put("_behaviors", block.toJsonValue());
+        behaviors.effectiveRepeat().ifPresent(repeat -> builder.put("repeat", repeat.value()));
+        Behaviors elements = block.withoutRepeats();
+        if (!elements.isEmpty()) {
+            builder.put("behaviors", elements.toJsonArray());
         }
     }
 
diff --git a/rift-java-core/src/main/java/io/github/achirdlabs/rift/spawn/RiftProcess.java b/rift-java-core/src/main/java/io/github/achirdlabs/rift/spawn/RiftProcess.java
index a30711f..1fc9b4c 100644
--- a/rift-java-core/src/main/java/io/github/achirdlabs/rift/spawn/RiftProcess.java
+++ b/rift-java-core/src/main/java/io/github/achirdlabs/rift/spawn/RiftProcess.java
@@ -241,6 +241,10 @@ static List<String> buildCommand(Path binary, SpawnOptions opts, int port, Path
             cmd.add("--journal-max-bytes");
             cmd.add(Long.toString(bytes));
         });
+        opts.scriptsDir().ifPresent(dir -> {
+            cmd.add("--scripts-dir");
+            cmd.add(dir.toString());
+        });
         opts.upstreamTrust().ifPresent(trust -> {
             if (trust instanceof UpstreamTrust.CaFile file) {
                 cmd.add("--upstream-ca-file");
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorRunOrderTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorRunOrderTest.java
index 9a492c0..bf180d4 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorRunOrderTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorRunOrderTest.java
@@ -32,9 +32,10 @@ void anOutOfOrderArrayKeepsItsOrder() {
         // An engine GET echoes an array in the order it was written, so this is also the read-back of DSL output.
         String decorateFirst = "\"behaviors\":[{\"decorate\":\"d\"},{\"shellTransform\":\"cat\"}]";
         assertEquals(expected(decorateFirst), written(decorateFirst));
-        String copyFirst = "\"behaviors\":[{\"copy\":[" + COPY + "]},{\"lookup\":[" + LOOKUP + "]}]";
-        assertEquals(expected(copyFirst), written(copyFirst));
-        String waitThenDecorateThenCopy = "\"behaviors\":[{\"wait\":100},{\"decorate\":\"d\"},{\"copy\":[" + COPY + "]}]";
+        // A list-valued element is written one item per element, which rift 0.24.0 requires (rift#1639).
+        assertEquals(expected("\"behaviors\":[{\"copy\":" + COPY + "},{\"lookup\":" + LOOKUP + "}]"),
+                written("\"behaviors\":[{\"copy\":[" + COPY + "]},{\"lookup\":[" + LOOKUP + "]}]"));
+        String waitThenDecorateThenCopy = "\"behaviors\":[{\"wait\":100},{\"decorate\":\"d\"},{\"copy\":" + COPY + "}]";
         assertEquals(expected(waitThenDecorateThenCopy), written(waitThenDecorateThenCopy));
     }
 
@@ -68,9 +69,10 @@ void waitRepeatAndUnknownKeysDoNotCountTowardsOrder() {
     }
 
     @Test
-    void anOutOfOrderDslChainKeepsItsUnknownAndRepeatEntriesInPlace() {
-        assertEquals("{\"is\":{\"statusCode\":\"200\"},\"behaviors\":[{\"decorate\":\"d\"},{\"repeat\":2},"
-                        + "{\"lookup\":[" + LOOKUP + "]}]}",
+    void anOutOfOrderDslChainKeepsItsUnknownEntryInPlaceAndMovesRepeatBesideTheResponse() {
+        // rift 0.24.0 refuses a {"repeat": n} element and a list-valued lookup element (rift#1582, rift#1639).
+        assertEquals("{\"is\":{\"statusCode\":\"200\"},\"repeat\":2,\"behaviors\":[{\"decorate\":\"d\"},"
+                        + "{\"lookup\":" + LOOKUP + "}]}",
                 status(200).decorate("d").repeat(2)
                         .withBehavior(new Behavior.Unknown("lookup", io.github.achirdlabs.rift.json.JsonValue.parse("[" + LOOKUP + "]")))
                         .build().toJsonValue().toJson());
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorsWriteFormTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorsWriteFormTest.java
index 1e9b53e..a2953a0 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorsWriteFormTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/BehaviorsWriteFormTest.java
@@ -171,36 +171,30 @@ void repeatedUnknownKeyEntriesSurviveTheWrite() {
         assertEquals("${b}", intoOf(soleValue(behaviors.items().get(1), "lookup")));
     }
 
-    @Test
-    void repeatedRepeatEntriesAreWrittenAsElements() {
-        JsonArray behaviors = writtenBehaviorsArray(TWO_REPEATS);
-        assertEquals(2, behaviors.items().size());
-        assertEquals(JsonNumber.of(2), soleValue(behaviors.items().get(0), "repeat"));
-        assertEquals(JsonNumber.of(5), soleValue(behaviors.items().get(1), "repeat"));
-    }
-
     /**
-     * A {@code repeat} is written as an array element, never hoisted to a response-level field: rift
-     * 0.17.0 and earlier have no response-level {@code repeat} field at all, so hoisting would
-     * silently drop it on an engine this SDK still supports.
-     *
-     * <p>A forward-looking guard on that decision, not coverage of the #217 fix: it passes against
-     * the pre-fix code too, since nothing hoisted then either.
+     * The array form never holds a {@code repeat}: rift 0.24.0 refuses a {@code {"repeat": n}}
+     * element (rift#1582). The effective one, the first, is written beside the response instead.
+     * That reverses #217's choice to keep it in the array for rift 0.17.0, which has no
+     * response-level field: the pinned engine refusing the imposter outweighs it.
      */
     @Test
-    void repeatIsNotHoistedToAResponseLevelField() {
+    void blockRepeatsInTheArrayFormAreWrittenAsTheEffectiveResponseLevelOne() {
         JsonObject response = writtenResponse(TWO_REPEATS);
-        assertNull(response.get("repeat"), "repeat must stay inside the behaviors array");
+        assertEquals(JsonNumber.of(2), response.get("repeat"), "the first block repeat is the effective one");
+        assertNull(response.get("behaviors"), "nothing else is left for the array");
+        assertNull(response.get("_behaviors"));
     }
 
+    /** rift 0.24.0 refuses a list-valued {@code copy} element (rift#1639); one element per item runs the same. */
     @Test
-    void perElementCopyFormIsPreserved() {
+    void aListValuedCopyElementIsWrittenOneItemPerElement() {
         JsonArray behaviors = writtenBehaviorsArray(MIXED_COPY_FORMS);
         assertEquals(2, behaviors.items().size());
-        assertInstanceOf(JsonObject.class, soleValue(behaviors.items().get(0), "copy"),
-                "an object-form copy element stays an object");
-        assertInstanceOf(JsonArray.class, soleValue(behaviors.items().get(1), "copy"),
-                "an array-form copy element stays an array");
+        assertInstanceOf(JsonObject.class, soleValue(behaviors.items().get(0), "copy"));
+        assertInstanceOf(JsonObject.class, soleValue(behaviors.items().get(1), "copy"),
+                "the one-item list is written as its item");
+        String written = Stub.fromJson(MIXED_COPY_FORMS).toJson();
+        RoundTripAssertions.assertRoundTrips(written, Stub::fromJson, Stub::toJson);
     }
 
     @Test
@@ -256,8 +250,6 @@ void arrayFormWithRepeatedKeysRoundTrips() {
         RoundTripAssertions.assertRoundTrips(TWO_COPIES, Stub::fromJson, Stub::toJson);
         RoundTripAssertions.assertRoundTrips(REPEATED_SCALARS, Stub::fromJson, Stub::toJson);
         RoundTripAssertions.assertRoundTrips(TWO_LOOKUPS, Stub::fromJson, Stub::toJson);
-        RoundTripAssertions.assertRoundTrips(MIXED_COPY_FORMS, Stub::fromJson, Stub::toJson);
-        RoundTripAssertions.assertRoundTrips(TWO_REPEATS, Stub::fromJson, Stub::toJson);
         RoundTripAssertions.assertRoundTrips(TWO_SHELL_TRANSFORMS, Stub::fromJson, Stub::toJson);
     }
 
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/FaultScriptRepeatTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/FaultScriptRepeatTest.java
index b5837e5..27d3ae1 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/FaultScriptRepeatTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/FaultScriptRepeatTest.java
@@ -58,8 +58,9 @@ void theEnginesResponseLevelEchoIsTyped() {
     void everySpellingRoundTripsInTheShapeItArrivedIn() {
         String faultBlock = "{\"fault\":\"CONNECTION_RESET_BY_PEER\",\"_behaviors\":{\"wait\":500,\"repeat\":2}}";
         assertEquals(faultBlock, roundTrip(faultBlock));
-        String scriptArray = "{\"_rift\":{\"script\":{\"engine\":\"rhai\",\"code\":\"x\"}},\"behaviors\":[{\"wait\":500},{\"repeat\":2},{\"repeat\":3}]}";
-        assertEquals(scriptArray, roundTrip(scriptArray));
+        // rift 0.24.0 refuses a {"repeat": n} element (rift#1582): the effective one goes beside the response.
+        assertEquals("{\"_rift\":{\"script\":{\"engine\":\"rhai\",\"code\":\"x\"}},\"repeat\":2,\"behaviors\":[{\"wait\":500}]}",
+                roundTrip("{\"_rift\":{\"script\":{\"engine\":\"rhai\",\"code\":\"x\"}},\"behaviors\":[{\"wait\":500},{\"repeat\":2},{\"repeat\":3}]}"));
         assertEquals("{\"fault\":\"CONNECTION_RESET_BY_PEER\",\"repeat\":2}",
                 roundTrip("{\"repeat\":2,\"fault\":\"CONNECTION_RESET_BY_PEER\"}"));
     }
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ProxyInjectBehaviorsTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ProxyInjectBehaviorsTest.java
index 35294be..013f376 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ProxyInjectBehaviorsTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ProxyInjectBehaviorsTest.java
@@ -59,8 +59,8 @@ void engineGetShapeOnProxyIsTypedAndWrittenBackUnmoved() {
 
         assertEquals(JsonValue.parse("""
                 {"proxy": {"to": "http://up", "mode": "proxyOnce", "predicateGenerators": []},
-                 "repeat": 2, "_behaviors": {"wait": 5, "decorate": "d"}}
-                """), proxy.toJsonValue(), "repeat stays response-level; the block keeps both entries");
+                 "repeat": 2, "behaviors": [{"wait": 5}, {"decorate": "d"}]}
+                """), proxy.toJsonValue(), "repeat stays response-level; the block stays the array rift 0.24.0 reads beside it");
     }
 
     @Test
@@ -72,7 +72,7 @@ void engineGetShapeOnInjectIsTyped() {
                 inject.behaviors().entries());
         JsonObject written = inject.toJsonValue();
         assertEquals(JsonNumber.of(4), written.get("repeat"));
-        assertEquals(JsonValue.parse("{\"wait\": 5}"), written.get("_behaviors"));
+        assertEquals(JsonValue.parse("[{\"wait\": 5}]"), written.get("behaviors"));
     }
 
     @Test
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
index c2e5e21..21dbe4f 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
@@ -108,9 +108,11 @@ void blockRepeatStillWritesInsideTheBlock() {
 
     /**
      * The response-level value wins where the engine honours it — but the block one is NOT
-     * discarded. Which spelling applies is engine-dependent (rift 0.17.0 and earlier ignore the
-     * response-level field and honour the block one), so dropping either at parse time would
-     * change how the imposter behaves after nothing but a read and a write.
+     * discarded at parse time: which spelling applies is engine-dependent (rift 0.17.0 and earlier
+     * ignore the response-level field and honour the block one). The write, though, is for the
+     * pinned engine: from rift 0.24.0 a {@code _behaviors} object beside a response-level {@code
+     * repeat} is ignored whole (rift#1709), so the block goes out as the array, which cannot hold a
+     * {@code repeat} (rift#1582) — the block one, which never took effect there, is dropped.
      */
     @Test
     void responseLevelRepeatWinsButTheBlockOneIsPreserved() {
@@ -124,10 +126,8 @@ void responseLevelRepeatWinsButTheBlockOneIsPreserved() {
 
         JsonObject written = writtenResponse(BOTH);
         assertEquals(JsonNumber.of(4), written.get("repeat"));
-        JsonObject block = assertInstanceOf(JsonObject.class, written.get("_behaviors"));
-        assertEquals(JsonNumber.of(2), block.get("repeat"), "the block repeat survives the write");
-        assertEquals(JsonNumber.of(1), block.get("wait"), "the rest of the block is untouched");
-        RoundTripAssertions.assertRoundTrips(BOTH, Stub::fromJson, Stub::toJson);
+        assertNull(written.get("_behaviors"), "rift 0.24.0 ignores a _behaviors object beside repeat");
+        assertEquals(JsonValue.parse("[{\"wait\": 1}]"), written.get("behaviors"), "the rest of the block runs");
     }
 
     /** The same, where the block independently needs the array form — the block repeat still survives. */
@@ -149,8 +149,9 @@ void responseLevelRepeatWinsWithAnArrayFormBlock() {
         JsonObject written = writtenResponse(json);
         assertEquals(JsonNumber.of(9), written.get("repeat"));
         JsonArray behaviors = assertInstanceOf(JsonArray.class, written.get("behaviors"));
-        assertEquals(3, behaviors.items().size(), "repeated wait keeps the array form, repeat included");
-        RoundTripAssertions.assertRoundTrips(json, Stub::fromJson, Stub::toJson);
+        assertEquals(2, behaviors.items().size(), "repeated wait keeps the array form, which holds no repeat");
+        String rewritten = Stub.fromJson(json).toJson();
+        RoundTripAssertions.assertRoundTrips(rewritten, Stub::fromJson, Stub::toJson);
     }
 
     /** A block-only repeat spelled via the array form stays a block entry. */
@@ -202,9 +203,9 @@ void responseLevelRepeatCoexistsWithArrayFormBehaviors() {
         RoundTripAssertions.assertRoundTrips(WITH_ARRAY_BEHAVIORS, Stub::fromJson, Stub::toJson);
     }
 
-    /** A lone response-level repeat must not drag the block into the array form. */
+    /** Beside a response-level repeat the block is the array: rift 0.24.0 ignores a _behaviors object there (rift#1709). */
     @Test
-    void aLoneResponseLevelRepeatDoesNotForceTheArrayForm() {
+    void aResponseLevelRepeatWritesTheBlockAsTheArray() {
         JsonObject written = writtenResponse("""
                 {
                   "predicates": [],
@@ -212,9 +213,8 @@ void aLoneResponseLevelRepeatDoesNotForceTheArrayForm() {
                 }
                 """);
         assertEquals(JsonNumber.of(2), written.get("repeat"));
-        JsonObject block = assertInstanceOf(JsonObject.class, written.get("_behaviors"));
-        assertEquals(JsonNumber.of(5), block.get("wait"));
-        assertNull(written.get("behaviors"), "one wait entry never needs the array form");
+        assertEquals(JsonValue.parse("[{\"wait\": 5}]"), written.get("behaviors"));
+        assertNull(written.get("_behaviors"));
     }
 
     @Test
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java
new file mode 100644
index 0000000..2b5c320
--- /dev/null
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java
@@ -0,0 +1,40 @@
+package io.github.achirdlabs.rift.spawn;
+
+import io.github.achirdlabs.rift.SpawnOptions;
+import org.junit.jupiter.api.Test;
+
+import java.nio.file.Path;
+import java.util.List;
+
+import static org.junit.jupiter.api.Assertions.assertEquals;
+import static org.junit.jupiter.api.Assertions.assertFalse;
+import static org.junit.jupiter.api.Assertions.assertThrows;
+import static org.junit.jupiter.api.Assertions.assertTrue;
+
+/** The {@code --scripts-dir} a spawned engine reads lookup CSVs and modules under from rift 0.24.0 (rift#1617). */
+class SpawnScriptsDirTest {
+
+    private static List<String> command(SpawnOptions opts) {
+        return RiftProcess.buildCommand(Path.of("/usr/bin/rift"), opts, 2525, Path.of("/tmp/rift.pid"));
+    }
+
+    @Test
+    void scriptsDirIsAGlobalOptionBeforeStart() {
+        List<String> cmd = command(SpawnOptions.builder().scriptsDir(Path.of("/srv/fixtures")).build());
+        int flag = cmd.indexOf("--scripts-dir");
+        assertTrue(flag >= 0 && flag < cmd.indexOf("start"), cmd.toString());
+        assertEquals("/srv/fixtures", cmd.get(flag + 1));
+    }
+
+    @Test
+    void unsetScriptsDirAddsNothing() {
+        SpawnOptions opts = SpawnOptions.builder().build();
+        assertFalse(command(opts).contains("--scripts-dir"));
+        assertTrue(opts.scriptsDir().isEmpty());
+    }
+
+    @Test
+    void nullScriptsDirIsRefused() {
+        assertThrows(NullPointerException.class, () -> SpawnOptions.builder().scriptsDir(null));
+    }
+}
diff --git a/rift-java-testcontainers/src/test/java/io/github/achirdlabs/rift/testcontainers/RiftContainerTest.java b/rift-java-testcontainers/src/test/java/io/github/achirdlabs/rift/testcontainers/RiftContainerTest.java
index 9ad0505..94db35d 100644
--- a/rift-java-testcontainers/src/test/java/io/github/achirdlabs/rift/testcontainers/RiftContainerTest.java
+++ b/rift-java-testcontainers/src/test/java/io/github/achirdlabs/rift/testcontainers/RiftContainerTest.java
@@ -36,9 +36,9 @@ class RiftContainerTest {
     @Test
     void defaultImageUsesPinnedEngineVersion() {
         // AC4: single-sourced from the <rift.engine.version> property via resource filtering.
-        assertEquals("0.23.0", RiftContainer.ENGINE_VERSION, "engine version resolved from filtered resource");
+        assertEquals("0.24.0", RiftContainer.ENGINE_VERSION, "engine version resolved from filtered resource");
         try (RiftContainer container = new RiftContainer()) {
-            assertEquals("zainalpour/rift-proxy:v0.23.0", container.configuredImageName());
+            assertEquals("zainalpour/rift-proxy:v0.24.0", container.configuredImageName());
         }
     }
 
@@ -155,7 +155,7 @@ void rejectsUpstreamTrustOnAnImageOlderThan018() {
     @Test
     void acceptsUpstreamTrustOnA018ImageOrAnUnversionedTag() {
         // A tag that is not a version (latest, a digest, a custom build) cannot be checked, so it is let through.
-        for (String image : new String[] {"zainalpour/rift-proxy:v0.23.0", "zainalpour/rift-proxy:0.19.1",
+        for (String image : new String[] {"zainalpour/rift-proxy:v0.24.0", "zainalpour/rift-proxy:0.19.1",
                 "zainalpour/rift-proxy:latest", "acme/rift:nightly"}) {
             try (RiftContainer container = new RiftContainer(DockerImageName.parse(image))) {
                 container.withUpstreamTrust(new UpstreamTrust.SkipVerify());

From 044f74e34f1318d1360d32355879f4a270ba83c3 Mon Sep 17 00:00:00 2001
From: Mohsen Zainalpour <zainalpour@gmail.com>
Date: Tue, 27 Oct 2026 08:57:43 -0400
Subject: [PATCH 2/3] test(spawn): compare the scripts-dir argument in the
 platform's path spelling

---
 .../io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java | 5 +++--
 1 file changed, 3 insertions(+), 2 deletions(-)

diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java
index 2b5c320..e7f5e42 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/spawn/SpawnScriptsDirTest.java
@@ -20,10 +20,11 @@ private static List<String> command(SpawnOptions opts) {
 
     @Test
     void scriptsDirIsAGlobalOptionBeforeStart() {
-        List<String> cmd = command(SpawnOptions.builder().scriptsDir(Path.of("/srv/fixtures")).build());
+        Path dir = Path.of("/srv/fixtures");
+        List<String> cmd = command(SpawnOptions.builder().scriptsDir(dir).build());
         int flag = cmd.indexOf("--scripts-dir");
         assertTrue(flag >= 0 && flag < cmd.indexOf("start"), cmd.toString());
-        assertEquals("/srv/fixtures", cmd.get(flag + 1));
+        assertEquals(dir.toString(), cmd.get(flag + 1), "the platform's spelling of the path");
     }
 
     @Test

From 24512709e2986bce1476af59d73bdc9ca0366a15 Mon Sep 17 00:00:00 2001
From: Mohsen Zainalpour <zainalpour@gmail.com>
Date: Tue, 27 Oct 2026 10:41:56 -0400
Subject: [PATCH 3/3] fix(model): read behaviors with Mountebank's precedence,
 as rift 0.24.0 does

From rift 0.24.0 a behaviors key (a null one included) or a response-level
repeat voids a _behaviors object beside it whole (rift#1709), as Mountebank
already did. The reader still read that block, so writing it back as the array
0.24.0 runs would have switched on behaviors the engine had been ignoring. A
voided block is no longer read. The legacy extra-map constructors keep both,
since a caller putting them there means both.

Closes #345
---
 docs/design/sdk-api.md                        |  3 ++
 .../achirdlabs/rift/model/Response.java       | 25 +++++++++----
 .../rift/model/ResponseLevelRepeatTest.java   | 36 ++++++++++---------
 3 files changed, 42 insertions(+), 22 deletions(-)

diff --git a/docs/design/sdk-api.md b/docs/design/sdk-api.md
index 9eba1a6..02741c4 100644
--- a/docs/design/sdk-api.md
+++ b/docs/design/sdk-api.md
@@ -570,6 +570,9 @@ public sealed interface BehaviorChain<S extends ResponseSpec & BehaviorChain<S>>
 // `repeat` is written beside the response and any other is dropped; and an element may not hold a
 // list of `copy`/`lookup` (rift#1639), so a list is written one item per element and read back the
 // same way. This trades rift 0.17.0's block-only `repeat` for an imposter the pinned engine accepts.
+// The read follows the same rule (rift#1709, Mountebank's upcast): a `behaviors` key (even `null`)
+// or a response-level `repeat` voids a `_behaviors` object beside it, so the voided block is not
+// read and a read + write never starts running it. The legacy `extra`-map constructors keep both.
 IsSpec templated()                                       // rename of template(); _rift.templated
 // declarative flow-state writes after the response (_rift.stateOps, rift >= 0.18.0; #227). Run in
 // chain order after templating and behaviors; engine-version gated at create/replaceAll.
diff --git a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
index 11f6564..f91f8f7 100644
--- a/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
+++ b/rift-java-core/src/main/java/io/github/achirdlabs/rift/model/Response.java
@@ -1,5 +1,6 @@
 package io.github.achirdlabs.rift.model;
 
+import io.github.achirdlabs.rift.json.JsonNull;
 import io.github.achirdlabs.rift.json.JsonObject;
 import io.github.achirdlabs.rift.json.JsonString;
 import io.github.achirdlabs.rift.json.JsonValue;
@@ -220,15 +221,22 @@ static Response read(JsonObject obj) {
      * Reads behaviors from either shape: the {@code _behaviors} object every fixture uses, or the
      * {@code behaviors} array-of-single-key-objects the engine itself emits in {@code GET /imposters}
      * output. Accepting the array form keeps consuming engine output from silently dropping them.
+     *
+     * <p>Which block runs follows Mountebank's rule, which rift 0.24.0 adopted (rift#1709): a
+     * {@code behaviors} key (a {@code null} one included) or a response-level {@code repeat} voids
+     * {@code _behaviors} whole, its {@code repeat} too. A voided block is not read, so a read and a
+     * write never turn on behaviors the engine was ignoring.
      */
     private static Behaviors readBehaviors(JsonObject obj) {
-        JsonValue underscore = obj.get("_behaviors");
-        if (underscore != null) {
-            return Behaviors.read(JsonSupport.requireObject(underscore, "_behaviors"));
-        }
         JsonValue array = obj.get("behaviors");
         if (array != null) {
-            return Behaviors.readArray(JsonSupport.requireArray(array, "behaviors"));
+            return array instanceof JsonNull
+                    ? Behaviors.EMPTY
+                    : Behaviors.readArray(JsonSupport.requireArray(array, "behaviors"));
+        }
+        JsonValue underscore = obj.get("_behaviors");
+        if (underscore != null && obj.get("repeat") == null) {
+            return Behaviors.read(JsonSupport.requireObject(underscore, "_behaviors"));
         }
         return Behaviors.EMPTY;
     }
@@ -295,8 +303,13 @@ private static Behaviors readAllBehaviors(JsonObject obj) {
         return foldResponseLevelRepeat(readBehaviors(obj), obj);
     }
 
+    /**
+     * The legacy {@code extra}-map constructors: a caller putting {@code _behaviors} beside {@code
+     * repeat} there means both, so a {@code repeat} does not void the block as it does on the wire.
+     */
     private static Behaviors liftBehaviors(Map<String, JsonValue> extra) {
-        return readAllBehaviors(new JsonObject(extra));
+        JsonObject obj = new JsonObject(extra);
+        return foldResponseLevelRepeat(readBehaviors(JsonSupport.withoutKeys(obj, "repeat")), obj);
     }
 
     private static Map<String, JsonValue> withoutBehaviorKeys(Map<String, JsonValue> extra) {
diff --git a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
index 21dbe4f..33a7d1b 100644
--- a/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
+++ b/rift-java-core/src/test/java/io/github/achirdlabs/rift/model/ResponseLevelRepeatTest.java
@@ -107,27 +107,31 @@ void blockRepeatStillWritesInsideTheBlock() {
     }
 
     /**
-     * The response-level value wins where the engine honours it — but the block one is NOT
-     * discarded at parse time: which spelling applies is engine-dependent (rift 0.17.0 and earlier
-     * ignore the response-level field and honour the block one). The write, though, is for the
-     * pinned engine: from rift 0.24.0 a {@code _behaviors} object beside a response-level {@code
-     * repeat} is ignored whole (rift#1709), so the block goes out as the array, which cannot hold a
-     * {@code repeat} (rift#1582) — the block one, which never took effect there, is dropped.
+     * A response-level {@code repeat} voids a {@code _behaviors} object beside it whole, its {@code
+     * repeat} included, as Mountebank and rift 0.24.0 read it (rift#1709). The voided block is not
+     * read, so a read and a write never start running behaviors the engine ignored.
      */
     @Test
-    void responseLevelRepeatWinsButTheBlockOneIsPreserved() {
+    void aResponseLevelRepeatVoidsTheBlockObjectBesideIt() {
         Response.Is is = isOf(BOTH);
-        List<Behavior> repeats = is.behaviors().entries().stream()
-                .filter(Behavior.Repeat.class::isInstance)
-                .toList();
-        assertEquals(2, repeats.size(), "both spellings are kept");
-        assertEquals(4, is.behaviors().effectiveRepeat().orElseThrow().count(),
-                "the response-level value is the effective one");
+        assertEquals(List.of(new Behavior.Repeat(4, true)), is.behaviors().entries());
 
         JsonObject written = writtenResponse(BOTH);
         assertEquals(JsonNumber.of(4), written.get("repeat"));
-        assertNull(written.get("_behaviors"), "rift 0.24.0 ignores a _behaviors object beside repeat");
-        assertEquals(JsonValue.parse("[{\"wait\": 1}]"), written.get("behaviors"), "the rest of the block runs");
+        assertNull(written.get("_behaviors"));
+        assertNull(written.get("behaviors"), "the voided wait does not come back as the array");
+    }
+
+    /** A {@code behaviors} key, a {@code null} one included, voids {@code _behaviors} too (rift#1709). */
+    @Test
+    void aBehaviorsKeyVoidsTheBlockObjectBesideIt() {
+        assertEquals(List.of(new Behavior.Decorate("d")), isOf("""
+                {"predicates": [], "responses": [
+                  {"is": {}, "behaviors": [{"decorate": "d"}], "_behaviors": {"wait": 9}}]}
+                """).behaviors().entries());
+        assertTrue(isOf("""
+                {"predicates": [], "responses": [{"is": {}, "behaviors": null, "_behaviors": {"wait": 9}}]}
+                """).behaviors().isEmpty());
     }
 
     /** The same, where the block independently needs the array form — the block repeat still survives. */
@@ -209,7 +213,7 @@ void aResponseLevelRepeatWritesTheBlockAsTheArray() {
         JsonObject written = writtenResponse("""
                 {
                   "predicates": [],
-                  "responses": [{"is": {"statusCode": 200}, "repeat": 2, "_behaviors": {"wait": 5}}]
+                  "responses": [{"is": {"statusCode": 200}, "repeat": 2, "behaviors": [{"wait": 5}]}]
                 }
                 """);
         assertEquals(JsonNumber.of(2), written.get("repeat"));