@openpkg-ts/sdk 0.33.0 → 0.34.0

package/dist/index.js

@@ -1,3 +1,32 @@
+import {
+  QueryBuilder,
+  analyzeSpec,
+  buildSignatureString,
+  findMissingParamDocs,
+  formatBadges,
+  formatConditionalType,
+  formatMappedType,
+  formatParameters,
+  formatReturnType,
+  formatSchema,
+  formatTypeParameters,
+  getDeprecationMessage,
+  getMemberBadges,
+  getMethods,
+  getProperties,
+  groupByVisibility,
+  hasDeprecatedTag,
+  isMethod,
+  isProperty,
+  query,
+  resolveTypeRef,
+  sortByName,
+  toAlgoliaRecords,
+  toPagefindRecords,
+  toSearchIndex,
+  toSearchIndexJSON
+} from "./shared/chunk-91b592v7.js";
+
 // src/primitives/diff.ts
 import {
   calculateNextVersion,
@@ -42,313 +71,9 @@ function mergeConfig(fileConfig, cliOptions) {
     }
   };
 }
-// src/core/diagnostics.ts
-function hasDeprecatedTag(exp) {
-  if (exp.deprecated === true)
-    return true;
-  return exp.tags?.some((t) => t.name === "deprecated" || t.name === "@deprecated") ?? false;
-}
-function getDeprecationMessage(exp) {
-  const tag = exp.tags?.find((t) => t.name === "deprecated" || t.name === "@deprecated");
-  if (tag?.text.trim()) {
-    return tag.text.trim();
-  }
-  return;
-}
-function findMissingParamDocs(exp) {
-  const missing = [];
-  for (const sig of exp.signatures ?? []) {
-    for (const param of sig.parameters ?? []) {
-      if (!param.description?.trim()) {
-        missing.push(param.name);
-      }
-    }
-  }
-  return missing;
-}
-function checkMemberDescriptions(exp, members) {
-  const items = [];
-  for (const member of members) {
-    if (!member.description?.trim() && member.name) {
-      items.push({
-        exportId: exp.id,
-        exportName: exp.name,
-        issue: "member missing description",
-        member: member.name
-      });
-    }
-  }
-  return items;
-}
-function analyzeSpec(spec) {
-  const missingDescriptions = [];
-  const deprecatedNoReason = [];
-  const missingParamDocs = [];
-  for (const exp of spec.exports) {
-    if (!exp.description?.trim()) {
-      missingDescriptions.push({
-        exportId: exp.id,
-        exportName: exp.name,
-        issue: "missing description"
-      });
-    }
-    if (exp.members) {
-      missingDescriptions.push(...checkMemberDescriptions(exp, exp.members));
-    }
-    if (hasDeprecatedTag(exp) && !getDeprecationMessage(exp)) {
-      deprecatedNoReason.push({
-        exportId: exp.id,
-        exportName: exp.name,
-        issue: "deprecated without reason"
-      });
-    }
-    const missingParams = findMissingParamDocs(exp);
-    for (const param of missingParams) {
-      missingParamDocs.push({
-        exportId: exp.id,
-        exportName: exp.name,
-        issue: "param missing description",
-        param
-      });
-    }
-  }
-  return {
-    missingDescriptions,
-    deprecatedNoReason,
-    missingParamDocs
-  };
-}
-// src/core/format.ts
-function getMemberBadges(member) {
-  const badges = [];
-  const visibility = member.visibility ?? "public";
-  if (visibility !== "public") {
-    badges.push(visibility);
-  }
-  const flags = member.flags;
-  if (flags?.static)
-    badges.push("static");
-  if (flags?.readonly)
-    badges.push("readonly");
-  if (flags?.async)
-    badges.push("async");
-  if (flags?.abstract)
-    badges.push("abstract");
-  return badges;
-}
-function formatBadges(badges) {
-  return badges.join(" ");
-}
 // src/core/loader.ts
 import * as fs2 from "node:fs";
 
