@archie/devtools 0.0.28 → 0.0.30

package/dist/collection-binding.d.mts

@@ -21,8 +21,12 @@ import { types, PluginObj } from '@babel/core';
  *   data-agent-row                {String(param?.id)}, on the row root
  *   data-agent-field              static string OR a runtime expression
  *                                 (??/ternary field selection, D5.5)
- *   data-agent-field-state        "mixed" | "unresolved"
- *   data-agent-field-parts        comma-separated field list (mixed leaves)
+ *   data-agent-field-state        "mixed" | "unresolved" | "rendered"
+ *                                 ("rendered": a formatter-CALL-wrapped
+ *                                 value — the DOM only ever holds the
+ *                                 FORMATTED string, ARCH-1065 M-COV FIX)
+ *   data-agent-field-parts        comma-separated field list (mixed leaves,
+ *                                 or the single field of a "rendered" leaf)
  *   data-agent-field-slot         text-node index of the dynamic part
  *                                 (label+value leaves, D6)
  *   data-agent-collection-order   "stable" | "derived" (D18), on the row root
@@ -35,8 +39,12 @@ import { types, PluginObj } from '@babel/core';
  * `.filter()/.slice()/.sort()/.map()` chain calls, through single-assignment
  * (`const`, never reassigned) local-variable hops (bounded to
  * `MAX_SOURCE_CHAIN_HOPS`), and through a `useMemo(() => …, deps)` /
- * `React.useMemo(() => …, deps)` unwrap (the common `() => expr` shape only —
- * see `resolveSliceSource`). A `.sort(` ANYWHERE in the chain marks the
+ * `React.useMemo(() => …, deps)` unwrap — EITHER the arrow-EXPRESSION-body
+ * shape (`() => expr`) OR a block body with exactly ONE return statement
+ * (`() => { …; return expr; }`, ARCH-1065 M-COV FIX, devtools 0.0.29); a
+ * block body with zero or 2+ returns (ambiguous control flow) is left
+ * unresolved, never guessed at (see `resolveSliceSource` /
+ * `findSingleReturnArgument`). A `.sort(` ANYWHERE in the chain marks the
  * collection `data-agent-collection-order="derived"`; otherwise `"stable"`
  * (D18). The identifier root must be exactly `slice` — this mirrors the
  * runtime's `window.__slice` (M3); the codemod does not trace how a `slice`
@@ -139,10 +147,25 @@ import { types, PluginObj } from '@babel/core';
  *     the duplicated test would double-evaluate it across SSR and hydration,
  *     so the whole leaf is left unstamped instead;
  *   - `cond ? 'Literal' : 'Other'` where `cond` is itself a bare field
