@openpkg-ts/sdk 0.55.0 → 0.55.1

package/dist/shared/chunk-jfjmy1r0.js

@@ -0,0 +1,1063 @@
+// 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/types/schema-normalizer.ts
+import { JSON_SCHEMA_DRAFT } from "@openpkg-ts/spec";
+var TS_PRIMITIVE_NORMALIZATIONS = {
+  void: () => ({ type: "null", "x-ts-type": "void" }),
+  never: () => ({ not: {} }),
+  any: () => ({ "x-ts-type": "any" }),
+  unknown: () => ({ "x-ts-type": "unknown" }),
+  undefined: () => ({ type: "null", "x-ts-type": "undefined" }),
+  bigint: () => ({ type: "integer", "x-ts-type": "bigint" }),
+  symbol: () => ({ type: "string", "x-ts-type": "symbol" })
+};
+function normalizeSchema(schema, options = {}) {
+  const { includeSchemaField = false } = options;
+  const normalized = normalizeSchemaInternal(schema, options);
+  if (includeSchemaField && typeof normalized === "object") {
+    return {
+      $schema: JSON_SCHEMA_DRAFT,
+      ...normalized
+    };
+  }
+  return normalized;
+}
+function normalizeSchemaInternal(schema, options) {
+  const result = normalizeSchemaDispatch(schema, options);
+  if (schema && typeof schema === "object" && !Array.isArray(schema)) {
+    const s = schema;
+    if (s.deprecated === true && result.deprecated === undefined) {
+      result.deprecated = true;
+    }
+    if (s.readOnly === true && result.readOnly === undefined) {
+      result.readOnly = true;
+    }
+    for (const key of Object.keys(s)) {
+      if (key.startsWith("x-") && s[key] !== undefined && result[key] === undefined) {
+        result[key] = s[key];
+      }
+    }
+    if (Array.isArray(s.typeArguments) && s.typeArguments.length > 0 && result["x-ts-type-arguments"] === undefined) {
+      result["x-ts-type-arguments"] = s.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
+    }
+  }
+  return result;
+}
+function normalizeSchemaDispatch(schema, options) {
+  if (typeof schema === "string") {
+    return normalizeStringType(schema);
+  }
+  if (schema == null) {
+    return {};
+  }
+  if (typeof schema !== "object") {
+    return {};
+  }
+  if ("anyOf" in schema && Array.isArray(schema.anyOf) && !isRequiredOnlyAnyOf(schema.anyOf)) {
+    return normalizeCombinator("anyOf", schema.anyOf, schema, options);
+  }
+  if ("allOf" in schema && Array.isArray(schema.allOf)) {
+    return normalizeCombinator("allOf", schema.allOf, schema, options);
+  }
+  if ("oneOf" in schema && Array.isArray(schema.oneOf)) {
+    return normalizeCombinator("oneOf", schema.oneOf, schema, options);
+  }
+  if ("$ref" in schema && typeof schema.$ref === "string") {
+    return normalizeRef(schema, options);
+  }
+  if ("type" in schema && typeof schema.type === "string") {
+    return normalizeTypedSchema(schema, options);
+  }
+  return normalizeGenericObject(schema, options);
+}
+function normalizeStringType(type) {
+  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
+  if (specialNormalization) {
+    return specialNormalization();
+  }
+  if (["string", "number", "boolean", "integer", "null", "object", "array"].includes(type)) {
+    return { type };
+  }
+  return { "x-ts-type": type };
+}
+function normalizeTypedSchema(schema, options) {
+  const { type } = schema;
+  const specialNormalization = TS_PRIMITIVE_NORMALIZATIONS[type];
+  if (specialNormalization) {
+    const normalized = specialNormalization();
+    return mergeSchemaFields(normalized, schema, ["type"]);
+  }
+  if (type === "function") {
+    return normalizeFunctionType(schema, options);
+  }
+  if (type === "tuple") {
+    return normalizeTupleType(schema, options);
+  }
+  if (type === "array") {
+    return normalizeArrayType(schema, options);
+  }
+  if (type === "object") {
+    return normalizeObjectType(schema, options);
+  }
+  if (["string", "number", "boolean", "integer", "null"].includes(type)) {
+    return normalizeStandardType(schema, options);
+  }
+  const result = { "x-ts-type": type };
+  return mergeSchemaFields(result, schema, ["type"]);
+}
+function normalizeFunctionType(schema, options) {
+  const result = {
+    "x-ts-function": true
+  };
+  if ("signatures" in schema && Array.isArray(schema.signatures)) {
+    result["x-ts-signatures"] = schema.signatures.map((sig) => normalizeSignature(sig, options));
+  }
+  if ("description" in schema && schema.description) {
+    result.description = schema.description;
+  }
+  return result;
+}
+function normalizeSignature(signature, options) {
+  const result = {};
+  if (signature.parameters) {
+    result.parameters = signature.parameters.map((param) => ({
+      name: param.name,
+      schema: normalizeSchemaInternal(param.schema, options),
+      ...param.required !== undefined ? { required: param.required } : {},
+      ...param.description ? { description: param.description } : {},
+      ...param.default !== undefined ? { default: param.default } : {},
+      ...param.rest ? { rest: param.rest } : {},
+      ...param["x-ts-destructured"] ? { "x-ts-destructured": true } : {}
+    }));
+  }
+  if (signature.returns) {
+    result.returns = {
+      schema: normalizeSchemaInternal(signature.returns.schema, options),
+      ...signature.returns.description ? { description: signature.returns.description } : {}
+    };
+  }
+  if (signature.description) {
+    result.description = signature.description;
+  }
+  if (signature.typeParameters) {
+    result.typeParameters = signature.typeParameters;
+  }
+  return result;
+}
+function normalizeTupleType(schema, options) {
+  const result = { type: "array" };
+  const prefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
+  if (prefix) {
+    result.prefixItems = prefix.map((item) => normalizeSchemaInternal(item, options));
+  } else if ("items" in schema && Array.isArray(schema.items)) {
+    result.prefixItems = schema.items.map((item) => normalizeSchemaInternal(item, options));
+    result.minItems = schema.items.length;
+    result.maxItems = schema.items.length;
+  }
+  if ("minItems" in schema && typeof schema.minItems === "number") {
+    result.minItems = schema.minItems;
+  }
+  if ("maxItems" in schema && typeof schema.maxItems === "number") {
+    result.maxItems = schema.maxItems;
+  }
+  if ("description" in schema && schema.description) {
+    result.description = schema.description;
+  }
+  return result;
+}
+function normalizeArrayType(schema, options) {
+  const result = { type: "array" };
+  if ("items" in schema && schema.items && !Array.isArray(schema.items)) {
+    result.items = normalizeSchemaInternal(schema.items, options);
+  }
+  const arrayPrefix = Array.isArray(schema.prefixItems) ? schema.prefixItems : Array.isArray(schema.prefixedItems) ? schema.prefixedItems : undefined;
+  if (arrayPrefix) {
+    result.prefixItems = arrayPrefix.map((item) => normalizeSchemaInternal(item, options));
+  }
+  if ("minItems" in schema && typeof schema.minItems === "number") {
+    result.minItems = schema.minItems;
+  }
+  if ("maxItems" in schema && typeof schema.maxItems === "number") {
+    result.maxItems = schema.maxItems;
+  }
+  if (schema.uniqueItems === true) {
+    result.uniqueItems = true;
+  }
+  if (schema.contains && typeof schema.contains === "object") {
+    result.contains = normalizeSchemaInternal(schema.contains, options);
+  }
+  for (const keyword of ["title", "default"]) {
+    if (keyword in schema && schema[keyword] !== undefined) {
+      result[keyword] = schema[keyword];
+    }
+  }
+  if ("description" in schema && schema.description) {
+    result.description = schema.description;
+  }
+  return result;
+}
+function normalizeObjectType(schema, options) {
+  const result = { type: "object" };
+  if ("properties" in schema && schema.properties) {
+    const properties = schema.properties;
+    result.properties = Object.fromEntries(Object.entries(properties).map(([key, value]) => [
+      key,
+      normalizeSchemaInternal(value, options)
+    ]));
+  }
+  if ("required" in schema && Array.isArray(schema.required)) {
+    result.required = schema.required;
+  }
+  if (Array.isArray(schema.anyOf) && isRequiredOnlyAnyOf(schema.anyOf)) {
+    result.anyOf = schema.anyOf;
+  }
+  if ("additionalProperties" in schema) {
+    if (typeof schema.additionalProperties === "boolean") {
+      result.additionalProperties = schema.additionalProperties;
+    } else if (schema.additionalProperties) {
+      result.additionalProperties = normalizeSchemaInternal(schema.additionalProperties, options);
+    }
+  }
+  for (const keyword of ["patternProperties", "$defs"]) {
+    const value = schema[keyword];
+    if (value && typeof value === "object" && !Array.isArray(value)) {
+      result[keyword] = Object.fromEntries(Object.entries(value).map(([key, nested]) => [
+        key,
+        normalizeSchemaInternal(nested, options)
+      ]));
+    }
+  }
+  if (schema.propertyNames && typeof schema.propertyNames === "object") {
+    result.propertyNames = normalizeSchemaInternal(schema.propertyNames, options);
+  }
+  for (const keyword of ["title", "default", "examples", "minProperties", "maxProperties"]) {
+    if (keyword in schema && schema[keyword] !== undefined) {
+      result[keyword] = schema[keyword];
+    }
+  }
+  if ("description" in schema && schema.description) {
+    result.description = schema.description;
+  }
+  return result;
+}
+function normalizeStandardType(schema, options) {
+  const result = { type: schema.type };
+  const validationKeywords = [
+    "enum",
+    "const",
+    "format",
+    "pattern",
+    "minimum",
+    "maximum",
+    "exclusiveMinimum",
+    "exclusiveMaximum",
+    "multipleOf",
+    "minLength",
+    "maxLength",
+    "description",
+    "default",
+    "examples",
+    "title"
+  ];
+  for (const keyword of validationKeywords) {
+    if (keyword in schema && schema[keyword] !== undefined) {
+      result[keyword] = schema[keyword];
+    }
+  }
+  for (const key of Object.keys(schema)) {
+    if (key.startsWith("x-") && schema[key] !== undefined) {
+      const value = schema[key];
+      if (isSchemaLike(value)) {
+        result[key] = normalizeSchemaInternal(value, options);
+      } else if (typeof value === "object" && value !== null && !Array.isArray(value)) {
+        result[key] = normalizeGenericObject(value, options);
+      } else {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function normalizeRef(schema, options) {
+  const result = { $ref: schema.$ref };
+  if (schema.typeArguments && schema.typeArguments.length > 0) {
+    result["x-ts-type-arguments"] = schema.typeArguments.map((arg) => normalizeSchemaInternal(arg, options));
+  }
+  for (const key of Object.keys(schema)) {
+    if (key.startsWith("x-ts-") && schema[key] !== undefined) {
+      result[key] = schema[key];
+    }
+  }
+  return result;
+}
+function isRequiredOnlyAnyOf(arms) {
+  return arms.length > 0 && arms.every((arm) => typeof arm === "object" && arm !== null && Object.keys(arm).length === 1 && Array.isArray(arm.required));
+}
+function normalizeCombinator(keyword, schemas, originalSchema, options) {
+  let branches = schemas.map((s) => normalizeSchemaInternal(s, options));
+  if (keyword !== "allOf") {
+    const seen = new Set;
+    branches = branches.filter((b) => {
+      const key = JSON.stringify(b);
+      if (seen.has(key))
+        return false;
+      seen.add(key);
+      return true;
+    });
+    if (branches.length === 1) {
+      const single = { ...branches[0] };
+      if ("description" in originalSchema && originalSchema.description && !single.description) {
+        single.description = originalSchema.description;
+      }
+      return single;
+    }
+  }
+  const result = { [keyword]: branches };
+  if ((keyword === "anyOf" || keyword === "oneOf") && "discriminator" in originalSchema && originalSchema.discriminator) {
+    result.discriminator = originalSchema.discriminator;
+  }
+  if ("description" in originalSchema && originalSchema.description) {
+    result.description = originalSchema.description;
+  }
+  return result;
+}
+function normalizeGenericObject(schema, options) {
+  const result = {};
+  for (const [key, value] of Object.entries(schema)) {
+    if (value == null)
+      continue;
+    if (isSchemaLike(value)) {
+      result[key] = normalizeSchemaInternal(value, options);
+    } else if (Array.isArray(value)) {
+      result[key] = value.map((item) => isSchemaLike(item) ? normalizeSchemaInternal(item, options) : item);
+    } else if (typeof value === "object") {
+      result[key] = normalizeGenericObject(value, options);
+    } else {
+      result[key] = value;
+    }
+  }
+  return result;
+}
+function isSchemaLike(value) {
+  if (typeof value !== "object" || value == null)
+    return false;
+  if (typeof value === "string")
+    return true;
+  const obj = value;
+  return "type" in obj || "$ref" in obj || "anyOf" in obj || "allOf" in obj || "oneOf" in obj || "properties" in obj || "items" in obj || "prefixItems" in obj || "prefixedItems" in obj;
+}
+function mergeSchemaFields(target, source, excludeKeys) {
+  if (typeof source !== "object" || source == null) {
+    return target;
+  }
+  const excludeSet = new Set(excludeKeys);
+  const result = { ...target };
+  for (const [key, value] of Object.entries(source)) {
+    if (!excludeSet.has(key) && value !== undefined) {
+      if (!(key in result)) {
+        result[key] = value;
+      }
+    }
+  }
+  return result;
+}
+function isVendorSchemaExport(exp) {
+  return !!exp.tags?.some((t) => t.name === "schema-source" && t.text === "standard-json-schema");
+}
+function normalizeExport(exp, options = {}) {
+  const result = { ...exp };
+  const vendorSchema = isVendorSchemaExport(exp);
+  if (exp.schema && !vendorSchema) {
+    result.schema = normalizeSchema(exp.schema, options);
+  }
+  if (exp.signatures) {
+    result.signatures = exp.signatures.map((sig) => normalizeSignatureSpec(sig, options));
+  }
+  if (exp.members) {
+    result.members = exp.members.map((member) => normalizeMember(member, options));
+  }
+  if (!vendorSchema && shouldGenerateMembersSchema(exp.kind) && exp.members && exp.members.length > 0) {
+    result.schema = withOpenArms(normalizeMembers(exp.members, options), result.schema);
+  }
+  return result;
+}
+function withOpenArms(membersSchema, provided) {
+  const arms = provided?.allOf;
+  return Array.isArray(arms) ? { allOf: [membersSchema, ...arms] } : membersSchema;
+}
+function normalizeType(type, options = {}) {
+  const result = { ...type };
+  if (type.schema) {
+    result.schema = normalizeSchema(type.schema, options);
+  }
+  if (type.members) {
+    result.members = type.members.map((member) => normalizeMember(member, options));
+  }
+  if (shouldGenerateMembersSchema(type.kind) && type.members && type.members.length > 0) {
+    result.schema = withOpenArms(normalizeMembers(type.members, options), result.schema);
+  }
+  return result;
+}
+function shouldGenerateMembersSchema(kind) {
+  return kind === "interface" || kind === "class";
+}
+function normalizeSignatureSpec(signature, options) {
+  const result = { ...signature };
+  if (signature.parameters) {
+    result.parameters = signature.parameters.map((param) => ({
+      ...param,
+      schema: normalizeSchema(param.schema, options)
+    }));
+  }
+  if (signature.returns) {
+    result.returns = {
+      ...signature.returns,
+      schema: normalizeSchema(signature.returns.schema, options)
+    };
+  }
+  return result;
+}
+function normalizeMember(member, options) {
+  const result = { ...member };
+  if (member.schema) {
+    result.schema = normalizeSchema(member.schema, options);
+  }
+  if (member.signatures) {
+    result.signatures = member.signatures.map((sig) => normalizeSignatureSpec(sig, options));
+  }
+  return result;
+}
+function normalizeMembers(members, options = {}) {
+  const properties = {};
+  const required = [];
+  let additionalProperties;
+  let numberIndexSchema;
+  for (const member of members) {
+    const { name, kind } = member;
+    if (kind === "index" || kind === "index-signature") {
+      if (name === "[number]") {
+        numberIndexSchema = normalizeMemberToSchema(member, options);
+      } else {
+        additionalProperties = normalizeMemberToSchema(member, options);
+      }
+      continue;
+    }
+    if (!name)
+      continue;
+    const memberSchema = normalizeMemberToSchema(member, options);
+    properties[name] = memberSchema;
+    if (!isOptionalMember(member)) {
+      required.push(name);
+    }
+  }
+  const result = {
+    type: "object",
+    properties
+  };
+  if (required.length > 0) {
+    result.required = required;
+  }
+  if (additionalProperties !== undefined) {
+    result.additionalProperties = additionalProperties;
+  }
+  if (numberIndexSchema !== undefined) {
+    result.patternProperties = { "^\\d+$": numberIndexSchema };
+    result["x-ts-index-key"] = "number";
+  }
+  return result;
+}
+function memberDocExtras(member) {
+  const extras = {};
+  if (member.description) {
+    extras.description = member.description;
+  }
+  if (member.flags?.readonly === true) {
+    extras.readOnly = true;
+  }
+  if (member.deprecated) {
+    extras.deprecated = true;
+    const reason = member.deprecationReason ?? member.tags?.find((t) => t.name === "deprecated")?.text;
+    if (reason?.trim()) {
+      extras["x-deprecated-reason"] = reason;
+    }
+  }
+  return extras;
+}
+function normalizeMemberToSchema(member, options) {
+  const { kind, schema, signatures } = member;
+  if (kind === "method" || kind === "call-signature") {
+    return normalizeMethodMember(member, options);
+  }
+  if (kind === "getter") {
+    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
+    return {
+      ...baseSchema2,
+      "x-ts-accessor": "getter",
+      ...memberDocExtras(member)
+    };
+  }
+  if (kind === "setter") {
+    const baseSchema2 = schema ? normalizeSchemaInternal(schema, options) : {};
+    return {
+      ...baseSchema2,
+      "x-ts-accessor": "setter",
+      ...memberDocExtras(member)
+    };
+  }
+  if (kind === "index" || kind === "index-signature") {
+    if (schema && typeof schema === "object" && "additionalProperties" in schema) {
+      return normalizeSchemaInternal(schema.additionalProperties, options);
+    }
+    return schema ? normalizeSchemaInternal(schema, options) : {};
+  }
+  if (signatures && signatures.length > 0) {
+    return normalizeMethodMember(member, options);
+  }
+  const baseSchema = schema ? normalizeSchemaInternal(schema, options) : {};
+  const extras = memberDocExtras(member);
+  return Object.keys(extras).length > 0 ? { ...baseSchema, ...extras } : baseSchema;
+}
+function normalizeMethodMember(member, options) {
+  const result = {
+    "x-ts-function": true
+  };
+  if (member.flags?.methodSyntax === true) {
+    result["x-ts-method"] = true;
+  }
+  const memberTypeText = member.schema && typeof member.schema === "object" ? member.schema["x-ts-type"] : undefined;
+  if (typeof memberTypeText === "string") {
+    result["x-ts-type"] = memberTypeText;
+  }
+  if (member.signatures && member.signatures.length > 0) {
+    result["x-ts-signatures"] = member.signatures.map((sig) => normalizeSignature(sig, options));
+  }
+  Object.assign(result, memberDocExtras(member));
+  return result;
+}
+function isOptionalMember(member) {
+  if (member.flags?.optional === true) {
+    return true;
+  }
+  if (member.name?.endsWith("?")) {
+    return true;
+  }
+  return false;
+}
+
+// src/core/query.ts
+import {
+  DISPLAY_KIND_ORDER
+} from "@openpkg-ts/spec";
+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 depth = options?._depth ?? 0;
+  const maxDepth = options?.maxDepth ?? 3;
+  if (depth >= maxDepth)
+    return "...";
+  const nextOpts = { ...options, _depth: depth + 1 };
+  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, nextOpts)}`;
+    }
+    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, nextOpts)).join(", ");
+        return withPackage(`${baseName}<${args}>`);
+      }
+      return withPackage(baseName);
+    }
+    if ("anyOf" in schema && Array.isArray(schema.anyOf) && !isRequiredOnlyAnyOf(schema.anyOf)) {
+      const threshold = options?.collapseUnionThreshold ?? 5;
+      const members = schema.anyOf;
+      if (members.length > threshold) {
+        const shown = members.slice(0, 3);
+        const remaining = members.length - 3;
+        const shownStr = shown.map((s) => formatSchema(s, nextOpts)).join(" | ");
+        return `${shownStr} | ... and ${remaining} more`;
+      }
+      return members.map((s) => formatSchema(s, nextOpts)).join(" | ");
+    }
+    if ("allOf" in schema && Array.isArray(schema.allOf)) {
+      return schema.allOf.map((s) => formatSchema(s, nextOpts)).join(" & ");
+    }
+    if ("type" in schema && schema.type === "array") {
+      const items = "items" in schema ? formatSchema(schema.items, nextOpts) : "unknown";
+      return `${items}[]`;
+    }
+    if ("type" in schema && schema.type === "tuple" && "items" in schema) {
+      const items = schema.items.map((s) => formatSchema(s, nextOpts)).join(", ");
+      return `[${items}]`;
+    }
+    if ("type" in schema && schema.type === "object") {
+      if ("properties" in schema && schema.properties) {
+        const required = new Set(Array.isArray(schema.required) ? schema.required : []);
+        const props = Object.entries(schema.properties).map(([k, v]) => `${k}${required.has(k) ? "" : "?"}: ${formatSchema(v, nextOpts)}`).join("; ");
+        return `{ ${props} }`;
+      }
+      return "object";
+    }
+    if ("const" in schema && schema.const !== undefined) {
+      const v = schema.const;
+      return withPackage(typeof v === "string" ? `"${v}"` : String(v));
+    }
+    if ("enum" in schema && Array.isArray(schema.enum)) {
+      const vals = schema.enum.map((v) => typeof v === "string" ? `"${v}"` : String(v));
+      return withPackage(vals.join(" | "));
+    }
+    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));
+}
+var KIND_ORDER = [
+  ...DISPLAY_KIND_ORDER,
+  "namespace",
+  "module",
+  "reference",
+  "external"
+];
+function groupByKind(items) {
+  const groups = {};
+  for (const item of items) {
+    if (!groups[item.kind])
+      groups[item.kind] = [];
+    groups[item.kind].push(item);
+  }
+  return groups;
+}
+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} }`;
+}
+function findExport(spec, name) {
+  const exp = spec.exports.find((e) => e.name === name || e.id === name);
+  if (!exp)
+    throw new Error(`Export not found: ${name}`);
+  return exp;
+}
+function filterExports(spec, names) {
+  const ids = new Set(names);
+  return spec.exports.filter((e) => ids.has(e.name) || ids.has(e.id));
+}
+
+// src/core/search.ts
+import { KIND_LABELS } from "@openpkg-ts/spec";
+var defaultSlugify = (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, options = {}) {
+  const { baseUrl = "/api", slugify = defaultSlugify } = 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, 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 = defaultSlugify, 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 = defaultSlugify } = 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: KIND_LABELS[exp.kind],
+      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/query-builder.ts
+class QueryBuilder {
+  spec;
+  predicates = [];
+  constructor(spec) {
+    this.spec = spec;
+  }
+  byKind(...kinds) {
+    if (kinds.length > 0) {
+      this.predicates.push((exp) => kinds.includes(exp.kind));
+    }
+    return this;
+  }
+  byName(pattern) {
+    if (typeof pattern === "string") {
+      this.predicates.push((exp) => exp.name === pattern);
+    } else {
+      this.predicates.push((exp) => pattern.test(exp.name));
+    }
+    return this;
+  }
+  byTag(...tags) {
+    if (tags.length > 0) {
+      this.predicates.push((exp) => {
+        const expTags = exp.tags?.map((t) => t.name) ?? [];
+        return tags.some((tag) => expTags.includes(tag));
+      });
+    }
+    return this;
+  }
+  deprecated(include) {
+    if (include !== undefined) {
+      this.predicates.push((exp) => (exp.deprecated ?? false) === include);
+    }
+    return this;
+  }
+  withDescription() {
+    this.predicates.push((exp) => Boolean(exp.description?.trim()));
+    return this;
+  }
+  search(term) {
+    const lower = term.toLowerCase();
+    this.predicates.push((exp) => exp.name.toLowerCase().includes(lower) || (exp.description?.toLowerCase().includes(lower) ?? false));
+    return this;
+  }
+  where(predicate) {
+    this.predicates.push(predicate);
+    return this;
+  }
+  byModule(modulePath) {
+    this.predicates.push((exp) => exp.source?.file?.includes(modulePath) ?? false);
+    return this;
+  }
+  matches(exp) {
+    return this.predicates.every((p) => p(exp));
+  }
+  find() {
+    return this.spec.exports.filter((exp) => this.matches(exp));
+  }
+  first() {
+    return this.spec.exports.find((exp) => this.matches(exp));
+  }
+  count() {
+    return this.spec.exports.filter((exp) => this.matches(exp)).length;
+  }
+  ids() {
+    return this.find().map((exp) => exp.id);
+  }
+  toSpec() {
+    return {
+      ...this.spec,
+      exports: this.find(),
+      types: this.spec.types ? [...this.spec.types] : undefined
+    };
+  }
+}
+function query(spec) {
+  return new QueryBuilder(spec);
+}
+
+export { getMemberBadges, formatBadges, normalizeSchema, isRequiredOnlyAnyOf, normalizeExport, normalizeType, normalizeMembers, formatSchema, formatTypeParameters, formatParameters, formatReturnType, buildSignatureString, resolveTypeRef, isMethod, isProperty, getMethods, getProperties, groupByVisibility, sortByName, KIND_ORDER, groupByKind, formatConditionalType, formatMappedType, findExport, filterExports, toSearchIndex, toPagefindRecords, toAlgoliaRecords, toSearchIndexJSON, QueryBuilder, query };