-// src/core/query.ts
-function formatFunctionSchema(schema) {
-  const sigs = schema["x-ts-signatures"];
-  if (!sigs?.length)
-    return "(...args: unknown[]) => unknown";
-  const sig = sigs[0];
-  const params = formatParameters(sig);
-  const ret = sig.returns ? formatSchema(sig.returns.schema) : "void";
-  return `${params} => ${ret}`;
-}
-function formatSchema(schema, options) {
-  if (!schema)
-    return "unknown";
-  if (typeof schema === "string")
-    return schema;
-  const withPackage = (typeStr) => {
-    if (options?.includePackage && typeof schema === "object" && "x-ts-package" in schema) {
-      const pkg = schema["x-ts-package"];
-      return `${typeStr} (from ${pkg})`;
-    }
-    return typeStr;
-  };
-  if (typeof schema === "object" && schema !== null) {
-    if ("x-ts-type" in schema && typeof schema["x-ts-type"] === "string") {
-      const tsType = schema["x-ts-type"];
-      if (tsType === "function" || schema["x-ts-function"]) {
-        return withPackage(formatFunctionSchema(schema));
-      }
-      return withPackage(tsType);
-    }
-    if ("x-ts-function" in schema && schema["x-ts-function"]) {
-      return withPackage(formatFunctionSchema(schema));
-    }
-    if ("x-ts-type-predicate" in schema) {
-      const pred = schema["x-ts-type-predicate"];
-      return `${pred.parameterName} is ${formatSchema(pred.type, options)}`;
-    }
-    if ("$ref" in schema && typeof schema.$ref === "string") {
-      const baseName = schema.$ref.replace("#/types/", "");
-      if ("x-ts-type-arguments" in schema && Array.isArray(schema["x-ts-type-arguments"])) {
-        const args = schema["x-ts-type-arguments"].map((s) => formatSchema(s, options)).join(", ");
-        return withPackage(`${baseName}<${args}>`);
-      }
-      return withPackage(baseName);
-    }
-    if ("anyOf" in schema && Array.isArray(schema.anyOf)) {
-      const threshold = options?.collapseUnionThreshold;
-      const members = schema.anyOf;
-      if (threshold && members.length > threshold) {
-        const shown = members.slice(0, 3);
-        const remaining = members.length - 3;
-        const shownStr = shown.map((s) => formatSchema(s, options)).join(" | ");
-        return `${shownStr} | ... (${remaining} more)`;
-      }
-      return members.map((s) => formatSchema(s, options)).join(" | ");
-    }
-    if ("allOf" in schema && Array.isArray(schema.allOf)) {
-      return schema.allOf.map((s) => formatSchema(s, options)).join(" & ");
-    }
-    if ("type" in schema && schema.type === "array") {
-      const items = "items" in schema ? formatSchema(schema.items, options) : "unknown";
-      return `${items}[]`;
-    }
-    if ("type" in schema && schema.type === "tuple" && "items" in schema) {
-      const items = schema.items.map((s) => formatSchema(s, options)).join(", ");
-      return `[${items}]`;
-    }
-    if ("type" in schema && schema.type === "object") {
-      if ("properties" in schema && schema.properties) {
-        const props = Object.entries(schema.properties).map(([k, v]) => `${k}: ${formatSchema(v, options)}`).join("; ");
-        return `{ ${props} }`;
-      }
-      return "object";
-    }
-    if ("type" in schema && typeof schema.type === "string") {
-      return withPackage(schema.type);
-    }
-  }
-  return "unknown";
-}
-function formatTypeParameters(typeParams) {
-  if (!typeParams?.length)
-    return "";
-  const params = typeParams.map((tp) => {
-    let str = "";
-    if ("const" in tp && tp.const)
-      str += "const ";
-    if (tp.variance === "in")
-      str += "in ";
-    else if (tp.variance === "out")
-      str += "out ";
-    else if (tp.variance === "inout")
-      str += "in out ";
-    str += tp.name;
-    if (tp.constraint)
-      str += ` extends ${tp.constraint}`;
-    if (tp.default)
-      str += ` = ${tp.default}`;
-    return str;
-  });
-  return `<${params.join(", ")}>`;
-}
-function formatParameters(sig) {
-  if (!sig?.parameters?.length)
-    return "()";
-  const params = sig.parameters.map((p) => {
-    const optional = p.required === false ? "?" : "";
-    const rest = p.rest ? "..." : "";
-    const type = formatSchema(p.schema);
-    return `${rest}${p.name}${optional}: ${type}`;
-  });
-  return `(${params.join(", ")})`;
-}
-function formatReturnType(sig) {
-  if (!sig?.returns)
-    return "void";
-  return formatSchema(sig.returns.schema);
-}
-function buildSignatureString(exp, sigIndex = 0) {
-  const sig = exp.signatures?.[sigIndex];
-  const typeParams = formatTypeParameters(exp.typeParameters || sig?.typeParameters);
-  switch (exp.kind) {
-    case "function": {
-      const params = formatParameters(sig);
-      const returnType = formatReturnType(sig);
-      return `function ${exp.name}${typeParams}${params}: ${returnType}`;
-    }
-    case "class": {
-      const ext = exp.extends ? ` extends ${exp.extends}` : "";
-      const impl = exp.implements?.length ? ` implements ${exp.implements.join(", ")}` : "";
-      return `class ${exp.name}${typeParams}${ext}${impl}`;
-    }
-    case "interface": {
-      const ext = exp.extends ? ` extends ${exp.extends}` : "";
-      return `interface ${exp.name}${typeParams}${ext}`;
-    }
-    case "type": {
-      const typeValue = typeof exp.type === "string" ? exp.type : formatSchema(exp.schema);
-      return `type ${exp.name}${typeParams} = ${typeValue}`;
-    }
-    case "enum": {
-      return `enum ${exp.name}`;
-    }
-    case "variable": {
-      const typeValue = typeof exp.type === "string" ? exp.type : formatSchema(exp.schema);
-      return `const ${exp.name}: ${typeValue}`;
-    }
-    default:
-      return exp.name;
-  }
-}
-function resolveTypeRef(ref, spec) {
-  const id = ref.replace("#/types/", "");
-  return spec.types?.find((t) => t.id === id);
-}
-function isMethod(member) {
-  return !!member.signatures?.length;
-}
-function isProperty(member) {
-  return !member.signatures?.length;
-}
-function getMethods(members) {
-  return members?.filter(isMethod) ?? [];
-}
-function getProperties(members) {
-  return members?.filter(isProperty) ?? [];
-}
-function groupByVisibility(members) {
-  const groups = {
-    public: [],
-    protected: [],
-    private: []
-  };
-  for (const member of members ?? []) {
-    const visibility = member.visibility ?? "public";
-    groups[visibility].push(member);
-  }
-  return groups;
-}
-function sortByName(items) {
-  return [...items].sort((a, b) => a.name.localeCompare(b.name));
-}
-function formatConditionalType(condType) {
-  const check = formatSchema(condType.checkType);
-  const ext = formatSchema(condType.extendsType);
-  const trueT = formatSchema(condType.trueType);
-  const falseT = formatSchema(condType.falseType);
-  return `${check} extends ${ext} ? ${trueT} : ${falseT}`;
-}
-function formatMappedType(mappedType) {
-  const keyStr = formatSchema(mappedType.keyType);
-  const valueStr = formatSchema(mappedType.valueType);
-  let readonlyMod = "";
-  if (mappedType.readonly === true || mappedType.readonly === "add") {
-    readonlyMod = "readonly ";
-  } else if (mappedType.readonly === "remove") {
-    readonlyMod = "-readonly ";
-  }
-  let optionalMod = "";
-  if (mappedType.optional === true || mappedType.optional === "add") {
-    optionalMod = "?";
-  } else if (mappedType.optional === "remove") {
-    optionalMod = "-?";
-  }
-  return `{ ${readonlyMod}[${keyStr}]${optionalMod}: ${valueStr} }`;
-}
-
 // src/render/html.ts
 var defaultCSS = `
 :root {
@@ -1368,171 +1093,6 @@ function toDocusaurusSidebarJS(spec, options = {}) {
   return `module.exports = ${JSON.stringify(sidebar, null, 2)};`;
 }
 
-// src/core/search.ts
-var defaultSlugify2 = (name) => name.toLowerCase().replace(/[^a-z0-9]+/g, "-");
-function extractKeywords(exp, options = {}) {
-  const keywords = new Set;
-  keywords.add(exp.name);
-  keywords.add(exp.name.toLowerCase());
-  const camelParts = exp.name.split(/(?=[A-Z])/);
-  for (const part of camelParts) {
-    if (part.length > 2)
-      keywords.add(part.toLowerCase());
-  }
-  if (exp.tags) {
-    for (const tag of exp.tags) {
-      keywords.add(tag.name.replace("@", ""));
-      const tagWords = tag.text.split(/\s+/);
-      for (const word of tagWords) {
-        if (word.length > 2)
-          keywords.add(word.toLowerCase());
-      }
-    }
-  }
-  if (exp.description) {
-    const descWords = exp.description.toLowerCase().split(/\W+/).filter((w) => w.length > 2);
-    for (const word of descWords) {
-      keywords.add(word);
-    }
-  }
-  if (options.includeMembers && exp.members) {
-    for (const member of exp.members) {
-      if (member.name) {
-        keywords.add(member.name.toLowerCase());
-      }
-    }
-  }
-  if (options.includeParameters && exp.signatures) {
-    for (const sig of exp.signatures) {
-      for (const param of sig.parameters || []) {
-        keywords.add(param.name.toLowerCase());
-      }
-    }
-  }
-  return Array.from(keywords);
-}
-function buildContent(exp, options = {}) {
-  const parts = [];
-  parts.push(exp.name);
-  if (exp.description) {
-    parts.push(exp.description);
-  }
-  if (options.includeSignatures !== false) {
-    parts.push(buildSignatureString(exp));
-  }
-  if (exp.tags) {
-    parts.push(...exp.tags.map((t) => `${t.name} ${t.text}`));
-  }
-  if (options.includeMembers !== false && exp.members) {
-    const props = getProperties(exp.members);
-    const methods = getMethods(exp.members);
-    for (const prop of props) {
-      if (prop.name) {
-        parts.push(prop.name);
-        if (prop.description)
-          parts.push(prop.description);
-      }
-    }
-    for (const method of methods) {
-      if (method.name) {
-        parts.push(method.name);
-        if (method.description)
-          parts.push(method.description);
-      }
-    }
-  }
-  if (options.includeParameters !== false && exp.signatures) {
-    for (const sig of exp.signatures) {
-      for (const param of sig.parameters || []) {
-        parts.push(param.name);
-        if (param.description)
-          parts.push(param.description);
-      }
-    }
-  }
-  return parts.join(" ");
-}
-function createSearchRecord(exp, _packageName, options = {}) {
-  const { baseUrl = "/api", slugify = defaultSlugify2 } = options;
-  return {
-    id: exp.id,
-    name: exp.name,
-    kind: exp.kind,
-    signature: buildSignatureString(exp),
-    description: exp.description,
-    content: buildContent(exp, options),
-    keywords: extractKeywords(exp, options),
-    url: `${baseUrl}/${slugify(exp.name)}`,
-    deprecated: exp.deprecated === true
-  };
-}
-function toSearchIndex(spec, options = {}) {
-  const records = spec.exports.map((exp) => createSearchRecord(exp, spec.meta.name, options));
-  return {
-    records,
-    version: spec.meta.version || "0.0.0",
-    generatedAt: new Date().toISOString(),
-    packageName: spec.meta.name
-  };
-}
-function toPagefindRecords(spec, options = {}) {
-  const { baseUrl = "/api", slugify = defaultSlugify2, weights = {} } = options;
-  const { name: nameWeight = 10, description: descWeight = 5, signature: sigWeight = 3 } = weights;
-  return spec.exports.map((exp) => {
-    const content = buildContent(exp, options);
-    const signature = buildSignatureString(exp);
-    const filters = {
-      kind: [exp.kind]
-    };
-    if (exp.deprecated) {
-      filters.deprecated = ["true"];
-    }
-    if (exp.tags?.length) {
-      filters.tags = exp.tags.map((t) => t.name.replace("@", ""));
-    }
-    return {
-      url: `${baseUrl}/${slugify(exp.name)}`,
-      content,
-      word_count: content.split(/\s+/).length,
-      filters,
-      meta: {
-        title: exp.name,
-        kind: exp.kind,
-        description: exp.description?.slice(0, 160),
-        signature
-      },
-      weighted_sections: [
-        { weight: nameWeight, text: exp.name },
-        ...exp.description ? [{ weight: descWeight, text: exp.description }] : [],
-        { weight: sigWeight, text: signature }
-      ]
-    };
-  });
-}
-function toAlgoliaRecords(spec, options = {}) {
-  const { baseUrl = "/api", slugify = defaultSlugify2 } = options;
-  return spec.exports.map((exp) => ({
-    objectID: exp.id,
-    name: exp.name,
-    kind: exp.kind,
-    description: exp.description,
-    signature: buildSignatureString(exp),
-    content: buildContent(exp, options),
-    tags: (exp.tags || []).map((t) => t.name.replace("@", "")),
-    deprecated: exp.deprecated === true,
-    url: `${baseUrl}/${slugify(exp.name)}`,
-    hierarchy: {
-      lvl0: spec.meta.name,
-      lvl1: `${exp.kind.charAt(0).toUpperCase() + exp.kind.slice(1)}s`,
-      lvl2: exp.name
-    }
-  }));
-}
-function toSearchIndexJSON(spec, options = {}) {
-  const index = toSearchIndex(spec, options);
-  return options.pretty ? JSON.stringify(index, null, 2) : JSON.stringify(index);
-}
-
 // src/core/loader.ts
 function loadSpec(spec) {
   return createDocsInstance(spec);
@@ -1589,8 +1149,8 @@ function createDocsInstance(spec) {
       const normalizedTag = tagName.startsWith("@") ? tagName : `@${tagName}`;
       return exportsByTag.get(normalizedTag) ?? [];
     },
-    search(query) {
-      const lowerQuery = query.toLowerCase();
+    search(query2) {
+      const lowerQuery = query2.toLowerCase();
       return spec.exports.filter((exp) => {
         if (exp.name.toLowerCase().includes(lowerQuery))
           return true;
@@ -1654,6 +1214,221 @@ function extractModuleName(exp) {
   }
   return;
 }
+// src/render/react.ts
+import * as fs3 from "node:fs";
+import * as path2 from "node:path";
+function generateFullLayout(spec, componentsPath) {
+  const pkgName = spec.meta.name;
+  return `'use client';
+
+import type { OpenPkg, SpecExport } from '@openpkg-ts/spec';
+import spec from './openpkg.json';
+
+// Add components via: openpkg docs add function-section class-section interface-section
+// Then uncomment the imports below and customize as needed.
+
+// import { FunctionSection } from '${componentsPath}/function-section';
+// import { ClassSection } from '${componentsPath}/class-section';
+// import { InterfaceSection } from '${componentsPath}/interface-section';
+// import { VariableSection } from '${componentsPath}/variable-section';
+// import { EnumSection } from '${componentsPath}/enum-section';
+
+/**
+ * Renders a single export based on its kind.
+ * Customize this to match your design system.
+ */
+function ExportSection({ exp }: { exp: SpecExport }) {
+  // Uncomment the switch once you've added components:
+  // switch (exp.kind) {
+  //   case 'function':
+  //     return <FunctionSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
+  //   case 'class':
+  //     return <ClassSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
+  //   case 'interface':
+  //   case 'type':
+  //     return <InterfaceSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
+  //   case 'variable':
+  //     return <VariableSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
+  //   case 'enum':
+  //     return <EnumSection key={exp.id} export={exp} spec={spec as OpenPkg} />;
+  //   default:
+  //     return null;
+  // }
+
+  // Placeholder: replace with component imports above
+  return (
+    <section id={exp.id} className="py-8 border-b">
+      <h2 className="text-xl font-semibold">{exp.name}</h2>
+      <p className="text-muted-foreground">{exp.description || 'No description'}</p>
+      <code className="text-sm">{exp.kind}</code>
+    </section>
+  );
+}
+
+/**
+ * Full API Reference Page for ${pkgName}
+ *
+ * This layout renders all exports on a single page.
+ * Customize the grouping, styling, and components to match your docs.
+ */
+export default function APIReferencePage() {
+  const typedSpec = spec as OpenPkg;
+  const exports = typedSpec.exports;
+
+  // Group exports by kind
+  const functions = exports.filter((e) => e.kind === 'function');
+  const classes = exports.filter((e) => e.kind === 'class');
+  const interfaces = exports.filter((e) => e.kind === 'interface' || e.kind === 'type');
+  const variables = exports.filter((e) => e.kind === 'variable');
+  const enums = exports.filter((e) => e.kind === 'enum');
+
+  return (
+    <div className="max-w-4xl mx-auto px-4 py-8">
+      <header className="mb-12">
+        <h1 className="text-3xl font-bold">{typedSpec.meta.name}</h1>
+        {typedSpec.meta.description && (
+          <p className="text-lg text-muted-foreground mt-2">{typedSpec.meta.description}</p>
+        )}
+        {typedSpec.meta.version && (
+          <p className="text-sm text-muted-foreground">v{typedSpec.meta.version}</p>
+        )}
+      </header>
+
+      {functions.length > 0 && (
+        <section className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">Functions</h2>
+          {functions.map((exp) => (
+            <ExportSection key={exp.id} exp={exp} />
+          ))}
+        </section>
+      )}
+
+      {classes.length > 0 && (
+        <section className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">Classes</h2>
+          {classes.map((exp) => (
+            <ExportSection key={exp.id} exp={exp} />
+          ))}
+        </section>
+      )}
+
+      {interfaces.length > 0 && (
+        <section className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">Types & Interfaces</h2>
+          {interfaces.map((exp) => (
+            <ExportSection key={exp.id} exp={exp} />
+          ))}
+        </section>
+      )}
+
+      {variables.length > 0 && (
+        <section className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">Variables</h2>
+          {variables.map((exp) => (
+            <ExportSection key={exp.id} exp={exp} />
+          ))}
+        </section>
+      )}
+
+      {enums.length > 0 && (
+        <section className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">Enums</h2>
+          {enums.map((exp) => (
+            <ExportSection key={exp.id} exp={exp} />
+          ))}
+        </section>
+      )}
+    </div>
+  );
+}
+
+export { spec };
+`;
+}
+function generateIndexLayout(spec, componentsPath) {
+  const pkgName = spec.meta.name;
+  return `'use client';
+
+import type { OpenPkg } from '@openpkg-ts/spec';
+import spec from './openpkg.json';
+
+// Add the export-card component: openpkg docs add export-card
+// import { ExportCard } from '${componentsPath}/export-card';
+
+/**
+ * API Reference Index Page for ${pkgName}
+ *
+ * Links to individual export pages. Best with file-based routing.
+ * Customize the card component and links to match your docs.
+ */
+export default function APIReferenceIndex() {
+  const typedSpec = spec as OpenPkg;
+  const exports = typedSpec.exports;
+
+  // Group exports by kind
+  const groups = [
+    { title: 'Functions', items: exports.filter((e) => e.kind === 'function') },
+    { title: 'Classes', items: exports.filter((e) => e.kind === 'class') },
+    { title: 'Types & Interfaces', items: exports.filter((e) => e.kind === 'interface' || e.kind === 'type') },
+    { title: 'Variables', items: exports.filter((e) => e.kind === 'variable') },
+    { title: 'Enums', items: exports.filter((e) => e.kind === 'enum') },
+  ].filter((g) => g.items.length > 0);
+
+  return (
+    <div className="max-w-4xl mx-auto px-4 py-8">
+      <header className="mb-12">
+        <h1 className="text-3xl font-bold">{typedSpec.meta.name}</h1>
+        {typedSpec.meta.description && (
+          <p className="text-lg text-muted-foreground mt-2">{typedSpec.meta.description}</p>
+        )}
+      </header>
+
+      {groups.map((group) => (
+        <section key={group.title} className="mb-12">
+          <h2 className="text-2xl font-bold mb-6">{group.title}</h2>
+          <div className="grid gap-4 md:grid-cols-2">
+            {group.items.map((exp) => (
+              // Replace with ExportCard once installed:
+              // <ExportCard key={exp.id} export={exp} href={\`/api/\${exp.name}\`} />
+              <a
+                key={exp.id}
+                href={\`/api/\${exp.name}\`}
+                className="block p-4 border rounded-lg hover:bg-muted transition-colors"
+              >
+                <h3 className="font-semibold">{exp.name}</h3>
+                <p className="text-sm text-muted-foreground line-clamp-2">
+                  {exp.description || 'No description'}
+                </p>
+                <span className="text-xs bg-muted px-2 py-1 rounded mt-2 inline-block">
+                  {exp.kind}
+                </span>
+              </a>
+            ))}
+          </div>
+        </section>
+      ))}
+    </div>
+  );
+}
+
+export { spec };
+`;
+}
+async function toReact(spec, options) {
+  const { outDir, variant = "full", componentsPath = "@/components/api" } = options;
+  if (!fs3.existsSync(outDir)) {
+    fs3.mkdirSync(outDir, { recursive: true });
+  }
+  const specPath = path2.join(outDir, "openpkg.json");
+  fs3.writeFileSync(specPath, JSON.stringify(spec, null, 2));
+  const layoutContent = variant === "index" ? generateIndexLayout(spec, componentsPath) : generateFullLayout(spec, componentsPath);
+  const layoutPath = path2.join(outDir, "page.tsx");
+  fs3.writeFileSync(layoutPath, layoutContent);
+}
+function toReactString(spec, options = {}) {
+  const { variant = "full", componentsPath = "@/components/api" } = options;
+  return variant === "index" ? generateIndexLayout(spec, componentsPath) : generateFullLayout(spec, componentsPath);
+}
 // src/primitives/filter.ts
 function matchesExport(exp, criteria) {
   if (criteria.kinds && criteria.kinds.length > 0) {
@@ -1761,8 +1536,8 @@ function filterSpec(spec, criteria) {
 import ts11 from "typescript";
 
 // src/compiler/program.ts
-import * as fs3 from "node:fs";
-import * as path2 from "node:path";
+import * as fs4 from "node:fs";
+import * as path3 from "node:path";
 import ts from "typescript";
 function isJsFile(file) {
   return /\.(js|mjs|cjs|jsx)$/.test(file);
@@ -1788,16 +1563,16 @@ function resolveProjectReferences(configPath, parsedConfig) {
   if (!parsedConfig.projectReferences?.length) {
     return additionalFiles;
   }
-  const configDir = path2.dirname(configPath);
+  const configDir = path3.dirname(configPath);
   for (const ref of parsedConfig.projectReferences) {
-    const refPath = path2.resolve(configDir, ref.path);
-    const refConfigPath = fs3.existsSync(path2.join(refPath, "tsconfig.json")) ? path2.join(refPath, "tsconfig.json") : refPath;
-    if (!fs3.existsSync(refConfigPath))
+    const refPath = path3.resolve(configDir, ref.path);
+    const refConfigPath = fs4.existsSync(path3.join(refPath, "tsconfig.json")) ? path3.join(refPath, "tsconfig.json") : refPath;
+    if (!fs4.existsSync(refConfigPath))
       continue;
     const refConfigFile = ts.readConfigFile(refConfigPath, ts.sys.readFile);
     if (refConfigFile.error)
       continue;
-    const refParsed = ts.parseJsonConfigFileContent(refConfigFile.config, ts.sys, path2.dirname(refConfigPath));
+    const refParsed = ts.parseJsonConfigFileContent(refConfigFile.config, ts.sys, path3.dirname(refConfigPath));
     additionalFiles.push(...refParsed.fileNames);
   }
   return additionalFiles;
@@ -1830,10 +1605,10 @@ function buildWorkspaceMap(baseDir) {
   let rootDir;
   let workspaceGlobs = [];
   for (let i = 0;i < 10; i++) {
-    const pnpmPath = path2.join(currentDir, "pnpm-workspace.yaml");
-    if (fs3.existsSync(pnpmPath)) {
+    const pnpmPath = path3.join(currentDir, "pnpm-workspace.yaml");
+    if (fs4.existsSync(pnpmPath)) {
       try {
-        const yamlContent = fs3.readFileSync(pnpmPath, "utf-8");
+        const yamlContent = fs4.readFileSync(pnpmPath, "utf-8");
         workspaceGlobs = parsePnpmWorkspace(yamlContent);
         if (workspaceGlobs.length > 0) {
           rootDir = currentDir;
@@ -1841,10 +1616,10 @@ function buildWorkspaceMap(baseDir) {
         }
       } catch {}
     }
-    const pkgPath = path2.join(currentDir, "package.json");
-    if (fs3.existsSync(pkgPath)) {
+    const pkgPath = path3.join(currentDir, "package.json");
+    if (fs4.existsSync(pkgPath)) {
       try {
-        const pkg = JSON.parse(fs3.readFileSync(pkgPath, "utf-8"));
+        const pkg = JSON.parse(fs4.readFileSync(pkgPath, "utf-8"));
         if (pkg.workspaces) {
           rootDir = currentDir;
           workspaceGlobs = Array.isArray(pkg.workspaces) ? pkg.workspaces : pkg.workspaces?.packages || [];
@@ -1852,7 +1627,7 @@ function buildWorkspaceMap(baseDir) {
         }
       } catch {}
     }
-    const parent = path2.dirname(currentDir);
+    const parent = path3.dirname(currentDir);
     if (parent === currentDir)
       break;
     currentDir = parent;
@@ -1861,21 +1636,21 @@ function buildWorkspaceMap(baseDir) {
     return;
   const packages = new Map;
   for (const glob of workspaceGlobs) {
-    const globDir = path2.join(rootDir, glob.replace(/\/\*$/, ""));
-    if (!fs3.existsSync(globDir) || !fs3.statSync(globDir).isDirectory())
+    const globDir = path3.join(rootDir, glob.replace(/\/\*$/, ""));
+    if (!fs4.existsSync(globDir) || !fs4.statSync(globDir).isDirectory())
       continue;
-    const entries = fs3.readdirSync(globDir, { withFileTypes: true });
+    const entries = fs4.readdirSync(globDir, { withFileTypes: true });
     for (const entry of entries) {
       if (!entry.isDirectory())
         continue;
-      const pkgDir = path2.join(globDir, entry.name);
-      const pkgJsonPath = path2.join(pkgDir, "package.json");
-      if (!fs3.existsSync(pkgJsonPath))
+      const pkgDir = path3.join(globDir, entry.name);
+      const pkgJsonPath = path3.join(pkgDir, "package.json");
+      if (!fs4.existsSync(pkgJsonPath))
         continue;
       try {
-        const pkg = JSON.parse(fs3.readFileSync(pkgJsonPath, "utf-8"));
+        const pkg = JSON.parse(fs4.readFileSync(pkgJsonPath, "utf-8"));
         if (pkg.name) {
-          const srcDir = fs3.existsSync(path2.join(pkgDir, "src")) ? path2.join(pkgDir, "src") : pkgDir;
+          const srcDir = fs4.existsSync(path3.join(pkgDir, "src")) ? path3.join(pkgDir, "src") : pkgDir;
           packages.set(pkg.name, srcDir);
         }
       } catch {}
@@ -1885,7 +1660,7 @@ function buildWorkspaceMap(baseDir) {
 }
 function createProgram({
   entryFile,
-  baseDir = path2.dirname(entryFile),
+  baseDir = path3.dirname(entryFile),
   content
 }) {
   let configPath = ts.findConfigFile(baseDir, ts.sys.fileExists, "tsconfig.json");
@@ -1896,9 +1671,11 @@ function createProgram({
   let additionalRootFiles = [];
   if (configPath) {
     const configFile = ts.readConfigFile(configPath, ts.sys.readFile);
-    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path2.dirname(configPath));
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path3.dirname(configPath));
     compilerOptions = { ...compilerOptions, ...parsedConfig.options };
     additionalRootFiles = resolveProjectReferences(configPath, parsedConfig);
+    const sourceFiles = parsedConfig.fileNames.filter((f) => !f.includes(".test.") && !f.includes(".spec.") && !f.includes("/dist/") && !f.includes("/node_modules/"));
+    additionalRootFiles.push(...sourceFiles);
   }
   if (isJsFile(entryFile)) {
     compilerOptions = {
@@ -1922,8 +1699,8 @@ function createProgram({
       return moduleNames.map((moduleName) => {
         const srcDir = workspaceMap.packages.get(moduleName);
         if (srcDir) {
-          const indexFile = path2.join(srcDir, "index.ts");
-          if (fs3.existsSync(indexFile)) {
+          const indexFile = path3.join(srcDir, "index.ts");
+          if (fs4.existsSync(indexFile)) {
             return { resolvedFileName: indexFile, isExternalLibraryImport: false };
           }
         }
@@ -4815,7 +4592,7 @@ function serializeDeclaration(declaration, _exportSymbol, _targetSymbol, exportN
   return result;
 }
 // src/primitives/list.ts
-import * as path3 from "node:path";
+import * as path4 from "node:path";
 import ts12 from "typescript";
 async function listExports(options) {
   const { entryFile, baseDir, content } = options;
@@ -4863,7 +4640,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
     return {
       name,
       kind: "namespace",
-      file: path3.relative(path3.dirname(entryFile), declaration.fileName),
+      file: path4.relative(path4.dirname(entryFile), declaration.fileName),
       line: 1,
       reexport: true
     };
@@ -4877,7 +4654,7 @@ function extractExportItem(symbol, checker, entryFile, entrySourceFile) {
   return {
     name,
     kind,
-    file: path3.relative(path3.dirname(entryFile), sourceFile.fileName),
+    file: path4.relative(path4.dirname(entryFile), sourceFile.fileName),
     line: line + 1,
     ...description ? { description } : {},
     ...deprecated ? { deprecated: true } : {},
@@ -4929,8 +4706,8 @@ function getDescriptionPreview(symbol, checker) {
   return `${firstLine.slice(0, 77)}...`;
 }
 // src/builder/spec-builder.ts
-import * as fs6 from "node:fs";
-import * as path6 from "node:path";
+import * as fs7 from "node:fs";
+import * as path7 from "node:path";
 import { SCHEMA_URL, SCHEMA_VERSION } from "@openpkg-ts/spec";
 import ts15 from "typescript";
 
@@ -4966,9 +4743,9 @@ function resolveExportTarget2(symbol, checker) {
 
 // src/schema/standard-schema.ts
 import { spawn, spawnSync } from "node:child_process";
-import * as fs4 from "node:fs";
+import * as fs5 from "node:fs";
 import * as os from "node:os";
-import * as path4 from "node:path";
+import * as path5 from "node:path";
 function isStandardJSONSchema(obj) {
   if (typeof obj !== "object" || obj === null)
     return false;
@@ -5214,21 +4991,21 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     result.errors.push("No TypeScript runtime available. Install bun, tsx, or ts-node, or use Node 22+.");
     return result;
   }
-  if (!fs4.existsSync(tsFilePath)) {
+  if (!fs5.existsSync(tsFilePath)) {
     result.errors.push(`TypeScript file not found: ${tsFilePath}`);
     return result;
   }
   const tempDir = os.tmpdir();
-  const workerPath = path4.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
+  const workerPath = path5.join(tempDir, `openpkg-extract-worker-${Date.now()}.ts`);
   try {
-    fs4.writeFileSync(workerPath, TS_WORKER_SCRIPT);
+    fs5.writeFileSync(workerPath, TS_WORKER_SCRIPT);
     const optionsJson = JSON.stringify({ target, libraryOptions });
     const args = [...runtime.args, workerPath, tsFilePath, optionsJson];
     return await new Promise((resolve2) => {
       const child = spawn(runtime.cmd, args, {
         timeout,
         stdio: ["ignore", "pipe", "pipe"],
-        cwd: path4.dirname(tsFilePath)
+        cwd: path5.dirname(tsFilePath)
       });
       let stdout = "";
       let stderr = "";
@@ -5240,7 +5017,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       });
       child.on("close", (code) => {
         try {
-          fs4.unlinkSync(workerPath);
+          fs5.unlinkSync(workerPath);
         } catch {}
         if (code !== 0) {
           result.errors.push(`Extraction failed (${runtime.name}): ${stderr || `exit code ${code}`}`);
@@ -5269,7 +5046,7 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
       });
       child.on("error", (err) => {
         try {
-          fs4.unlinkSync(workerPath);
+          fs5.unlinkSync(workerPath);
         } catch {}
         result.errors.push(`Subprocess error: ${err.message}`);
         resolve2(result);
@@ -5277,19 +5054,19 @@ async function extractStandardSchemasFromTs(tsFilePath, options = {}) {
     });
   } catch (e) {
     try {
-      fs4.unlinkSync(workerPath);
+      fs5.unlinkSync(workerPath);
     } catch {}
     result.errors.push(`Failed to create worker script: ${e}`);
     return result;
   }
 }
 function readTsconfigOutDir(baseDir) {
-  const tsconfigPath = path4.join(baseDir, "tsconfig.json");
+  const tsconfigPath = path5.join(baseDir, "tsconfig.json");
   try {
-    if (!fs4.existsSync(tsconfigPath)) {
+    if (!fs5.existsSync(tsconfigPath)) {
       return null;
     }
-    const content = fs4.readFileSync(tsconfigPath, "utf-8");
+    const content = fs5.readFileSync(tsconfigPath, "utf-8");
     const stripped = content.replace(/\/\*[\s\S]*?\*\//g, "").replace(/\/\/.*$/gm, "");
     const tsconfig = JSON.parse(stripped);
     if (tsconfig.compilerOptions?.outDir) {
@@ -5299,7 +5076,7 @@ function readTsconfigOutDir(baseDir) {
   return null;
 }
 function resolveCompiledPath(tsPath, baseDir) {
-  const relativePath = path4.relative(baseDir, tsPath);
+  const relativePath = path5.relative(baseDir, tsPath);
   const withoutExt = relativePath.replace(/\.tsx?$/, "");
   const srcPrefix = withoutExt.replace(/^src\//, "");
   const tsconfigOutDir = readTsconfigOutDir(baseDir);
@@ -5307,7 +5084,7 @@ function resolveCompiledPath(tsPath, baseDir) {
   const candidates = [];
   if (tsconfigOutDir) {
     for (const ext of extensions) {
-      candidates.push(path4.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
+      candidates.push(path5.join(baseDir, tsconfigOutDir, `${srcPrefix}${ext}`));
     }
   }
   const commonOutDirs = ["dist", "build", "lib", "out"];
@@ -5315,21 +5092,21 @@ function resolveCompiledPath(tsPath, baseDir) {
     if (outDir === tsconfigOutDir)
       continue;
     for (const ext of extensions) {
-      candidates.push(path4.join(baseDir, outDir, `${srcPrefix}${ext}`));
+      candidates.push(path5.join(baseDir, outDir, `${srcPrefix}${ext}`));
     }
   }
   for (const ext of extensions) {
-    candidates.push(path4.join(baseDir, `${withoutExt}${ext}`));
+    candidates.push(path5.join(baseDir, `${withoutExt}${ext}`));
   }
   const workspaceMatch = baseDir.match(/^(.+\/packages\/[^/]+)$/);
   if (workspaceMatch) {
     const pkgRoot = workspaceMatch[1];
     for (const ext of extensions) {
-      candidates.push(path4.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
+      candidates.push(path5.join(pkgRoot, "dist", `${srcPrefix}${ext}`));
     }
   }
   for (const candidate of candidates) {
-    if (fs4.existsSync(candidate)) {
+    if (fs5.existsSync(candidate)) {
       return candidate;
     }
   }
@@ -5341,7 +5118,7 @@ async function extractStandardSchemas(compiledJsPath, options = {}) {
     schemas: new Map,
     errors: []
   };
-  if (!fs4.existsSync(compiledJsPath)) {
+  if (!fs5.existsSync(compiledJsPath)) {
     result.errors.push(`Compiled JS not found: ${compiledJsPath}`);
     return result;
   }
@@ -5423,8 +5200,8 @@ async function extractStandardSchemasFromProject(entryFile, baseDir, options = {
 }
 
 // src/builder/external-resolver.ts
-import * as fs5 from "node:fs";
-import * as path5 from "node:path";
+import * as fs6 from "node:fs";
+import * as path6 from "node:path";
 import picomatch from "picomatch";
 import ts14 from "typescript";
 function matchesExternalPattern(packageName, include, exclude) {
@@ -5458,20 +5235,20 @@ function findPackageJson(resolvedPath, packageName) {
   const isScoped = packageName.startsWith("@");
   const packageParts = isScoped ? packageName.split("/").slice(0, 2) : [packageName.split("/")[0]];
   const packageDir = packageParts.join("/");
-  let dir = path5.dirname(resolvedPath);
+  let dir = path6.dirname(resolvedPath);
   const maxDepth = 10;
   for (let i = 0;i < maxDepth; i++) {
     if (dir.endsWith(`node_modules/${packageDir}`)) {
-      const pkgPath = path5.join(dir, "package.json");
-      if (fs5.existsSync(pkgPath)) {
+      const pkgPath = path6.join(dir, "package.json");
+      if (fs6.existsSync(pkgPath)) {
         try {
-          return JSON.parse(fs5.readFileSync(pkgPath, "utf-8"));
+          return JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
         } catch {
           return;
         }
       }
     }
-    const parent = path5.dirname(dir);
+    const parent = path6.dirname(dir);
     if (parent === dir)
       break;
     dir = parent;
@@ -5916,7 +5693,7 @@ async function extract(options) {
   const verification = buildVerificationSummary(exportedSymbols.length, exports.length, exportTracker);
   const meta = await getPackageMeta(entryFile, baseDir);
   const types = ctx.typeRegistry.getAll();
-  const projectBaseDir = baseDir ?? path6.dirname(entryFile);
+  const projectBaseDir = baseDir ?? path7.dirname(entryFile);
   const definedTypes = new Set(types.map((t) => t.id));
   const forgottenExports = collectForgottenExports(exports, types, program, sourceFile, exportedIds, projectBaseDir, definedTypes);
   for (const forgotten of forgottenExports) {
@@ -5949,7 +5726,7 @@ async function extract(options) {
   }
   let runtimeMetadata;
   if (options.schemaExtraction === "hybrid") {
-    const projectBaseDir2 = baseDir || path6.dirname(entryFile);
+    const projectBaseDir2 = baseDir || path7.dirname(entryFile);
     const runtimeResult = await extractStandardSchemasFromProject(entryFile, projectBaseDir2, {
       target: options.schemaTarget || "draft-2020-12",
       timeout: 15000
@@ -6099,8 +5876,8 @@ function isExternalType2(definedIn, baseDir) {
     return true;
   if (definedIn.includes("node_modules"))
     return true;
-  const normalizedDefined = path6.resolve(definedIn);
-  const normalizedBase = path6.resolve(baseDir);
+  const normalizedDefined = path7.resolve(definedIn);
+  const normalizedBase = path7.resolve(baseDir);
   return !normalizedDefined.startsWith(normalizedBase);
 }
 function hasInternalTag(typeName, program, sourceFile) {
@@ -6402,7 +6179,7 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
   return {
     ...includeSchema ? { $schema: SCHEMA_URL } : {},
     openpkg: SCHEMA_VERSION,
-    meta: { name: path6.basename(entryFile, path6.extname(entryFile)) },
+    meta: { name: path7.basename(entryFile, path7.extname(entryFile)) },
     exports: [],
     generation: {
       generator: "@openpkg-ts/sdk",
@@ -6415,19 +6192,19 @@ function createEmptySpec(entryFile, includeSchema, isDtsSource) {
   };
 }
 async function getPackageMeta(entryFile, baseDir) {
-  const searchDir = baseDir ?? path6.dirname(entryFile);
-  const pkgPath = path6.join(searchDir, "package.json");
+  const searchDir = baseDir ?? path7.dirname(entryFile);
+  const pkgPath = path7.join(searchDir, "package.json");
   try {
-    if (fs6.existsSync(pkgPath)) {
-      const pkg = JSON.parse(fs6.readFileSync(pkgPath, "utf-8"));
+    if (fs7.existsSync(pkgPath)) {
+      const pkg = JSON.parse(fs7.readFileSync(pkgPath, "utf-8"));
       return {
-        name: pkg.name ?? path6.basename(searchDir),
+        name: pkg.name ?? path7.basename(searchDir),
         version: pkg.version,
         description: pkg.description
       };
     }
   } catch {}
-  return { name: path6.basename(searchDir) };
+  return { name: path7.basename(searchDir) };
 }
 
 // src/primitives/spec.ts
@@ -6453,6 +6230,8 @@ export {
   typeboxAdapter,
   toSearchIndexJSON,
   toSearchIndex,
+  toReactString,
+  toReact,
   toPagefindRecords,
   toNavigation,
   toMarkdown,
@@ -6477,6 +6256,7 @@ export {
   registerReferencedTypes,
   registerAdapter,
   recommendSemverBump,
+  query,
   normalizeType,
   normalizeSchema,
   normalizeMembers,
@@ -6545,6 +6325,7 @@ export {
   arktypeAdapter,
   analyzeSpec,
   TypeRegistry,
+  QueryBuilder,
   CONFIG_FILENAME,
   BUILTIN_TYPE_SCHEMAS,
   ARRAY_PROTOTYPE_METHODS