- *     member (a boolean-typed field driving two literal branches) → static
- *     field named by `cond` — the FE's typed controls (D7, a different
- *     mechanism, M3) read the boolean's true/false rendering from
- *     `window.__slice`, not from this attribute;
+ *     member (a boolean-typed field driving two literal branches), OR a
+ *     CALL-FREE comparison (`===`/`!==`/`==`/`!=`/`</<=`/`>`/`>=`) naming a
+ *     field on either side (`r.status === 'Active' ? 'Pause' : 'Enable'`,
+ *     D5.5 widening, ARCH-1065 M-COV FIX) → static field named by the
+ *     resolved test field — the FE's typed controls (D7, a different
+ *     mechanism, M3) read the boolean's/status's true/false or vocabulary
+ *     rendering from `window.__slice`, not from this attribute. Nothing
+ *     about the test is ever duplicated into the DOM here (only the field
+ *     NAME is emitted), so there is no C3 double-evaluation concern for this
+ *     shape — `containsEvaluation(test)` is still checked defensively;
+ *   - a formatter CALL with exactly one argument that is itself a bare
+ *     member/optional-member field (`Kit.date(r.updated_at)`,
+ *     `money(auction.currentPrice)`, ARCH-1065 M-COV FIX) → the resolved
+ *     field name, PLUS `data-agent-field-state="rendered"` and
+ *     `data-agent-field-parts` (the same field name) — the DOM only ever
+ *     holds the FORMATTED string, never the raw value, so this is marked
+ *     the same "honest, non-invertible" way a `??`/boolean fallback is (D8);
+ *     a multi-arg call, or a call whose sole argument isn't a bare field
+ *     member, is left unstamped rather than guessed at;
  *   - a COMPUTED member (`a[expr]`, `expr` not a string literal) → no field
  *     name, `data-agent-field-state="unresolved"` (a positive "this is
  *     row-scoped data, but which field is unknown" signal — never silent).
@@ -171,6 +194,13 @@ import { types, PluginObj } from '@babel/core';
  * that is itself slice-rooted gets discovered and stamped independently by
  * the same Program-wide `.map()` scan, with its own entity/row identity.
  *
+ * A JSXExpressionContainer wrapping `cond && <JSX/>` / `cond || <JSX/>` / a
+ * ternary IS a structural child, though (ARCH-1065 M-COV FIX, devtools
+ * 0.0.29, see `collectConditionalJsxBranchPaths`): the walker descends into
+ * whichever branch(es) are themselves a JSXElement, with the SAME scope —
+ * purely structural, the guard/test is never duplicated or stamped, only the
+ * JSX it conditionally renders is walked for further fields.
+ *
  * ── Failure posture ─────────────────────────────────────────────────────
  *
  * Every resolution step is an explicit allowlist; anything the resolver is

package/dist/collection-binding.d.ts

@@ -21,8 +21,12 @@ import { types, PluginObj } from '@babel/core';
  *   data-agent-row                {String(param?.id)}, on the row root
  *   data-agent-field              static string OR a runtime expression
  *                                 (??/ternary field selection, D5.5)
- *   data-agent-field-state        "mixed" | "unresolved"
- *   data-agent-field-parts        comma-separated field list (mixed leaves)
+ *   data-agent-field-state        "mixed" | "unresolved" | "rendered"
+ *                                 ("rendered": a formatter-CALL-wrapped
+ *                                 value — the DOM only ever holds the
+ *                                 FORMATTED string, ARCH-1065 M-COV FIX)
+ *   data-agent-field-parts        comma-separated field list (mixed leaves,
+ *                                 or the single field of a "rendered" leaf)
  *   data-agent-field-slot         text-node index of the dynamic part
  *                                 (label+value leaves, D6)
  *   data-agent-collection-order   "stable" | "derived" (D18), on the row root
@@ -35,8 +39,12 @@ import { types, PluginObj } from '@babel/core';
  * `.filter()/.slice()/.sort()/.map()` chain calls, through single-assignment
  * (`const`, never reassigned) local-variable hops (bounded to
  * `MAX_SOURCE_CHAIN_HOPS`), and through a `useMemo(() => …, deps)` /
- * `React.useMemo(() => …, deps)` unwrap (the common `() => expr` shape only —
- * see `resolveSliceSource`). A `.sort(` ANYWHERE in the chain marks the
+ * `React.useMemo(() => …, deps)` unwrap — EITHER the arrow-EXPRESSION-body
+ * shape (`() => expr`) OR a block body with exactly ONE return statement
+ * (`() => { …; return expr; }`, ARCH-1065 M-COV FIX, devtools 0.0.29); a
+ * block body with zero or 2+ returns (ambiguous control flow) is left
+ * unresolved, never guessed at (see `resolveSliceSource` /
+ * `findSingleReturnArgument`). A `.sort(` ANYWHERE in the chain marks the
  * collection `data-agent-collection-order="derived"`; otherwise `"stable"`
  * (D18). The identifier root must be exactly `slice` — this mirrors the
  * runtime's `window.__slice` (M3); the codemod does not trace how a `slice`
@@ -139,10 +147,25 @@ import { types, PluginObj } from '@babel/core';
  *     the duplicated test would double-evaluate it across SSR and hydration,
  *     so the whole leaf is left unstamped instead;
  *   - `cond ? 'Literal' : 'Other'` where `cond` is itself a bare field
- *     member (a boolean-typed field driving two literal branches) → static
- *     field named by `cond` — the FE's typed controls (D7, a different
- *     mechanism, M3) read the boolean's true/false rendering from
- *     `window.__slice`, not from this attribute;
+ *     member (a boolean-typed field driving two literal branches), OR a
+ *     CALL-FREE comparison (`===`/`!==`/`==`/`!=`/`</<=`/`>`/`>=`) naming a
+ *     field on either side (`r.status === 'Active' ? 'Pause' : 'Enable'`,
+ *     D5.5 widening, ARCH-1065 M-COV FIX) → static field named by the
+ *     resolved test field — the FE's typed controls (D7, a different
+ *     mechanism, M3) read the boolean's/status's true/false or vocabulary
+ *     rendering from `window.__slice`, not from this attribute. Nothing
+ *     about the test is ever duplicated into the DOM here (only the field
+ *     NAME is emitted), so there is no C3 double-evaluation concern for this
+ *     shape — `containsEvaluation(test)` is still checked defensively;
+ *   - a formatter CALL with exactly one argument that is itself a bare
+ *     member/optional-member field (`Kit.date(r.updated_at)`,
+ *     `money(auction.currentPrice)`, ARCH-1065 M-COV FIX) → the resolved
+ *     field name, PLUS `data-agent-field-state="rendered"` and
+ *     `data-agent-field-parts` (the same field name) — the DOM only ever
+ *     holds the FORMATTED string, never the raw value, so this is marked
+ *     the same "honest, non-invertible" way a `??`/boolean fallback is (D8);
+ *     a multi-arg call, or a call whose sole argument isn't a bare field
+ *     member, is left unstamped rather than guessed at;
  *   - a COMPUTED member (`a[expr]`, `expr` not a string literal) → no field
  *     name, `data-agent-field-state="unresolved"` (a positive "this is
  *     row-scoped data, but which field is unknown" signal — never silent).
@@ -171,6 +194,13 @@ import { types, PluginObj } from '@babel/core';
  * that is itself slice-rooted gets discovered and stamped independently by
  * the same Program-wide `.map()` scan, with its own entity/row identity.
  *
+ * A JSXExpressionContainer wrapping `cond && <JSX/>` / `cond || <JSX/>` / a
+ * ternary IS a structural child, though (ARCH-1065 M-COV FIX, devtools
+ * 0.0.29, see `collectConditionalJsxBranchPaths`): the walker descends into
+ * whichever branch(es) are themselves a JSXElement, with the SAME scope —
+ * purely structural, the guard/test is never duplicated or stamped, only the
+ * JSX it conditionally renders is walked for further fields.
+ *
  * ── Failure posture ─────────────────────────────────────────────────────
  *
  * Every resolution step is an explicit allowlist; anything the resolver is

package/dist/collection-binding.js

@@ -45,6 +45,7 @@ var ATTR_COLLECTION_ORDER = "data-agent-collection-order";
 var SLICE_ROOT_NAME = "slice";
 var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
 var MAX_SOURCE_CHAIN_HOPS = 4;
+var COMPARISON_OPERATORS = /* @__PURE__ */ new Set(["==", "!=", "===", "!==", "<", "<=", ">", ">="]);
 var MAX_PROJECTION_DEPTH = 3;
 function babelPluginCollectionBinding({ types: t }, opts = {}) {
   const { fileExclude = /node_modules/, forwardingComponents = [] } = opts;
@@ -92,44 +93,72 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (t.isIdentifier(callee, { name: "useMemo" })) return true;
     return t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property, { name: "useMemo" });
   }
