Fix interpreter/binary parity for dict extraction and SSE test timeouts

KrisSimon · KrisSimon · commit 4b0149790469 · 2026-03-29T00:32:02.000+01:00
ExtractAction now extracts from pre-parsed dictionaries using result
specifiers, fixing [object Object] in interpreter mode when the HTTP
body is already parsed. SSE example test hints corrected from invalid
type:keepalive to proper keep-alive:true with 8s timeout.
diff --git a/Examples/SQLiteExample/plugins/SQLitePlugin/Package.resolved b/Examples/SQLiteExample/plugins/SQLitePlugin/Package.resolved
diff --git a/Examples/SSEClient/test.hint b/Examples/SSEClient/test.hint
@@ -1,5 +1,7 @@
 # Test hints for SSEClient
 # Connects to a live SSE stream; verifies startup output.
-type: keepalive
+type: console
+keep-alive: true
+timeout: 8
 allow-error: true
 occurrence-check: true
diff --git a/Examples/SSEStreamDemo/test.hint b/Examples/SSEStreamDemo/test.hint
@@ -1,7 +1,8 @@
 # Test hints for SSEStreamDemo
 # This example connects to a live SSE stream; output is non-deterministic.
 # We only verify that the application starts and connects successfully.
-# The test times out after 8 seconds (SSE streams are persistent).
-type: keepalive
+type: console
+keep-alive: true
+timeout: 8
 allow-error: true
 occurrence-check: true
diff --git a/Sources/AROParser/AST.swift b/Sources/AROParser/AST.swift
@@ -1147,6 +1147,23 @@ public enum BinaryOperator: String, Sendable, CaseIterable {
     // Collection
     case contains = "contains"
     case matches = "matches"
+
+    /// True for comparison/equality operators (==, !=, <, >, <=, >=, is, is not, contains, matches)
+    public var isComparison: Bool {
+        switch self {
+        case .equal, .notEqual, .lessThan, .greaterThan,
+             .lessEqual, .greaterEqual, .is, .isNot,
+             .contains, .matches:
+            return true
+        default:
+            return false
+        }
+    }
+
+    /// True for logical connectives (and, or)
+    public var isLogical: Bool {
+        self == .and || self == .or
+    }
 }
 
 /// Unary operators
diff --git a/Sources/AROParser/Parser.swift b/Sources/AROParser/Parser.swift
@@ -1819,6 +1819,20 @@ extension Parser {
             let right = try parsePrecedence(precedence)
             let span = left.span.merged(with: right.span)
 
+            // Short-hand logical: `<x> = "a" or "b"` → `<x> = "a" or <x> = "b"`
+            // When `or`/`and` joins a comparison on the left with a bare value on the right,
+            // distribute the left-hand comparison's subject and operator to the right side.
+            if (actualOp == .or || actualOp == .and),
+               let leftBin = left as? BinaryExpression,
+               leftBin.op.isComparison,
+               !((right as? BinaryExpression)?.op.isComparison ?? false),
+               !((right as? BinaryExpression)?.op.isLogical ?? false) {
+                let expandedRight = BinaryExpression(
+                    left: leftBin.left, op: leftBin.op, right: right, span: right.span
+                )
+                return BinaryExpression(left: left, op: actualOp, right: expandedRight, span: span)
+            }
+
             return BinaryExpression(left: left, op: actualOp, right: right, span: span)
         }
     }
diff --git a/Sources/ARORuntime/Actions/BuiltIn/ExtractAction.swift b/Sources/ARORuntime/Actions/BuiltIn/ExtractAction.swift
@@ -112,6 +112,15 @@ public struct ExtractAction: SynchronousAction {
             return extracted
         }
 
+        // Extract from dictionary using result specifier as key
+        // Example: <Extract> the <message-text: message> from the <body>.
+        // When body is already a parsed dictionary, uses "message" as key
+        if let specifier = result.specifiers.first,
+           let dict = resolvedSource as? [String: any Sendable],
+           let value = dict[specifier] {
+            return value
+        }
+
         // Use result specifier to extract from string (form data, JSON, etc.)
         // Example: <Extract> the <message-text: message> from the <body>.
         // Uses "message" as the key to extract from body string
diff --git a/Sources/ARORuntime/Core/ExecutionEngine.swift b/Sources/ARORuntime/Core/ExecutionEngine.swift
@@ -1310,6 +1310,9 @@ public actor ExecutionEngine {
             let eventData: [String: any Sendable] = ["key": event.key]
             context.bind("event", value: eventData)
             context.bind("event:key", value: event.key)
+            // Also bind plain "key" so `where <key> = "down"` works
+            // (consistent with binary mode which binds all payload keys)
+            context.bind("key", value: event.key)
         }
     }
 

Original file line number	Diff line number	Diff line change
`@@ -1310,6 +1310,9 @@ public actor ExecutionEngine {`
`1310`	`1310`	`let eventData: [String: any Sendable] = ["key": event.key]`
`1311`	`1311`	`context.bind("event", value: eventData)`
`1312`	`1312`	`context.bind("event:key", value: event.key)`
	`1313`	+ // Also bind plain "key" so `where <key> = "down"` works
	`1314`	`+ // (consistent with binary mode which binds all payload keys)`
	`1315`	`+ context.bind("key", value: event.key)`
`1313`	`1316`	`}`
`1314`	`1317`	`}`
`1315`	`1318`