fix: deduplicate destructure props to prevent duplicate bindings

buildDestructurePatternProps now skips destructureProps entries that
already exist in baseProps. This prevents duplicate bindings like
`const { href, href, ...rest } = props` when pseudo guard props
overlap with intrinsic props (e.g. href/target on links, type/readOnly
on inputs).

https://claude.ai/code/session_01CEoafpHoAaRMVmm1WtcXu1

Author: claude

src/__tests__/build-destructure-pattern-props.test.ts

@@ -0,0 +1,56 @@
+import { describe, expect, it } from "vitest";
+import jscodeshift from "jscodeshift";
+import { buildDestructurePatternProps } from "../internal/emit-wrappers/jsx-builders.js";
+import { patternProp } from "../internal/transform-utils.js";
+
+const j = jscodeshift.withParser("tsx");
+const pp = (name: string) => patternProp(j, name);
+
+describe("buildDestructurePatternProps", () => {
+  it("skips destructureProps that already exist in baseProps", () => {
+    // Simulates the link emitter where baseProps already has "href" and "target"
+    // and pseudoGuardProps also contains "href" from a guard condition.
+    const baseProps = [pp("href"), pp("target"), pp("children")];
+
+    const result = buildDestructurePatternProps(j, pp, {
+      baseProps,
+      destructureProps: ["href", "newProp"],
+      includeRest: true,
+      restId: j.identifier("rest"),
+    });
+
+    const names = result.map((p) => {
+      if (p.type === "RestElement") {
+        return "...rest";
+      }
+      const key = (p as { key?: { name?: string } }).key;
+      return key?.name ?? "?";
+    });
+
+    // "href" should NOT be duplicated; "newProp" should be added
+    expect(names).toEqual(["href", "target", "children", "newProp", "...rest"]);
+  });
+
+  it("skips destructureProps that match 'as' prop with AssignmentPattern value", () => {
+    // The "as" prop in baseProps uses j.property.from() with an AssignmentPattern value
+    const asProp = j.property.from({
+      kind: "init",
+      key: j.identifier("as"),
+      value: j.assignmentPattern(j.identifier("Component"), j.literal("div")),
+      shorthand: false,
+    });
+    const baseProps = [asProp, pp("className")];
+
+    const result = buildDestructurePatternProps(j, pp, {
+      baseProps,
+      destructureProps: ["as", "extraProp"],
+    });
+
+    const names = result.map((p) => {
+      const key = (p as { key?: { name?: string } }).key;
+      return key?.name ?? "?";
+    });
+
+    expect(names).toEqual(["as", "className", "extraProp"]);
+  });
+});

src/internal/emit-wrappers/jsx-builders.ts

@@ -313,7 +313,21 @@ export function buildDestructurePatternProps(
   const { baseProps, destructureProps, propDefaults, includeRest = false, restId } = args;
   const patternProps: Array<Property | RestElement> = [...baseProps];
 
-  for (const name of destructureProps.filter((n): n is string => Boolean(n))) {
+  // Collect names already present in baseProps to avoid duplicate bindings
+  // (e.g. pseudo guard props overlapping with intrinsic props like href/type)
+  const existingNames = new Set<string>();
+  for (const prop of baseProps) {
+    if (prop.type !== "RestElement") {
+      const key = (prop as { key?: { type?: string; name?: string } }).key;
+      if (key?.type === "Identifier" && key.name) {
+        existingNames.add(key.name);
+      }
+    }
+  }
+
+  for (const name of destructureProps.filter(
+    (n): n is string => typeof n === "string" && n.length > 0 && !existingNames.has(n),
+  )) {
     const defaultVal = propDefaults?.get(name);
     if (defaultVal !== undefined) {
       patternProps.push(buildShorthandDefaultPatternProp(j, name, defaultVal));