DeepSWE‑style long‑horizon SWE tasks

diff --git a/packages/terra-draw/src/modes/grid-snapping.behavior.ts b/packages/terra-draw/src/modes/grid-snapping.behavior.ts
new file mode 100644
--- /dev/null
+++ b/packages/terra-draw/src/modes/grid-snapping.behavior.ts
@@ -0,0 +1,142 @@
+import { Position } from "geojson";
+import { SnapToGrid, TerraDrawMouseEvent } from "../common";
+import { isNonNullObject } from "../common/checks";
+import {
+	validLatitude,
+	validLongitude,
+} from "../geometry/boolean/is-valid-coordinate";
+import { limitPrecision } from "../geometry/limit-decimal-precision";
+import {
+	lngLatToWebMercatorXY,
+	webMercatorXYToLngLat,
+} from "../geometry/project/web-mercator";
+import { BehaviorConfig, TerraDrawModeBehavior } from "./base.behavior";
+
+type GridUnits = NonNullable<SnapToGrid["units"]>;
+
+type ValidGrid = {
+	size: number;
+	units: GridUnits;
+	origin: [number, number];
+};
+
+const DEFAULT_UNITS: GridUnits = "degrees";
+
+const isFiniteNumber = (value: unknown): value is number =>
+	typeof value === "number" && Number.isFinite(value);
+
+/**
+ * Snaps positions to a regular grid (lattice), either in degrees of
+ * longitude/latitude or in meters on the spherical Web Mercator plane.
+ */
+export class GridSnappingBehavior extends TerraDrawModeBehavior {
+	constructor(readonly config: BehaviorConfig) {
+		super(config);
+	}
+
+	/**
+	 * Returns the grid position nearest to the event, rounded to the coordinate
+	 * precision. Returns undefined if the grid options are invalid, or if the
+	 * snapped position falls outside of valid longitude/latitude bounds, in which
+	 * case the grid does not apply to the event.
+	 */
+	public getSnappableCoordinate(
+		event: Pick<TerraDrawMouseEvent, "lng" | "lat">,
+		options: SnapToGrid | undefined,
+	): Position | undefined {
+		const grid = this.getValidGrid(options);
+
+		if (!grid) {
+			return undefined;
+		}
+
+		const [snappedLng, snappedLat] =
+			grid.units === "meters"
+				? this.snapMeters(event, grid)
+				: this.snapDegrees(event, grid);
+
+		const lng = this.limitPrecision(snappedLng);
+		const lat = this.limitPrecision(snappedLat);
+
+		if (!validLongitude(lng) || !validLatitude(lat)) {
+			return undefined;
+		}
+
+		return [lng, lat];
+	}
+
+	private snapDegrees(
+		{ lng, lat }: Pick<TerraDrawMouseEvent, "lng" | "lat">,
+		{ size, origin }: ValidGrid,
+	): Position {
+		return [
+			this.snapValue(lng, origin[0], size),
+			this.snapValue(lat, origin[1], size),
+		];
+	}
+
+	private snapMeters(
+		{ lng, lat }: Pick<TerraDrawMouseEvent, "lng" | "lat">,
+		{ size, origin }: ValidGrid,
+	): Position {
+		const { x, y } = lngLatToWebMercatorXY(lng, lat);
+		const { x: originX, y: originY } = lngLatToWebMercatorXY(
+			origin[0],
+			origin[1],
+		);
+
+		const snapped = webMercatorXYToLngLat(
+			this.snapValue(x, originX, size),
+			this.snapValue(y, originY, size),
+		);
+
+		return [snapped.lng, snapped.lat];
+	}
+
+	/**
+	 * Snaps a single value to the nearest grid line. Math.round means
+	 * that exact halves round towards +infinity.
+	 */
+	private snapValue(value: number, origin: number, size: number) {
+		return origin + Math.round((value - origin) / size) * size;
+	}
+
+	private limitPrecision(value: number) {
+		const limited = limitPrecision(value, this.coordinatePrecision);
+
+		// Normalise negative zero, which can result from rounding
+		// tiny negative values, so that coordinates are always [0, 0]
+		return limited === 0 ? 0 : limited;
+	}
+
+	/**
+	 * Validates the grid options, applying defaults. Invalid options
+	 * return undefined which silently disables grid snapping.
+	 */
+	private getValidGrid(options: unknown): ValidGrid | undefined {
+		if (!isNonNullObject(options)) {
+			return undefined;
+		}
+
+		const { size, units = DEFAULT_UNITS, origin = [0, 0] } = options;
+
+		if (!isFiniteNumber(size) || size <= 0) {
+			return undefined;
+		}
… 3,133 more lines not shown (29 files changed in all)

diff --git a/rdflib/term.py b/rdflib/term.py
--- a/rdflib/term.py
+++ b/rdflib/term.py
@@ -110,6 +110,17 @@ def _is_valid_langtag(tag: str) -> bool:
     return bool(_lang_tag_regex.match(tag))
 
 
+# RDF 1.2 base directions of directional language-tagged strings, see
+# https://www.w3.org/TR/rdf12-concepts/#dfn-base-direction
+_VALID_DIRECTIONS = frozenset(("ltr", "rtl"))
+
+
+def _is_valid_direction(direction: Any) -> bool:
+    """Is `direction` a valid RDF 1.2 base direction (exactly `ltr` or `rtl`)?"""
+    # str() so that str subclasses (e.g. a Literal "rtl") are judged by value
+    return isinstance(direction, str) and str(direction) in _VALID_DIRECTIONS
+
+
 def _is_valid_unicode(value: Union[str, bytes]) -> bool:
     """
     Verify that the provided value can be converted into a Python
@@ -532,6 +543,24 @@ class Literal(Identifier):
 
     A literal is a language-tagged string if the third element is present. Lexical representations of language tags MAY be converted to lower case. The value space of language tags is always in lower case.
 
+    RDF 1.2 adds an optional fourth element to language-tagged strings, a
+    [base direction](https://www.w3.org/TR/rdf12-concepts/#dfn-base-direction)
+    which is either `ltr` or `rtl`. Such a *directional language-tagged
+    string* has the datatype `rdf:dirLangString`, it is written as
+    `"..."@ar--rtl` in N-Triples, Turtle, SPARQL etc. and is created with the
+    `direction` parameter:
+
+    ```python
+    >>> lit = Literal("hello", lang="ar", direction="rtl")
+    >>> lit.language, lit.direction, lit.datatype
+    ('ar', 'rtl', None)
+    >>> lit.n3()
+    '"hello"@ar--rtl'
+    >>> lit == Literal("hello", lang="ar")
+    False
+
+    ```
+
     ---
 
     For valid XSD datatypes, the lexical form is optionally normalized
@@ -631,7 +660,8 @@ class Literal(Identifier):
     # NOTE: _datatype should maybe be of type URIRef, and not optional.
     _datatype: Optional[URIRef]
     _ill_typed: Optional[bool]
-    __slots__ = ("_language", "_datatype", "_value", "_ill_typed")
+    _direction: Optional[str]
+    __slots__ = ("_language", "_datatype", "_value", "_ill_typed", "_direction")
 
     def __new__(
         cls,
@@ -639,8 +669,26 @@ class Literal(Identifier):
         lang: Optional[str] = None,
         datatype: Optional[str] = None,
         normalize: Optional[bool] = None,
+        direction: Optional[str] = None,
     ):
-        """Create a new Literal instance."""
+        """Create a new Literal instance.
+
+        Args:
+            lexical_or_value: The lexical form (a `str`), a Python value to
+                convert, or another `Literal` to copy.
+            lang: An optional language tag.
+            datatype: An optional datatype IRI, mutually exclusive with `lang`.
+            normalize: Whether to normalize the lexical form of recognized
+                datatypes, defaults to `rdflib.NORMALIZE_LITERALS`.
+            direction: An optional RDF 1.2 base direction, `"ltr"` or `"rtl"`;
+                only allowed together with a language tag.
+
+        Raises:
+            TypeError: If both `lang` and `datatype` are given, or if a
+                `direction` is given without a language tag.
+            ValueError: If `lang` is not a valid language tag or `direction`
+                is not `"ltr"` or `"rtl"`.
+        """
         if lang == "":
             lang = None  # no empty lang-tags in RDF
 
@@ -655,6 +703,25 @@ class Literal(Identifier):
         if lang is not None and not _is_valid_langtag(lang):
             raise ValueError(f"'{str(lang)}' is not a valid language tag!")
 
+        if direction is not None:
+            if not _is_valid_direction(direction):
+                raise ValueError(
+                    f"{direction!r} is not a valid base direction, "
+                    "it must be 'ltr' or 'rtl'"
+                )
+            direction = str(direction)
+            if datatype is not None or (
+                lang is None
+                and not (
+                    isinstance(lexical_or_value, Literal) and lexical_or_value.language
+                )
+            ):
+                raise TypeError(
+                    "A Literal can only have a base direction if it has a "
+                    "language tag (and no datatype), "
+                    "per https://www.w3.org/TR/rdf12-concepts/#section-Graph-Literal"
+                )
+
         if datatype is not None:
             datatype = URIRef(datatype)
 
@@ -664,6 +731,9 @@ class Literal(Identifier):
             # create from another Literal instance
 
             lang = lang or lexical_or_value.language
+            if direction is None and lang and datatype is None:
+                # keep the base direction of the copied (language-tagged) literal
+                direction = lexical_or_value.direction
             if datatype is not None:
                 # override datatype
                 value = _castLexicalToPython(lexical_or_value, datatype)
@@ -699,6 +769,7 @@ class Literal(Identifier):
                 lexical_or_value = _value
             if datatype is not None:
                 lang = None
+                direction = None
 
         if isinstance(lexical_or_value, bytes):
             lexical_or_value = lexical_or_value.decode("utf-8")
… 2,025 more lines not shown (19 files changed in all)

diff --git a/src/xmlparser/OrderedObjParser.js b/src/xmlparser/OrderedObjParser.js
--- a/src/xmlparser/OrderedObjParser.js
+++ b/src/xmlparser/OrderedObjParser.js
@@ -10,6 +10,7 @@ import { Expression, Matcher } from 'path-expression-matcher';
 import { ExpressionSet } from 'path-expression-matcher';
 import { EntityDecoder, XML, CURRENCY, COMMON_HTML, ENTITY_ACTION } from '@nodable/entities';
 import { isUnsafe, HTML as HTML_CONTEXT, XML as XML_CONTEXT } from "is-unsafe"
+import { getNamespaceAliases, createRootScope, isNamespaceDeclaration, declareNamespaces, resolveQName } from './namespaces.js';
 
 
 // const regx =
@@ -79,12 +80,22 @@ export default class OrderedObjParser {
     this.parseTextData = parseTextData;
     this.resolveNameSpace = resolveNameSpace;
     this.buildAttributesMap = buildAttributesMap;
+    this.buildAttributes = buildAttributes;
+    this.readNamespacedStartTag = readNamespacedStartTag;
     this.isItStopNode = isItStopNode;
     this.replaceEntitiesValue = replaceEntitiesValue;
     this.readStopNodeData = readStopNodeData;
     this.saveTextToParentTag = saveTextToParentTag;
     this.addChild = addChild;
     this.ignoreAttributesFn = getIgnoreAttributesFn(this.options.ignoreAttributes)
+    // resolveNamespaces: namespace URI to alias map when enabled, null otherwise
+    this.nsAliases = getNamespaceAliases(this.options.resolveNamespaces);
+    // removeNSPrefix is ignored when names are resolved by namespace URI
+    this.removeNSPrefix = this.options.removeNSPrefix && this.nsAliases === null;
+    this.decodeNamespaceUri = (value) => {
+      const entityConfig = this.options.processEntities;
+      return entityConfig && entityConfig.enabled ? this.entityDecoder.decode(value) : value;
+    };
     this.entityExpansionCount = 0;
     this.currentExpandedLength = 0;
     this.doctypefound = false;
@@ -181,7 +192,7 @@ function parseTextData(val, tagName, jPath, dontTrim, hasAttributes, isLeafNode,
 }
 
 function resolveNameSpace(tagname) {
-  if (this.options.removeNSPrefix) {
+  if (this.removeNSPrefix) {
     const tags = tagname.split(':');
     const prefix = tagname.charAt(0) === '/' ? '/' : '';
     if (tags[0] === 'xmlns') {
@@ -206,82 +217,148 @@ function buildAttributesMap(attrStr, jPath, tagName, force = false) {
 
     const matches = getAllMatches(attrStr, attrsRegx);
     const len = matches.length; //don't make it inline
-    const attrs = {};
-
-    // Pre-process values once: trim + entity replacement
-    // Reused in both matcher update and second pass
-    const processedVals = new Array(len);
-    let hasRawAttrs = false;
-    const rawAttrsForMatcher = {};
-
+    const attrNames = new Array(len);
     for (let i = 0; i < len; i++) {
-      const attrName = this.resolveNameSpace(matches[i][1]);
-      const oldVal = matches[i][4];
-
-      if (attrName.length && oldVal !== undefined) {
-        let val = oldVal;
-        if (options.trimValues) val = val.trim();
-        val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
-        processedVals[i] = val;
-
-        rawAttrsForMatcher[attrName] = val;
-        hasRawAttrs = true;
-      }
+      attrNames[i] = this.resolveNameSpace(matches[i][1]);
     }
+    return this.buildAttributes(matches, attrNames, jPath, tagName);
+  }
+}
 
-    // Update matcher ONCE before second pass, if applicable
-    if (hasRawAttrs && typeof jPath === 'object' && jPath.updateCurrent) {
-      jPath.updateCurrent(rawAttrsForMatcher);
+/**
+ * Build the attributes map of a tag
+ * @param {Array<Array<string>>} matches - attribute matches of attrsRegx; [4] is the raw value
+ * @param {Array<string>} attrNames - name to use for each match ('' to skip it)
+ * @param {Matcher} jPath - matcher positioned at the tag
+ * @param {string} tagName
+ */
+function buildAttributes(matches, attrNames, jPath, tagName) {
+  const options = this.options;
+  const len = matches.length; //don't make it inline
+  const attrs = {};
+
+  // Pre-process values once: trim + entity replacement
+  // Reused in both matcher update and second pass
+  const processedVals = new Array(len);
+  let hasRawAttrs = false;
+  const rawAttrsForMatcher = {};
+
+  for (let i = 0; i < len; i++) {
+    const attrName = attrNames[i];
+    const oldVal = matches[i][4];
+
+    if (attrName.length && oldVal !== undefined) {
+      let val = oldVal;
+      if (options.trimValues) val = val.trim();
+      val = this.replaceEntitiesValue(val, tagName, this.readonlyMatcher);
+      processedVals[i] = val;
+
+      rawAttrsForMatcher[attrName] = val;
+      hasRawAttrs = true;
     }
+  }
 
-    // Hoist toString() once — path doesn't change during attribute processing
-    const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;
+  // Update matcher ONCE before second pass, if applicable
+  if (hasRawAttrs && typeof jPath === 'object' && jPath.updateCurrent) {
+    jPath.updateCurrent(rawAttrsForMatcher);
+  }
 
-    // Second pass: apply processors, build final attrs
-    let hasAttrs = false;
-    for (let i = 0; i < len; i++) {
-      const attrName = this.resolveNameSpace(matches[i][1]);
+  // Hoist toString() once — path doesn't change during attribute processing
+  const jPathStr = options.jPath ? jPath.toString() : this.readonlyMatcher;
 
-      if (this.ignoreAttributesFn(attrName, jPathStr)) continue;
+  // Second pass: apply processors, build final attrs
+  let hasAttrs = false;
+  for (let i = 0; i < len; i++) {
+    const attrName = attrNames[i];
… 988 more lines not shown (9 files changed in all)

diff --git a/sqladmin/application.py b/sqladmin/application.py
--- a/sqladmin/application.py
+++ b/sqladmin/application.py
@@ -15,10 +15,12 @@ from typing import (
 )
 from urllib.parse import parse_qsl, urljoin
 
+import wtforms
 from jinja2 import ChoiceLoader, FileSystemLoader, PackageLoader, PrefixLoader
 from sqlalchemy.engine import Engine
 from sqlalchemy.ext.asyncio import AsyncSession, async_sessionmaker
 from sqlalchemy.orm import Session, sessionmaker
+from sqlalchemy.orm.exc import DetachedInstanceError
 from starlette import status
 from starlette.applications import Starlette
 from starlette.datastructures import URL, FormData, MultiDict, UploadFile
@@ -53,7 +55,9 @@ from sqladmin.forms import WTFORMS_ATTRS, WTFORMS_ATTRS_REVERSED
 from sqladmin.helpers import (
     get_object_identifier,
     is_async_session_maker,
+    object_identifier_values,
     slugify_action_name,
+    to_json_value,
 )
 from sqladmin.i18n import (
     BABEL_INSTALLED,
@@ -88,6 +92,24 @@ def _save_button_clicked(form: FormData, label: str) -> bool:
     return form.get("save") in (label, gettext(label))
 
 
+def _ajax_errors(*messages: Any) -> JSONResponse:
+    """The 400 answer of `Admin.ajax_update`."""
+
+    return JSONResponse(
+        {"errors": [str(message) for message in messages]},
+        status_code=status.HTTP_400_BAD_REQUEST,
+    )
+
+
+def _csrf_field(form: wtforms.Form) -> wtforms.Field | None:
+    """The CSRF token field of ``form``, if its form class enables WTForms CSRF."""
+
+    if not getattr(form.meta, "csrf", False):
+        return None
+    name = form.meta.csrf_field_name
+    return form[name] if name in form else None
+
+
 class BaseAdmin:
     """Base class for implementing Admin interface.
 
@@ -458,6 +480,33 @@ class BaseAdminView(BaseAdmin):
             if can_edit_row is not True:
                 raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
 
+    async def _ajax_update(self, request: Request) -> tuple[ModelView, Any]:
+        """Guard an in-place edit from the list page and return its view and row.
+
+        Unlike `_edit`, the row is loaded before `check_can_edit` is asked
+        about it, so an unknown row is a 404 rather than a question about
+        ``None``.
+        """
+
+        model_view = self._find_model_view(request.path_params["identity"])
+        if not model_view.can_edit or not model_view.is_accessible(request):
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+        try:
+            object_identifier_values(request.path_params["pk"], model_view.model)
+        except (ArithmeticError, TypeError, ValueError) as exc:
+            # A malformed identifier matches no row.
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND) from exc
+
+        obj = await model_view.get_object_for_edit(request)
+        if obj is None:
+            raise HTTPException(status_code=status.HTTP_404_NOT_FOUND)
+
+        if await model_view.check_can_edit(request, obj) is not True:
+            raise HTTPException(status_code=status.HTTP_403_FORBIDDEN)
+
+        return model_view, obj
+
     async def _import(self, request: Request) -> None:
         model_view = self._find_model_view(request.path_params["identity"])
         if not model_view.is_accessible(request):
@@ -650,6 +699,12 @@ class Admin(BaseAdminView):
             Route(
                 "/{identity}/ajax/lookup", endpoint=self.ajax_lookup, name="ajax_lookup"
             ),
+            Route(
+                "/{identity}/ajax/update/{pk:path}",
+                endpoint=self.ajax_update,
+                name="ajax_update",
+                methods=["POST"],
+            ),
             Route("/login", endpoint=self.login, name="login", methods=["GET", "POST"]),
             Route("/logout", endpoint=self.logout, name="logout", methods=["GET"]),
             Route(
@@ -1077,6 +1132,106 @@ class Admin(BaseAdminView):
         data = [loader.format(m) for m in await loader.get_list(request, term)]
         return JSONResponse({"results": data})
 
+    @login_required
+    async def ajax_update(self, request: Request) -> Response:
+        """Save one column of one row, edited in place on the list page.
+
+        Takes the form fields ``name``, the attribute to change (which must
+        be in `ModelView.column_editable_list`), and ``value``. The value is
+        validated by that column's edit form field alone and saved through
+        `ModelView.update_model`, so `on_model_change`, `after_model_change`
+        and the audit backend all see ``{name: data}``. An empty ``value``
+        stores ``NULL`` in a nullable column.
+
+        Answers with JSON: the row's ``pk``, the ``name``, the stored
+        ``value`` and its ``display``, i.e. the list page cell as a string.
+        Invalid input or a failed save answers 400 with ``{"errors": [...]}``,
+        while a `Response` returned by `after_model_change` is used as is.
+        """
+
+        model_view, _ = await self._ajax_update(request)
+        pk = request.path_params["pk"]
+
+        request_form = await request.form()
+        name = request_form.get("name")
+        if not isinstance(name, str) or not name:
+            return _ajax_errors("The 'name' field is required.")
+        if name not in model_view._editable_fields:
+            return _ajax_errors(f"{name!r} cannot be edited in place.")
+
+        Form = await model_view.scaffold_form(model_view._form_edit_rules)
+        form = Form()
+        key = WTFORMS_ATTRS.get(name, name)
+        if key not in form:
+            return _ajax_errors(f"{name!r} is not a field of the edit form.")
… 2,125 more lines not shown (11 files changed in all)

diff --git a/cloud/retry.go b/cloud/retry.go
new file mode 100644
--- /dev/null
+++ b/cloud/retry.go
@@ -0,0 +1,262 @@
+package cloud
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"math"
+	"net/http"
+	"strconv"
+	"time"
+)
+
+const (
+	// defaultMinBackoff is used by RetryPolicy.Backoff if MinBackoff is not positive.
+	defaultMinBackoff = 1 * time.Second
+
+	// defaultMaxBackoff is used by RetryPolicy.Backoff if MaxBackoff is not positive.
+	defaultMaxBackoff = 30 * time.Second
+
+	// maxDrainBytes limits how much of a response body is read before a retry discards it.
+	// Small bodies are read completely so that the connection can be reused,
+	// without the risk of reading an arbitrarily large body.
+	maxDrainBytes = 64 << 10
+
+	// maxDuration is the largest representable time.Duration.
+	maxDuration = time.Duration(math.MaxInt64)
+
+	// maxDurationSeconds is the largest number of whole seconds a time.Duration can hold.
+	maxDurationSeconds = int64(maxDuration / time.Second)
+)
+
+// RetryPolicy configures how Client.Do retries requests that Jira rejected because of
+// rate limiting (429 Too Many Requests) or temporary unavailability (503 Service Unavailable).
+//
+// Retries are opt-in: they only happen if Client.RetryPolicy is set and MaxRetries is positive.
+// A request is retried only if all of the following conditions are met:
+//
+//   - the response status is 429 or 503. No other status is retried (not even 500, 502 or 504),
+//     and errors returned by the http.Client (e.g. network errors) are returned immediately.
+//   - the method is GET, HEAD, OPTIONS, PUT or DELETE, or RetryNonIdempotent is set.
+//   - the request body can be replayed: the request has no body or Request.GetBody is set.
+//     This is the case for all requests created by NewRequest and NewMultiPartRequest,
+//     and for NewRawRequest with a *strings.Reader, *bytes.Reader or *bytes.Buffer body.
+//     Requests created by NewRawRequest with any other reader are sent only once.
+//   - fewer than MaxRetries retries have been made, so at most MaxRetries+1 requests are sent.
+//
+// A retry resends the same method, URL, headers and body.
+// Before retry n (1-based), the previous response is drained and closed and
+// Sleep is called with the request's context and Backoff(n, previousResponse).
+//
+// Once a response is not retried (or no retries are left), Do handles it as without a policy.
+// The returned Response therefore always describes the last attempt.
+type RetryPolicy struct {
+	// MaxRetries is the maximum number of retries per request.
+	// Zero or a negative value disables retries.
+	MaxRetries int
+
+	// MinBackoff is the base delay of the exponential backoff (default 1s if <= 0).
+	MinBackoff time.Duration
+
+	// MaxBackoff caps every delay, including those requested via Retry-After (default 30s if <= 0).
+	MaxBackoff time.Duration
+
+	// RetryNonIdempotent enables retries for all request methods, including POST and PATCH.
+	// Only enable it if sending such a request more than once is safe for your use case.
+	RetryNonIdempotent bool
+
+	// Sleep waits for the given delay before a retry.
+	// It is called before every retry, even if the delay is zero.
+	// If it returns an error, Do stops retrying and returns a nil *Response
+	// together with an error that wraps the returned error.
+	//
+	// If Sleep is nil, Do waits for the delay on a timer, but returns
+	// ctx.Err() as soon as the context is done.
+	Sleep func(ctx context.Context, d time.Duration) error
+}
+
+// Backoff returns how long to wait before retry number attempt (1-based),
+// given resp, the response to the previous attempt (which may be nil).
+//
+// If resp has a Retry-After header holding a non-negative integer number of seconds,
+// that delay is returned. Otherwise, the delay grows exponentially: MinBackoff * 2^(attempt-1).
+// Retry-After values in the HTTP-date format as well as negative or malformed values are ignored.
+// The result is capped at MaxBackoff.
+//
+// A MinBackoff <= 0 is treated as 1s, a MaxBackoff <= 0 as 30s and an attempt < 1 as 1.
+func (p *RetryPolicy) Backoff(attempt int, resp *http.Response) time.Duration {
+	minBackoff, maxBackoff := defaultMinBackoff, defaultMaxBackoff
+	if p != nil && p.MinBackoff > 0 {
+		minBackoff = p.MinBackoff
+	}
+	if p != nil && p.MaxBackoff > 0 {
+		maxBackoff = p.MaxBackoff
+	}
+
+	if resp != nil {
+		if d, ok := parseDelaySeconds(resp.Header.Get("Retry-After")); ok {
+			if d > maxBackoff {
+				return maxBackoff
+			}
+			return d
+		}
+	}
+
+	if attempt < 1 {
+		attempt = 1
+	}
+	// minBackoff << shift <= maxBackoff holds exactly if minBackoff <= maxBackoff >> shift.
+	// Checking it this way avoids overflowing for large attempts.
+	shift := uint(attempt - 1)
+	if minBackoff > maxBackoff>>shift {
+		return maxBackoff
+	}
+	return minBackoff << shift
+}
+
+// shouldRetry reports whether p allows retrying req at all.
+// It does not consider the response status or the number of retries made so far.
+func (p *RetryPolicy) shouldRetry(req *http.Request) bool {
+	if p == nil || p.MaxRetries <= 0 {
+		return false
+	}
+	if !p.RetryNonIdempotent && !isIdempotentMethod(req.Method) {
+		return false
+	}
… 2,538 more lines not shown (12 files changed in all)

diff --git a/src/time/matcher-walker.ts b/src/time/matcher-walker.ts
--- a/src/time/matcher-walker.ts
+++ b/src/time/matcher-walker.ts
@@ -1,4 +1,4 @@
-import { LocalizedTime, localTimeToTimestamp } from './localized-time';
+import { LocalizedTime, WallClock, getOffsetMinutes, localTimeToTimestamp } from './localized-time';
 import { TimeMatcher } from './time-matcher';
 import { matchesDayOfMonth, DayOfMonthField } from './day-of-month';
 import { matchesDayOfWeek, DayOfWeekField } from './day-of-week';
@@ -8,6 +8,13 @@ import { matchesDayOfWeek, DayOfWeekField } from './day-of-week';
 // cheap, so reaching it means the expression can never match (e.g. `0 0 31 2 *`).
 const MAX_DAYS = 366 * 100;
 
+const DAY_MS = 86400000;
+
+// A JS Date spans +/-8.64e15 ms. Within a day of either end, the UTC offset
+// applied while materializing a wall-clock time can step outside that range.
+const DATE_RANGE_MS = 8.64e15;
+const SAFE_RANGE_MS = DATE_RANGE_MS - DAY_MS;
+
 export class MatcherWalker {
   baseDate: Date;
   timeMatcher: TimeMatcher;
@@ -40,7 +47,21 @@ export class MatcherWalker {
 
   /**
    * Finds the next instant that satisfies the expression, strictly after the
-   * base date.
+   * base date. Throws when there is none within the search bound; see
+   * findNext() for the algorithm.
+   */
+  matchNext(): LocalizedTime {
+    const next = this.findNext();
+    if (next === null) {
+      throw new Error('Could not find next matching date within reasonable time range');
+    }
+    return new LocalizedTime(new Date(next), this.timezone);
+  }
+
+  /**
+   * Finds the next instant that satisfies the expression, strictly after the
+   * base date, and returns its timestamp, or null when there is none within
+   * the search bound (MAX_DAYS calendar days, starting at the base day).
    *
    * Instead of scanning time tick by tick, it infers candidates directly from
    * the cron fields: it walks the calendar day by day (a Y/M/D is the same
@@ -50,10 +71,7 @@ export class MatcherWalker {
    * real matcher, which both enforces the weekday constraint and rejects
    * non-existent local times (the DST spring-forward gap) by construction.
    */
-  matchNext(): LocalizedTime {
-    const months = this.months;
-    const days = this.days;
-
+  findNext(): number | null {
     const baseMs = Math.floor(this.baseDate.getTime() / 1000) * 1000;
     const baseParts = new LocalizedTime(new Date(baseMs), this.timezone).getParts();
 
@@ -65,20 +83,82 @@ export class MatcherWalker {
       // exactly, so it only skips days that would be rejected anyway, and it
       // avoids scanning every time on a day whose weekday can't match (e.g.
       // `* * * 15 * 1`, the 15th only when it is a Monday).
-      if (months.includes(month) && matchesDayOfMonth(days, year, month, day) && this.matchesWeekday(year, month, day)) {
+      if (this.isCandidateDay(year, month, day)) {
         // On the base day the result must be strictly after the base instant;
         // on later days any matching time of day qualifies.
         const lowerBound = i === 0 ? baseParts : null;
         const found = this.firstTimeOnDay(year, month, day, lowerBound, baseMs);
         if (found !== null) {
-          return new LocalizedTime(new Date(found), this.timezone);
+          return found;
         }
       }
 
       ({ year, month, day } = nextDay(year, month, day));
     }
 
-    throw new Error('Could not find next matching date within reasonable time range');
+    return null;
+  }
+
+  /**
+   * Finds the latest instant strictly before the base date that the forward
+   * walk (findNext) can produce, and returns its timestamp, or null when there
+   * is none within the search bound (MAX_DAYS calendar days, ending at the
+   * starting day).
+   *
+   * It mirrors findNext(): it walks the calendar backwards day by day and, on
+   * each eligible day, tries the matching times in descending order. Every
+   * candidate is materialized exactly like the forward walk does, so:
+   *  - a wall-clock time repeated by a DST fall-back resolves to the single
+   *    instant the scheduler fires for it, never to the other one;
+   *  - a time inside a spring-forward gap materializes past the gap and is
+   *    rejected by the matcher (it never fires either).
+   * Within a day, later wall-clock times materialize to later instants, so the
+   * first confirmed candidate is the latest one.
+   *
+   * Occurrences are whole seconds while the base may carry milliseconds: the
+   * latest admissible instant is the last whole second strictly before it.
+   */
+  findPrevious(): number | null {
+    let latest = Math.ceil(this.baseDate.getTime() / 1000) * 1000 - 1000;
+    if (!(latest >= -DATE_RANGE_MS)) return null;
+
+    let bound = this.wallClockAt(latest);
+    const materialized = materialize(bound, this.timezone);
+    // NaN: the wall-clock time lies past the end of the Date range; the scan
+    // below simply skips the times that cannot be materialized.
+    if (materialized !== latest && !Number.isNaN(materialized)) {
+      // `latest` is the instance of a repeated (fall-back) wall-clock time that
+      // is never fired, and so is every instant from the start of that run up
+      // to it. Restart from the last instant before the run, whose wall-clock
+      // is an exact bound for the time-of-day scan below. The run is at most as
+      // long as the distance between the two instances of the wall-clock time.
+      const before = this.lastMaterializedBefore(latest, Math.abs(materialized - latest));
+      // Null only for timezone data not shaped like a DST overlap; the scan
+      // below then still never returns an instant after `latest`.
+      /* v8 ignore else */
+      if (before !== null) {
+        latest = before;
+        bound = this.wallClockAt(latest);
+      }
+    }
+
+    let { year, month, day } = bound;
+
+    for (let i = 0; i < MAX_DAYS; i++) {
+      if (this.isCandidateDay(year, month, day)) {
+        // On the starting day only times up to the bound qualify; on earlier
+        // days any matching time of day does.
… 1,495 more lines not shown (15 files changed in all)

diff --git a/cedar-policy/src/api/explain.rs b/cedar-policy/src/api/explain.rs
new file mode 100644
--- /dev/null
+++ b/cedar-policy/src/api/explain.rs
@@ -0,0 +1,341 @@
…
+fn explain_conditions(
+    evaluator: &Evaluator<'_>,
+    policy: &Policy,
+) -> (PolicyOutcome, Option<usize>) {
+    // The AST has no non-scope constraints exactly when the policy has no
+    // `when` or `unless` clauses, in which case there's nothing to evaluate
+    if policy.ast.non_scope_constraints().is_none() {
+        return (PolicyOutcome::Satisfied, None);
+    }
+    // The AST combines all the clauses of a policy into a single expression
+    // (and may simplify that expression), so we can't recover the individual
+    // clauses from it. Instead, use the same lossless representation which
+    // `Policy::to_json()` uses, so that clause indices match the order of the
+    // `conditions` in the policy's JSON form. If that isn't available, fall
+    // back to the representation derived from the AST, which (like the JSON
+    // form of a policy constructed from an AST) has a single `when` clause
+    // containing all the conditions.
+    let est = policy
+        .lossless
+        .est(|| policy.ast.clone().into())
+        .unwrap_or_else(|_| policy.ast.clone().into());
+    for (index, clause) in est.conditions().iter().enumerate() {
+        // `when` clauses are satisfied when they evaluate to `true`, and
+        // `unless` clauses when they evaluate to `false`
+        let (body, satisfied_when) = match clause {
+            est::Clause::When(body) => (body, true),
+            est::Clause::Unless(body) => (body, false),
+        };
+        // A clause which can't be converted to an AST can't be evaluated
+        // successfully, so we report it as erroring
+        let value = body
+            .clone()
+            .try_into_ast(policy.ast.id())
+            .ok()
+            .and_then(|body| evaluate_to_bool(evaluator, &body, policy.ast.env()));
+        match value {
+            Some(value) if value == satisfied_when => {}
+            Some(_) => return (PolicyOutcome::ConditionFalse, Some(index)),
+            None => return (PolicyOutcome::Error, Some(index)),
+        }
+    }
+    (PolicyOutcome::Satisfied, None)
+}
+
+/// Returns `true` if `expr` evaluates to `true`.
+fn evaluates_to_true(evaluator: &Evaluator<'_>, expr: &ast::Expr, slots: &ast::SlotEnv) -> bool {
+    evaluate_to_bool(evaluator, expr, slots) == Some(true)
+}
+
+/// Evaluate `expr`, returning `None` if evaluation produces an error or a
+/// value which is not a boolean (including a residual, if the request or
+/// entities contain unknowns).
+fn evaluate_to_bool(
+    evaluator: &Evaluator<'_>,
+    expr: &ast::Expr,
+    slots: &ast::SlotEnv,
+) -> Option<bool> {
+    let value = evaluator.interpret(expr, slots).ok()?;
+    match value.value_kind() {
+        ast::ValueKind::Lit(ast::Literal::Bool(b)) => Some(*b),
+        _ => None,
+    }
+}
+
+/// An authorization [`Response`], together with an explanation of how each
+/// policy evaluated against the request.
+///
+/// Returned by [`Authorizer::explain()`](super::Authorizer::explain).
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct AuthorizationExplanation {
…
+impl ScopeMatches {
+    /// Evaluate each of the scope constraints of `policy` on its own, so that
+    /// we can report all of the constraints which don't match
+    fn new(evaluator: &Evaluator<'_>, policy: &Policy) -> Self {
+        // The constraints of the template may contain slots, which are filled
+        // in by `slots` for template-linked policies
+        let template = policy.ast.template();
+        let slots = policy.ast.env();
+        Self {
+            principal: evaluates_to_true(
+                evaluator,
+                &template.principal_constraint().as_expr(),
+                slots,
+            ),
+            action: evaluates_to_true(evaluator, &template.action_constraint().as_expr(), slots),
+            resource: evaluates_to_true(
+                evaluator,
+                &template.resource_constraint().as_expr(),
+                slots,
+            ),
+        }
+    }
+
+    /// Whether all the scope constraints match the request
+    fn all(self) -> bool {
+        self.principal && self.action && self.resource
+    }
+}
+
+/// Explanation of how a single static or template-linked policy evaluated
+/// against an authorization request.
+///
+/// Obtained from [`AuthorizationExplanation::policies()`] or
+/// [`AuthorizationExplanation::policy()`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PolicyExplanation {
+    /// ID of the policy
+    id: PolicyId,
+    /// Effect of the policy
+    effect: Effect,
+    /// Which of the policy's scope constraints match the request
+    scope: ScopeMatches,
… 2,505 more lines not shown (13 files changed in all)

diff --git a/internal/decoder/path_parse.go b/internal/decoder/path_parse.go
new file mode 100644
--- /dev/null
+++ b/internal/decoder/path_parse.go
@@ -0,0 +1,787 @@
…
+// filterOr parses the expression of a filter at pos: the expressions which || joins, which binds the least.
+func (p *pathParser) filterOr() (pathFilter, error) {
+	return p.filterTerms(pathFilterOr, "||", (*pathParser).filterAnd)
+}
+
+// filterAnd parses the expressions which && joins.
+func (p *pathParser) filterAnd() (pathFilter, error) {
+	return p.filterTerms(pathFilterAnd, "&&", (*pathParser).filterBasic)
+}
+
+// filterTerms parses the expressions which the operator joins, each by term: one of them is the expression itself.
+// The white spaces after the last one are skipped.
+func (p *pathParser) filterTerms(kind pathFilterKind, operator string, term func(*pathParser) (pathFilter, error)) (pathFilter, error) {
+	first, err := term(p)
+	if err != nil {
+		return first, err
+	}
+	var terms []pathFilter
+	for {
+		p.skipSpaces()
+		if !strings.HasPrefix(p.text[p.pos:], operator) {
+			break
+		}
+		p.pos += len(operator)
+		p.skipSpaces()
+		next, err := term(p)
+		if err != nil {
+			return next, err
+		}
+		if terms == nil {
+			terms = []pathFilter{first}
+		}
+		terms = append(terms, next)
+	}
+	if terms == nil {
+		return first, nil
+	}
+	return pathFilter{kind: kind, terms: terms}, nil
+}
+
+// filterBasic parses what && and || join: an expression in parentheses or a query, which ! may negate, or a
+// comparison. As in RFC 9535, a comparison is negated in parentheses, and a literal is compared.
+func (p *pathParser) filterBasic() (pathFilter, error) {
+	negated := p.peek() == '!'
+	if negated {
+		p.pos++
+		p.skipSpaces()
+	}
+	var filter pathFilter
+	var err error
+	switch c := p.peek(); {
+	case c == '(':
+		if p.nesting == maxPathNesting {
+			return filter, p.errorf("the parentheses of a filter nest too deep")
+		}
+		p.nesting++
+		p.pos++
+		p.skipSpaces()
+		if filter, err = p.filterOr(); err != nil {
+			return filter, err
+		}
+		if p.peek() != ')' {
+			return filter, p.unexpected("a right parenthesis")
+		}
+		p.pos++
+		p.nesting--
+	case negated && c != '@':
+		return filter, p.unexpected("a left parenthesis or a query after !")
+	default:
+		if filter.left, err = p.operand(); err != nil {
+			return filter, err
+		}
+		var compared bool
+		if !negated {
+			filter.op, compared = p.compareOp()
+		}
+		switch {
+		case compared:
+			filter.kind = pathFilterCompare
+			p.skipSpaces()
+			if filter.right, err = p.operand(); err != nil {
+				return filter, err
+			}
+		case filter.left.query:
+			filter.kind = pathFilterExists
+		default:
+			return filter, p.unexpected("a comparison operator after a literal")
+		}
+	}
+	if negated {
+		filter = pathFilter{kind: pathFilterNot, terms: []pathFilter{filter}}
+	}
+	return filter, nil
+}
…
+// operand parses what a filter compares at pos: a literal or a query.
+func (p *pathParser) operand() (pathOperand, error) {
+	rest := p.text[p.pos:]
+	switch c := p.peek(); {
+	case c == '@':
+		steps, err := p.query()
+		return pathOperand{query: true, steps: steps}, err
+	case c == '\'' || c == '"':
+		str, err := p.quoted()
+		return pathOperand{kind: pathKindString, str: str}, err
+	case c == '-' || ('0' <= c && c <= '9'):
+		return p.number()
+	case strings.HasPrefix(rest, "true"):
+		p.pos += len("true")
+		return pathOperand{kind: pathKindTrue}, nil
+	case strings.HasPrefix(rest, "false"):
+		p.pos += len("false")
+		return pathOperand{kind: pathKindFalse}, nil
+	case strings.HasPrefix(rest, "null"):
+		p.pos += len("null")
+		return pathOperand{kind: pathKindNull}, nil
+	case c == '$':
+		return pathOperand{}, p.errorf("a query from the root identifier $ is not supported in a filter")
+	}
+	// the name of a function of RFC 9535, which its arguments follow in parentheses
+	name := strings.TrimLeft(rest, "_abcdefghijklmnopqrstuvwxyz0123456789")
+	if len(name) < len(rest) && strings.HasPrefix(name, "(") {
+		return pathOperand{}, p.errorf("the function %s is not supported in a filter", rest[:len(rest)-len(name)])
+	}
+	return pathOperand{}, p.unexpected("a literal or a query")
+}
… 5,878 more lines not shown (35 files changed in all)