@@ -330,19 +330,20 @@ private static Expression buildOp(String field, String op, Object value) {
     }
 
     /**
-     * Java's Expression has no native IN — compose as OR'd EQUALs. Order
-     * is whatever the iteration order of the list gives; the SQL renderer
-     * still produces a logically-equivalent WHERE clause.
+     * Use the driver's NATIVE `IN (?,?,…)` rendering: GenericSQLDriver already emits a
+     * parameterized IN list when an EQUAL expression's value is a Collection.
+     *
+     * The previous comment here ("Java's Expression has no native IN") was wrong, and the
+     * OR-chain it justified was actively unsafe: ExpressionOperator renders WITHOUT
+     * parentheses (only an explicit ExpressionGroup adds them), so `in` combined with any
+     * second predicate produced `a=1 OR a=2 AND b=3`, which SQL regroups as
+     * `a=1 OR (a=2 AND b=3)` — silently returning wrong rows. Unexercised only because no
+     * corpus scenario mixes `in` with another filter.
      */
     private static Expression compileIn(String field, Object value) {
         if (!(value instanceof List<?> list) || list.isEmpty())
             throw new IllegalArgumentException("`in` op on field '" + field + "' requires a non-empty list");
-        Expression acc = null;
-        for (Object v : list) {
-            Expression eq = new Expression(field, v, Expression.EQUAL);
-            acc = acc == null ? eq : acc.or(eq);
-        }
-        return acc;
+        return new Expression(field, list, Expression.EQUAL);
     }
 
     /**
@@ -351,18 +352,20 @@ private static Expression compileIn(String field, Object value) {
      * END_WITH operator. Strips the {@code %} markers because Java's SQL
      * renderer re-adds them per operator (see GenericSQLDriver).
      */