-  function resolveSliceSource(expr, scope, hops, hasSort) {
-    if (t.isCallExpression(expr)) {
-      const callee = expr.callee;
-      if (!t.isExpression(callee)) return null;
-      if (isUseMemoCallee(callee)) {
-        const [factory] = expr.arguments;
-        if (!factory || !t.isArrowFunctionExpression(factory)) return null;
-        if (!t.isExpression(factory.body)) return null;
-        return resolveSliceSource(factory.body, scope, hops, hasSort);
+  function findSingleReturnArgument(blockPath) {
+    const returnPaths = [];
+    blockPath.traverse({
+      Function(inner) {
+        inner.skip();
+      },
+      ReturnStatement(rp) {
+        returnPaths.push(rp);
       }
-      if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property)) {
-        const method = callee.property.name;
+    });
+    if (returnPaths.length !== 1) return null;
+    const argPath = returnPaths[0].get("argument");
+    if (Array.isArray(argPath) || !argPath.node || !argPath.isExpression()) return null;
+    return argPath;
+  }
+  function resolveSliceSource(path, hops, hasSort) {
+    if (path.isCallExpression()) {
+      const calleePath = path.get("callee");
+      if (Array.isArray(calleePath) || !calleePath.isExpression()) return null;
+      if (isUseMemoCallee(calleePath.node)) {
+        const argPaths = path.get("arguments");
+        const factoryPath = argPaths[0];
+        if (!factoryPath || !factoryPath.isArrowFunctionExpression()) return null;
+        const bodyPath = factoryPath.get("body");
+        if (Array.isArray(bodyPath)) return null;
+        if (bodyPath.isExpression()) {
+          return resolveSliceSource(bodyPath, hops, hasSort);
+        }
+        if (bodyPath.isBlockStatement()) {
+          const returnArgPath = findSingleReturnArgument(bodyPath);
+          if (!returnArgPath) return null;
+          return resolveSliceSource(returnArgPath, hops, hasSort);
+        }
+        return null;
+      }
+      const calleeNode = calleePath.node;
+      if (t.isMemberExpression(calleeNode) && !calleeNode.computed && t.isIdentifier(calleeNode.property)) {
+        const method = calleeNode.property.name;
         if (!CHAIN_METHODS.has(method)) return null;
-        if (!t.isExpression(callee.object)) return null;
-        return resolveSliceSource(callee.object, scope, hops, hasSort || method === "sort");
+        const objectPath = calleePath.get("object");
+        if (Array.isArray(objectPath) || !objectPath.isExpression()) return null;
+        return resolveSliceSource(objectPath, hops, hasSort || method === "sort");
       }
       return null;
     }
-    if (t.isMemberExpression(expr)) {
-      if (!t.isIdentifier(expr.object, { name: SLICE_ROOT_NAME })) return null;
-      if (!isPageSliceBinding(scope)) return null;
-      if (!expr.computed && t.isIdentifier(expr.property)) {
-        return { entity: expr.property.name, hasSort };
+    if (path.isMemberExpression()) {
+      const { object, property, computed } = path.node;
+      if (!t.isIdentifier(object, { name: SLICE_ROOT_NAME })) return null;
+      if (!isPageSliceBinding(path.scope)) return null;
+      if (!computed && t.isIdentifier(property)) {
+        return { entity: property.name, hasSort };
       }
-      if (expr.computed && t.isStringLiteral(expr.property)) {
-        return { entity: expr.property.value, hasSort };
+      if (computed && t.isStringLiteral(property)) {
+        return { entity: property.value, hasSort };
       }
       return null;
     }
-    if (t.isIdentifier(expr)) {
+    if (path.isIdentifier()) {
       if (hops >= MAX_SOURCE_CHAIN_HOPS) return null;
-      const binding = scope.getBinding(expr.name);
+      const binding = path.scope.getBinding(path.node.name);
       if (!binding || !binding.constant) return null;
       const declarator = binding.path;
       if (!declarator.isVariableDeclarator()) return null;
-      const init = declarator.node.init;
-      if (!init || !t.isExpression(init)) return null;
-      return resolveSliceSource(init, declarator.scope, hops + 1, hasSort);
+      const initPath = declarator.get("init");
+      if (Array.isArray(initPath) || !initPath.node || !initPath.isExpression()) return null;
+      return resolveSliceSource(initPath, hops + 1, hasSort);
     }
     return null;
   }
@@ -267,11 +296,27 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     const field = fieldNameForBranch(expr.left, scope);
     return field ? { kind: "static", field } : null;
   }
+  function fieldNameForLiteralBranchTest(expr, scope) {
+    const direct = fieldNameForBranch(expr, scope);
+    if (direct) return direct;
+    if (t.isBinaryExpression(expr) && COMPARISON_OPERATORS.has(expr.operator)) {
+      if (t.isExpression(expr.left)) {
+        const leftField = fieldNameForBranch(expr.left, scope);
+        if (leftField) return leftField;
+      }
+      if (t.isExpression(expr.right)) {
+        const rightField = fieldNameForBranch(expr.right, scope);
+        if (rightField) return rightField;
+      }
+    }
+    return null;
+  }
   function classifyConditional(expr, scope) {
     const { test, consequent, alternate } = expr;
     if (!t.isExpression(test) || !t.isExpression(consequent) || !t.isExpression(alternate)) return null;
     if (isStaticLiteralExpr(consequent) && isStaticLiteralExpr(alternate)) {
-      const testField = fieldNameForBranch(test, scope);
+      if (containsEvaluation(test)) return null;
+      const testField = fieldNameForLiteralBranchTest(test, scope);
       return testField ? { kind: "static", field: testField } : null;
     }
     const consField = fieldNameForBranch(consequent, scope);
@@ -284,6 +329,14 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       expr: t.conditionalExpression(t.cloneNode(test), t.stringLiteral(consField), t.stringLiteral(altField))
     };
   }
+  function classifyFormatterCall(expr, scope) {
+    if (expr.arguments.length !== 1) return null;
+    const [arg] = expr.arguments;
+    if (!t.isMemberExpression(arg) && !t.isOptionalMemberExpression(arg)) return null;
+    const verdict = classifyMemberField(arg, scope);
+    if (!verdict || verdict.kind !== "static") return null;
+    return { kind: "formatted", field: verdict.field };
+  }
   function classifyFieldExpr(expr, scope) {
     if (t.isIdentifier(expr)) {
       const binding = scope.identifiers.get(expr.name);
@@ -295,6 +348,7 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (t.isLogicalExpression(expr) && expr.operator === "??") return classifyNullishChain(expr, scope);
     if (t.isLogicalExpression(expr) && expr.operator === "||") return classifySimpleLogicalOr(expr, scope);
     if (t.isConditionalExpression(expr)) return classifyConditional(expr, scope);
+    if (t.isCallExpression(expr)) return classifyFormatterCall(expr, scope);
     return null;
   }
   function applyFieldVerdict(elementPath, verdict) {
@@ -307,6 +361,12 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
       return;
     }
+    if (verdict.kind === "formatted") {
+      addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
+      addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("rendered"));
+      addAttr(elementPath, ATTR_FIELD_PARTS, t.stringLiteral(verdict.field));
+      return;
+    }
     addAttr(elementPath, ATTR_FIELD, t.jsxExpressionContainer(verdict.expr));
   }
   function meaningfulChildPaths(elementPath) {
@@ -485,13 +545,42 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (!innerReturn) return null;
     return resolveFieldProjection(innerReturn, { identifiers }, depth + 1);
   }
+  function collectConditionalJsxBranchPaths(containerPath) {
+    const exprPath = containerPath.get("expression");
+    if (Array.isArray(exprPath)) return [];
+    if (exprPath.isLogicalExpression() && (exprPath.node.operator === "&&" || exprPath.node.operator === "||")) {
+      const rightPath = exprPath.get("right");
+      return !Array.isArray(rightPath) && rightPath.isJSXElement() ? [rightPath] : [];
+    }
+    if (exprPath.isConditionalExpression()) {
+      const branches = [];
+      const consPath = exprPath.get("consequent");
+      const altPath = exprPath.get("alternate");
+      if (!Array.isArray(consPath) && consPath.isJSXElement()) branches.push(consPath);
+      if (!Array.isArray(altPath) && altPath.isJSXElement()) branches.push(altPath);
+      return branches;
+    }
+    return [];
+  }
   function walkFieldsWithinRow(elementPath, scope) {
     const childPaths = meaningfulChildPaths(elementPath);
-    const hasElementChild = childPaths.some((p) => p.isJSXElement());
+    const conditionalBranchesByChild = /* @__PURE__ */ new Map();
+    for (const p of childPaths) {
+      if (!p.isJSXExpressionContainer()) continue;
+      const branches = collectConditionalJsxBranchPaths(p);
+      if (branches.length > 0) conditionalBranchesByChild.set(p, branches);
+    }
+    const hasElementChild = childPaths.some((p) => p.isJSXElement() || conditionalBranchesByChild.has(p));
     if (hasElementChild) {
       for (const childPath of childPaths) {
-        if (!childPath.isJSXElement()) continue;
-        handleStructuralChild(childPath, scope);
+        if (childPath.isJSXElement()) {
+          handleStructuralChild(childPath, scope);
+          continue;
+        }
+        const branches = conditionalBranchesByChild.get(childPath);
+        if (branches) {
+          for (const branchPath of branches) handleStructuralChild(branchPath, scope);
+        }
       }
       return;
     }
@@ -525,7 +614,11 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (!t.isMemberExpression(callee) || callee.computed) return;
     if (!t.isIdentifier(callee.property, { name: "map" })) return;
     if (!t.isExpression(callee.object)) return;
-    const source = resolveSliceSource(callee.object, callPath.scope, 0, false);
+    const calleePath = callPath.get("callee");
+    if (Array.isArray(calleePath) || !calleePath.isMemberExpression()) return;
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) return;
+    const source = resolveSliceSource(objectPath, 0, false);
     if (!source) return;
     const [callback] = node.arguments;
     if (!callback || !t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) return;

package/dist/collection-binding.mjs

@@ -14,6 +14,7 @@ var ATTR_COLLECTION_ORDER = "data-agent-collection-order";
 var SLICE_ROOT_NAME = "slice";
 var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
 var MAX_SOURCE_CHAIN_HOPS = 4;
+var COMPARISON_OPERATORS = /* @__PURE__ */ new Set(["==", "!=", "===", "!==", "<", "<=", ">", ">="]);
 var MAX_PROJECTION_DEPTH = 3;
 function babelPluginCollectionBinding({ types: t }, opts = {}) {
   const { fileExclude = /node_modules/, forwardingComponents = [] } = opts;
@@ -61,44 +62,72 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (t.isIdentifier(callee, { name: "useMemo" })) return true;
     return t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property, { name: "useMemo" });
   }
-  function resolveSliceSource(expr, scope, hops, hasSort) {
-    if (t.isCallExpression(expr)) {
-      const callee = expr.callee;
-      if (!t.isExpression(callee)) return null;
-      if (isUseMemoCallee(callee)) {
-        const [factory] = expr.arguments;
-        if (!factory || !t.isArrowFunctionExpression(factory)) return null;
-        if (!t.isExpression(factory.body)) return null;
-        return resolveSliceSource(factory.body, scope, hops, hasSort);
+  function findSingleReturnArgument(blockPath) {
+    const returnPaths = [];
+    blockPath.traverse({
+      Function(inner) {
+        inner.skip();
+      },
+      ReturnStatement(rp) {
+        returnPaths.push(rp);
       }
-      if (t.isMemberExpression(callee) && !callee.computed && t.isIdentifier(callee.property)) {
-        const method = callee.property.name;
+    });
+    if (returnPaths.length !== 1) return null;
+    const argPath = returnPaths[0].get("argument");
+    if (Array.isArray(argPath) || !argPath.node || !argPath.isExpression()) return null;
+    return argPath;
+  }
+  function resolveSliceSource(path, hops, hasSort) {
+    if (path.isCallExpression()) {
+      const calleePath = path.get("callee");
+      if (Array.isArray(calleePath) || !calleePath.isExpression()) return null;
+      if (isUseMemoCallee(calleePath.node)) {
+        const argPaths = path.get("arguments");
+        const factoryPath = argPaths[0];
+        if (!factoryPath || !factoryPath.isArrowFunctionExpression()) return null;
+        const bodyPath = factoryPath.get("body");
+        if (Array.isArray(bodyPath)) return null;
+        if (bodyPath.isExpression()) {
+          return resolveSliceSource(bodyPath, hops, hasSort);
+        }
+        if (bodyPath.isBlockStatement()) {
+          const returnArgPath = findSingleReturnArgument(bodyPath);
+          if (!returnArgPath) return null;
+          return resolveSliceSource(returnArgPath, hops, hasSort);
+        }
+        return null;
+      }
+      const calleeNode = calleePath.node;
+      if (t.isMemberExpression(calleeNode) && !calleeNode.computed && t.isIdentifier(calleeNode.property)) {
+        const method = calleeNode.property.name;
         if (!CHAIN_METHODS.has(method)) return null;
-        if (!t.isExpression(callee.object)) return null;
-        return resolveSliceSource(callee.object, scope, hops, hasSort || method === "sort");
+        const objectPath = calleePath.get("object");
+        if (Array.isArray(objectPath) || !objectPath.isExpression()) return null;
+        return resolveSliceSource(objectPath, hops, hasSort || method === "sort");
       }
       return null;
     }
-    if (t.isMemberExpression(expr)) {
-      if (!t.isIdentifier(expr.object, { name: SLICE_ROOT_NAME })) return null;
-      if (!isPageSliceBinding(scope)) return null;
-      if (!expr.computed && t.isIdentifier(expr.property)) {
-        return { entity: expr.property.name, hasSort };
+    if (path.isMemberExpression()) {
+      const { object, property, computed } = path.node;
+      if (!t.isIdentifier(object, { name: SLICE_ROOT_NAME })) return null;
+      if (!isPageSliceBinding(path.scope)) return null;
+      if (!computed && t.isIdentifier(property)) {
+        return { entity: property.name, hasSort };
       }
-      if (expr.computed && t.isStringLiteral(expr.property)) {
-        return { entity: expr.property.value, hasSort };
+      if (computed && t.isStringLiteral(property)) {
+        return { entity: property.value, hasSort };
       }
       return null;
     }
-    if (t.isIdentifier(expr)) {
+    if (path.isIdentifier()) {
       if (hops >= MAX_SOURCE_CHAIN_HOPS) return null;
-      const binding = scope.getBinding(expr.name);
+      const binding = path.scope.getBinding(path.node.name);
       if (!binding || !binding.constant) return null;
       const declarator = binding.path;
       if (!declarator.isVariableDeclarator()) return null;
-      const init = declarator.node.init;
-      if (!init || !t.isExpression(init)) return null;
-      return resolveSliceSource(init, declarator.scope, hops + 1, hasSort);
+      const initPath = declarator.get("init");
+      if (Array.isArray(initPath) || !initPath.node || !initPath.isExpression()) return null;
+      return resolveSliceSource(initPath, hops + 1, hasSort);
     }
     return null;
   }
@@ -236,11 +265,27 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     const field = fieldNameForBranch(expr.left, scope);
     return field ? { kind: "static", field } : null;
   }
+  function fieldNameForLiteralBranchTest(expr, scope) {
+    const direct = fieldNameForBranch(expr, scope);
+    if (direct) return direct;
+    if (t.isBinaryExpression(expr) && COMPARISON_OPERATORS.has(expr.operator)) {
+      if (t.isExpression(expr.left)) {
+        const leftField = fieldNameForBranch(expr.left, scope);
+        if (leftField) return leftField;
+      }
+      if (t.isExpression(expr.right)) {
+        const rightField = fieldNameForBranch(expr.right, scope);
+        if (rightField) return rightField;
+      }
+    }
+    return null;
+  }
   function classifyConditional(expr, scope) {
     const { test, consequent, alternate } = expr;
     if (!t.isExpression(test) || !t.isExpression(consequent) || !t.isExpression(alternate)) return null;
     if (isStaticLiteralExpr(consequent) && isStaticLiteralExpr(alternate)) {
-      const testField = fieldNameForBranch(test, scope);
+      if (containsEvaluation(test)) return null;
+      const testField = fieldNameForLiteralBranchTest(test, scope);
       return testField ? { kind: "static", field: testField } : null;
     }
     const consField = fieldNameForBranch(consequent, scope);
@@ -253,6 +298,14 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       expr: t.conditionalExpression(t.cloneNode(test), t.stringLiteral(consField), t.stringLiteral(altField))
     };
   }
+  function classifyFormatterCall(expr, scope) {
+    if (expr.arguments.length !== 1) return null;
+    const [arg] = expr.arguments;
+    if (!t.isMemberExpression(arg) && !t.isOptionalMemberExpression(arg)) return null;
+    const verdict = classifyMemberField(arg, scope);
+    if (!verdict || verdict.kind !== "static") return null;
+    return { kind: "formatted", field: verdict.field };
+  }
   function classifyFieldExpr(expr, scope) {
     if (t.isIdentifier(expr)) {
       const binding = scope.identifiers.get(expr.name);
@@ -264,6 +317,7 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (t.isLogicalExpression(expr) && expr.operator === "??") return classifyNullishChain(expr, scope);
     if (t.isLogicalExpression(expr) && expr.operator === "||") return classifySimpleLogicalOr(expr, scope);
     if (t.isConditionalExpression(expr)) return classifyConditional(expr, scope);
+    if (t.isCallExpression(expr)) return classifyFormatterCall(expr, scope);
     return null;
   }
   function applyFieldVerdict(elementPath, verdict) {
@@ -276,6 +330,12 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
       return;
     }
+    if (verdict.kind === "formatted") {
+      addAttr(elementPath, ATTR_FIELD, t.stringLiteral(verdict.field));
+      addAttr(elementPath, ATTR_FIELD_STATE, t.stringLiteral("rendered"));
+      addAttr(elementPath, ATTR_FIELD_PARTS, t.stringLiteral(verdict.field));
+      return;
+    }
     addAttr(elementPath, ATTR_FIELD, t.jsxExpressionContainer(verdict.expr));
   }
   function meaningfulChildPaths(elementPath) {
@@ -454,13 +514,42 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (!innerReturn) return null;
     return resolveFieldProjection(innerReturn, { identifiers }, depth + 1);
   }
+  function collectConditionalJsxBranchPaths(containerPath) {
+    const exprPath = containerPath.get("expression");
+    if (Array.isArray(exprPath)) return [];
+    if (exprPath.isLogicalExpression() && (exprPath.node.operator === "&&" || exprPath.node.operator === "||")) {
+      const rightPath = exprPath.get("right");
+      return !Array.isArray(rightPath) && rightPath.isJSXElement() ? [rightPath] : [];
+    }
+    if (exprPath.isConditionalExpression()) {
+      const branches = [];
+      const consPath = exprPath.get("consequent");
+      const altPath = exprPath.get("alternate");
+      if (!Array.isArray(consPath) && consPath.isJSXElement()) branches.push(consPath);
+      if (!Array.isArray(altPath) && altPath.isJSXElement()) branches.push(altPath);
+      return branches;
+    }
+    return [];
+  }
   function walkFieldsWithinRow(elementPath, scope) {
     const childPaths = meaningfulChildPaths(elementPath);
-    const hasElementChild = childPaths.some((p) => p.isJSXElement());
+    const conditionalBranchesByChild = /* @__PURE__ */ new Map();
+    for (const p of childPaths) {
+      if (!p.isJSXExpressionContainer()) continue;
+      const branches = collectConditionalJsxBranchPaths(p);
+      if (branches.length > 0) conditionalBranchesByChild.set(p, branches);
+    }
+    const hasElementChild = childPaths.some((p) => p.isJSXElement() || conditionalBranchesByChild.has(p));
     if (hasElementChild) {
       for (const childPath of childPaths) {
-        if (!childPath.isJSXElement()) continue;
-        handleStructuralChild(childPath, scope);
+        if (childPath.isJSXElement()) {
+          handleStructuralChild(childPath, scope);
+          continue;
+        }
+        const branches = conditionalBranchesByChild.get(childPath);
+        if (branches) {
+          for (const branchPath of branches) handleStructuralChild(branchPath, scope);
+        }
       }
       return;
     }
@@ -494,7 +583,11 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
     if (!t.isMemberExpression(callee) || callee.computed) return;
     if (!t.isIdentifier(callee.property, { name: "map" })) return;
     if (!t.isExpression(callee.object)) return;
-    const source = resolveSliceSource(callee.object, callPath.scope, 0, false);
+    const calleePath = callPath.get("callee");
+    if (Array.isArray(calleePath) || !calleePath.isMemberExpression()) return;
+    const objectPath = calleePath.get("object");
+    if (Array.isArray(objectPath) || !objectPath.isExpression()) return;
+    const source = resolveSliceSource(objectPath, 0, false);
     if (!source) return;
     const [callback] = node.arguments;
     if (!callback || !t.isArrowFunctionExpression(callback) && !t.isFunctionExpression(callback)) return;

package/dist/inspector.standalone.js

@@ -615,6 +615,122 @@
         }
       }
 
+      // ARCH-1065 M3 (v2.3.0) — the nearest data-agent-row-bearing element
+      // SELF-outward. This is `nearestRowId` above but returning the ELEMENT
+      // (not just its id), because QUERY_COLLECTION_ORDER needs the row
+      // root's sibling `data-agent-entity`/`data-agent-collection-order`
+      // frame too, not only the row id. Nested collections resolve correctly
+      // "for free": walking self-outward finds the INNERMOST row root first,
+      // i.e. the nearest enclosing collection of the target node.
+      function nearestRowRootElement(el) {
+        var node = el
+        for (var depth = 0; node && depth < MAX_ANCHOR_CHAIN; depth++) {
+          if (node.nodeType === 1 && typeof node.getAttribute === "function") {
+            var rowId = node.getAttribute("data-agent-row")
+            if (typeof rowId === "string" && rowId !== "") return node
+          }
+          node = node.parentElement
+        }
+        return null
+      }
+
+      // The first row-root element stamped with the given entity name,
+      // anywhere in the document. Used when QUERY_COLLECTION_ORDER is
+      // addressed by `entity` alone (no `selector`) — the entity-name
+      // targeting mode.
+      function findFirstRowRootForEntity(entity) {
+        if (typeof entity !== "string" || entity === "") return null
+        try {
+          return safeQuerySelector(
+            '[data-agent-entity="' +
+              escapeAttributeSelectorValue(entity) +
+              '"][data-agent-row]'
+          )
+        } catch (e) {
+          return null
+        }
+      }
+
+      // Every row root that belongs to the SAME collection instantiation as
+      // `rowRootEl`: the babel codemod (M2) stamps each `.map()` row's root
+      // element as a DIRECT child of whatever wraps the `.map()` call, so
+      // siblings sharing `data-agent-entity` under `rowRootEl`'s parent ARE
+      // the collection, in DOM order. Falls back to `[rowRootEl]` alone when
+      // no parent is reachable (defensive — should not happen for an
+      // attached element).
+      function collectionRowElements(rowRootEl, entity) {
+        var parent = rowRootEl.parentElement
+        if (!parent) return [rowRootEl]
+        var siblings = []
+        var kids = parent.children
+        for (var i = 0; i < kids.length; i++) {
+          var kid = kids[i]
+          if (
+            kid.nodeType === 1 &&
+            typeof kid.getAttribute === "function" &&
+            kid.getAttribute("data-agent-entity") === entity &&
+            kid.hasAttribute("data-agent-row")
+          ) {
+            siblings.push(kid)
+          }
+        }
+        return siblings.length > 0 ? siblings : [rowRootEl]
+      }
+
+      // ARCH-1065 M3 (v2.3.0) — {entity, order, rowIds, rowCount} for the
+      // collection enclosing a target node, read live off the DOM
+      // (data-agent-entity/-row/-collection-order, D18) and cross-checked
+      // against window.__slice[entity].length when the slice is available.
+      //
+      // `order` fails CLOSED ("derived") on anything but an explicit
+      // "stable" attribute value. babel-plugin-collection-binding stamps
+      // entity/row/collection-order ATOMICALLY — three addAttr calls back to
+      // back with no branch between them — and no other emitter of
+      // data-agent-row exists. So data-agent-row present WITHOUT
+      // data-agent-collection-order can only mean the stamping contract
+      // never ran for this element: the order is UNKNOWN, not "stable".
+      // Defaulting unknown to "stable" would let the FE permit a drag whose
+      // Save can't be honored (silent, user-visible corruption); defaulting
+      // to "derived" only disables reorder on markup we can't vouch for.
+      function queryCollectionOrder(rowRootEl) {
+        if (!rowRootEl) return null
+        var entity = rowRootEl.getAttribute("data-agent-entity")
+        if (typeof entity !== "string" || entity === "") return null
+
+        var orderAttr = rowRootEl.getAttribute("data-agent-collection-order")
+        var order = orderAttr === "stable" ? "stable" : "derived"
+
+        var rowElements = collectionRowElements(rowRootEl, entity)
+        var rowIds = []
+        for (var i = 0; i < rowElements.length; i++) {
+          var rowId = rowElements[i].getAttribute("data-agent-row")
+          if (typeof rowId === "string" && rowId !== "") rowIds.push(rowId)
+        }
+        var domRowCount = rowIds.length
+
+        var sliceRows = resolveSliceEntityRows(entity)
+        var sliceRowCount = sliceRows ? sliceRows.length : null
+
+        // `rowCount` is the A17 primary field — DOM population, the same
+        // rows the FE samples values from. `domRowCount`/`sliceRowCount` are
+        // the divergence-diagnostic pair (identical to rowCount when the
+        // slice agrees, or absent from parity entirely when the slice is
+        // unavailable). Known limit: two same-entity `.map()`s that happen
+        // to share one DOM parent merge into a single reported collection —
+        // rare by construction (siblings of a `.map()` output share a
+        // parent by definition), and there is no collection-INSTANCE stamp
+        // (only per-row entity/row/order) to disambiguate two side-by-side
+        // instantiations of the same entity.
+        return {
+          entity: entity,
+          order: order,
+          rowIds: rowIds,
+          rowCount: domRowCount,
+          domRowCount: domRowCount,
+          sliceRowCount: sliceRowCount,
+        }
+      }
+
       if (window._inspectorSharedTargetObserver) {
         try {
           window._inspectorSharedTargetObserver.disconnect()
@@ -1231,7 +1347,10 @@
         // `QUERY_SLICE_FIELD` in the message protocol, and
         // `capabilities.bindingContract` below. No existing field changed
         // shape, so `protocolVersion` stays 1.
-        version: "2.2.0",
+        // 2.3.0 (ARCH-1065 A17-support): additive only — `QUERY_COLLECTION_ORDER`
+        // in the message protocol and `capabilities.collectionOrderQuery`
+        // below. No existing field changed shape, so `protocolVersion` stays 1.
+        version: "2.3.0",
         protocolVersion: 1,
         capabilities: {
           // 2.1.1: function-valued __editorMeta props are invoked before any
@@ -1257,6 +1376,12 @@
           // before relying on either — a frozen pre-1065 inspector has
           // neither.
           collectionBinding: true,
+          // ARCH-1065 A17-support (v2.3.0): `QUERY_COLLECTION_ORDER` resolves
+          // the enclosing collection's order ("stable"/"derived") and row
+          // ids/count for a target node, off the same data-agent-* grammar
+          // as `collectionBinding`. Hosts MUST feature-detect on this flag —
+          // a frozen pre-2.3.0 inspector has no handler for the message.
+          collectionOrderQuery: true,
           // The BUILD-TIME contract version this specific page was stamped
           // with, forwarded verbatim from `<meta name="archie-binding-contract">`
           // when the kit build emitted one — null on any page built before
@@ -3881,6 +4006,58 @@
             field: queryField,
             result: queryResult,
           })
+        } else if (event.data && event.data.type === "QUERY_COLLECTION_ORDER") {
+          // ARCH-1065 M3 (v2.3.0) — {order, rowIds, rowCount} for the
+          // collection enclosing a target node, so the FE can refuse
+          // reorder-at-drag on "derived" collections and drive the
+          // repetition-aware enum threshold off rowCount. Mirrors
+          // QUERY_SLICE_FIELD's request/response envelope and graceful
+          // (result: null) failure shape.
+          //
+          // Targeting, in priority order:
+          //   1. `selector` — a CSS selector for ANY element inside the
+          //      collection (a row, or a leaf nested inside one); resolved
+          //      the same way other selector-addressed messages resolve one
+          //      (`findElementBySelector`), then walked up to the nearest
+          //      enclosing row root.
+          //   2. `entity` alone (no selector) — the first row root in the
+          //      document stamped with that entity name.
+          //   3. neither — mirrors QUERY_SLICE_FIELD's no-rowId fallback:
+          //      the currently selected (else hovered) element.
+          var collectionQuerySelector =
+            typeof event.data.selector === "string" && event.data.selector !== ""
+              ? event.data.selector
+              : null
+          var collectionQueryEntity =
+            typeof event.data.entity === "string" && event.data.entity !== ""
+              ? event.data.entity
+              : null
+
+          var collectionRowRoot = null
+          if (collectionQuerySelector) {
+            var collectionTargetEl = findElementBySelector(collectionQuerySelector)
+            collectionRowRoot = collectionTargetEl
+              ? nearestRowRootElement(collectionTargetEl)
+              : null
+          } else if (collectionQueryEntity) {
+            collectionRowRoot = findFirstRowRootForEntity(collectionQueryEntity)
+          } else {
+            var collectionContextEl = getSelectedElement() || highlightedElement
+            collectionRowRoot = collectionContextEl
+              ? nearestRowRootElement(collectionContextEl)
+              : null
+          }
+
+          var collectionQueryResult = queryCollectionOrder(collectionRowRoot)
+
+          postMessageToParent({
+            type: "COLLECTION_ORDER_RESULT",
+            requestId: event.data.requestId,
+            entity: collectionQueryResult
+              ? collectionQueryResult.entity
+              : collectionQueryEntity,
+            result: collectionQueryResult,
+          })
         }
       }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@archie/devtools",
-  "version": "0.0.28",
+  "version": "0.0.30",
   "description": "DevTools for Archie generated applications - Route synchronization and editor communication",
   "repository": {
     "type": "git",