@thehoneyjar/sigil-diagnostics 0.1.0

package/dist/index.js

@@ -0,0 +1,931 @@
+// src/types.ts
+var DiagnosticsErrorCodes = {
+  ANALYSIS_FAILED: "ANALYSIS_FAILED",
+  PATTERN_NOT_FOUND: "PATTERN_NOT_FOUND",
+  INVALID_EFFECT: "INVALID_EFFECT",
+  ANCHOR_NOT_AVAILABLE: "ANCHOR_NOT_AVAILABLE"
+};
+var DiagnosticsError = class extends Error {
+  constructor(message, code, recoverable = true) {
+    super(message);
+    this.code = code;
+    this.recoverable = recoverable;
+    this.name = "DiagnosticsError";
+  }
+};
+
+// src/detection.ts
+var FINANCIAL_KEYWORDS = [
+  "claim",
+  "deposit",
+  "withdraw",
+  "transfer",
+  "swap",
+  "send",
+  "pay",
+  "purchase",
+  "mint",
+  "burn",
+  "stake",
+  "unstake",
+  "bridge",
+  "approve",
+  "redeem",
+  "harvest",
+  "collect",
+  "vest",
+  "unlock",
+  "liquidate",
+  "borrow",
+  "lend",
+  "repay",
+  "airdrop",
+  "delegate",
+  "undelegate",
+  "redelegate",
+  "bond",
+  "unbond",
+  "checkout",
+  "order",
+  "subscribe",
+  "upgrade",
+  "downgrade",
+  "refund"
+];
+var DESTRUCTIVE_KEYWORDS = [
+  "delete",
+  "remove",
+  "destroy",
+  "revoke",
+  "terminate",
+  "purge",
+  "erase",
+  "wipe",
+  "clear",
+  "reset",
+  "ban",
+  "block",
+  "suspend",
+  "deactivate",
+  "cancel",
+  "void",
+  "invalidate",
+  "expire",
+  "kill",
+  "close account",
+  "delete account",
+  "remove access",
+  "revoke permissions"
+];
+var SOFT_DELETE_KEYWORDS = [
+  "archive",
+  "hide",
+  "trash",
+  "dismiss",
+  "snooze",
+  "mute",
+  "silence",
+  "ignore",
+  "skip",
+  "defer",
+  "postpone",
+  "mark as read",
+  "mark as spam",
+  "move to folder",
+  "soft-delete",
+  "temporary hide",
+  "pause"
+];
+var STANDARD_KEYWORDS = [
+  "save",
+  "update",
+  "edit",
+  "create",
+  "add",
+  "like",
+  "follow",
+  "bookmark",
+  "favorite",
+  "star",
+  "pin",
+  "tag",
+  "label",
+  "comment",
+  "share",
+  "repost",
+  "quote",
+  "reply",
+  "mention",
+  "react",
+  "submit",
+  "post",
+  "publish",
+  "upload",
+  "attach",
+  "link",
+  "change",
+  "modify",
+  "set",
+  "configure",
+  "customize",
+  "personalize"
+];
+var LOCAL_KEYWORDS = [
+  "toggle",
+  "switch",
+  "expand",
+  "collapse",
+  "select",
+  "focus",
+  "show",
+  "hide",
+  "open",
+  "close",
+  "reveal",
+  "conceal",
+  "check",
+  "uncheck",
+  "enable",
+  "disable",
+  "activate",
+  "sort",
+  "filter",
+  "search",
+  "zoom",
+  "pan",
+  "scroll",
+  "dark mode",
+  "light mode",
+  "theme",
+  "appearance",
+  "display"
+];
+var NAVIGATION_KEYWORDS = [
+  "navigate",
+  "go",
+  "back",
+  "forward",
+  "link",
+  "route",
+  "visit",
+  "open page",
+  "view",
+  "browse",
+  "explore",
+  "next",
+  "previous",
+  "first",
+  "last",
+  "jump to",
+  "tab",
+  "step",
+  "page",
+  "section",
+  "anchor"
+];
+var QUERY_KEYWORDS = [
+  "fetch",
+  "load",
+  "get",
+  "list",
+  "search",
+  "find",
+  "query",
+  "lookup",
+  "retrieve",
+  "request",
+  "poll",
+  "refresh",
+  "reload",
+  "sync",
+  "check status",
+  "preview",
+  "peek",
+  "inspect",
+  "examine"
+];
+var FINANCIAL_TYPE_PATTERNS = [
+  "Currency",
+  "Money",
+  "Amount",
+  "Wei",
+  "BigInt",
+  "Token",
+  "Balance",
+  "Price",
+  "Fee"
+];
+var SOFT_DELETE_CONTEXT = ["with undo", "reversible", "recycle bin", "can undo"];
+function matchesKeywords(text, keywords2) {
+  const lowerText = text.toLowerCase();
+  return keywords2.some((k) => lowerText.includes(k.toLowerCase()));
+}
+function hasFinancialTypes(types) {
+  return types.some(
+    (t) => FINANCIAL_TYPE_PATTERNS.some(
+      (pattern) => t.includes(pattern) || t.toLowerCase().includes(pattern.toLowerCase())
+    )
+  );
+}
+function hasSoftDeleteContext(text) {
+  const lowerText = text.toLowerCase();
+  return SOFT_DELETE_CONTEXT.some((c) => lowerText.includes(c));
+}
+function detectEffect(keywords2, types = []) {
+  const combinedText = keywords2.join(" ");
+  if (hasFinancialTypes(types)) {
+    return "financial";
+  }
+  if (hasSoftDeleteContext(combinedText)) {
+    if (matchesKeywords(combinedText, DESTRUCTIVE_KEYWORDS)) {
+      return "soft-delete";
+    }
+  }
+  if (matchesKeywords(combinedText, FINANCIAL_KEYWORDS)) {
+    return "financial";
+  }
+  if (matchesKeywords(combinedText, DESTRUCTIVE_KEYWORDS)) {
+    return "destructive";
+  }
+  if (matchesKeywords(combinedText, SOFT_DELETE_KEYWORDS)) {
+    return "soft-delete";
+  }
+  if (matchesKeywords(combinedText, LOCAL_KEYWORDS)) {
+    return "local";
+  }
+  if (matchesKeywords(combinedText, NAVIGATION_KEYWORDS)) {
+    return "navigation";
+  }
+  if (matchesKeywords(combinedText, QUERY_KEYWORDS)) {
+    return "query";
+  }
+  if (matchesKeywords(combinedText, STANDARD_KEYWORDS)) {
+    return "standard";
+  }
+  return "standard";
+}
+function getExpectedPhysics(effect) {
+  switch (effect) {
+    case "financial":
+      return { sync: "pessimistic", timing: 800, confirmation: true };
+    case "destructive":
+      return { sync: "pessimistic", timing: 600, confirmation: true };
+    case "soft-delete":
+      return { sync: "optimistic", timing: 200, confirmation: false };
+    case "standard":
+      return { sync: "optimistic", timing: 200, confirmation: false };
+    case "navigation":
+      return { sync: "immediate", timing: 150, confirmation: false };
+    case "query":
+      return { sync: "optimistic", timing: 150, confirmation: false };
+    case "local":
+      return { sync: "immediate", timing: 100, confirmation: false };
+    default:
+      return { sync: "optimistic", timing: 200, confirmation: false };
+  }
+}
+var keywords = {
+  financial: FINANCIAL_KEYWORDS,
+  destructive: DESTRUCTIVE_KEYWORDS,
+  softDelete: SOFT_DELETE_KEYWORDS,
+  standard: STANDARD_KEYWORDS,
+  local: LOCAL_KEYWORDS,
+  navigation: NAVIGATION_KEYWORDS,
+  query: QUERY_KEYWORDS
+};
+
+// src/compliance.ts
+var EXPECTED_ANIMATION = {
+  financial: { easing: "ease-out", duration: 800 },
+  destructive: { easing: "ease-out", duration: 600 },
+  "soft-delete": { easing: "spring(500)", duration: 200 },
+  standard: { easing: "spring(500)", duration: 200 },
+  navigation: { easing: "ease", duration: 150 },
+  query: { easing: "ease-out", duration: 150 },
+  local: { easing: "spring(700)", duration: 100 }
+};
+var EXPECTED_MATERIAL = {
+  financial: { surface: "elevated", shadow: "soft" },
+  destructive: { surface: "elevated", shadow: "none" },
+  "soft-delete": { surface: "flat", shadow: "none" },
+  standard: { surface: "elevated", shadow: "soft" },
+  navigation: { surface: "flat", shadow: "none" },
+  query: { surface: "flat", shadow: "none" },
+  local: { surface: "flat", shadow: "none" }
+};
+var TIMING_TOLERANCE = 100;
+function checkBehavioralCompliance(effect, actual) {
+  const expected = getExpectedPhysics(effect);
+  const syncMatch = actual.sync === expected.sync;
+  const timingMatch = actual.timing === void 0 || Math.abs(actual.timing - expected.timing) <= TIMING_TOLERANCE;
+  const confirmMatch = actual.confirmation === void 0 || actual.confirmation === expected.confirmation;
+  const compliant = syncMatch && timingMatch && confirmMatch;
+  let reason;
+  if (!compliant) {
+    const issues = [];
+    if (!syncMatch) {
+      issues.push(`sync should be ${expected.sync}, got ${actual.sync}`);
+    }
+    if (!timingMatch) {
+      issues.push(`timing should be ${expected.timing}ms, got ${actual.timing}ms`);
+    }
+    if (!confirmMatch) {
+      issues.push(
+        `confirmation should be ${expected.confirmation}, got ${actual.confirmation}`
+      );
+    }
+    reason = issues.join("; ");
+  }
+  return {
+    sync: actual.sync ?? expected.sync,
+    timing: actual.timing ?? expected.timing,
+    confirmation: actual.confirmation ?? expected.confirmation,
+    compliant,
+    reason
+  };
+}
+function checkAnimationCompliance(effect, actual) {
+  const expected = EXPECTED_ANIMATION[effect];
+  const easingMatch = actual.easing === void 0 || isCompatibleEasing(actual.easing, expected.easing);
+  const durationMatch = actual.duration === void 0 || Math.abs(actual.duration - expected.duration) <= TIMING_TOLERANCE;
+  const compliant = easingMatch && durationMatch;
+  let reason;
+  if (!compliant) {
+    const issues = [];
+    if (!easingMatch) {
+      issues.push(`easing should be ${expected.easing}, got ${actual.easing}`);
+    }
+    if (!durationMatch) {
+      issues.push(
+        `duration should be ${expected.duration}ms, got ${actual.duration}ms`
+      );
+    }
+    reason = issues.join("; ");
+  }
+  return {
+    easing: actual.easing ?? expected.easing,
+    duration: actual.duration ?? expected.duration,
+    compliant,
+    reason
+  };
+}
+function isCompatibleEasing(actual, expected) {
+  if (actual === expected)
+    return true;
+  if (expected.includes("spring") && actual.includes("spring"))
+    return true;
+  if (expected.includes("ease") && actual.includes("ease"))
+    return true;
+  return false;
+}
+function checkMaterialCompliance(effect, actual) {
+  const expected = EXPECTED_MATERIAL[effect];
+  const surfaceMatch = actual.surface === void 0 || actual.surface === expected.surface;
+  const shadowMatch = actual.shadow === void 0 || actual.shadow === expected.shadow;
+  const compliant = surfaceMatch && shadowMatch;
+  let reason;
+  if (!compliant) {
+    const issues = [];
+    if (!surfaceMatch) {
+      issues.push(`surface should be ${expected.surface}, got ${actual.surface}`);
+    }
+    if (!shadowMatch) {
+      issues.push(`shadow should be ${expected.shadow}, got ${actual.shadow}`);
+    }
+    reason = issues.join("; ");
+  }
+  return {
+    surface: actual.surface ?? expected.surface,
+    shadow: actual.shadow ?? expected.shadow,
+    radius: actual.radius,
+    compliant,
+    reason
+  };
+}
+function checkCompliance(effect, physics) {
+  return {
+    behavioral: checkBehavioralCompliance(effect, physics.behavioral ?? {}),
+    animation: checkAnimationCompliance(effect, physics.animation ?? {}),
+    material: checkMaterialCompliance(effect, physics.material ?? {})
+  };
+}
+function complianceToIssues(compliance) {
+  const issues = [];
+  if (!compliance.behavioral.compliant && compliance.behavioral.reason) {
+    issues.push({
+      severity: "error",
+      code: "BEHAVIORAL_NONCOMPLIANT",
+      message: `Behavioral physics non-compliant: ${compliance.behavioral.reason}`,
+      suggestion: "Review sync strategy, timing, and confirmation settings"
+    });
+  }
+  if (!compliance.animation.compliant && compliance.animation.reason) {
+    issues.push({
+      severity: "warning",
+      code: "ANIMATION_NONCOMPLIANT",
+      message: `Animation physics non-compliant: ${compliance.animation.reason}`,
+      suggestion: "Adjust easing and duration to match effect type"
+    });
+  }
+  if (!compliance.material.compliant && compliance.material.reason) {
+    issues.push({
+      severity: "info",
+      code: "MATERIAL_NONCOMPLIANT",
+      message: `Material physics non-compliant: ${compliance.material.reason}`,
+      suggestion: "Consider adjusting surface and shadow properties"
+    });
+  }
+  return issues;
+}
+function isFullyCompliant(compliance) {
+  return compliance.behavioral.compliant && compliance.animation.compliant && compliance.material.compliant;
+}
+
+// src/patterns.ts
+var PATTERNS = [
+  // Hydration Issues
+  {
+    id: "hydration-media-query",
+    name: "useMediaQuery Hydration Mismatch",
+    category: "hydration",
+    severity: "error",
+    symptoms: [
+      "Text content does not match server-rendered HTML",
+      "Hydration failed because the initial UI does not match",
+      "Component flickers on load",
+      "Different content on refresh vs navigation"
+    ],
+    keywords: ["hydration", "flicker", "mismatch", "ssr", "server"],
+    causes: [
+      {
+        name: "useMediaQuery SSR mismatch",
+        signature: "useMediaQuery returns false on server, true on client",
+        codeSmell: `const isDesktop = useMediaQuery("(min-width: 768px)");
+return isDesktop ? <Dialog /> : <Drawer />;`,
+        solution: `// Option 1: Loading state until mounted
+const [mounted, setMounted] = useState(false);
+useEffect(() => setMounted(true), []);
+if (!mounted) return <Skeleton />;
+
+// Option 2: CSS-only responsive
+<div className="hidden md:block"><Dialog /></div>
+<div className="md:hidden"><Drawer /></div>`
+      },
+      {
+        name: "Date/time in render",
+        signature: "new Date() in render path",
+        codeSmell: `return <span>{new Date().toLocaleString()}</span>`,
+        solution: `const [time, setTime] = useState<string | null>(null);
+useEffect(() => {
+  setTime(new Date().toLocaleString());
+}, []);
+return <span>{time ?? 'Loading...'}</span>;`
+      },
+      {
+        name: "Random values in render",
+        signature: "Math.random() or crypto.randomUUID() in render",
+        solution: `// Use useId() for stable IDs
+const id = useId();
+
+// Or generate once
+const [randomId] = useState(() => crypto.randomUUID());`
+      }
+    ]
+  },
+  // Dialog Issues
+  {
+    id: "dialog-instability",
+    name: "Dialog/Modal Instability",
+    category: "dialog",
+    severity: "error",
+    symptoms: [
+      "Dialog doesn't open reliably",
+      "Visual glitch during open/close",
+      "Works on desktop, fails on mobile",
+      "Absolute positioned elements misaligned",
+      "Content jumps or shifts"
+    ],
+    keywords: ["dialog", "modal", "drawer", "glitch", "popup", "open", "close"],
+    causes: [
+      {
+        name: "ResponsiveDialog hydration",
+        signature: "useMediaQuery controlling Dialog vs Drawer",
+        solution: `// Option 1: CSS container queries
+.dialog-content {
+  @container (min-width: 768px) {
+    /* desktop styles */
+  }
+}
+
+// Option 2: Consistent loading state
+if (!mounted) return <DialogSkeleton />;`
+      },
+      {
+        name: "Absolute positioning context mismatch",
+        signature: "absolute positioning with varying parent chains",
+        codeSmell: `<div className="absolute -top-4">Title</div>`,
+        solution: `// Ensure explicit positioning context
+<div className="relative">
+  <div className="absolute -top-4">Title</div>
+</div>`
+      },
+      {
+        name: "CSS overflow conflicts",
+        signature: "overflow-auto on parent, overflow-visible on child",
+        solution: `// Be explicit at each level
+// Or restructure to avoid conflict
+// Or use style prop for explicit control`
+      }
+    ]
+  },
+  // Performance Issues
+  {
+    id: "render-performance",
+    name: "Render Performance Issues",
+    category: "performance",
+    severity: "warning",
+    symptoms: [
+      "Laggy interactions",
+      "Delayed response to clicks",
+      "Janky animations",
+      "UI feels heavy",
+      "High INP"
+    ],
+    keywords: ["slow", "laggy", "janky", "performance", "heavy", "delay"],
+    causes: [
+      {
+        name: "Unnecessary re-renders",
+        signature: "Large component tree re-rendering on state change",
+        solution: `// Memoize expensive children
+const MemoizedChild = memo(Child);
+
+// Colocate state (move it down)
+// Use useMemo for expensive computations
+const processed = useMemo(() => expensiveWork(data), [data]);`
+      },
+      {
+        name: "Layout thrashing",
+        signature: "Reading layout, writing, reading again",
+        solution: `// Batch reads, then batch writes
+// Use requestAnimationFrame
+// Use CSS transforms instead of top/left`
+      }
+    ]
+  },
+  // Layout Shift
+  {
+    id: "layout-shift",
+    name: "Cumulative Layout Shift (CLS)",
+    category: "layout",
+    severity: "warning",
+    symptoms: [
+      "Content jumps after load",
+      "Buttons move as clicking",
+      "High CLS score",
+      "Page is jumpy"
+    ],
+    keywords: ["jump", "shift", "cls", "move", "jumpy"],
+    causes: [
+      {
+        name: "Images without dimensions",
+        signature: "<img> without width/height",
+        solution: `<Image
+  src={src}
+  width={400}
+  height={300}
+  alt="..."
+/>
+
+// Or use aspect-ratio
+<div className="aspect-video">
+  <img className="object-cover" />
+</div>`
+      },
+      {
+        name: "Dynamic content without placeholder",
+        signature: "Content loads and pushes things down",
+        solution: `// Reserve space
+<div className="min-h-[200px]">
+  {loading ? <Skeleton /> : <Content />}
+</div>`
+      }
+    ]
+  },
+  // Server Components
+  {
+    id: "server-component-error",
+    name: "Server Component Errors",
+    category: "server-component",
+    severity: "error",
+    symptoms: [
+      "useState is not a function",
+      "useEffect is not a function",
+      "Cannot use hooks in Server Component",
+      "Event handlers cannot be passed"
+    ],
+    keywords: ["server", "component", "hook", "usestate", "useeffect", "client"],
+    causes: [
+      {
+        name: "Hooks in Server Component",
+        signature: 'useState/useEffect without "use client"',
+        solution: `// Add at top of file
+'use client';
+
+// Or extract to Client Component`
+      }
+    ]
+  },
+  // React 19
+  {
+    id: "react-19-changes",
+    name: "React 19 Breaking Changes",
+    category: "react-19",
+    severity: "warning",
+    symptoms: ["forwardRef is deprecated", "Unexpected behavior after upgrade"],
+    keywords: ["react 19", "forwardref", "upgrade", "deprecated"],
+    causes: [
+      {
+        name: "forwardRef deprecated",
+        signature: "Using forwardRef pattern",
+        codeSmell: `const Button = forwardRef((props, ref) => ...);`,
+        solution: `// ref is now a regular prop
+function Button({ ref, ...props }) {
+  return <button ref={ref} {...props} />;
+}`
+      }
+    ]
+  },
+  // Physics Compliance
+  {
+    id: "physics-financial-optimistic",
+    name: "Financial Action Using Optimistic Sync",
+    category: "physics",
+    severity: "error",
+    symptoms: [
+      "Financial action uses optimistic update",
+      "Money operation without confirmation",
+      "Transaction rolls back after user sees success"
+    ],
+    keywords: [
+      "claim",
+      "deposit",
+      "withdraw",
+      "transfer",
+      "swap",
+      "optimistic"
+    ],
+    causes: [
+      {
+        name: "Optimistic update on financial mutation",
+        signature: "onMutate used for financial operations",
+        codeSmell: `useMutation({
+  mutationFn: claimRewards,
+  onMutate: async () => {
+    // Optimistic update - WRONG for financial!
+    queryClient.setQueryData(['balance'], newBalance)
+  }
+})`,
+        solution: `// Use pessimistic sync for financial operations
+useMutation({
+  mutationFn: claimRewards,
+  // NO onMutate - wait for server confirmation
+  onSuccess: () => {
+    queryClient.invalidateQueries(['balance'])
+  }
+})`
+      }
+    ]
+  },
+  {
+    id: "physics-destructive-no-confirm",
+    name: "Destructive Action Without Confirmation",
+    category: "physics",
+    severity: "error",
+    symptoms: [
+      "Delete button with no confirmation",
+      "Permanent action happens immediately",
+      "No way to undo destructive operation"
+    ],
+    keywords: ["delete", "remove", "destroy", "revoke", "terminate"],
+    causes: [
+      {
+        name: "Missing confirmation for destructive action",
+        signature: "Destructive action without confirmation step",
+        codeSmell: `<button onClick={() => deleteItem()}>Delete</button>`,
+        solution: `// Add confirmation step
+const [showConfirm, setShowConfirm] = useState(false);
+
+return showConfirm ? (
+  <ConfirmDialog
+    message="Are you sure you want to delete?"
+    onConfirm={() => deleteItem()}
+    onCancel={() => setShowConfirm(false)}
+  />
+) : (
+  <button onClick={() => setShowConfirm(true)}>Delete</button>
+);`
+      }
+    ]
+  }
+];
+function getPatterns() {
+  return PATTERNS;
+}
+function getPatternsByCategory(category) {
+  return PATTERNS.filter((p) => p.category === category);
+}
+function getPatternById(id) {
+  return PATTERNS.find((p) => p.id === id);
+}
+
+// src/service.ts
+function createDefaultCompliance(effect) {
+  const behavioral = getExpectedPhysics(effect);
+  return {
+    behavioral: {
+      ...behavioral,
+      compliant: true
+    },
+    animation: {
+      easing: "ease-out",
+      duration: behavioral.timing,
+      compliant: true
+    },
+    material: {
+      surface: "elevated",
+      shadow: "soft",
+      compliant: true
+    }
+  };
+}
+function createDiagnosticsService(anchorClient, config = {}) {
+  const patterns = [...PATTERNS, ...config.customPatterns ?? []];
+  return {
+    async analyze(component, code) {
+      const keywords2 = extractKeywords(component, code);
+      const effect = detectEffect(keywords2);
+      const compliance = createDefaultCompliance(effect);
+      const issues = complianceToIssues(compliance);
+      if (code) {
+        const patternIssues = matchCodePatterns(code);
+        issues.push(...patternIssues);
+      }
+      const suggestions = generateSuggestions(effect, compliance);
+      return {
+        component,
+        effect,
+        issues,
+        compliance,
+        suggestions
+      };
+    },
+    checkCompliance(effect, physics) {
+      const result = checkCompliance(effect, physics);
+      return isFullyCompliant(result);
+    },
+    detectEffect(keywords2, types) {
+      return detectEffect(keywords2, types);
+    },
+    matchPatterns(symptoms) {
+      const results = [];
+      const lowerSymptoms = symptoms.toLowerCase();
+      for (const pattern of patterns) {
+        if (config.categories && !config.categories.includes(pattern.category)) {
+          continue;
+        }
+        const keywordMatches = pattern.keywords.filter(
+          (k) => lowerSymptoms.includes(k.toLowerCase())
+        );
+        if (keywordMatches.length === 0)
+          continue;
+        const symptomMatches = pattern.symptoms.filter(
+          (s) => lowerSymptoms.includes(s.toLowerCase()) || s.toLowerCase().split(" ").some((word) => lowerSymptoms.includes(word))
+        );
+        const confidence = Math.min(
+          0.95,
+          keywordMatches.length * 0.2 + symptomMatches.length * 0.3
+        );
+        if (confidence > 0.3) {
+          const matchedCause = pattern.causes[0];
+          results.push({
+            pattern,
+            matchedCause,
+            confidence
+          });
+        }
+      }
+      return results.sort((a, b) => b.confidence - a.confidence);
+    },
+    diagnose(symptom) {
+      const results = this.matchPatterns(symptom);
+      if (results.length === 0) {
+        return "I couldn't match this to a known pattern. Can you describe what's happening in more detail?";
+      }
+      const top = results[0];
+      let response = `**Found: ${top.pattern.name}** (${Math.round(top.confidence * 100)}% confidence)
+
+`;
+      response += `**Cause:** ${top.matchedCause.name}
+
+`;
+      if (top.matchedCause.codeSmell) {
+        response += `**Code smell:**
+\`\`\`typescript
+${top.matchedCause.codeSmell}
+\`\`\`
+
+`;
+      }
+      response += `**Solution:**
+\`\`\`typescript
+${top.matchedCause.solution}
+\`\`\``;
+      return response.trim();
+    }
+  };
+}
+function extractKeywords(component, code) {
+  const keywords2 = [];
+  const componentWords = component.replace(/([A-Z])/g, " $1").toLowerCase().split(/[\s_-]+/).filter(Boolean);
+  keywords2.push(...componentWords);
+  if (code) {
+    const patterns = [
+      /onClick\s*=\s*\{.*?(delete|remove|save|submit|claim|withdraw)/gi,
+      /mutation[Ff]n:\s*.*?(delete|remove|save|submit|claim|withdraw)/gi,
+      /useMutation.*?(delete|remove|save|submit|claim|withdraw)/gi
+    ];
+    for (const pattern of patterns) {
+      const matches = code.match(pattern);
+      if (matches) {
+        keywords2.push(...matches);
+      }
+    }
+  }
+  return keywords2;
+}
+function matchCodePatterns(code, patterns) {
+  const issues = [];
+  if (code.includes("onMutate") && (code.includes("claim") || code.includes("withdraw") || code.includes("transfer"))) {
+    issues.push({
+      severity: "error",
+      code: "FINANCIAL_OPTIMISTIC",
+      message: "Detected optimistic update (onMutate) on financial operation. Financial operations should use pessimistic sync.",
+      suggestion: "Remove onMutate and use onSuccess with query invalidation instead."
+    });
+  }
+  if (code.includes("delete") && !code.includes("confirm") && !code.includes("showConfirm")) {
+    const hasDirectDelete = /onClick\s*=\s*\{.*?delete/i.test(code) || /<button[^>]*>.*?[Dd]elete.*?<\/button>/i.test(code);
+    if (hasDirectDelete) {
+      issues.push({
+        severity: "warning",
+        code: "DESTRUCTIVE_NO_CONFIRM",
+        message: "Delete operation appears to have no confirmation step. Destructive actions should require confirmation.",
+        suggestion: "Add a confirmation dialog before executing the delete operation."
+      });
+    }
+  }
+  if (code.includes("useMediaQuery") && !code.includes("mounted")) {
+    issues.push({
+      severity: "warning",
+      code: "HYDRATION_MEDIA_QUERY",
+      message: "useMediaQuery without mount check may cause hydration mismatch.",
+      suggestion: "Add a mounted state check: const [mounted, setMounted] = useState(false); useEffect(() => setMounted(true), []);"
+    });
+  }
+  return issues;
+}
+function generateSuggestions(effect, compliance) {
+  const suggestions = [];
+  if (effect === "financial") {
+    suggestions.push("Use pessimistic sync - no onMutate for financial operations");
+    suggestions.push("Show amount and confirmation before executing");
+    suggestions.push("Invalidate queries on success to refresh balances");
+  }
+  if (effect === "destructive") {
+    suggestions.push("Add two-step confirmation before destructive actions");
+    suggestions.push("Use 600ms timing for deliberate feel");
+    suggestions.push("Provide clear description of what will be deleted");
+  }
+  if (effect === "soft-delete") {
+    suggestions.push("Use toast with undo action instead of confirmation dialog");
+    suggestions.push("Optimistic update is safe since operation is reversible");
+  }
+  if (!compliance.behavioral.compliant) {
+    suggestions.push(
+      `Consider changing sync to ${compliance.behavioral.sync} for ${effect} operations`
+    );
+  }
+  return suggestions;
+}
+var defaultDiagnosticsService = null;
+function getDiagnosticsService(anchorClient) {
+  if (!defaultDiagnosticsService) {
+    defaultDiagnosticsService = createDiagnosticsService();
+  }
+  return defaultDiagnosticsService;
+}
+function resetDiagnosticsService() {
+  defaultDiagnosticsService = null;
+}
+
+export { DiagnosticsError, DiagnosticsErrorCodes, PATTERNS, checkAnimationCompliance, checkBehavioralCompliance, checkCompliance, checkMaterialCompliance, complianceToIssues, createDiagnosticsService, detectEffect, getDiagnosticsService, getExpectedPhysics, getPatternById, getPatterns, getPatternsByCategory, isFullyCompliant, keywords, resetDiagnosticsService };