@estiva-app/ui 0.35.1 → 0.36.0

package/dist/registry/{chunk-XVII7P6G.js → chunk-SIB44CES.js}

@@ -6,13 +6,162 @@ import {
 // src/registry/build.ts
 import { readFileSync as readFileSync2, readdirSync } from "node:fs";
 import { join as join2 } from "node:path";
-import ts2 from "typescript";
+import ts3 from "typescript";
+import { OWNED_BEHAVIOURS as OWNED_BEHAVIOURS2 } from "../eslint/index.js";
+
+// src/registry/behaviours.ts
+import ts from "typescript";
 import { OWNED_BEHAVIOURS } from "../eslint/index.js";
+var isBaseUi = (specifier) => /^@base-ui(?:-components)?\/react(?:\/|$)/.test(specifier);
+function baseUiBehaviours(part, piece) {
+  const whole = !piece || piece === "Root" || piece === "Provider";
+  return OWNED_BEHAVIOURS.filter((owned) => owned.id === "base-ui" || owned.baseUi.includes(part) && (whole || owned.id === "role")).map((owned) => owned.id);
+}
+var HANDED_ON = /* @__PURE__ */ new Set(["portal", "press-outside", "page-keys", "focus", "scroll-lock", "follow", "scroll"]);
+var HINTS = /* @__PURE__ */ new Set(["Tooltip", "WithTooltip", "TooltipProvider", "PreviewCard"]);
+var handedOn = (name, owned) => HINTS.has(name) ? [] : [...owned].filter((id) => HANDED_ON.has(id));
+function asBehaviours(ids) {
+  const held = new Set(ids);
+  return OWNED_BEHAVIOURS.filter((owned) => held.has(owned.id)).map((owned) => ({ id: owned.id, behaviour: owned.behaviour }));
+}
+function tagText(tag) {
+  if (ts.isIdentifier(tag)) return tag.text;
+  if (ts.isPropertyAccessExpression(tag)) {
+    const inner = tagText(tag.expression);
+    return inner && `${inner}.${tag.name.text}`;
+  }
+  return null;
+}
+var splitTag = (tag) => {
+  const [root, piece] = tag.split(".");
+  return [root, piece];
+};
+function tagsUnder(node) {
+  const found = /* @__PURE__ */ new Set();
+  const visit = (n) => {
+    if (ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n)) {
+      const tag = tagText(n.tagName);
+      if (tag && /^[A-Z]/.test(tag)) found.add(tag);
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function drawnIn(sf) {
+  const direct = /* @__PURE__ */ new Map();
+  for (const statement of sf.statements) {
+    if ((ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) && statement.name) direct.set(statement.name.text, tagsUnder(statement));
+    else if (ts.isVariableStatement(statement)) {
+      for (const d of statement.declarationList.declarations) if (ts.isIdentifier(d.name) && d.initializer) direct.set(d.name.text, tagsUnder(d.initializer));
+    }
+  }
+  const closed = /* @__PURE__ */ new Map();
+  for (const name of direct.keys()) {
+    const out = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([name]);
+    const stack = [name];
+    while (stack.length) {
+      for (const tag of direct.get(stack.pop()) ?? []) {
+        out.add(tag);
+        if (direct.has(tag) && !seen.has(tag)) {
+          seen.add(tag);
+          stack.push(tag);
+        }
+      }
+    }
+    closed.set(name, out);
+  }
+  return closed;
+}
+function rootsOfExpression(e, out) {
+  if (!e) return;
+  if (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isSatisfiesExpression(e) || ts.isNonNullExpression(e)) return rootsOfExpression(e.expression, out);
+  if (ts.isConditionalExpression(e)) {
+    rootsOfExpression(e.whenTrue, out);
+    rootsOfExpression(e.whenFalse, out);
+    return;
+  }
+  if (ts.isBinaryExpression(e)) {
+    if (e.operatorToken.kind !== ts.SyntaxKind.AmpersandAmpersandToken) rootsOfExpression(e.left, out);
+    rootsOfExpression(e.right, out);
+    return;
+  }
+  if (ts.isJsxFragment(e)) return;
+  const tag = ts.isJsxElement(e) ? tagText(e.openingElement.tagName) : ts.isJsxSelfClosingElement(e) ? tagText(e.tagName) : null;
+  if (tag && /^[A-Z]/.test(tag)) out.add(tag);
+}
+function rootsOfFunction(fn) {
+  const out = /* @__PURE__ */ new Set();
+  if (ts.isArrowFunction(fn) && !ts.isBlock(fn.body)) rootsOfExpression(fn.body, out);
+  const visit = (n) => {
+    if (n !== fn && (ts.isFunctionLike(n) || ts.isClassLike(n))) return;
+    if (ts.isReturnStatement(n)) rootsOfExpression(n.expression, out);
+    ts.forEachChild(n, visit);
+  };
+  visit(fn);
+  return out;
+}
+function functionOf(node) {
+  if (!node) return void 0;
+  if (ts.isFunctionDeclaration(node) || ts.isFunctionExpression(node) || ts.isArrowFunction(node)) return node;
+  if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node)) return functionOf(node.expression);
+  if (ts.isCallExpression(node)) for (const argument of node.arguments) {
+    const fn = functionOf(argument);
+    if (fn) return fn;
+  }
+  return void 0;
+}
+function rootsIn(sf) {
+  const direct = /* @__PURE__ */ new Map();
+  for (const statement of sf.statements) {
+    if (ts.isFunctionDeclaration(statement) && statement.name) direct.set(statement.name.text, rootsOfFunction(statement));
+    else if (ts.isVariableStatement(statement)) {
+      for (const d of statement.declarationList.declarations) {
+        const fn = functionOf(d.initializer);
+        if (ts.isIdentifier(d.name) && fn) direct.set(d.name.text, rootsOfFunction(fn));
+      }
+    }
+  }
+  const closed = /* @__PURE__ */ new Map();
+  for (const name of direct.keys()) {
+    const out = /* @__PURE__ */ new Set();
+    const seen = /* @__PURE__ */ new Set([name]);
+    const stack = [name];
+    while (stack.length) {
+      for (const tag of direct.get(stack.pop()) ?? []) {
+        if (direct.has(tag)) {
+          if (!seen.has(tag)) {
+            seen.add(tag);
+            stack.push(tag);
+          }
+        } else out.add(tag);
+      }
+    }
+    closed.set(name, out);
+  }
+  return closed;
+}
+function importsOf(sf) {
+  const out = /* @__PURE__ */ new Map();
+  for (const statement of sf.statements) {
+    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    const clause = statement.importClause;
+    if (!clause || clause.isTypeOnly) continue;
+    const specifier = statement.moduleSpecifier.text;
+    if (clause.name) out.set(clause.name.text, { specifier, imported: "default" });
+    const bindings = clause.namedBindings;
+    if (bindings && ts.isNamedImports(bindings)) {
+      for (const e of bindings.elements) if (!e.isTypeOnly) out.set(e.name.text, { specifier, imported: (e.propertyName ?? e.name).text });
+    }
+  }
+  return out;
+}
 
 // src/eslint/looks-of.ts
 import { existsSync, readFileSync } from "node:fs";
 import { dirname, join, resolve as resolvePath } from "node:path";
-import ts from "typescript";
+import ts2 from "typescript";
 var PLACEMENT = [
   /^m[xytrblse]?-/,
   /^p[xytrblse]?-/,
@@ -37,10 +186,10 @@ var CAP = 24;
 function classUnits(source, follow) {
   const consts = /* @__PURE__ */ new Map();
   const collect = (node) => {
-    if (ts.isVariableDeclaration(node) && ts.isIdentifier(node.name) && node.initializer && ts.isVariableDeclarationList(node.parent) && node.parent.flags & ts.NodeFlags.Const) {
+    if (ts2.isVariableDeclaration(node) && ts2.isIdentifier(node.name) && node.initializer && ts2.isVariableDeclarationList(node.parent) && node.parent.flags & ts2.NodeFlags.Const) {
       consts.set(node.name.text, node.initializer);
     }
-    ts.forEachChild(node, collect);
+    ts2.forEachChild(node, collect);
   };
   collect(source);
   const product = (lists) => {
@@ -54,30 +203,30 @@ function classUnits(source, follow) {
   };
   const resolve = (node, depth = 0) => {
     if (!node || depth > 8) return [[]];
-    if (ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) return [words(node.text)];
-    if (ts.isTemplateExpression(node)) return product([[words(node.head.text)], ...node.templateSpans.flatMap((span) => [resolve(span.expression, depth + 1), [words(span.literal.text)]])]);
-    if (ts.isParenthesizedExpression(node) || ts.isAsExpression(node) || ts.isSatisfiesExpression(node) || ts.isNonNullExpression(node)) return resolve(node.expression, depth + 1);
-    if (ts.isJsxExpression(node)) return resolve(node.expression, depth + 1);
-    if (ts.isCallExpression(node)) return ts.isIdentifier(node.expression) && CLASS_FUNCTIONS.has(node.expression.text) ? product(node.arguments.map((a) => resolve(a, depth + 1))) : [[]];
-    if (ts.isConditionalExpression(node)) return [...resolve(node.whenTrue, depth + 1), ...resolve(node.whenFalse, depth + 1)].slice(0, CAP);
-    if (ts.isBinaryExpression(node)) {
-      if (node.operatorToken.kind === ts.SyntaxKind.AmpersandAmpersandToken) return [[], ...resolve(node.right, depth + 1)];
-      if (node.operatorToken.kind === ts.SyntaxKind.BarBarToken || node.operatorToken.kind === ts.SyntaxKind.QuestionQuestionToken) return [...resolve(node.left, depth + 1), ...resolve(node.right, depth + 1)].slice(0, CAP);
+    if (ts2.isStringLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) return [words(node.text)];
+    if (ts2.isTemplateExpression(node)) return product([[words(node.head.text)], ...node.templateSpans.flatMap((span) => [resolve(span.expression, depth + 1), [words(span.literal.text)]])]);
+    if (ts2.isParenthesizedExpression(node) || ts2.isAsExpression(node) || ts2.isSatisfiesExpression(node) || ts2.isNonNullExpression(node)) return resolve(node.expression, depth + 1);
+    if (ts2.isJsxExpression(node)) return resolve(node.expression, depth + 1);
+    if (ts2.isCallExpression(node)) return ts2.isIdentifier(node.expression) && CLASS_FUNCTIONS.has(node.expression.text) ? product(node.arguments.map((a) => resolve(a, depth + 1))) : [[]];
+    if (ts2.isConditionalExpression(node)) return [...resolve(node.whenTrue, depth + 1), ...resolve(node.whenFalse, depth + 1)].slice(0, CAP);
+    if (ts2.isBinaryExpression(node)) {
+      if (node.operatorToken.kind === ts2.SyntaxKind.AmpersandAmpersandToken) return [[], ...resolve(node.right, depth + 1)];
+      if (node.operatorToken.kind === ts2.SyntaxKind.BarBarToken || node.operatorToken.kind === ts2.SyntaxKind.QuestionQuestionToken) return [...resolve(node.left, depth + 1), ...resolve(node.right, depth + 1)].slice(0, CAP);
       return [[]];
     }
-    if (ts.isArrayLiteralExpression(node)) return product(node.elements.map((e) => resolve(e, depth + 1)));
-    if (ts.isObjectLiteralExpression(node)) return [[], node.properties.flatMap((p) => p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) ? words(p.name.text) : [])];
-    if (ts.isIdentifier(node)) {
+    if (ts2.isArrayLiteralExpression(node)) return product(node.elements.map((e) => resolve(e, depth + 1)));
+    if (ts2.isObjectLiteralExpression(node)) return [[], node.properties.flatMap((p) => p.name && (ts2.isIdentifier(p.name) || ts2.isStringLiteral(p.name)) ? words(p.name.text) : [])];
+    if (ts2.isIdentifier(node)) {
       const init = consts.get(node.text) ?? follow?.(node.text);
       return init ? resolve(init, depth + 1) : [[]];
     }
-    if (ts.isPropertyAccessExpression(node) || ts.isElementAccessExpression(node)) {
+    if (ts2.isPropertyAccessExpression(node) || ts2.isElementAccessExpression(node)) {
       let target = node.expression;
-      if (ts.isIdentifier(target)) target = consts.get(target.text) ?? follow?.(target.text);
-      while (target && (ts.isAsExpression(target) || ts.isSatisfiesExpression(target) || ts.isParenthesizedExpression(target))) target = target.expression;
-      if (!target || !ts.isObjectLiteralExpression(target)) return [[]];
-      const key = ts.isPropertyAccessExpression(node) ? node.name.text : ts.isStringLiteral(node.argumentExpression) ? node.argumentExpression.text : null;
-      return target.properties.filter((p) => ts.isPropertyAssignment(p) && (key === null || !!p.name && (ts.isIdentifier(p.name) || ts.isStringLiteral(p.name)) && p.name.text === key)).flatMap((p) => resolve(p.initializer, depth + 1)).slice(0, CAP);
+      if (ts2.isIdentifier(target)) target = consts.get(target.text) ?? follow?.(target.text);
+      while (target && (ts2.isAsExpression(target) || ts2.isSatisfiesExpression(target) || ts2.isParenthesizedExpression(target))) target = target.expression;
+      if (!target || !ts2.isObjectLiteralExpression(target)) return [[]];
+      const key = ts2.isPropertyAccessExpression(node) ? node.name.text : ts2.isStringLiteral(node.argumentExpression) ? node.argumentExpression.text : null;
+      return target.properties.filter((p) => ts2.isPropertyAssignment(p) && (key === null || !!p.name && (ts2.isIdentifier(p.name) || ts2.isStringLiteral(p.name)) && p.name.text === key)).flatMap((p) => resolve(p.initializer, depth + 1)).slice(0, CAP);
     }
     return [[]];
   };
@@ -85,14 +234,14 @@ function classUnits(source, follow) {
   const seen = /* @__PURE__ */ new Set();
   const sharedAt = (node) => {
     for (let at = node; at; at = at.parent) {
-      if (ts.isVariableDeclaration(at)) return ts.isIdentifier(at.name) && /_CLASSES$/.test(at.name.text) && !!at.parent?.parent && ts.isVariableStatement(at.parent.parent) && !!at.parent.parent.modifiers?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      if (ts2.isVariableDeclaration(at)) return ts2.isIdentifier(at.name) && /_CLASSES$/.test(at.name.text) && !!at.parent?.parent && ts2.isVariableStatement(at.parent.parent) && !!at.parent.parent.modifiers?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
     }
     return false;
   };
   const lineStart = (node) => {
     const line = source.getLineAndCharacterOfPosition(node.getStart(source)).line;
     let at = node;
-    while (at.parent && !ts.isSourceFile(at.parent) && source.getLineAndCharacterOfPosition(at.parent.getStart(source)).line === line) at = at.parent;
+    while (at.parent && !ts2.isSourceFile(at.parent) && source.getLineAndCharacterOfPosition(at.parent.getStart(source)).line === line) at = at.parent;
     return at.getStart(source);
   };
   const add = (tokens, node, via, anchor = via === "literal" ? lineStart(node) : node.getStart(source)) => {
@@ -105,12 +254,12 @@ function classUnits(source, follow) {
     units.push({ tokens: list, look, start: node.getStart(source), end: node.getEnd(), via, anchor, shared: via === "literal" && sharedAt(node) });
   };
   const visit = (node) => {
-    if (ts.isJsxAttribute(node) && ts.isIdentifier(node.name) && CLASS_PROP.test(node.name.text) && node.initializer) {
+    if (ts2.isJsxAttribute(node) && ts2.isIdentifier(node.name) && CLASS_PROP.test(node.name.text) && node.initializer) {
       const element = node.parent.parent;
       for (const alternative of resolve(node.initializer)) add(alternative, node, "attribute", element.getStart(source));
     }
-    if ((ts.isStringLiteral(node) || ts.isNoSubstitutionTemplateLiteral(node)) && isClassList(node.text)) add(words(node.text), node, "literal");
-    ts.forEachChild(node, visit);
+    if ((ts2.isStringLiteral(node) || ts2.isNoSubstitutionTemplateLiteral(node)) && isClassList(node.text)) add(words(node.text), node, "literal");
+    ts2.forEachChild(node, visit);
   };
   visit(source);
   return units;
@@ -119,15 +268,15 @@ function componentsOf(source) {
   const found = /* @__PURE__ */ new Map();
   const fn = (node) => {
     let current = node;
-    while (current && ts.isCallExpression(current) && current.arguments.length) current = current.arguments[0];
-    return current && (ts.isArrowFunction(current) || ts.isFunctionExpression(current)) ? current : void 0;
+    while (current && ts2.isCallExpression(current) && current.arguments.length) current = current.arguments[0];
+    return current && (ts2.isArrowFunction(current) || ts2.isFunctionExpression(current)) ? current : void 0;
   };
   for (const statement of source.statements) {
-    if (ts.isFunctionDeclaration(statement) && statement.name && /^[A-Z]/.test(statement.name.text)) found.set(statement.name.text, { start: statement.getStart(source), end: statement.getEnd() });
-    if (ts.isVariableStatement(statement)) {
+    if (ts2.isFunctionDeclaration(statement) && statement.name && /^[A-Z]/.test(statement.name.text)) found.set(statement.name.text, { start: statement.getStart(source), end: statement.getEnd() });
+    if (ts2.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
         const body = fn(declaration.initializer);
-        if (ts.isIdentifier(declaration.name) && /^[A-Z]/.test(declaration.name.text) && body) found.set(declaration.name.text, { start: body.getStart(source), end: body.getEnd() });
+        if (ts2.isIdentifier(declaration.name) && /^[A-Z]/.test(declaration.name.text) && body) found.set(declaration.name.text, { start: body.getStart(source), end: body.getEnd() });
       }
     }
   }
@@ -147,7 +296,7 @@ function looksOf(source, names) {
   return out;
 }
 function parseForLooks(fileName, text) {
-  return ts.createSourceFile(fileName, text, ts.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+  return ts2.createSourceFile(fileName, text, ts2.ScriptTarget.Latest, true, fileName.endsWith("x") ? ts2.ScriptKind.TSX : ts2.ScriptKind.TS);
 }
 function importTarget(fromFile, specifier) {
   let base;
@@ -167,8 +316,8 @@ function constantsOf(file) {
   const found = /* @__PURE__ */ new Map();
   const source = parseForLooks(file, readFileSync(file, "utf8"));
   for (const statement of source.statements) {
-    if (!ts.isVariableStatement(statement)) continue;
-    for (const d of statement.declarationList.declarations) if (ts.isIdentifier(d.name) && d.initializer) found.set(d.name.text, d.initializer);
+    if (!ts2.isVariableStatement(statement)) continue;
+    for (const d of statement.declarationList.declarations) if (ts2.isIdentifier(d.name) && d.initializer) found.set(d.name.text, d.initializer);
   }
   constantsCache.set(file, found);
   return found;
@@ -176,9 +325,9 @@ function constantsOf(file) {
 function importedConstants(source) {
   const imported = /* @__PURE__ */ new Map();
   for (const statement of source.statements) {
-    if (!ts.isImportDeclaration(statement) || !ts.isStringLiteral(statement.moduleSpecifier)) continue;
+    if (!ts2.isImportDeclaration(statement) || !ts2.isStringLiteral(statement.moduleSpecifier)) continue;
     const bindings = statement.importClause?.namedBindings;
-    if (!bindings || !ts.isNamedImports(bindings)) continue;
+    if (!bindings || !ts2.isNamedImports(bindings)) continue;
     const target = importTarget(source.fileName, statement.moduleSpecifier.text);
     if (!target) continue;
     for (const element of bindings.elements) {
@@ -207,13 +356,13 @@ function storyNameFromExport(key) {
 }
 var toId = (title, name) => `${sanitize(title)}--${sanitize(storyNameFromExport(name))}`;
 function readIndexExports(source) {
-  const file = ts2.createSourceFile("index.ts", source, ts2.ScriptTarget.Latest, true);
+  const file = ts3.createSourceFile("index.ts", source, ts3.ScriptTarget.Latest, true);
   const found = [];
   for (const statement of file.statements) {
-    if (!ts2.isExportDeclaration(statement)) continue;
+    if (!ts3.isExportDeclaration(statement)) continue;
     const from = statement.moduleSpecifier;
     const clause = statement.exportClause;
-    if (!from || !ts2.isStringLiteral(from) || !clause || !ts2.isNamedExports(clause)) continue;
+    if (!from || !ts3.isStringLiteral(from) || !clause || !ts3.isNamedExports(clause)) continue;
     for (const element of clause.elements) {
       found.push({ name: element.name.text, module: from.text.replace(/^\.\//, ""), isType: statement.isTypeOnly || element.isTypeOnly });
     }
@@ -221,7 +370,7 @@ function readIndexExports(source) {
   return found;
 }
 function docAbove(source, node, headerPos = null) {
-  const ranges = ts2.getLeadingCommentRanges(source, node.getFullStart()) ?? [];
+  const ranges = ts3.getLeadingCommentRanges(source, node.getFullStart()) ?? [];
   const jsdoc = ranges.filter((range) => source.slice(range.pos, range.pos + 3) === "/**").pop();
   if (!jsdoc) return "";
   if (headerPos !== null && jsdoc.pos === headerPos) return "";
@@ -254,23 +403,23 @@ function pageOpening(mdx) {
 }
 function propName(member) {
   if (!member.name) return null;
-  if (ts2.isIdentifier(member.name) || ts2.isStringLiteral(member.name)) return member.name.text;
+  if (ts3.isIdentifier(member.name) || ts3.isStringLiteral(member.name)) return member.name.text;
   return null;
 }
 function literalUnion(type, aliases, seen = /* @__PURE__ */ new Set()) {
   if (!type) return null;
-  if (ts2.isTypeReferenceNode(type) && ts2.isIdentifier(type.typeName)) {
+  if (ts3.isTypeReferenceNode(type) && ts3.isIdentifier(type.typeName)) {
     const name = type.typeName.text;
     if (seen.has(name)) return null;
     seen.add(name);
     const alias = aliases.get(name);
     return alias ? literalUnion(alias, aliases, seen) : null;
   }
-  if (ts2.isLiteralTypeNode(type) && ts2.isStringLiteral(type.literal)) return [type.literal.text];
-  if (!ts2.isUnionTypeNode(type)) return null;
+  if (ts3.isLiteralTypeNode(type) && ts3.isStringLiteral(type.literal)) return [type.literal.text];
+  if (!ts3.isUnionTypeNode(type)) return null;
   const values = [];
   for (const member of type.types) {
-    if (member.kind === ts2.SyntaxKind.UndefinedKeyword || member.kind === ts2.SyntaxKind.NullKeyword) continue;
+    if (member.kind === ts3.SyntaxKind.UndefinedKeyword || member.kind === ts3.SyntaxKind.NullKeyword) continue;
     const inner = literalUnion(member, aliases, seen);
     if (!inner) return null;
     values.push(...inner);
@@ -278,7 +427,7 @@ function literalUnion(type, aliases, seen = /* @__PURE__ */ new Set()) {
   return values.length > 1 ? values : null;
 }
 function readModule(source, sibling = () => void 0, { lendFirstComment = true } = {}) {
-  const file = ts2.createSourceFile("module.tsx", source, ts2.ScriptTarget.Latest, true);
+  const file = ts3.createSourceFile("module.tsx", source, ts3.ScriptTarget.Latest, true);
   const declarations = /* @__PURE__ */ new Map();
   const aliases = /* @__PURE__ */ new Map();
   const shapes = /* @__PURE__ */ new Map();
@@ -287,60 +436,60 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
   const propsTypeOf = (parameters) => parameters[0]?.type;
   const propsOfInitializer = (initializer) => {
     if (!initializer) return void 0;
-    if (ts2.isArrowFunction(initializer) || ts2.isFunctionExpression(initializer)) return propsTypeOf(initializer.parameters);
-    if (ts2.isCallExpression(initializer)) {
-      const callee = ts2.isPropertyAccessExpression(initializer.expression) ? initializer.expression.name.text : ts2.isIdentifier(initializer.expression) ? initializer.expression.text : "";
+    if (ts3.isArrowFunction(initializer) || ts3.isFunctionExpression(initializer)) return propsTypeOf(initializer.parameters);
+    if (ts3.isCallExpression(initializer)) {
+      const callee = ts3.isPropertyAccessExpression(initializer.expression) ? initializer.expression.name.text : ts3.isIdentifier(initializer.expression) ? initializer.expression.text : "";
       if (callee === "forwardRef" && initializer.typeArguments?.[1]) return initializer.typeArguments[1];
-      const wrapped = initializer.arguments.find((argument) => ts2.isArrowFunction(argument) || ts2.isFunctionExpression(argument));
+      const wrapped = initializer.arguments.find((argument) => ts3.isArrowFunction(argument) || ts3.isFunctionExpression(argument));
       if (wrapped) return propsTypeOf(wrapped.parameters);
     }
     return void 0;
   };
   const propsOfAnnotation = (type) => {
-    if (!type || !ts2.isTypeReferenceNode(type)) return void 0;
-    const named = ts2.isIdentifier(type.typeName) ? type.typeName.text : type.typeName.right.text;
+    if (!type || !ts3.isTypeReferenceNode(type)) return void 0;
+    const named = ts3.isIdentifier(type.typeName) ? type.typeName.text : type.typeName.right.text;
     return named === "FC" || named === "FunctionComponent" ? type.typeArguments?.[0] : void 0;
   };
-  const opening = file.statements.find((statement) => !ts2.isImportDeclaration(statement));
-  const headerPos = opening ? (ts2.getLeadingCommentRanges(source, opening.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
-  const topPos = file.statements[0] ? (ts2.getLeadingCommentRanges(source, file.statements[0].getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
-  const aboveImports = !!file.statements[0] && ts2.isImportDeclaration(file.statements[0]);
+  const opening = file.statements.find((statement) => !ts3.isImportDeclaration(statement));
+  const headerPos = opening ? (ts3.getLeadingCommentRanges(source, opening.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
+  const topPos = file.statements[0] ? (ts3.getLeadingCommentRanges(source, file.statements[0].getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**")?.pos ?? null : null;
+  const aboveImports = !!file.statements[0] && ts3.isImportDeclaration(file.statements[0]);
   const refused = lendFirstComment ? topPos ?? headerPos : aboveImports ? topPos : null;
   for (const statement of file.statements) {
-    if (ts2.isImportDeclaration(statement) && ts2.isStringLiteral(statement.moduleSpecifier)) {
+    if (ts3.isImportDeclaration(statement) && ts3.isStringLiteral(statement.moduleSpecifier)) {
       const bindings = statement.importClause?.namedBindings;
-      if (bindings && ts2.isNamedImports(bindings)) {
+      if (bindings && ts3.isNamedImports(bindings)) {
         for (const element of bindings.elements) importedFrom.set(element.name.text, { specifier: statement.moduleSpecifier.text, imported: (element.propertyName ?? element.name).text });
       }
     }
-    if (ts2.isExportDeclaration(statement) && statement.moduleSpecifier && ts2.isStringLiteral(statement.moduleSpecifier) && statement.exportClause && ts2.isNamedExports(statement.exportClause)) {
+    if (ts3.isExportDeclaration(statement) && statement.moduleSpecifier && ts3.isStringLiteral(statement.moduleSpecifier) && statement.exportClause && ts3.isNamedExports(statement.exportClause)) {
       for (const element of statement.exportClause.elements) importedFrom.set(element.name.text, { specifier: statement.moduleSpecifier.text, imported: (element.propertyName ?? element.name).text });
     }
-    if (ts2.isTypeAliasDeclaration(statement)) aliases.set(statement.name.text, statement.type);
-    if (ts2.isInterfaceDeclaration(statement)) {
+    if (ts3.isTypeAliasDeclaration(statement)) aliases.set(statement.name.text, statement.type);
+    if (ts3.isInterfaceDeclaration(statement)) {
       shapes.set(statement.name.text, [...statement.members]);
       const extended = (statement.heritageClauses ?? []).flatMap((clause) => [...clause.types]);
       if (extended.length) bases.set(statement.name.text, extended);
     }
-    if (ts2.isTypeAliasDeclaration(statement) && ts2.isTypeLiteralNode(statement.type)) shapes.set(statement.name.text, [...statement.type.members]);
-    if (ts2.isClassDeclaration(statement)) {
-      const base = (statement.heritageClauses ?? []).find((clause) => clause.token === ts2.SyntaxKind.ExtendsKeyword)?.types[0];
-      const name = statement.name?.text ?? (ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword) ? "default" : null);
+    if (ts3.isTypeAliasDeclaration(statement) && ts3.isTypeLiteralNode(statement.type)) shapes.set(statement.name.text, [...statement.type.members]);
+    if (ts3.isClassDeclaration(statement)) {
+      const base = (statement.heritageClauses ?? []).find((clause) => clause.token === ts3.SyntaxKind.ExtendsKeyword)?.types[0];
+      const name = statement.name?.text ?? (ts3.getModifiers(statement)?.some((m) => m.kind === ts3.SyntaxKind.DefaultKeyword) ? "default" : null);
       if (name) declarations.set(name, { doc: docAbove(source, statement, refused), deprecated: false, propsType: base?.typeArguments?.[0] });
       continue;
     }
-    if (ts2.isExportAssignment(statement) && !statement.isExportEquals && !ts2.isIdentifier(statement.expression)) {
+    if (ts3.isExportAssignment(statement) && !statement.isExportEquals && !ts3.isIdentifier(statement.expression)) {
       declarations.set("default", { doc: docAbove(source, statement, refused), deprecated: false, propsType: propsOfInitializer(statement.expression) });
       continue;
     }
-    if (ts2.isFunctionDeclaration(statement) && !statement.name && ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.DefaultKeyword)) {
+    if (ts3.isFunctionDeclaration(statement) && !statement.name && ts3.getModifiers(statement)?.some((m) => m.kind === ts3.SyntaxKind.DefaultKeyword)) {
       declarations.set("default", { doc: docAbove(source, statement, refused), deprecated: false, propsType: propsTypeOf(statement.parameters) });
       continue;
     }
-    if (!ts2.isFunctionDeclaration(statement) && !ts2.isVariableStatement(statement)) continue;
+    if (!ts3.isFunctionDeclaration(statement) && !ts3.isVariableStatement(statement)) continue;
     const doc = docAbove(source, statement, refused);
     const deprecated = /(^|\n)@deprecated\b/.test(doc) || /\*\s*@deprecated\b/.test(source.slice(Math.max(0, statement.getFullStart()), statement.getStart()));
-    if (ts2.isFunctionDeclaration(statement) && statement.name) {
+    if (ts3.isFunctionDeclaration(statement) && statement.name) {
       const held = declarations.get(statement.name.text);
       if (held) {
         if (!held.doc && doc) held.doc = doc;
@@ -349,9 +498,9 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
       declarations.set(statement.name.text, { doc, deprecated, propsType: propsTypeOf(statement.parameters) });
       continue;
     }
-    if (ts2.isVariableStatement(statement)) {
+    if (ts3.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts2.isIdentifier(declaration.name)) continue;
+        if (!ts3.isIdentifier(declaration.name)) continue;
         declarations.set(declaration.name.text, { doc, deprecated, propsType: propsOfInitializer(declaration.initializer) ?? propsOfAnnotation(declaration.type) });
       }
     }
@@ -359,11 +508,11 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
   const EMPTY = { props: [], variants: [] };
   const keysOf = (type) => {
     if (!type) return null;
-    if (ts2.isLiteralTypeNode(type) && ts2.isStringLiteral(type.literal)) return [type.literal.text];
-    if (!ts2.isUnionTypeNode(type)) return null;
+    if (ts3.isLiteralTypeNode(type) && ts3.isStringLiteral(type.literal)) return [type.literal.text];
+    if (!ts3.isUnionTypeNode(type)) return null;
     const keys = [];
     for (const member of type.types) {
-      if (!ts2.isLiteralTypeNode(member) || !ts2.isStringLiteral(member.literal)) return null;
+      if (!ts3.isLiteralTypeNode(member) || !ts3.isStringLiteral(member.literal)) return null;
       keys.push(member.literal.text);
     }
     return keys;
@@ -401,7 +550,7 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
     const variants = [];
     for (const member of members) {
       const name = propName(member);
-      if (name === null || !ts2.isPropertySignature(member)) continue;
+      if (name === null || !ts3.isPropertySignature(member)) continue;
       const values = literalUnion(member.type, aliases);
       const note = firstSentence(docAbove(source, member));
       props.push({ name, takes: takes(member.type, values), required: !member.questionToken, note: note || null });
@@ -411,9 +560,9 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
   };
   const resolveNode = (type, seen) => {
     if (!type || seen.size > 12) return EMPTY;
-    if (ts2.isTypeLiteralNode(type)) return fromMembers(type.members);
-    if (ts2.isIntersectionTypeNode(type)) return merge(type.types.map((side) => resolveNode(side, seen)));
-    if (ts2.isTypeReferenceNode(type) && ts2.isIdentifier(type.typeName)) {
+    if (ts3.isTypeLiteralNode(type)) return fromMembers(type.members);
+    if (ts3.isIntersectionTypeNode(type)) return merge(type.types.map((side) => resolveNode(side, seen)));
+    if (ts3.isTypeReferenceNode(type) && ts3.isIdentifier(type.typeName)) {
       const named = type.typeName.text;
       if (named === "Omit" || named === "Pick") {
         return narrow(resolveNode(type.typeArguments?.[0], seen), named, keysOf(type.typeArguments?.[1]));
@@ -423,7 +572,7 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
     return EMPTY;
   };
   const resolveBase = (base, seen) => {
-    if (!ts2.isIdentifier(base.expression)) return EMPTY;
+    if (!ts3.isIdentifier(base.expression)) return EMPTY;
     const named = base.expression.text;
     if (named === "Omit" || named === "Pick") {
       return narrow(resolveNode(base.typeArguments?.[0], seen), named, keysOf(base.typeArguments?.[1]));
@@ -444,7 +593,7 @@ function readModule(source, sibling = () => void 0, { lendFirstComment = true }
     return (from ? sibling(from.specifier, from.imported) : void 0) ?? EMPTY;
   }
   const resolve = (propsType) => resolveNode(propsType, /* @__PURE__ */ new Set());
-  const jsdocAt = (node) => node ? (ts2.getLeadingCommentRanges(source, node.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**") : void 0;
+  const jsdocAt = (node) => node ? (ts3.getLeadingCommentRanges(source, node.getFullStart()) ?? []).find((range) => source.slice(range.pos, range.pos + 3) === "/**") : void 0;
   const headerRange = jsdocAt(file.statements[0]) ?? jsdocAt(opening);
   return { declarations, headerDoc: headerRange ? headerComment(source, headerRange) : "", resolve, resolveName: (name) => resolveName(name, /* @__PURE__ */ new Set()) };
 }
@@ -452,23 +601,23 @@ function headerComment(source, range) {
   return source.slice(range.pos, range.end).split(/\r?\n/).map((line) => line.trim().replace(/^\/\*\*/, "").replace(/\*\/$/, "").replace(/^\*/, "").trim()).join("\n").trim();
 }
 function readStories(source) {
-  const file = ts2.createSourceFile("x.stories.tsx", source, ts2.ScriptTarget.Latest, true);
+  const file = ts3.createSourceFile("x.stories.tsx", source, ts3.ScriptTarget.Latest, true);
   let title = null;
   const stories = [];
   for (const statement of file.statements) {
-    if (ts2.isVariableStatement(statement)) {
+    if (ts3.isVariableStatement(statement)) {
       for (const declaration of statement.declarationList.declarations) {
-        if (!ts2.isIdentifier(declaration.name)) continue;
+        if (!ts3.isIdentifier(declaration.name)) continue;
         const initializer = declaration.initializer;
-        const object = initializer && ts2.isSatisfiesExpression(initializer) ? initializer.expression : initializer;
-        if (declaration.name.text === "meta" && object && ts2.isObjectLiteralExpression(object)) {
+        const object = initializer && ts3.isSatisfiesExpression(initializer) ? initializer.expression : initializer;
+        if (declaration.name.text === "meta" && object && ts3.isObjectLiteralExpression(object)) {
           for (const property of object.properties) {
-            if (ts2.isPropertyAssignment(property) && ts2.isIdentifier(property.name) && property.name.text === "title" && ts2.isStringLiteral(property.initializer)) {
+            if (ts3.isPropertyAssignment(property) && ts3.isIdentifier(property.name) && property.name.text === "title" && ts3.isStringLiteral(property.initializer)) {
               title = property.initializer.text;
             }
           }
         }
-        const exported = ts2.getModifiers(statement)?.some((m) => m.kind === ts2.SyntaxKind.ExportKeyword);
+        const exported = ts3.getModifiers(statement)?.some((m) => m.kind === ts3.SyntaxKind.ExportKeyword);
         if (exported && declaration.name.text !== "meta") stories.push(declaration.name.text);
       }
     }
@@ -481,7 +630,7 @@ function kindOf(name) {
   return /^[A-Z]/.test(name) && !isAllCaps(name) ? "component" : "helper";
 }
 function behavioursOf(name) {
-  return OWNED_BEHAVIOURS.filter((owned) => owned.owners.includes(name)).map((owned) => ({ id: owned.id, behaviour: owned.behaviour }));
+  return OWNED_BEHAVIOURS2.filter((owned) => owned.owners.includes(name)).map((owned) => ({ id: owned.id, behaviour: owned.behaviour }));
 }
 function buildRegistry({ root = process.cwd(), repo = "estiva-ui" } = {}) {
   const src = join2(root, "src");
@@ -548,6 +697,36 @@ function buildRegistry({ root = process.cwd(), repo = "estiva-ui" } = {}) {
   }
   if (problems.length) throw new Error(`the registry cannot be built:
   ${problems.join("\n  ")}`);
+  const moduleByName = new Map(values.map((v) => [v.name, v.module]));
+  const drawing = /* @__PURE__ */ new Map();
+  const drawingOf = (moduleName) => {
+    if (!drawing.has(moduleName)) {
+      const file = moduleOf(moduleName).file;
+      const sf = ts3.createSourceFile(file, readFileSync2(join2(root, file), "utf8"), ts3.ScriptTarget.Latest, true, file.endsWith("x") ? ts3.ScriptKind.TSX : ts3.ScriptKind.TS);
+      drawing.set(moduleName, { drawn: drawnIn(sf), roots: rootsIn(sf), imports: importsOf(sf) });
+    }
+    return drawing.get(moduleName);
+  };
+  const owns = (name, seen) => {
+    const out = new Set(behavioursOf(name).map((b) => b.id));
+    const moduleName = moduleByName.get(name);
+    if (!moduleName || seen.has(name)) return out;
+    seen.add(name);
+    const { drawn, roots, imports } = drawingOf(moduleName);
+    for (const tag of drawn.get(name) ?? []) {
+      const [local, piece] = splitTag(tag);
+      const from = imports.get(local);
+      if (from && isBaseUi(from.specifier)) for (const id of baseUiBehaviours(from.imported, piece)) out.add(id);
+    }
+    for (const tag of roots.get(name) ?? []) {
+      const [local] = splitTag(tag);
+      const from = imports.get(local);
+      const part = from?.specifier.startsWith("./") ? from.imported : !from && local !== name ? local : void 0;
+      if (part && moduleByName.has(part)) for (const id of handedOn(part, owns(part, seen))) out.add(id);
+    }
+    return out;
+  };
+  for (const entry of entries) if (entry.kind === "component") entry.ownsBehaviours = asBehaviours(owns(entry.name, /* @__PURE__ */ new Set()));
   entries.sort((a, b) => a.name.localeCompare(b.name));
   return {
     schemaVersion: SCHEMA_VERSION,
@@ -579,6 +758,13 @@ function serializeRegistry(registry) {
 }
 
 export {
+  isBaseUi,
+  baseUiBehaviours,
+  handedOn,
+  asBehaviours,
+  splitTag,
+  drawnIn,
+  rootsIn,
   looksOf,
   parseForLooks,
   PACKAGE_IMPORT,
@@ -592,4 +778,4 @@ export {
   buildRegistry,
   serializeRegistry
 };
-//# sourceMappingURL=chunk-XVII7P6G.js.map
+//# sourceMappingURL=chunk-SIB44CES.js.map