@archie/devtools 0.0.27 → 0.0.28

package/dist/collection-binding.d.mts

@@ -72,6 +72,50 @@ import { types, PluginObj } from '@babel/core';
  * specific field OR several), because no row identity is at stake — only
  * further field leaves.
  *
+ * ── Forwarding-component allowlist descent (ARCH-1065 M-COV fix) ──────────
+ *
+ * D5.4 only ever sees THROUGH a component whose own source is available
+ * (module-local, co-located in the same file). Kit/imported components
+ * (`Card`, `CardContent`, `StatusBadge`, …) are opaque to the AST — the
+ * plugin has no body to project into — but many of them forward unrecognized
+ * JSX attributes onto their own root DOM element (typically via
+ * `{...rest}`), which makes them valid attribute CARRIERS even though
+ * they're not valid PROJECTION targets. `forwardingComponents` (a plugin
+ * option, see `CollectionBindingPluginOptions`) names exactly which ones.
+ *
+ * Two independent mechanisms use that allowlist:
+ *
+ *   - (a2) ROW ROOT: when the `.map()` callback's own returned JSX element
+ *     is an allowlisted component (`<Card key={r.id}>…</Card>` as the row
+ *     root itself), the row-identity attributes stamp directly onto that
+ *     component usage — NOT a projection into a separate definition, since
+ *     there is none to project into. The field walk continues into the
+ *     component's own JSX children with the SAME binding scope the row
+ *     callback already established.
+ *   - (c2-ii) LEAF: when a component usage directly hugs a field expression
+ *     with no host element beneath it (`<StatusBadge>{w.status}</StatusBadge>`),
+ *     the field attribute stamps onto the component itself IFF its name is
+ *     allowlisted; otherwise the leaf is left unstamped — a leaf is never
+ *     given an invented carrier.
+ *
+ * Separately, and regardless of allowlist membership at all — walking a
+ * component's own JSX children costs nothing, since no attribute lands
+ * anywhere until a valid carrier (host, or allowlisted leaf) is actually
+ * found — (a1) DESCENT: the field walk always continues INTO a structural
+ * child that is a component usage, as long as that usage has its own JSX
+ * children in source. `<Card><span>{w.name}</span></Card>` reaches the
+ * `<span>` (a host, stamped unconditionally) even though `Card` itself is
+ * never a stamp target unless allowlisted. This is what makes (c2-ii) safe
+ * to leave allowlist-gated: a wrapper with a host descendant never needs the
+ * wrapper itself to carry anything.
+ *
+ * The allowlist is ALWAYS an explicit option, never a built-in default list
+ * baked into this plugin — kit-manifest is the single source of truth for
+ * which components forward attributes (`forwardsDataAttributes`), and the
+ * kit build (`build-d.mjs`) is what threads that list in. An absent/empty
+ * option is exactly today's fail-closed behavior: zero component-carried
+ * stamps, byte-identical to the plugin before this mechanism existed.
+ *
  * ── Field resolution ────────────────────────────────────────────────────
  *
  * Reuses `meaningfulChildren` from `babel-plugin-editor-meta.ts` (the exact
@@ -148,6 +192,27 @@ import { types, PluginObj } from '@babel/core';
 interface CollectionBindingPluginOptions {
     /** Skip files matching this pattern. @default /node_modules/ */
     fileExclude?: RegExp;
+    /**
+     * Component names known to forward unrecognized JSX attributes onto their
+     * own root DOM element (e.g. via `{...rest}`) — the exact set that makes
+     * a component usage a valid attribute CARRIER (row-root or leaf) even
+     * though it's opaque to the AST (see the "Forwarding-component allowlist
+     * descent" section above).
+     *
+     * Sourced from kit-manifest's `forwardsDataAttributes` flags by the kit
+     * build (`build-d.mjs` passes it) — this plugin NEVER hardcodes a default
+     * list here; that would be a shadow copy of kit-manifest's own truth, and
+     * would drift the moment a kit component's forwarding behavior changed
+     * without this plugin's knowledge. Synthetic lists are fine in tests, to
+     * keep the plugin testable standalone.
+     *
+     * Absent or empty = today's fail-closed behavior: no component ever
+     * carries a stamp, byte-identical to the plugin before this option
+     * existed.
+     *
+     * @default []
+     */
+    forwardingComponents?: string[];
 }
 declare function babelPluginCollectionBinding({ types: t }: {
     types: typeof types;

package/dist/collection-binding.d.ts

@@ -72,6 +72,50 @@ import { types, PluginObj } from '@babel/core';
  * specific field OR several), because no row identity is at stake — only
  * further field leaves.
  *
+ * ── Forwarding-component allowlist descent (ARCH-1065 M-COV fix) ──────────
+ *
+ * D5.4 only ever sees THROUGH a component whose own source is available
+ * (module-local, co-located in the same file). Kit/imported components
+ * (`Card`, `CardContent`, `StatusBadge`, …) are opaque to the AST — the
+ * plugin has no body to project into — but many of them forward unrecognized
+ * JSX attributes onto their own root DOM element (typically via
+ * `{...rest}`), which makes them valid attribute CARRIERS even though
+ * they're not valid PROJECTION targets. `forwardingComponents` (a plugin
+ * option, see `CollectionBindingPluginOptions`) names exactly which ones.
+ *
+ * Two independent mechanisms use that allowlist:
+ *
+ *   - (a2) ROW ROOT: when the `.map()` callback's own returned JSX element
+ *     is an allowlisted component (`<Card key={r.id}>…</Card>` as the row
+ *     root itself), the row-identity attributes stamp directly onto that
+ *     component usage — NOT a projection into a separate definition, since
+ *     there is none to project into. The field walk continues into the
+ *     component's own JSX children with the SAME binding scope the row
+ *     callback already established.
+ *   - (c2-ii) LEAF: when a component usage directly hugs a field expression
+ *     with no host element beneath it (`<StatusBadge>{w.status}</StatusBadge>`),
+ *     the field attribute stamps onto the component itself IFF its name is
+ *     allowlisted; otherwise the leaf is left unstamped — a leaf is never
+ *     given an invented carrier.
+ *
+ * Separately, and regardless of allowlist membership at all — walking a
+ * component's own JSX children costs nothing, since no attribute lands
+ * anywhere until a valid carrier (host, or allowlisted leaf) is actually
+ * found — (a1) DESCENT: the field walk always continues INTO a structural
+ * child that is a component usage, as long as that usage has its own JSX
+ * children in source. `<Card><span>{w.name}</span></Card>` reaches the
+ * `<span>` (a host, stamped unconditionally) even though `Card` itself is
+ * never a stamp target unless allowlisted. This is what makes (c2-ii) safe
+ * to leave allowlist-gated: a wrapper with a host descendant never needs the
+ * wrapper itself to carry anything.
+ *
+ * The allowlist is ALWAYS an explicit option, never a built-in default list
+ * baked into this plugin — kit-manifest is the single source of truth for
+ * which components forward attributes (`forwardsDataAttributes`), and the
+ * kit build (`build-d.mjs`) is what threads that list in. An absent/empty
+ * option is exactly today's fail-closed behavior: zero component-carried
+ * stamps, byte-identical to the plugin before this mechanism existed.
+ *
  * ── Field resolution ────────────────────────────────────────────────────
  *
  * Reuses `meaningfulChildren` from `babel-plugin-editor-meta.ts` (the exact
@@ -148,6 +192,27 @@ import { types, PluginObj } from '@babel/core';
 interface CollectionBindingPluginOptions {
     /** Skip files matching this pattern. @default /node_modules/ */
     fileExclude?: RegExp;
+    /**
+     * Component names known to forward unrecognized JSX attributes onto their
+     * own root DOM element (e.g. via `{...rest}`) — the exact set that makes
+     * a component usage a valid attribute CARRIER (row-root or leaf) even
+     * though it's opaque to the AST (see the "Forwarding-component allowlist
+     * descent" section above).
+     *
+     * Sourced from kit-manifest's `forwardsDataAttributes` flags by the kit
+     * build (`build-d.mjs` passes it) — this plugin NEVER hardcodes a default
+     * list here; that would be a shadow copy of kit-manifest's own truth, and
+     * would drift the moment a kit component's forwarding behavior changed
+     * without this plugin's knowledge. Synthetic lists are fine in tests, to
+     * keep the plugin testable standalone.
+     *
+     * Absent or empty = today's fail-closed behavior: no component ever
+     * carries a stamp, byte-identical to the plugin before this option
+     * existed.
+     *
+     * @default []
+     */
+    forwardingComponents?: string[];
 }
 declare function babelPluginCollectionBinding({ types: t }: {
     types: typeof types;

package/dist/collection-binding.js

@@ -47,7 +47,8 @@ var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
 var MAX_SOURCE_CHAIN_HOPS = 4;
 var MAX_PROJECTION_DEPTH = 3;
 function babelPluginCollectionBinding({ types: t }, opts = {}) {
-  const { fileExclude = /node_modules/ } = opts;
+  const { fileExclude = /node_modules/, forwardingComponents = [] } = opts;
+  const forwardingComponentSet = new Set(forwardingComponents);
   function hasOwnAttr(elementPath, name) {
     return elementPath.node.openingElement.attributes.some(
       (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name })
@@ -75,6 +76,10 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   function isLowercaseTag(tag) {
     return tag.length > 0 && tag[0] === tag[0].toLowerCase();
   }
+  function canCarryFieldStamp(elementPath) {
+    const tag = getTagName(elementPath.node.openingElement);
+    return isLowercaseTag(tag) || forwardingComponentSet.has(tag);
+  }
   function getAttrName(attr) {
     return t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
   }
@@ -324,11 +329,13 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   }
   function stampPureLeaf(elementPath, expr, scope) {
     if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (!canCarryFieldStamp(elementPath)) return;
     if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) return;
     applyFieldVerdict(elementPath, classifyFieldExpr(expr, scope));
   }
   function stampLabelValueOrMixed(elementPath, childPaths, scope) {
     if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (!canCarryFieldStamp(elementPath)) return;
     const hasInvisibleSibling = childPaths.some(
       (p) => p.isJSXExpressionContainer() && t.isExpression(p.node.expression) && isInvisibleRenderExpr(p.node.expression)
     );
@@ -432,6 +439,7 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   function resolveRowRoot(jsxPath, scope, depth) {
     const tag = getTagName(jsxPath.node.openingElement);
     if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (forwardingComponentSet.has(tag)) return { hostPath: jsxPath, scope };
     if (depth >= MAX_PROJECTION_DEPTH) return null;
     const fnPath = resolveComponentDefinition(tag, jsxPath);
     if (!fnPath) return null;
@@ -503,6 +511,10 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       walkFieldsWithinRow(childPath, scope);
       return;
     }
+    if (meaningfulChildPaths(childPath).length > 0) {
+      walkFieldsWithinRow(childPath, scope);
+      return;
+    }
     const projected = resolveFieldProjection(childPath, scope, 0);
     if (!projected) return;
     walkFieldsWithinRow(projected.hostPath, projected.scope);

package/dist/collection-binding.mjs

@@ -16,7 +16,8 @@ var CHAIN_METHODS = /* @__PURE__ */ new Set(["filter", "slice", "sort", "map"]);
 var MAX_SOURCE_CHAIN_HOPS = 4;
 var MAX_PROJECTION_DEPTH = 3;
 function babelPluginCollectionBinding({ types: t }, opts = {}) {
-  const { fileExclude = /node_modules/ } = opts;
+  const { fileExclude = /node_modules/, forwardingComponents = [] } = opts;
+  const forwardingComponentSet = new Set(forwardingComponents);
   function hasOwnAttr(elementPath, name) {
     return elementPath.node.openingElement.attributes.some(
       (a) => t.isJSXAttribute(a) && t.isJSXIdentifier(a.name, { name })
@@ -44,6 +45,10 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   function isLowercaseTag(tag) {
     return tag.length > 0 && tag[0] === tag[0].toLowerCase();
   }
+  function canCarryFieldStamp(elementPath) {
+    const tag = getTagName(elementPath.node.openingElement);
+    return isLowercaseTag(tag) || forwardingComponentSet.has(tag);
+  }
   function getAttrName(attr) {
     return t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
   }
@@ -293,11 +298,13 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   }
   function stampPureLeaf(elementPath, expr, scope) {
     if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (!canCarryFieldStamp(elementPath)) return;
     if (t.isJSXEmptyExpression(expr) || !t.isExpression(expr)) return;
     applyFieldVerdict(elementPath, classifyFieldExpr(expr, scope));
   }
   function stampLabelValueOrMixed(elementPath, childPaths, scope) {
     if (hasOwnAttr(elementPath, ATTR_FIELD) || hasOwnAttr(elementPath, ATTR_FIELD_STATE)) return;
+    if (!canCarryFieldStamp(elementPath)) return;
     const hasInvisibleSibling = childPaths.some(
       (p) => p.isJSXExpressionContainer() && t.isExpression(p.node.expression) && isInvisibleRenderExpr(p.node.expression)
     );
@@ -401,6 +408,7 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
   function resolveRowRoot(jsxPath, scope, depth) {
     const tag = getTagName(jsxPath.node.openingElement);
     if (isLowercaseTag(tag)) return { hostPath: jsxPath, scope };
+    if (forwardingComponentSet.has(tag)) return { hostPath: jsxPath, scope };
     if (depth >= MAX_PROJECTION_DEPTH) return null;
     const fnPath = resolveComponentDefinition(tag, jsxPath);
     if (!fnPath) return null;
@@ -472,6 +480,10 @@ function babelPluginCollectionBinding({ types: t }, opts = {}) {
       walkFieldsWithinRow(childPath, scope);
       return;
     }
+    if (meaningfulChildPaths(childPath).length > 0) {
+      walkFieldsWithinRow(childPath, scope);
+      return;
+    }
     const projected = resolveFieldProjection(childPath, scope, 0);
     if (!projected) return;
     walkFieldsWithinRow(projected.hostPath, projected.scope);

package/package.json

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