@estiva-app/ui 0.22.0 → 0.24.0

package/dist/registry/chunk-WMFF3MPP.js

@@ -0,0 +1,648 @@
+#!/usr/bin/env node
+import {
+  PACKAGE_IMPORT,
+  firstSentence,
+  pageOpening,
+  readModule,
+  sanitize,
+  toId
+} from "./chunk-NJN4MQAM.js";
+import {
+  SCHEMA_VERSION
+} from "./chunk-E4JNV7PC.js";
+
+// src/registry/app.ts
+import { existsSync, readFileSync, readdirSync, statSync } from "node:fs";
+import { basename, dirname, extname, join, relative, resolve, sep } from "node:path";
+import ts from "typescript";
+var WRITABLE = ["reusable", "one-off", "promote-candidate"];
+var WRITTEN = /^@registry\s+([a-z-]+)\s*:\s*(.+)$/m;
+var isStory = (file) => /\.stories\.[cm]?[jt]sx?$/.test(file);
+var isTest = (file) => /\.(test|spec)\.[cm]?[jt]sx?$/.test(file) || /(^|\/)__(tests|mocks)__\//.test(file);
+var isPascal = (name) => /^[A-Z][A-Za-z0-9]*$/.test(name) && !/^[A-Z0-9_]+$/.test(name);
+function pickedFrom(call) {
+  const then = call.parent;
+  const invoked = then?.parent;
+  if (then && ts.isPropertyAccessExpression(then) && then.name.text === "then" && invoked && ts.isCallExpression(invoked)) {
+    const callback = invoked.arguments[0];
+    const param = callback && (ts.isArrowFunction(callback) || ts.isFunctionExpression(callback)) ? callback.parameters[0]?.name : void 0;
+    if (param && ts.isIdentifier(param)) {
+      const names = /* @__PURE__ */ new Set();
+      const visit = (n) => {
+        if (ts.isPropertyAccessExpression(n) && ts.isIdentifier(n.expression) && n.expression.text === param.text) names.add(n.name.text);
+        ts.forEachChild(n, visit);
+      };
+      visit(callback);
+      if (names.size) return [...names].map((imported) => ({ imported, local: "(dynamic)" }));
+    }
+  }
+  return [{ imported: "*", local: "(dynamic)" }];
+}
+function unwrapDefault(ex) {
+  if (!ex.isDefault || ex.local || !ex.node || !ts.isExpression(ex.node)) return ex;
+  const name = handedOut(ex.node);
+  return name ? { ...ex, local: name, node: null } : ex;
+}
+function handedOut(expression) {
+  let e = expression;
+  for (; ; ) {
+    if (ts.isIdentifier(e)) return e.text;
+    if (ts.isParenthesizedExpression(e) || ts.isAsExpression(e) || ts.isSatisfiesExpression(e) || ts.isNonNullExpression(e) || ts.isTypeAssertionExpression(e)) e = e.expression;
+    else if (ts.isTaggedTemplateExpression(e)) e = e.tag;
+    else if (ts.isCallExpression(e) && e.arguments[0] && !e.arguments.some((a) => ts.isArrowFunction(a) || ts.isFunctionExpression(a))) e = e.arguments[0];
+    else return null;
+  }
+}
+var pascalOf = (stem) => stem.split(/[^A-Za-z0-9]+/).filter(Boolean).map((word) => word[0].toUpperCase() + word.slice(1)).join("");
+var defaultNameOf = (file) => {
+  const stem = basename(file, extname(file));
+  return pascalOf(stem === "index" ? basename(dirname(file)) : stem);
+};
+var CODE = [".tsx", ".ts", ".jsx", ".js", ".mts", ".cts"];
+function packageOf(specifier) {
+  const parts = specifier.split("/");
+  return specifier.startsWith("@") ? parts.slice(0, 2).join("/") : parts[0];
+}
+function packageSelf() {
+  const at = (rel) => new URL(rel, import.meta.url);
+  const manifest = JSON.parse(readFileSync(at("../../package.json"), "utf8"));
+  const registryUrl = at("../../registry.json");
+  const registry = existsSync(registryUrl) ? JSON.parse(readFileSync(registryUrl, "utf8")) : null;
+  return { dependencies: [manifest.name, ...Object.keys(manifest.dependencies ?? {}), ...Object.keys(manifest.peerDependencies ?? {})], registry };
+}
+function readAliases(root) {
+  const aliases = [];
+  const bases = [];
+  for (const name of readdirSync(root).filter((file) => /^tsconfig.*\.json$/.test(file)).sort()) {
+    const read = ts.readConfigFile(join(root, name), ts.sys.readFile);
+    const options = read.config?.compilerOptions ?? {};
+    const base = resolve(root, options.baseUrl ?? ".");
+    if (options.baseUrl !== void 0 && !bases.includes(base)) bases.push(base);
+    for (const [pattern, targets] of Object.entries(options.paths ?? {})) {
+      if (!pattern.endsWith("/*") || !targets[0]?.endsWith("/*")) continue;
+      const prefix = pattern.slice(0, -1);
+      if (!aliases.some((alias) => alias.prefix === prefix)) aliases.push({ prefix, target: resolve(base, targets[0].slice(0, -2)) });
+    }
+  }
+  return { aliases, bases };
+}
+function walk(dir) {
+  return readdirSync(dir).flatMap((name) => {
+    if (name === "node_modules" || name.startsWith(".")) return [];
+    const path = join(dir, name);
+    return statSync(path).isDirectory() ? walk(path) : [path];
+  });
+}
+function draws(node) {
+  let found = false;
+  const visit = (n) => {
+    if (found) return;
+    if (ts.isJsxElement(n) || ts.isJsxSelfClosingElement(n) || ts.isJsxFragment(n)) {
+      found = true;
+      return;
+    }
+    if (ts.isCallExpression(n)) {
+      const callee = ts.isPropertyAccessExpression(n.expression) ? n.expression.name.text : ts.isIdentifier(n.expression) ? n.expression.text : "";
+      if (callee === "createElement" || callee === "createPortal") {
+        found = true;
+        return;
+      }
+    }
+    ts.forEachChild(n, visit);
+  };
+  visit(node);
+  return found;
+}
+function mentions(sf, local, home) {
+  let named = false;
+  const visit = (n) => {
+    if (named) return;
+    if (ts.isIdentifier(n) && n.text === local) {
+      const parent = n.parent;
+      const declares = (ts.isPropertySignature(parent) || ts.isPropertyDeclaration(parent) || ts.isMethodDeclaration(parent) || ts.isMethodSignature(parent) || ts.isGetAccessorDeclaration(parent) || ts.isSetAccessorDeclaration(parent) || ts.isEnumMember(parent) || ts.isVariableDeclaration(parent) || ts.isFunctionDeclaration(parent) || ts.isClassDeclaration(parent) || ts.isParameter(parent) || ts.isBindingElement(parent)) && parent.name === n;
+      const bindingKey = ts.isBindingElement(parent) && parent.propertyName === n;
+      const isName = declares || bindingKey || ts.isPropertyAccessExpression(parent) && parent.name === n || ts.isPropertyAssignment(parent) && parent.name === n || ts.isJsxAttribute(parent) || ts.isExportSpecifier(parent) || ts.isImportSpecifier(parent) || ts.isJsxClosingElement(parent);
+      const configures = ts.isPropertyAccessExpression(parent) && parent.expression === n && ts.isBinaryExpression(parent.parent) && parent.parent.left === parent && parent.parent.operatorToken.kind === ts.SyntaxKind.EqualsToken;
+      if (configures) {
+        ts.forEachChild(n, visit);
+        return;
+      }
+      let inType = false;
+      for (let a = parent; a && a !== sf; a = a.parent) if (ts.isTypeNode(a)) inType = true;
+      if (!isName && !inType && !shadowed(n, local, sf)) named = true;
+    }
+    ts.forEachChild(n, visit);
+  };
+  for (const s of sf.statements) {
+    if (s === home || ts.isExportDeclaration(s) || ts.isImportDeclaration(s)) continue;
+    if (ts.isExportAssignment(s) && handedOut(s.expression)) continue;
+    visit(s);
+  }
+  return named;
+}
+function binds(name, local) {
+  if (!name) return false;
+  if (ts.isIdentifier(name)) return name.text === local;
+  return name.elements.some((element) => !ts.isOmittedExpression(element) && binds(element.name, local));
+}
+function shadowed(n, local, sf) {
+  for (let a = n.parent; a && a !== sf; a = a.parent) {
+    if (ts.isFunctionLike(a)) {
+      if (a.parameters.some((p) => binds(p.name, local))) return true;
+      if ((ts.isFunctionExpression(a) || ts.isClassExpression(a)) && a.name?.text === local) return true;
+    }
+    if (ts.isCatchClause(a) && binds(a.variableDeclaration?.name, local)) return true;
+    if (ts.isBlock(a) || ts.isModuleBlock(a) || ts.isCaseClause(a) || ts.isDefaultClause(a)) {
+      for (const s of a.statements) {
+        if (ts.isVariableStatement(s) && s.declarationList.declarations.some((d) => binds(d.name, local))) return true;
+        if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name?.text === local) return true;
+      }
+    }
+    if ((ts.isForStatement(a) || ts.isForOfStatement(a) || ts.isForInStatement(a)) && a.initializer && ts.isVariableDeclarationList(a.initializer) && a.initializer.declarations.some((d) => binds(d.name, local))) return true;
+  }
+  return false;
+}
+function drawingBody(node) {
+  if (ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node)) return node;
+  const init = ts.isVariableDeclaration(node) ? node.initializer : ts.isExpression(node) ? node : void 0;
+  if (!init) return null;
+  if (ts.isArrowFunction(init) || ts.isFunctionExpression(init) || ts.isClassExpression(init)) return init;
+  if (ts.isCallExpression(init)) {
+    const callee = init.expression.getText();
+    if (/(^|\.)createContext$/.test(callee)) return null;
+    if (init.arguments.some((a) => ts.isArrowFunction(a) || ts.isFunctionExpression(a))) return init;
+  }
+  return null;
+}
+function buildAppRegistry({ root = process.cwd(), repo, packageRegistry, packageDependencies } = {}) {
+  const app = resolve(root);
+  const src = join(app, "src");
+  if (!existsSync(src)) throw new Error(`${app} has no src/ folder: estiva-ui reads an app's parts from src/`);
+  const manifest = JSON.parse(readFileSync(join(app, "package.json"), "utf8"));
+  const self = packageRegistry === void 0 || packageDependencies === void 0 ? packageSelf() : null;
+  const theRegistry = packageRegistry === void 0 ? self?.registry ?? null : packageRegistry;
+  const allowed = new Set(packageDependencies ?? self?.dependencies ?? []);
+  const repoName = repo ?? manifest.name ?? basename(app);
+  const { aliases, bases } = readAliases(app);
+  const rel = (abs) => relative(app, abs).split(sep).join("/");
+  const files = walk(src).filter((path) => CODE.includes(extname(path)) && !path.endsWith(".d.ts")).map(rel).sort();
+  const known = new Set(files);
+  const resolveSpecifier = (from, specifier) => {
+    let base = null;
+    if (specifier.startsWith(".")) base = resolve(app, dirname(from), specifier);
+    else {
+      const alias = aliases.find((a) => specifier.startsWith(a.prefix));
+      if (alias) base = join(alias.target, specifier.slice(alias.prefix.length));
+    }
+    const lookUp = (at) => {
+      const stem = at.replace(/\.(js|jsx)$/, "");
+      for (const candidate of [at, ...CODE.map((e) => stem + e), ...CODE.map((e) => join(at, `index${e}`))]) {
+        const r = rel(candidate);
+        if (known.has(r)) return r;
+      }
+      return null;
+    };
+    if (base === null) {
+      for (const folder of bases) {
+        const hit = lookUp(join(folder, specifier));
+        if (hit) return hit;
+      }
+      return null;
+    }
+    return lookUp(base) ?? "?";
+  };
+  const facts = /* @__PURE__ */ new Map();
+  for (const file of files) {
+    const source = readFileSync(join(app, file), "utf8");
+    const sf = ts.createSourceFile(file, source, ts.ScriptTarget.Latest, true, /x$/.test(file) ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+    const links = [];
+    const exports = [];
+    const reexports = [];
+    const starFrom = [];
+    const namespaces = [];
+    for (const statement of sf.statements) {
+      if (ts.isImportDeclaration(statement)) {
+        if (!ts.isStringLiteral(statement.moduleSpecifier)) continue;
+        const specifier = statement.moduleSpecifier.text;
+        const clause = statement.importClause;
+        const names = [];
+        if (clause && !clause.isTypeOnly) {
+          if (clause.name) names.push({ imported: "default", local: clause.name.text });
+          const bindings2 = clause.namedBindings;
+          if (bindings2 && ts.isNamedImports(bindings2)) {
+            for (const e of bindings2.elements) if (!e.isTypeOnly) names.push({ imported: (e.propertyName ?? e.name).text, local: e.name.text });
+          }
+          if (bindings2 && ts.isNamespaceImport(bindings2)) names.push({ imported: "*", local: bindings2.name.text });
+        }
+        links.push({ specifier, target: resolveSpecifier(file, specifier), names, typeOnly: !!clause?.isTypeOnly || clause !== void 0 && names.length === 0 && !!clause.namedBindings, kind: "import" });
+        continue;
+      }
+      if (ts.isExportDeclaration(statement)) {
+        const specifier = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier) ? statement.moduleSpecifier.text : null;
+        if (specifier === null) {
+          if (!statement.isTypeOnly && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+            for (const e of statement.exportClause.elements) if (!e.isTypeOnly) exports.push({ name: e.name.text, local: (e.propertyName ?? e.name).text, isDefault: e.name.text === "default", node: null });
+          }
+          continue;
+        }
+        const target = resolveSpecifier(file, specifier);
+        links.push({ specifier, target, names: [], typeOnly: statement.isTypeOnly, kind: "re-export" });
+        if (statement.isTypeOnly) continue;
+        if (!statement.exportClause) starFrom.push({ specifier, target });
+        else if (ts.isNamedExports(statement.exportClause)) {
+          for (const e of statement.exportClause.elements) if (!e.isTypeOnly) reexports.push({ name: e.name.text, source: (e.propertyName ?? e.name).text, specifier, target });
+        } else if (ts.isNamespaceExport(statement.exportClause)) {
+          namespaces.push({ name: statement.exportClause.name.text, target });
+        }
+        continue;
+      }
+      if (ts.isExportAssignment(statement) && !statement.isExportEquals) {
+        const e = statement.expression;
+        exports.push({ name: "default", local: ts.isIdentifier(e) ? e.text : null, isDefault: true, node: ts.isIdentifier(e) ? null : e });
+        continue;
+      }
+      const mods = ts.canHaveModifiers(statement) ? ts.getModifiers(statement) ?? [] : [];
+      if (!mods.some((m) => m.kind === ts.SyntaxKind.ExportKeyword)) continue;
+      const isDefault = mods.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+      if (ts.isFunctionDeclaration(statement) && !statement.body) continue;
+      if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) {
+        exports.push({ name: isDefault ? "default" : statement.name?.text ?? "default", local: statement.name?.text ?? null, isDefault, node: statement });
+      } else if (ts.isVariableStatement(statement)) {
+        for (const d of statement.declarationList.declarations) if (ts.isIdentifier(d.name)) exports.push({ name: d.name.text, local: d.name.text, isDefault: false, node: d });
+      }
+    }
+    const tags = /* @__PURE__ */ new Set();
+    const visit = (n) => {
+      if (ts.isCallExpression(n) && n.expression.kind === ts.SyntaxKind.ImportKeyword && n.arguments[0] && ts.isStringLiteralLike(n.arguments[0])) {
+        const specifier = n.arguments[0].text;
+        links.push({ specifier, target: resolveSpecifier(file, specifier), names: pickedFrom(n), typeOnly: false, kind: "dynamic" });
+      }
+      if ((ts.isJsxOpeningElement(n) || ts.isJsxSelfClosingElement(n)) && ts.isIdentifier(n.tagName)) tags.add(n.tagName.text);
+      ts.forEachChild(n, visit);
+    };
+    visit(sf);
+    const bindings = /* @__PURE__ */ new Map();
+    for (const link of links) if (link.kind === "import") {
+      for (const n of link.names) if (n.imported !== "*") bindings.set(n.local, { specifier: link.specifier, imported: n.imported, target: link.target });
+    }
+    facts.set(file, { file, source, sf, links, exports, reexports, starFrom, namespaces, tags, bindings });
+  }
+  const drawnAnywhere = /* @__PURE__ */ new Set();
+  for (const f of facts.values()) for (const tag of f.tags) drawnAnywhere.add(tag);
+  const declarationOf = (f, local) => {
+    for (const s of f.sf.statements) {
+      if (ts.isFunctionDeclaration(s) && s.name?.text === local && !s.body) continue;
+      if ((ts.isFunctionDeclaration(s) || ts.isClassDeclaration(s)) && s.name?.text === local) return s;
+      if (ts.isVariableStatement(s)) {
+        for (const d of s.declarationList.declarations) if (ts.isIdentifier(d.name) && d.name.text === local) return d;
+      }
+    }
+    return null;
+  };
+  const problems = [];
+  const found = [];
+  const targets = files.filter((file) => file.endsWith(".tsx") && !isStory(file) && !isTest(file));
+  for (const file of targets) {
+    const f = facts.get(file);
+    for (const written of f.exports) {
+      const ex = unwrapDefault(written);
+      if (ex !== written && ex.local && isPascal(ex.local) && !declarationOf(f, ex.local) && f.bindings.has(ex.local)) {
+        found.push({ file, name: defaultNameOf(file), local: null, defaultExport: true, from: null });
+        continue;
+      }
+      if (ex.isDefault && ex.local && f.exports.some((other) => !other.isDefault && other.local === ex.local)) continue;
+      const node = ex.node ?? (ex.local ? declarationOf(f, ex.local) : null);
+      const own = ex.local ?? (ex.isDefault ? defaultNameOf(file) : ex.name);
+      const name = ex.isDefault ? own : ex.name;
+      if (!isPascal(name)) continue;
+      const bound = node === null && ex.local ? f.bindings.get(ex.local) : void 0;
+      if (bound) {
+        if (bound.target === null) found.push({ file, name, local: null, defaultExport: ex.isDefault, from: { specifier: bound.specifier, name: bound.imported } });
+        continue;
+      }
+      const alias = node && ts.isVariableDeclaration(node) && node.initializer && ts.isIdentifier(node.initializer) ? f.bindings.get(node.initializer.text) : void 0;
+      if (alias) {
+        if (alias.target === null) found.push({ file, name, local: null, defaultExport: ex.isDefault, from: { specifier: alias.specifier, name: alias.imported } });
+        continue;
+      }
+      const body = node ? drawingBody(node) : null;
+      const isPart = body !== null && draws(body) || drawnAnywhere.has(ex.local ?? name);
+      if (isPart) found.push({ file, name, local: ex.local, defaultExport: ex.isDefault, from: null });
+    }
+    for (const re of f.reexports) {
+      if (re.target !== null || !isPascal(re.name)) continue;
+      found.push({ file, name: re.name, local: null, defaultExport: false, from: { specifier: re.specifier, name: re.source } });
+    }
+    for (const star of f.starFrom) {
+      if (star.target === null) problems.push(`${file} hands on everything from '${star.specifier}' with export *: name the parts it hands on, so the catalogue can list them`);
+    }
+  }
+  const key = (file, name) => `${file}#${name}`;
+  const byKey = new Map(found.map((p) => [key(p.file, p.name), p]));
+  const partsIn = (file) => found.filter((p) => p.file === file);
+  const defaultPartOf = (file) => {
+    const written = facts.get(file)?.exports.find((e) => e.isDefault);
+    if (!written) return null;
+    const d = unwrapDefault(written);
+    return partsIn(file).find((p) => p.defaultExport || d.local !== null && p.local === d.local) ?? null;
+  };
+  const origin = (file, name, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(key(file, name))) return null;
+    seen.add(key(file, name));
+    const direct = byKey.get(key(file, name));
+    if (direct) return direct;
+    const f = facts.get(file);
+    if (!f) return null;
+    if (name === "default") {
+      const d = defaultPartOf(file);
+      if (d) return d;
+    }
+    const re = f.reexports.find((r) => r.name === name);
+    if (re && re.target && re.target !== "?") return origin(re.target, re.source, seen);
+    const ex = f.exports.find((e) => name === "default" ? e.isDefault : e.name === name && !e.isDefault);
+    const renamed = ex?.node && ts.isVariableDeclaration(ex.node) && ex.node.initializer && ts.isIdentifier(ex.node.initializer) ? f.bindings.get(ex.node.initializer.text) : void 0;
+    const bound = (ex?.local && !ex.node && !declarationOf(f, ex.local) ? f.bindings.get(ex.local) : void 0) ?? renamed;
+    if (bound?.target && bound.target !== "?") return origin(bound.target, bound.imported, seen);
+    for (const star of f.starFrom) if (star.target && star.target !== "?") {
+      const hit = origin(star.target, name, seen);
+      if (hit) return hit;
+    }
+    return null;
+  };
+  const everyPartOf = (file, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(file)) return [];
+    seen.add(file);
+    const f = facts.get(file);
+    if (!f) return [];
+    const out = [...partsIn(file)];
+    for (const re of f.reexports) if (re.target && re.target !== "?") {
+      const o = origin(re.target, re.source);
+      if (o) out.push(o);
+    }
+    for (const star of f.starFrom) if (star.target && star.target !== "?") out.push(...everyPartOf(star.target, seen));
+    for (const ns of f.namespaces) if (ns.target && ns.target !== "?") out.push(...everyPartOf(ns.target, seen));
+    return out;
+  };
+  const namespaceParts = (file, name, seen = /* @__PURE__ */ new Set()) => {
+    if (seen.has(`${file}#${name}`)) return [];
+    seen.add(`${file}#${name}`);
+    const f = facts.get(file);
+    if (!f) return [];
+    const ns = f.namespaces.find((x) => x.name === name);
+    if (ns) return ns.target && ns.target !== "?" ? everyPartOf(ns.target) : [];
+    const re = f.reexports.find((r) => r.name === name);
+    if (re?.target && re.target !== "?") return namespaceParts(re.target, re.source, seen);
+    return f.starFrom.flatMap((star) => star.target && star.target !== "?" ? namespaceParts(star.target, name, seen) : []);
+  };
+  const users = /* @__PURE__ */ new Map();
+  for (const p of found) users.set(key(p.file, p.name), { app: /* @__PURE__ */ new Set(), stories: /* @__PURE__ */ new Set(), tests: /* @__PURE__ */ new Set() });
+  for (const f of facts.values()) {
+    const bucket = (p) => {
+      const u = users.get(key(p.file, p.name));
+      return isStory(f.file) ? u.stories : isTest(f.file) ? u.tests : u.app;
+    };
+    for (const link of f.links) {
+      if (link.kind === "re-export" || link.typeOnly || !link.target || link.target === "?") continue;
+      for (const n of link.names) {
+        if (n.imported === "*") {
+          const theDefault = link.kind === "dynamic" ? defaultPartOf(link.target) : null;
+          const chosen = theDefault ? [theDefault] : everyPartOf(link.target);
+          for (const p2 of chosen) if (p2.file !== f.file) bucket(p2).add(f.file);
+          continue;
+        }
+        const p = origin(link.target, n.imported);
+        const handsOn = f.exports.some((e) => e.local === n.local && e.node === null) && !mentions(f.sf, n.local, null);
+        if (handsOn) continue;
+        if (p) {
+          if (p.file !== f.file) bucket(p).add(f.file);
+          continue;
+        }
+        for (const part of namespaceParts(link.target, n.imported)) if (part.file !== f.file) bucket(part).add(f.file);
+      }
+    }
+  }
+  for (const p of found) {
+    if (p.from || !p.local) continue;
+    const f = facts.get(p.file);
+    const decl = declarationOf(f, p.local);
+    const home = decl ? ts.isVariableDeclaration(decl) ? decl.parent.parent : decl : null;
+    if (mentions(f.sf, p.local, home)) users.get(key(p.file, p.name)).app.add(p.file);
+  }
+  const directTies = /* @__PURE__ */ new Map();
+  const appDeps = /* @__PURE__ */ new Map();
+  for (const f of facts.values()) {
+    const ties = [];
+    const deps = [];
+    for (const link of f.links) {
+      if (link.target === null) {
+        const tie = link.specifier.startsWith("node:") ? link.specifier : allowed.has(packageOf(link.specifier)) ? null : packageOf(link.specifier);
+        if (tie && !ties.includes(tie)) ties.push(tie);
+      } else if (link.target === "?") {
+        if (!ties.includes(link.specifier)) ties.push(link.specifier);
+      } else if (link.target !== f.file && !deps.includes(link.target)) deps.push(link.target);
+    }
+    directTies.set(f.file, ties);
+    appDeps.set(f.file, deps);
+  }
+  const tied = new Set([...directTies].filter(([, t]) => t.length > 0).map(([file]) => file));
+  for (let changed = true; changed; ) {
+    changed = false;
+    for (const [file, deps] of appDeps) if (!tied.has(file) && deps.some((d) => tied.has(d))) tied.add(file), changed = true;
+  }
+  const tiesOf = (file) => [...directTies.get(file), ...appDeps.get(file).filter((d) => tied.has(d))].sort();
+  const stories = files.filter(isStory).map((file) => {
+    const f = facts.get(file);
+    let title = null;
+    let component = null;
+    let noDocs = false;
+    const names = [];
+    for (const s of f.sf.statements) {
+      if (!ts.isVariableStatement(s)) continue;
+      const exported = (ts.getModifiers(s) ?? []).some((m) => m.kind === ts.SyntaxKind.ExportKeyword);
+      for (const d of s.declarationList.declarations) {
+        if (!ts.isIdentifier(d.name)) continue;
+        if (d.name.text === "meta") {
+          let init = d.initializer;
+          while (init && (ts.isSatisfiesExpression(init) || ts.isAsExpression(init) || ts.isParenthesizedExpression(init))) init = init.expression;
+          if (init && ts.isObjectLiteralExpression(init)) {
+            for (const prop of init.properties) {
+              if (!ts.isPropertyAssignment(prop) || !ts.isIdentifier(prop.name)) continue;
+              if (prop.name.text === "title" && ts.isStringLiteralLike(prop.initializer)) title = prop.initializer.text;
+              if (prop.name.text === "component" && ts.isIdentifier(prop.initializer)) component = prop.initializer.text;
+              if (prop.name.text === "tags" && ts.isArrayLiteralExpression(prop.initializer)) noDocs = prop.initializer.elements.some((e) => ts.isStringLiteralLike(e) && e.text === "!autodocs");
+            }
+          }
+        } else if (exported) names.push(d.name.text);
+      }
+    }
+    const imported = /* @__PURE__ */ new Map();
+    for (const link of f.links) {
+      if (!link.target || link.target === "?") continue;
+      for (const n of link.names) {
+        if (n.imported === "*") continue;
+        const p = origin(link.target, n.imported);
+        if (p) imported.set(n.local, p);
+      }
+    }
+    return { file, title, component: component ? imported.get(component) ?? null : null, noDocs, names, imports: [...imported.values()] };
+  });
+  const storyOf = (p) => {
+    const stem = (file) => basename(file).replace(/\.stories\.[cm]?[jt]sx?$/, "");
+    const own = basename(p.file, extname(p.file));
+    const candidates = stories.filter((s2) => s2.title && s2.names.length && (s2.component === p || s2.imports.includes(p) && (stem(s2.file) === p.name || stem(s2.file) === own)));
+    candidates.sort((a, b) => Number(b.component === p) - Number(a.component === p) || a.file.localeCompare(b.file));
+    const s = candidates[0];
+    if (!s || !s.title) return { docsId: null, storyId: null };
+    return { docsId: s.noDocs ? null : `${sanitize(s.title)}--docs`, storyId: toId(s.title, s.names.includes(p.name) ? p.name : s.names[0]) };
+  };
+  const modules = /* @__PURE__ */ new Map();
+  const moduleAt = (file) => {
+    const held = modules.get(file);
+    if (held) return held;
+    const read = readModule(facts.get(file).source, (specifier, typeName) => {
+      if (specifier === PACKAGE_IMPORT) {
+        const part = typeName.endsWith("Props") ? theRegistry?.entries.find((entry) => entry.name === typeName.slice(0, -"Props".length)) : void 0;
+        return part ? { props: part.props, variants: part.variants } : void 0;
+      }
+      const target = resolveSpecifier(file, specifier);
+      return target && target !== "?" ? moduleAt(target).resolveName(typeName) : void 0;
+    }, { lendFirstComment: false });
+    modules.set(file, read);
+    return read;
+  };
+  const namesakes = new Set((theRegistry?.entries ?? []).map((e) => e.name));
+  const importPathOf = (file) => {
+    const abs = join(app, file);
+    const alias = aliases.find((a) => abs.startsWith(a.target + sep));
+    const stem = file.replace(/\.[cm]?[jt]sx?$/, "").replace(/\/index$/, "");
+    return alias ? `${alias.prefix}${relative(alias.target, join(app, stem)).split(sep).join("/")}` : stem;
+  };
+  const port = /(?:-p|--port)[\s=]+(\d+)/.exec(manifest.scripts?.storybook ?? "")?.[1] ?? "6006";
+  const entries = [];
+  for (const p of found) {
+    const u = users.get(key(p.file, p.name));
+    const usedIn = [...u.app].sort();
+    const pass = p.from;
+    const onePart = partsIn(p.file).filter((q) => !q.from).length === 1;
+    const module = pass ? null : moduleAt(p.file);
+    const declared = pass ? void 0 : module.declarations.get(p.local ?? "default");
+    const header = module?.headerDoc ?? "";
+    const doc = declared?.doc || (defaultPartOf(p.file) === p ? module?.declarations.get("default")?.doc ?? "" : "");
+    const page = pass ? null : join(dirname(p.file), `${p.name}.mdx`).split(sep).join("/");
+    const pageText = page && existsSync(join(app, page)) ? pageOpening(readFileSync(join(app, page), "utf8")) : "";
+    let purpose = "";
+    let purposeFrom = "comment";
+    if (pass) {
+      const as = pass.name === p.name ? "" : ` as ${p.name}`;
+      purpose = pass.specifier === PACKAGE_IMPORT ? `The package's ${pass.name}, handed on${as} so the app can import it from ${importPathOf(p.file)}.` : `${pass.name} from ${pass.specifier}, handed on${as} so the app can import it from ${importPathOf(p.file)}.`;
+      purposeFrom = "package";
+    } else if (firstSentence(pageText)) {
+      purpose = firstSentence(pageText);
+      purposeFrom = "page";
+    } else if (firstSentence(doc)) {
+      purpose = firstSentence(doc);
+    } else if (onePart && firstSentence(header)) {
+      purpose = firstSentence(header);
+      purposeFrom = "file";
+    }
+    if (!purpose) {
+      problems.push(`${p.name} in ${p.file} has no one-line description. Write one as a /** \u2026 */ comment directly above it${onePart ? ", or at the top of the file" : ""}.`);
+      continue;
+    }
+    const writtenLine = WRITTEN.exec(doc) ?? (onePart ? WRITTEN.exec(header) : null);
+    const ties = pass ? [] : tiesOf(p.file);
+    let cls;
+    let reason;
+    let written = false;
+    if (pass) {
+      cls = "re-export";
+      reason = `Its file only hands on ${pass.specifier === PACKAGE_IMPORT ? `the package's ${pass.name}` : `${pass.name} from ${pass.specifier}`}.`;
+      if (writtenLine) problems.push(`${p.name} in ${p.file} is a pass-on, so its kind is read from the file: remove "@registry ${writtenLine[1]}"`);
+    } else if (writtenLine) {
+      const said = writtenLine[1];
+      if (!WRITABLE.includes(said)) {
+        problems.push(`${p.name} in ${p.file} says "@registry ${writtenLine[1]}": the kinds a person may write are ${WRITABLE.join(", ")}`);
+        continue;
+      }
+      cls = said;
+      reason = writtenLine[2].trim();
+      written = true;
+    } else if (usedIn.length === 0) {
+      cls = "unused";
+      reason = u.stories.size ? "No file of the app uses it; only its stories do." : u.tests.size ? "No file of the app uses it; only its tests do." : "Nothing uses it.";
+    } else if (usedIn.length === 1) {
+      cls = "one-off";
+      reason = `Used in one place: ${usedIn[0]}.`;
+    } else if (ties.length) {
+      cls = "reusable";
+      reason = `Used in ${usedIn.length} places, and tied to the app by ${ties[0]}${ties.length > 1 ? ` and ${ties.length - 1} more` : ""}.`;
+    } else {
+      cls = "promote-candidate";
+      reason = `Used in ${usedIn.length} places, and everything it uses is already in the package.`;
+    }
+    const shape = declared ? module.resolve(declared.propsType) : { props: [], variants: [] };
+    const facts_ = {
+      class: cls,
+      reason,
+      written,
+      handsOn: pass ? pass.specifier === PACKAGE_IMPORT ? pass.name : `${pass.name} from ${pass.specifier}` : null,
+      usedIn,
+      tiedTo: ties,
+      packageNamesake: namesakes.has(p.name) && !(pass && pass.specifier === PACKAGE_IMPORT && pass.name === p.name) ? p.name : null,
+      defaultExport: p.defaultExport
+    };
+    const { docsId, storyId } = pass ? { docsId: null, storyId: null } : storyOf(p);
+    entries.push({
+      name: p.name,
+      repo: repoName,
+      kind: "component",
+      importPath: importPathOf(p.file),
+      sourceFile: p.file,
+      purpose,
+      purposeFrom,
+      props: shape.props,
+      variants: shape.variants,
+      ownsBehaviours: [],
+      status: declared?.deprecated ? "deprecated" : "stable",
+      migrationStage: null,
+      docsId,
+      storyId,
+      docPage: pageText ? page : null,
+      app: facts_
+    });
+  }
+  if (problems.length) throw new Error(`the catalogue of ${repoName} cannot be built:
+  ${problems.join("\n  ")}`);
+  entries.sort((a, b) => a.name.localeCompare(b.name) || a.sourceFile.localeCompare(b.sourceFile));
+  const withParts = new Set(found.map((p) => p.file));
+  const filesWithoutParts = targets.filter((file) => !withParts.has(file)).map((file) => {
+    const f = facts.get(file);
+    const names = [...f.exports.map((e) => e.isDefault ? e.local ?? "a default" : e.name), ...f.reexports.map((r) => r.name)];
+    return { file, reason: names.length ? `It exports no part, only ${names.join(", ")}.` : "It exports nothing." };
+  });
+  return {
+    schemaVersion: SCHEMA_VERSION,
+    builtFrom: {
+      kind: "app",
+      repo: repoName,
+      package: manifest.name ?? repoName,
+      packageVersion: manifest.version ?? "0.0.0",
+      exports: found.length,
+      typeExports: 0,
+      files: targets.length
+    },
+    storybook: {
+      docsPath: "/?path=/docs/{docsId}",
+      storyPath: "/?path=/story/{storyId}",
+      devUrl: `http://localhost:${port}`
+    },
+    entries,
+    excluded: [],
+    filesWithoutParts
+  };
+}
+
+export {
+  buildAppRegistry
+};
+//# sourceMappingURL=chunk-WMFF3MPP.js.map