@archie/devtools 0.0.41 → 0.0.43

package/dist/index.d.ts

@@ -12,6 +12,10 @@ import { types, PluginObj } from '@babel/core';
  *   nodeId, file, line, col, componentName, staticProps, movable, parentNodeId
  *   + (ARCH-883 F1) slot, propBindings, propOwner
  *   + (ARCH-883-KOI) origin
+ *   + (ARCH-1444) childrenText — non-host elements only
+ *   + (ARCH-1450) childrenSource, propSources — same-file identifier tracing
+ *     for values `propBindings` cannot reach (no destructured-prop component
+ *     in scope, or a value that never touches a prop at all)
  *
  * At runtime the Fiber bridge reads `memoizedProps.__editorMeta` to resolve
  * element identity without any DOM attributes.
@@ -169,6 +173,17 @@ declare function babelPluginEditorMeta({ types: t }: {
  * `id`/`htmlFor`/`name`/`type`/`role`/`slot`) are downgraded to `formatted` by the
  * PRODUCER, because no usage value could make them a text edit. The consumer does
  * not need to re-derive that list; it only needs the allowlist above.
+ *
+ * ARCH-1443: `{ target: 'children', prop: 'children', kind: 'direct' }` is emitted
+ * for an element that forwards its component's props REST and renders no children
+ * of its own — the shape EVERY ejected shadcn-style primitive has
+ * (`({ className, ...p }) => <h3 className={…} {...p} />`). Nothing about the
+ * allowlist changes: the usage value of `children` is the JSX children written at
+ * the usage site (`<CardTitle>Cómo funciona</CardTitle>`), and the same
+ * usage-value law applies to it — plain text is writable, a nested element or a
+ * computed expression is a gap. The producer refuses whenever more than one
+ * element in the component forwards the rest, since one `children` prop cannot
+ * name which of them an edit is about.
  */
 interface PropBinding {
     /**
@@ -204,6 +219,134 @@ interface PropBinding {
      */
     kind: 'direct' | 'derived' | 'formatted';
 }
+/**
+ * ARCH-1450 — where a rendered EXPRESSION traces to in the SAME file, for the
+ * one case `propBindings` structurally cannot answer: a value that never
+ * touches a component prop at all.
+ *
+ * `propBindings`/`propOwner` trace an expression to a PROP of the enclosing
+ * (module-level, destructured) component — that machinery is silent whenever
+ * there is no such component (a screen's `export default function X()` with
+ * no destructured params) or whenever the expression bottoms out in a plain
+ * local rather than a prop (`const title = "Contenido"; … <Section
+ * title={title}>`). In both cases `collectPropBindings` returns `{bindings:
+ * [], owner: null}` and the identifier name never crosses the postMessage
+ * boundary in any form — the FE's `usage-prop-resolver` has nothing to walk.
+ * `childrenSource`/`propSources` close exactly that gap, independently of
+ * whether a `PropBinding` was also emitted for the same target: the two
+ * fields answer different questions ("is this a prop, and is it a safe
+ * rewrite" vs "what source-level thing does this identifier name") and a
+ * consumer may need either, or both, depending on what it already knows.
+ *
+ * THE FOUR ANSWERS:
+ *
+ *   `identifier`   — the expression is a bare identifier whose binding
+ *                    resolves (constant, same file, not an import) but is
+ *                    not a literal-init local — a destructured prop used
+ *                    directly, a plain function parameter, or a local
+ *                    `const`/`let` whose initializer is not itself a plain
+ *                    string. `name` is the LOCAL identifier as written at
+ *                    this usage — NOT necessarily the prop name `propBindings`
+ *                    would report for a renamed destructure
+ *                    (`{ headline: h }` reports `h` here, `headline` there).
+ *                    Consumers that need the true prop name still read
+ *                    `propBindings`; this field only says "this traces to a
+ *                    resolvable local named X", which is enough to tell a
+ *                    prop/parameter apart from a dead end.
+ *   `local-const`  — the identifier resolves to a `const`/`let` declared in
+ *                    THIS SAME FILE (by construction — scope resolution never
+ *                    crosses a file boundary) whose initializer is a
+ *                    `StringLiteral` or a `TemplateLiteral` with NO
+ *                    interpolations. `literal` is that string — the exact
+ *                    text a consumer would show/replace. `file`/`line`/`col`
+ *                    point at the INITIALIZER, not the identifier's usage —
+ *                    that is where a rewrite must land: replacing the
+ *                    identifier's occurrence would rename a variable, not
+ *                    change what it renders wherever else it is used.
+ *                    `refs` (FE MINOR-5) is `binding.referencePaths.length` —
+ *                    how many places in the file READ this const, counting
+ *                    every usage, not only the one this `PropSource` sits on.
+ *                    `refs > 1` means the SAME initializer feeds more than
+ *                    one rendered element (`const title = "X"; <A
+ *                    title={title}/><B title={title}/>` — both usages report
+ *                    `refs: 2`): rewriting the initializer changes what BOTH
+ *                    elements show, so a consumer must warn or refuse rather
+ *                    than treat the write as scoped to the one element the
+ *                    edit was made on. `refs === 1` is the only shape safe to
+ *                    treat as a single-target rewrite.
+ *   `member`       — a non-computed member-expression chain
+ *                    (`props.title`, `item.address.city`) whose ROOT resolves
+ *                    the same way `identifier`'s binding does (constant, same
+ *                    file, not an import). `root` is the base identifier;
+ *                    `path` is the property chain beyond it, in order
+ *                    (`['address', 'city']` for `item.address.city`).
+ *   `other`        — the honest gap marker, same role `formatted` plays for
+ *                    `PropBinding.kind` and `'__dynamic__'` plays for
+ *                    `childrenText`: an expression the plugin looked at and
+ *                    declined to trace — a computed member (`obj[key]`), a
+ *                    call, a template WITH interpolations, a conditional, an
+ *                    identifier with no binding (a free/global read), a
+ *                    binding that IS reassigned somewhere in the file, or one
+ *                    that comes from an `import`. NEVER inferred past any of
+ *                    those — a wrong trace is strictly worse than an honest
+ *                    gap.
+ *
+ * SCOPE — deliberately NARROW, unlike `childrenText`/`origin`: both fields
+ * are OMITTED (not stamped `other`) whenever there is nothing to say, the
+ * same convention `propBindings`/`propOwner`/`slot` already use ("emitted
+ * only when it carries information"). `childrenSource` is only computed when
+ * the element's children are EXACTLY one `JSXExpressionContainer` (the case
+ * that makes `childrenText === '__dynamic__'` for the single most common
+ * reason — `<h1>{title}</h1>` — and therefore the case where a source trace
+ * is actually useful); self-closing elements, plain-text children and
+ * mixed/multi children never get it. `propSources` only carries entries for
+ * attributes whose value is a `JSXExpressionContainer` wrapping something
+ * OTHER than a literal `extractStaticProps` already captures exactly
+ * (`staticProps` already has the true value for `title={"Static"}`; adding a
+ * `propSources.title: {kind:'other'}` next to it would look like a gap where
+ * there is none). Both fields are ABSENT — not `null`/`{}` — on every bundle
+ * built before ARCH-1450, the same absence-means-"cannot answer" law every
+ * other additive field in this file states.
+ *
+ * Emitted for BOTH host and non-host elements for `propSources` (attribute
+ * resolution does not depend on the element being a component usage — a host
+ * `<div title={title}>` traces exactly the same way `staticProps` treats host
+ * and component attributes identically). `childrenSource` follows
+ * `childrenText`'s own host exemption: a host element's children are the
+ * screen's own literal JSX, not a component usage, so there is no target for
+ * an editor-driven rewrite to route through in the first place.
+ *
+ * CROSS-REPO CONTRACT (ARCH-1450 CR MINOR-1): `usage-prop-resolver.ts`
+ * (archie-app) is the only consumer, and the two repos share no fixture of
+ * their own — a rename here (e.g. `literal` -> `value`) would leave both
+ * suites green while every real generated project broke. The published
+ * package ships `fixtures/prop-source.fixture.json` (see `files` in
+ * `package.json`) specifically so archie-app's tests can assert against the
+ * REAL emitted shape instead of a hand-typed copy of it. That file is
+ * GENERATED, never hand-edited — see `src/prop-source-fixture.generate.test.ts`,
+ * which regenerates it from the live plugin and fails loud the moment the
+ * committed copy drifts. Regenerate with `UPDATE_FIXTURES=1 npx vitest run
+ * src/prop-source-fixture.generate.test.ts`, review the diff, and bump
+ * archie-app's copy in the same change.
+ */
+type PropSource = {
+    kind: 'identifier';
+    name: string;
+} | {
+    kind: 'local-const';
+    name: string;
+    file: string;
+    line: number;
+    col: number;
+    literal: string | null;
+    refs: number;
+} | {
+    kind: 'member';
+    root: string;
+    path: string[];
+} | {
+    kind: 'other';
+};
 /** Metadata injected into every JSX element by babel-plugin-editor-meta. */
 interface EditorMeta {
     /** Stable identifier: "file:line:col:componentName" */
@@ -216,6 +359,38 @@ interface EditorMeta {
     componentName: string;
     /** Safely serializable literal prop values. Dynamic expressions are "__dynamic__". */
     staticProps: Record<string, unknown> | null;
+    /**
+     * ARCH-1444 — the SHAPE of this element's JSX children, and their text when
+     * that text is plain. `staticProps` is built from ATTRIBUTES only, so without
+     * this field the `children` prop is the one binding target whose value at the
+     * usage a consumer cannot see — and the usage-value law above ("plain text is
+     * writable, a nested element or a computed expression is a gap") is stated in
+     * terms of exactly that value.
+     *
+     *   `null`          — the element is SELF-CLOSING: no children container at
+     *                     all. NOT the same as `''` (`<X></X>`), which can take a
+     *                     text write; `<X />` cannot without a structural rewrite.
+     *   `''`            — an empty children container.
+     *   `'__dynamic__'` — anything that is not exactly one JSXText child: an
+     *                     expression container, a nested element, a comment, or
+     *                     several children. Same sentinel as `staticProps`.
+     *   any other string— the sole JSXText child, TRIMMED (JSX itself trims
+     *                     leading/trailing whitespace-with-newlines, so the
+     *                     trimmed form is what renders). A newline that SURVIVES
+     *                     the trim is real multi-line content: a consumer that
+     *                     writes by splicing must refuse it, because replacing it
+     *                     with one line deletes source lines and invalidates every
+     *                     anchor below.
+     *
+     * Emitted for NON-HOST elements only — a usage is always a component tag, and
+     * stamping every `<div>` would be weight for an answer nothing asks.
+     *
+     * ABSENT (`undefined`) on a host element and on every bundle built before this
+     * change. Absence is NOT "no children": it means the page cannot answer the
+     * question, and a consumer must gap the edit rather than assume (the same law
+     * `origin`'s docstring states at length).
+     */
+    childrenText?: string | null;
     /**
      * Whether the JSX node is in a reorderable position (2+ siblings).
      *
@@ -354,6 +529,30 @@ interface EditorMeta {
      * not the usage's, and routing those would write the wrong prop. Mismatch = gap.
      */
     propOwner?: string | null;
+    /**
+     * ARCH-1450 — source trace for this element's SOLE children expression
+     * (`<h1>{title}</h1>`), independently of whether `propBindings` also has a
+     * `target: 'children'` entry for the same node. See `PropSource`'s own
+     * docstring for the full contract (the four kinds, the narrow emission
+     * scope, why it exists alongside `propBindings`).
+     *
+     * Absent when the element is self-closing, has plain-text children, has
+     * more than one child, or is a HOST element — see `PropSource`'s docstring.
+     * Absent on every bundle built before ARCH-1450.
+     */
+    childrenSource?: PropSource;
+    /**
+     * ARCH-1450 — source trace for each ATTRIBUTE whose value is a
+     * `JSXExpressionContainer`, keyed by the attribute name (never `attr:`
+     * prefixed — this is not `PropBinding.target`). See `PropSource`'s own
+     * docstring for the full contract.
+     *
+     * Emitted only when non-empty — read it as `meta.propSources ?? {}`. An
+     * attribute whose expression is a literal already exact in `staticProps`
+     * never gets an entry here (nothing to trace beyond what `staticProps`
+     * already says). Absent on every bundle built before ARCH-1450.
+     */
+    propSources?: Record<string, PropSource>;
 }
 
 interface ArchieDevToolsOptions {

package/dist/index.js

@@ -277,6 +277,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return "";
   }
+  function isIntrinsicTagName(name) {
+    return t.isJSXIdentifier(name) && /^[a-z]/.test(name.name);
+  }
   function isHostLikeMemberExpressionName(name) {
     if (!t.isJSXMemberExpression(name)) return false;
     const propertyName = name.property.name;
@@ -367,6 +370,158 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return hasAny ? t.objectExpression(props) : null;
   }
+  function describeChildrenText(opening) {
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return null;
+    const element = elementPath.node;
+    if (!element.closingElement) return null;
+    const children = element.children;
+    if (children.length === 0) return "";
+    if (children.length !== 1) return "__dynamic__";
+    const [only] = children;
+    if (!t.isJSXText(only)) return "__dynamic__";
+    return only.value.trim();
+  }
+  function literalInitText(init) {
+    if (t.isStringLiteral(init)) return init.value;
+    if (t.isTemplateLiteral(init) && init.expressions.length === 0) {
+      const [quasi] = init.quasis;
+      if (!quasi) return null;
+      return quasi.value.cooked ?? quasi.value.raw;
+    }
+    return null;
+  }
+  function describeLocalConstSource(name, binding) {
+    const declarator = binding.path;
+    if (!declarator.isVariableDeclarator()) return null;
+    const declaration = declarator.parentPath;
+    if (!declaration?.isVariableDeclaration()) return null;
+    if (declaration.node.kind !== "const" && declaration.node.kind !== "let") return null;
+    const init = declarator.node.init;
+    if (!init) return null;
+    const literal = literalInitText(init);
+    if (literal === null) return null;
+    const loc = init.loc?.start;
+    if (!loc) return null;
+    return {
+      kind: "local-const",
+      name,
+      // The init lives in the SAME file being transformed by construction —
+      // `scope.getBinding` never crosses a file boundary — so the caller's
+      // own `file` (computed once per visited node) is correct here too.
+      file: currentFile,
+      line: loc.line,
+      col: loc.column + 1,
+      literal,
+      // FE MINOR-5: how many places in the FILE read this const — every
+      // reference, not only the one this call is describing. `refs > 1`
+      // means one initializer feeds more than one rendered element, so a
+      // consumer must warn/refuse rather than treat a rewrite as scoped to
+      // just this usage (see `PropSource`'s docstring for the full contract).
+      refs: binding.referencePaths.length
+    };
+  }
+  function resolvableSameFileBinding(name, scope) {
+    const binding = scope.getBinding(name);
+    if (!binding) return null;
+    if (!binding.constant) return null;
+    const bp = binding.path;
+    if (bp.isImportSpecifier() || bp.isImportDefaultSpecifier() || bp.isImportNamespaceSpecifier()) {
+      return null;
+    }
+    return binding;
+  }
+  function memberChain(expr) {
+    const path = [];
+    let current = expr;
+    while (t.isMemberExpression(current)) {
+      if (current.computed) return null;
+      if (!t.isIdentifier(current.property)) return null;
+      path.unshift(current.property.name);
+      current = current.object;
+    }
+    if (!t.isIdentifier(current)) return null;
+    return { root: current.name, path };
+  }
+  let currentFile = "";
+  function describeSource(expr, scope) {
+    if (t.isIdentifier(expr)) {
+      const binding = resolvableSameFileBinding(expr.name, scope);
+      if (!binding) return { kind: "other" };
+      const local = describeLocalConstSource(expr.name, binding);
+      if (local) return local;
+      return { kind: "identifier", name: expr.name };
+    }
+    if (t.isMemberExpression(expr) && !expr.computed) {
+      const chain = memberChain(expr);
+      if (chain && resolvableSameFileBinding(chain.root, scope)) {
+        return { kind: "member", root: chain.root, path: chain.path };
+      }
+    }
+    return { kind: "other" };
+  }
+  function isStaticPropsLiteral(expr) {
+    return t.isStringLiteral(expr) || t.isNumericLiteral(expr) || t.isBooleanLiteral(expr) || t.isNullLiteral(expr);
+  }
+  function describeChildrenSource(opening) {
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return null;
+    const children = elementPath.node.children;
+    if (children.length !== 1) return null;
+    const [only] = children;
+    if (!t.isJSXExpressionContainer(only)) return null;
+    if (t.isJSXEmptyExpression(only.expression)) return null;
+    return describeSource(only.expression, opening.scope);
+  }
+  function collectPropSources(attrs, scope) {
+    const entries = [];
+    for (const attr of attrs) {
+      if (!t.isJSXAttribute(attr)) continue;
+      const name = t.isJSXIdentifier(attr.name) ? attr.name.name : `${attr.name.namespace.name}:${attr.name.name.name}`;
+      if (NON_BINDING_ATTRS.has(name)) continue;
+      const value = attr.value;
+      if (!t.isJSXExpressionContainer(value)) continue;
+      const expression = value.expression;
+      if (t.isJSXEmptyExpression(expression)) continue;
+      if (isStaticPropsLiteral(expression)) continue;
+      entries.push([name, describeSource(expression, scope)]);
+    }
+    return entries;
+  }
+  function propSourceToAst(source) {
+    switch (source.kind) {
+      case "identifier":
+        return t.objectExpression([
+          t.objectProperty(t.identifier("kind"), t.stringLiteral("identifier")),
+          t.objectProperty(t.identifier("name"), t.stringLiteral(source.name))
+        ]);
+      case "local-const":
+        return t.objectExpression([
+          t.objectProperty(t.identifier("kind"), t.stringLiteral("local-const")),
+          t.objectProperty(t.identifier("name"), t.stringLiteral(source.name)),
+          t.objectProperty(t.identifier("file"), t.stringLiteral(source.file)),
+          t.objectProperty(t.identifier("line"), t.numericLiteral(source.line)),
+          t.objectProperty(t.identifier("col"), t.numericLiteral(source.col)),
+          t.objectProperty(
+            t.identifier("literal"),
+            source.literal === null ? t.nullLiteral() : t.stringLiteral(source.literal)
+          ),
+          t.objectProperty(t.identifier("refs"), t.numericLiteral(source.refs))
+        ]);
+      case "member":
+        return t.objectExpression([
+          t.objectProperty(t.identifier("kind"), t.stringLiteral("member")),
+          t.objectProperty(t.identifier("root"), t.stringLiteral(source.root)),
+          t.objectProperty(
+            t.identifier("path"),
+            t.arrayExpression(source.path.map((segment) => t.stringLiteral(segment)))
+          )
+        ]);
+      case "other":
+      default:
+        return t.objectExpression([t.objectProperty(t.identifier("kind"), t.stringLiteral("other"))]);
+    }
+  }
   function isMetaStripSpreadExpression(arg) {
     if (!t.isCallExpression(arg)) return false;
     if (!t.isArrowFunctionExpression(arg.callee)) return false;
@@ -474,6 +629,14 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     }
     return map;
   }
+  function restParamName(pattern) {
+    for (const prop of pattern.properties) {
+      if (!t.isRestElement(prop)) continue;
+      if (t.isIdentifier(prop.argument)) return prop.argument.name;
+      return null;
+    }
+    return null;
+  }
   function resolvePropContext(path) {
     let fn = path.getFunctionParent();
     while (fn) {
@@ -482,7 +645,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
         return {
           componentScope: fn.scope,
           propMap: buildPropMap(first),
-          componentName: getFunctionName(fn)
+          componentName: getFunctionName(fn),
+          restParam: restParamName(first),
+          componentPath: fn
         };
       }
       fn = fn.getFunctionParent();
@@ -602,12 +767,62 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
     const props = collectPropIdentifiers(expr, scope, ctx);
     return props.length > 0 ? { kind: "formatted", prop: props[0] } : null;
   }
+  function unwrapSanitizedSpread(arg) {
+    if (!t.isCallExpression(arg)) return arg;
+    if (!isMetaStripSpreadExpression(arg)) return arg;
+    if (arg.arguments.length !== 1) return arg;
+    const [payload] = arg.arguments;
+    if (!t.isObjectExpression(payload) || payload.properties.length !== 1) return arg;
+    const [only] = payload.properties;
+    if (!t.isSpreadElement(only)) return arg;
+    return only.argument;
+  }
+  function forwardsOwnerRestChildren(opening, ctx) {
+    if (ctx.restParam === null) return false;
+    const elementPath = opening.parentPath;
+    if (!elementPath || !elementPath.isJSXElement()) return false;
+    if (meaningfulChildren(t, elementPath.node.children).length > 0) return false;
+    let spreadsRest = 0;
+    for (const attr of opening.node.attributes) {
+      if (t.isJSXAttribute(attr)) {
+        if (t.isJSXIdentifier(attr.name, { name: "children" })) return false;
+        continue;
+      }
+      if (!t.isJSXSpreadAttribute(attr)) continue;
+      const payload = unwrapSanitizedSpread(attr.argument);
+      if (!t.isIdentifier(payload, { name: ctx.restParam })) return false;
+      spreadsRest += 1;
+    }
+    if (spreadsRest !== 1) return false;
+    const binding = opening.scope.getBinding(ctx.restParam);
+    if (!binding) return false;
+    if (binding.scope !== ctx.componentScope) return false;
+    return binding.constant;
+  }
+  const restForwarderCounts = /* @__PURE__ */ new WeakMap();
+  function countRestForwarders(ctx) {
+    const cached = restForwarderCounts.get(ctx.componentPath.node);
+    if (cached !== void 0) return cached;
+    let count = 0;
+    ctx.componentPath.traverse({
+      JSXOpeningElement(inner) {
+        if (forwardsOwnerRestChildren(inner, ctx)) count += 1;
+      }
+    });
+    restForwarderCounts.set(ctx.componentPath.node, count);
+    return count;
+  }
   function collectPropBindings(path, attrs) {
     const ctx = resolvePropContext(path);
-    if (!ctx || ctx.propMap.size === 0) return { bindings: [], owner: null };
+    if (!ctx || ctx.propMap.size === 0 && ctx.restParam === null) {
+      return { bindings: [], owner: null };
+    }
     if (ctx.componentName === null) return { bindings: [], owner: null };
     const scope = path.scope;
     const bindings = [];
+    if (forwardsOwnerRestChildren(path, ctx) && countRestForwarders(ctx) === 1) {
+      bindings.push({ target: "children", prop: "children", kind: "direct" });
+    }
     const elementPath = path.parentPath;
     if (elementPath && elementPath.isJSXElement()) {
       const children = meaningfulChildren(t, elementPath.node.children);
@@ -698,6 +913,7 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
         if (!loc) return;
         const root = state.file.opts.root ?? "";
         const file = root ? nodePath.relative(root, filename) : filename;
+        currentFile = file;
         const line = loc.line;
         const col = loc.column + 1;
         const componentName = getJSXTagName(path.node);
@@ -709,7 +925,9 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
           return;
         }
         let rootName = null;
-        if (t.isJSXIdentifier(path.node.name)) {
+        if (isIntrinsicTagName(path.node.name)) {
+          rootName = null;
+        } else if (t.isJSXIdentifier(path.node.name)) {
           rootName = path.node.name.name;
         } else if (t.isJSXMemberExpression(path.node.name)) {
           let cur = path.node.name;
@@ -771,6 +989,21 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             t.objectProperty(t.identifier("slot"), t.stringLiteral(slot))
           );
         }
+        if (!isHostElement) {
+          const childrenText = describeChildrenText(path);
+          metaObj.properties.push(
+            t.objectProperty(
+              t.identifier("childrenText"),
+              childrenText === null ? t.nullLiteral() : t.stringLiteral(childrenText)
+            )
+          );
+          const childrenSource = describeChildrenSource(path);
+          if (childrenSource) {
+            metaObj.properties.push(
+              t.objectProperty(t.identifier("childrenSource"), propSourceToAst(childrenSource))
+            );
+          }
+        }
         if (bindings.length > 0) {
           metaObj.properties.push(
             t.objectProperty(t.identifier("propBindings"), propBindingsToAst(bindings))
@@ -782,6 +1015,19 @@ function babelPluginEditorMeta({ types: t }, opts = {}) {
             )
           );
         }
+        const propSourceEntries = collectPropSources(path.node.attributes, path.scope);
+        if (propSourceEntries.length > 0) {
+          metaObj.properties.push(
+            t.objectProperty(
+              t.identifier("propSources"),
+              t.objectExpression(
+                propSourceEntries.map(
+                  ([name, source]) => t.objectProperty(t.stringLiteral(name), propSourceToAst(source))
+                )
+              )
+            )
+          );
+        }
         if (isHostElement && includeHostSourceRef) {
           path.node.attributes.push(
             t.jsxAttribute(

package/dist/index.mjs

@@ -1,7 +1,7 @@
 import {
   __dirname,
   babelPluginEditorMeta
-} from "./chunk-6QB35SLQ.mjs";
+} from "./chunk-P5XMHBFS.mjs";
 
 // src/index.ts
 import { readFileSync } from "fs";