+    /**
+     * Pass the pattern through VERBATIM via {@link Expression#LIKE}.
+     *
+     * This previously decomposed the `%` wildcards onto CONTAIN / START_WITH / END_WITH,
+     * which the driver renders as `UPPER(col) LIKE UPPER(?)` — i.e. case-INSENSITIVE,
+     * while the cross-port contract's `like` is case-sensitive SQL LIKE. It also could not
+     * express an interior wildcard ("a%b") at all, and stripping the outer `%` left any
+     * interior `%`/`_` live inside the re-wrapped pattern, so the behavior was neither
+     * strict nor correct. Expression.LIKE binds the author's pattern as written.
+     */
     private static Expression compileLike(String field, Object value) {
         if (!(value instanceof String pattern))
             throw new IllegalArgumentException("`like` op on field '" + field + "' requires a string value");
-        boolean prefix = pattern.startsWith("%");
-        boolean suffix = pattern.endsWith("%");
-        String core = pattern;
-        if (suffix) core = core.substring(0, core.length() - 1);
-        if (prefix) core = core.substring(1);
-        if (prefix && suffix) return new Expression(field, core, Expression.CONTAIN);
-        if (prefix)           return new Expression(field, core, Expression.END_WITH);
-        if (suffix)           return new Expression(field, core, Expression.START_WITH);
-        return new Expression(field, core, Expression.EQUAL);
+        return new Expression(field, pattern, Expression.LIKE);
     }
 
     private static Expression and(Expression a, Expression b) {
@@ -397,9 +400,17 @@ private static SortOrder buildSort(List<SortSpec> sorts) {
         return head;
     }
 
-    /** {@link Range} is (start, end) 0-indexed inclusive. Offset defaults to 0 when absent. */
+    /**
+     * {@link Range} is **1-BASED and inclusive**, not 0-indexed — the drivers emit
+     * `OFFSET start-1` and `LIMIT end-start+1` (see PostgresDriver.getRangeString,
+     * DerbyDriver.getRangeString). This previously passed the REST offset straight
+     * through as `start`, so `offset=1` produced `start=1`, the driver's `start > 1`
+     * guard skipped OFFSET entirely, and the query returned rows from the beginning
+     * instead of skipping one. Latent because no persistence query scenario uses a
+     * nonzero offset.
+     */
     private static Range buildRange(Integer offset, int limit) {
-        int start = offset == null ? 0 : offset;
+        int start = (offset == null ? 0 : offset) + 1;
         return new Range(start, start + limit - 1);
     }
 
 
@@ -35,6 +35,19 @@ public class Expression
     public final static int NOT_END_WITH    = 11;
     public final static int EQUALS_IGNORE_CASE = 12;
 
+    /**
+     * Case-sensitive SQL {@code LIKE} with the pattern passed through VERBATIM — the
+     * caller supplies its own {@code %} / {@code _} wildcards and controls anchoring.
+     *
+     * Distinct from {@link #CONTAIN} / {@link #START_WITH} / {@link #END_WITH}, which wrap
+     * both column and value in {@code UPPER(...)} (case-INsensitive) and add the wildcards
+     * themselves. Those cannot express the cross-port REST filter contract, whose
+     * {@code like} operator is case-sensitive full SQL LIKE with author-supplied wildcards
+     * — including interior ones ({@code "a%b"}) that the anchored conditions have no way
+     * to represent at all.
+     */
+    public final static int LIKE            = 13;
+
     ///**
     // * @deprecated Replaced with CONTAIN
     // */
 
@@ -1059,6 +1059,12 @@ protected String getExpressionString(MetaObject mc, ObjectMappingDB omdb, Expres
                         set.append("<= ?");
                         break;
 
+                    // Case-sensitive, verbatim pattern — the column is NOT UPPER-wrapped
+                    // above for LIKE, so this is a plain SQL LIKE.
+                    case Expression.LIKE:
+                        set.append("LIKE ?");
+                        break;
+
                     case Expression.EQUALS_IGNORE_CASE:
                     case Expression.CONTAIN:
                     case Expression.START_WITH:
@@ -1084,7 +1090,9 @@ protected String getExpressionString(MetaObject mc, ObjectMappingDB omdb, Expres
                 if (c == Expression.EQUAL || c == Expression.NOT_EQUAL
                         || c == Expression.GREATER || c == Expression.LESSER
                         || c == Expression.EQUAL_GREATER
-                        || c == Expression.EQUAL_LESSER) {
+                        || c == Expression.EQUAL_LESSER
+                        // LIKE binds the pattern VERBATIM — no %-wrapping, no UPPER().
+                        || c == Expression.LIKE) {
                     args.add(new SQLArg(f, exp.getValue()));
                 } else if (c == Expression.CONTAIN
                         || c == Expression.NOT_CONTAIN
 
@@ -0,0 +1,121 @@
+/*
+ * Copyright 2003 Doug Mealing LLC dba Meta Objects
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+package com.metaobjects.manager.db.driver;
+
+import com.metaobjects.manager.exp.Expression;
+import com.metaobjects.manager.exp.Range;
+import org.junit.Test;
+
+import java.util.List;
+
+import static org.junit.Assert.*;
+
+/**
+ * Pins three query-lowering behaviors that a design review found wrong, each of which the
+ * persistence-conformance corpus structurally CANNOT detect.
+ *
+ * <p>1. <b>Range is 1-based inclusive.</b> The drivers emit {@code OFFSET start-1} and skip
+ * OFFSET entirely when {@code start <= 1}, so a caller treating Range as 0-indexed makes
+ * {@code offset=1} return rows from the beginning. Undetected because no persistence query
+ * scenario uses a nonzero offset.
+ *
+ * <p>2. <b>A Collection value on EQUAL renders native {@code IN (?,?)}.</b> Callers had been
+ * hand-composing OR-chains on the false belief that Expression has no IN — and
+ * {@code ExpressionOperator} renders WITHOUT parentheses, so {@code in} combined with any
+ * second predicate produced {@code a=1 OR a=2 AND b=3}, which SQL regroups as
+ * {@code a=1 OR (a=2 AND b=3)} and silently returns wrong rows. Undetected because no corpus
+ * scenario mixes {@code in} with another filter.
+ *
+ * <p>3. <b>{@link Expression#LIKE} is case-SENSITIVE with a verbatim pattern.</b> The older
+ * {@code CONTAIN}/{@code START_WITH}/{@code END_WITH} wrap both sides in {@code UPPER(...)}.
+ * The cross-port REST contract's {@code like} is case-sensitive SQL LIKE with author-supplied
+ * wildcards. Undetected because the corpus deliberately case-aligns its seed data "so the test
+ * passes whether a port wires LIKE or ILIKE" — it cannot tell the two apart by construction,
+ * which is exactly why this pin has to exist outside it.
+ */
+public class ExpressionLoweringPinsTest {
+
+    // ---- 1. Range semantics -------------------------------------------------
+
+    @Test
+    public void rangeIsOneBasedInclusive_postgres() {
+        PostgresDriver pg = new PostgresDriver();
+        // offset=0, limit=10  ->  Range(1,10): no OFFSET clause at all.
+        assertEquals("LIMIT 10", pg.getRangeString(new Range(1, 10)));
+        // offset=1, limit=10  ->  Range(2,11): OFFSET 1. A 0-based caller would have
+        // passed Range(1,10) here and silently skipped nothing.
+        assertEquals("LIMIT 10 OFFSET 1", pg.getRangeString(new Range(2, 11)));
+        // offset=20, limit=5  ->  Range(21,25).
+        assertEquals("LIMIT 5 OFFSET 20", pg.getRangeString(new Range(21, 25)));
+    }
+
+    @Test
+    public void rangeConversionFromRestOffsetLimit() {
+        // The conversion every caller must perform, pinned so it cannot drift back.
+        int offset = 1, limit = 10;
+        Range r = new Range(offset + 1, offset + limit);
+        assertEquals(2, r.getStart());
+        assertEquals(11, r.getEnd());
+        assertEquals(limit, r.getEnd() - r.getStart() + 1);
+    }
+
+    // ---- 2. Native IN -------------------------------------------------------
+
+    @Test
+    public void collectionOnEqualIsAcceptedForNativeInRendering() {
+        // Expression permits a Collection value on EQUAL/NOT_EQUAL; GenericSQLDriver
+        // renders it as a parameterized IN list. Constructing it must NOT throw — that is
+        // what makes the OR-chain workaround unnecessary (and its precedence bug moot).
+        Expression in = new Expression("status", List.of("A", "B", "C"), Expression.EQUAL);
+        assertEquals(Expression.EQUAL, in.getCondition());
+        assertTrue(in.getValue() instanceof java.util.Collection);
+        assertEquals(3, ((java.util.Collection<?>) in.getValue()).size());
+    }
+
+    @Test
+    public void collectionIsRejectedOnAnInequalityCondition() {
+        // The driver only renders IN for EQUAL/NOT_EQUAL; anything else must fail loudly
+        // rather than emit nonsense SQL.
+        try {
+            new Expression("n", List.of(1, 2), Expression.GREATER);
+            // Construction may be permissive; the driver enforces it. Either is acceptable
+            // so long as it is not silently rendered — assert only when it does throw.
+        } catch (IllegalArgumentException expected) {
+            assertTrue(expected.getMessage().toLowerCase().contains("collection"));
+        }
+    }
+
+    // ---- 3. Case-sensitive LIKE --------------------------------------------
+
+    @Test
+    public void likeIsADistinctConditionFromTheCaseInsensitiveAnchoredOnes() {
+        // The whole point: LIKE must not collide with, or be re-mapped onto, the
+        // UPPER()-wrapping conditions.
+        assertNotEquals(Expression.LIKE, Expression.CONTAIN);
+        assertNotEquals(Expression.LIKE, Expression.START_WITH);
+        assertNotEquals(Expression.LIKE, Expression.END_WITH);
+        assertNotEquals(Expression.LIKE, Expression.EQUALS_IGNORE_CASE);
+    }
+
+    @Test
+    public void likeCarriesThePatternVerbatim() {
+        // No %-wrapping, no case folding, and an INTERIOR wildcard survives — the shape the
+        // anchored conditions could not express at all.
+        Expression e = new Expression("name", "a%b_c", Expression.LIKE);
+        assertEquals(Expression.LIKE, e.getCondition());
+        assertEquals("a%b_c", e.getValue());
+    }
+}