chore: clean up knip config + prune unused code

.github/workflows/ci.yml

···
         run: pnpm install
 
       - name: 🔍 Check for unused code
-        run: pnpm knip:production
+        run: pnpm knip

app/composables/useAtproto.ts

···
 import type { UserSession } from '#shared/schemas/userSession'
 
-/** @public */
 export function useAtproto() {
   const { data: user, pending, clear } = useFetch<UserSession | null>('/api/auth/session')
 

app/composables/useCachedFetch.ts

···
  *   )
  * }
  * ```
- * @public
  */
 export function useCachedFetch(): CachedFetchFunction {
   // On client, return a function that just uses $fetch (no caching, not stale)

app/composables/useCharts.ts

···
   return versionDates[0] ?? null
 }
 
-/** @public */
 export function useCharts() {
   function resolveDateRange(
     downloadEvolutionOptions: PackageDownloadEvolutionOptions,

app/composables/useConnector.ts

···
 const STORAGE_KEY = 'npmx-connector'
 const DEFAULT_PORT = 31415
 
-/** @public */
 export const useConnector = createSharedComposable(function useConnector() {
   // Persisted connection config
   const config = useState<{ token: string; port: number } | null>('connector-config', () => null)

app/composables/useFacetSelection.ts

···
 /**
  * Composable for managing comparison facet selection with URL sync.
  *
- * @public
  * @param queryParam - The URL query parameter name to use (default: 'facets')
  */
 export function useFacetSelection(queryParam = 'facets') {

app/composables/useFileTreeState.ts

···
-/** @public */
 export function useFileTreeState(baseUrl: string) {
   const stateKey = computed(() => `npmx-file-tree${baseUrl}`)
 

app/composables/useI18nStatus.ts

···
 /**
  * Composable for accessing translation status data from Lunaria.
  * Provides information about translation progress for each locale.
- * @public
  */
 export function useI18nStatus() {
   const { locale } = useI18n()

app/composables/useInstallCommand.ts

···
 /**
  * Composable for generating install commands with support for
  * multiple package managers, @types packages, and JSR.
- * @public
  */
 export function useInstallCommand(
   packageName: MaybeRefOrGetter<string | null>,

app/composables/useIsMobile.ts

···
  * Uses the same breakpoint as Tailwind's `md:` (768px).
  *
  * Returns `false` during SSR to avoid hydration mismatches.
- * @public
  */
 export function useIsMobile() {
   return useMediaQuery('(max-width: 767px)')

app/composables/useJsonLd.ts

···
 
 /**
  * Inject JSON-LD script into head
- * @public
  */
 export function setJsonLd(schema: JsonLdSchema | JsonLdSchema[]) {
   const schemas = Array.isArray(schema) ? schema : [schema]
···
 
 /**
  * Create WebSite schema with search action
- * @public
  */
 export function createWebSiteSchema(options?: {
   name?: string

app/composables/useModuleReplacement.ts

···
 import type { ModuleReplacement } from 'module-replacements'
 
-/** @public */
 export function useModuleReplacement(packageName: MaybeRefOrGetter<string>) {
   return useLazyFetch<ModuleReplacement | null>(() => `/api/replacements/${toValue(packageName)}`)
 }

app/composables/useNpmRegistry.ts

···
   }
 }
 
-/** @public */
 export function usePackage(
   name: MaybeRefOrGetter<string>,
   requestedVersion?: MaybeRefOrGetter<string | null>,
···
   return resolved
 }
 
-/** @public */
 export function usePackageDownloads(
   name: MaybeRefOrGetter<string>,
   period: MaybeRefOrGetter<'last-day' | 'last-week' | 'last-month' | 'last-year'> = 'last-week',
···
 /**
  * Fetch download range data from npm API.
  * Exported for external use (e.g., in components).
- * @public
  */
 export async function fetchNpmDownloadsRange(
   packageName: string,
···
   size?: number
 }
 
-/** @public */
 export function useNpmSearch(
   query: MaybeRefOrGetter<string>,
   options: MaybeRefOrGetter<NpmSearchOptions> = {},
···
 /**
  * Fetch all packages for an npm organization
  * Returns search-result-like objects for compatibility with PackageList
- * @public
  */
 export function useOrgPackages(orgName: MaybeRefOrGetter<string>) {
   const cachedFetch = useCachedFetch()
···
 /**
  * Composable to check for outdated dependencies.
  * Returns a reactive map of dependency name to outdated info.
- * @public
  */
 export function useOutdatedDependencies(
   dependencies: MaybeRefOrGetter<Record<string, string> | undefined>,
···
 
 /**
  * Get tooltip text for an outdated dependency
- * @public
  */
 export function getOutdatedTooltip(
   info: OutdatedDependencyInfo,
···
 
 /**
  * Get CSS class for a dependency version based on outdated status
- * @public
  */
 export function getVersionClass(info: OutdatedDependencyInfo | undefined): string {
   if (!info) return 'text-fg-subtle'

app/composables/usePackageAnalysis.ts

···
 
 /**
  * Composable for fetching package analysis data (module format, types info, etc.)
- * @public
  */
 export function usePackageAnalysis(
   packageName: MaybeRefOrGetter<string>,

app/composables/usePackageComparison.ts

···
 /**
  * Composable for fetching and comparing multiple packages.
  *
- * @public
  */
 export function usePackageComparison(packageNames: MaybeRefOrGetter<string[]>) {
   const packages = computed(() => toValue(packageNames))

app/composables/usePackageListPreferences.ts

···
  * Composable for managing package list display preferences
  * Persists to localStorage and provides reactive state
  *
- * @public
  */
 export function usePackageListPreferences() {
   const {

app/composables/usePackageRoute.ts

···
  *   /@nuxt/kit/v/1.0.0 → packageName: "@nuxt/kit", requestedVersion: "1.0.0"
  *   /axios@1.13.3 → packageName: "axios", requestedVersion: "1.13.3"
  *   /@nuxt/kit@1.0.0 → packageName: "@nuxt/kit", requestedVersion: "1.0.0"
- * @public
  */
 export function usePackageRoute() {
   const route = useRoute('package')

app/composables/usePreferencesProvider.ts

···
  * Composable for managing preferences storage
  * Abstracts the storage mechanism to allow future migration to API-based storage
  *
- * @public
  */
 export function usePreferencesProvider<T>(defaultValue: T) {
   const provider = createLocalStorageProvider<T>(STORAGE_KEY)

app/composables/useRepoMeta.ts

···
 
 const parseRepoFromUrl = parseRepoUrl
 
-/** @public */
 export function useRepoMeta(repositoryUrl: MaybeRefOrGetter<string | null | undefined>) {
   // Get cachedFetch in setup context (outside async handler)
   const cachedFetch = useCachedFetch()

app/composables/useSelectedPackageManager.ts

···
  * `data-pm` attribute on `<html>`. The attribute enables CSS-based
  * visibility of PM-specific content without JavaScript.
  *
- * @public
  */
 export const useSelectedPackageManager = createSharedComposable(
   function useSelectedPackageManager() {

app/composables/useSettings.ts

···
 /**
  * Composable for accessing just the relative dates setting.
  * Useful for components that only need to read this specific setting.
- * @public
  */
 export function useRelativeDates() {
   const { settings } = useSettings()

app/composables/useStructuredFilters.ts

···
 /**
  * Composable for structured filtering and sorting of package lists
  *
- * @public
  */
 export function useStructuredFilters(options: UseStructuredFiltersOptions) {
   const { packages, initialFilters, initialSort } = options

app/composables/useVirtualInfiniteScroll.ts

···
  * Composable for handling infinite scroll with virtua's WindowVirtualizer
  * Detects when user scrolls near the end and triggers loading more items
  * Also tracks current visible page for URL persistence
- * @public
  */
 export function useVirtualInfiniteScroll(options: UseVirtualInfiniteScrollOptions) {
   const {

app/utils/charts.ts

···
   return result
 }
 
-/** @public */
 export function buildWeeklyEvolutionFromDaily(
   daily: Array<{ day: string; downloads: number }>,
 ): Array<{ weekStart: string; weekEnd: string; downloads: number }> {
···
   })
 }
 
-/** @public */
 export function addDays(date: Date, days: number): Date {
   const d = new Date(date)
   d.setUTCDate(d.getUTCDate() + days)

app/utils/colors.ts

···
  * Used to create light tints of accent colors for better visibility in light mode.
  * @param hex - The hex color to lighten (e.g., "#ff0000")
  * @param factor - Lighten factor from 0 to 1 (0.5 = 50% lighter, mixed with white)
- * @public
  */
 export function lightenHex(hex: string, factor: number = 0.5): string {
   const rgb = hexToRgb(hex)
···
   return rgbToHex(...lightened)
 }
 
-/** @public */
 export function oklchToHex(color: string | undefined | null): string | undefined | null {
   if (color == null) return color
 

app/utils/formatters.ts

···
-/** @public */
 export function toIsoDateString(date: Date): string {
   const year = date.getUTCFullYear()
   const month = String(date.getUTCMonth() + 1).padStart(2, '0')
···
   return `${year}-${month}-${day}`
 }
 
-/** @public */
 export function formatCompactNumber(
   value: number,
   options?: { decimals?: number; space?: boolean },

app/utils/input.ts

···
-/** @public */
 export const noCorrect = {
   autocapitalize: 'off',
   autocomplete: 'off',

app/utils/install-command.ts

···
 
 /**
  * Generate the full install command for a package.
- * @public
  */
 export function getInstallCommand(options: InstallCommandOptions): string {
   return getInstallCommandParts(options).join(' ')
···
   isCreatePackage?: boolean
 }
 
-/** @public */
 export function getExecuteCommand(options: ExecuteCommandOptions): string {
   return getExecuteCommandParts(options).join(' ')
 }

app/utils/prehydrate.ts

···
  * to show the correct content before Vue hydration occurs.
  *
  * Call this in app.vue or any page that needs early access to user preferences.
- * @public
  */
 export function initPreferencesOnPrehydrate() {
   // Callback is stringified by Nuxt - external variables won't be available.

app/utils/responsive.ts

···
-/** @public */
 export function isTouchDevice() {
   if (import.meta.server) {
     return false

app/utils/run-command.ts

···
  * - Name starts with "create-" (e.g., create-vite)
  * - Scoped name contains "/create-" (e.g., @vue/create-app)
  * - Has bin field but no main, module, or exports fields
- * @public
  */
 export function isBinaryOnlyPackage(pkg: PackageMetadata): boolean {
   const baseName = pkg.name.startsWith('@') ? pkg.name.split('/')[1] : pkg.name
···
 
 /**
  * Check if a package uses the create-* naming convention.
- * @public
  */
 export function isCreatePackage(packageName: string): boolean {
   const baseName = packageName.startsWith('@') ? packageName.split('/')[1] : packageName
···
 /**
  * Extract executable command information from a package's bin field.
  * Handles both string format ("bin": "./cli.js") and object format ("bin": { "cmd": "./cli.js" }).
- * @public
  */
 export function getExecutableInfo(
   packageName: string,
···
 
 /**
  * Generate the full run command for a package.
- * @public
  */
 export function getRunCommand(options: RunCommandOptions): string {
   return getRunCommandParts(options).join(' ')

app/utils/versions.ts

···
  * Sort tags with 'latest' first, then alphabetically
  * @param tags - Array of tag names
  * @returns New sorted array
- * @public
  */
 export function sortTags(tags: string[]): string[] {
   return [...tags].sort((a, b) => {
···
  * Each unique version appears once with all its tags
  * @param distTags - Object mapping tag names to version strings
  * @returns Array of rows sorted by version (descending)
- * @public
  */
 export function buildTaggedVersionRows(distTags: Record<string, string>): TaggedVersionRow[] {
   const versionToTags = buildVersionToTagsMap(distTags)

cli/src/logger.ts

···
 export const logDebug = createDebug('npmx-connector')
 
 /**
- * Log a message (generic)
- * @public
- */
-export function logMessage(message: string): void {
-  p.log.message(message)
-}
-
-/**
  * Show the connection token in a nice box
  */
 export function showToken(token: string, port: number, frontendUrl: string): void {
···
     'Click to connect',
   )
 }
-
-/**
- * Show outro message
- * @public
- */
-export function showOutro(message: string): void {
-  p.outro(message)
-}
-
-/**
- * Create a spinner for async operations
- * @public
- */
-export function createSpinner() {
-  return p.spinner()
-}

cli/src/npm-client.ts

···
     .trim()
 }
 
-export async function execNpm(
+async function execNpm(
   args: string[],
   options: { otp?: string; silent?: boolean } = {},
 ): Promise<NpmExecResult> {

cli/src/schemas.ts

···
 )
 
 /**
- * Validates a team name (without scope prefix)
- * @public
- */
-export const TeamNameSchema = v.pipe(
-  v.string(),
-  v.nonEmpty('Team name is required'),
-  v.maxLength(50, 'Team name is too long'),
-  v.regex(NPM_USERNAME_RE, 'Invalid team name format'),
-)
-
-/**
  * Validates a scope:team format (e.g., @myorg:developers)
  */
 export const ScopeTeamSchema = v.pipe(
···
 ])
 
 /**
- * Validates operation status
- */
-export const OperationStatusSchema = v.picklist([
-  'pending',
-  'approved',
-  'running',
-  'completed',
-  'failed',
-  'cancelled',
-])
-
-/**
  * Validates OTP (6-digit code)
  */
 export const OtpSchema = v.optional(
···
  * Schema for operation params based on type
  * Validates the params object for each operation type
  */
-export const OperationParamsSchema = v.record(v.string(), v.string())
+const OperationParamsSchema = v.record(v.string(), v.string())
 
 /**
  * Schema for single operation request body
···
   role: OrgRoleSchema,
 })
 
-export const OrgRemoveUserParamsSchema = v.object({
+const OrgRemoveUserParamsSchema = v.object({
   org: OrgNameSchema,
   user: UsernameSchema,
 })
 
-export const TeamCreateParamsSchema = v.object({
+const TeamCreateParamsSchema = v.object({
   scopeTeam: ScopeTeamSchema,
 })
 
-export const TeamDestroyParamsSchema = v.object({
+const TeamDestroyParamsSchema = v.object({
   scopeTeam: ScopeTeamSchema,
 })
 
-export const TeamAddUserParamsSchema = v.object({
+const TeamAddUserParamsSchema = v.object({
   scopeTeam: ScopeTeamSchema,
   user: UsernameSchema,
 })
 
-export const TeamRemoveUserParamsSchema = v.object({
+const TeamRemoveUserParamsSchema = v.object({
   scopeTeam: ScopeTeamSchema,
   user: UsernameSchema,
 })
···
   pkg: PackageNameSchema,
 })
 
-export const AccessRevokeParamsSchema = v.object({
+const AccessRevokeParamsSchema = v.object({
   scopeTeam: ScopeTeamSchema,
   pkg: PackageNameSchema,
 })
 
-export const OwnerAddParamsSchema = v.object({
+const OwnerAddParamsSchema = v.object({
   user: UsernameSchema,
   pkg: PackageNameSchema,
 })
 
-export const OwnerRemoveParamsSchema = v.object({
+const OwnerRemoveParamsSchema = v.object({
   user: UsernameSchema,
   pkg: PackageNameSchema,
 })
···
     error: path ? `${path}: ${message}` : message,
   }
 }
-
-// ============================================================================
-// Type Exports
-// ============================================================================
-
-/** @public */
-export type PackageName = v.InferOutput<typeof PackageNameSchema>
-/** @public */
-export type NewPackageName = v.InferOutput<typeof NewPackageNameSchema>
-/** @public */
-export type Username = v.InferOutput<typeof UsernameSchema>
-/** @public */
-export type OrgName = v.InferOutput<typeof OrgNameSchema>
-/** @public */
-export type ScopeTeam = v.InferOutput<typeof ScopeTeamSchema>
-/** @public */
-export type OrgRole = v.InferOutput<typeof OrgRoleSchema>
-/** @public */
-export type Permission = v.InferOutput<typeof PermissionSchema>
-/** @public */
-export type OperationType = v.InferOutput<typeof OperationTypeSchema>
-/** @public */
-export type OperationStatus = v.InferOutput<typeof OperationStatusSchema>
-/** @public */
-export type ConnectBody = v.InferOutput<typeof ConnectBodySchema>
-/** @public */
-export type ExecuteBody = v.InferOutput<typeof ExecuteBodySchema>
-/** @public */
-export type CreateOperationBody = v.InferOutput<typeof CreateOperationBodySchema>

cli/src/types.ts

···
-/** @public */
 export interface ConnectorConfig {
   port: number
   host: string

knip.json

···
 {
   "$schema": "https://unpkg.com/knip@5/schema.json",
-  "includeEntryExports": true,
-  "ignoreExportsUsedInFile": true,
-  "ignoreBinaries": ["simple-git-hooks", "lint-staged", "lex"],
   "ignore": ["shared/types/lexicons/**"],
   "workspaces": {
     ".": {
       "entry": [
-        "scripts/*.sh",
-        "lunaria/**/*.ts!",
-        "modules/**/*.ts!",
-        "i18n/i18n.config.ts!",
-        "app/app.vue!",
-        "app/error.vue!",
-        "app/pages/**/*.vue!",
-        "app/middleware/**/*.ts!",
-        "app/composables/**/*.ts!",
-        "app/utils/**/*.ts!",
-        "app/plugins/**/*.ts!",
-        "app/components/**/*.vue!",
-        "config/**/*.ts!",
-        "server/utils/**/*.ts!",
-        "shared/**/*.ts!"
-      ],
-      "project": [
-        "app/**/*.{ts,vue}!",
-        "server/**/*.ts!",
-        "shared/**/*.ts!",
-        "test/**/*.ts",
-        "tests/**/*.ts",
+        "app/app.vue",
+        "app/error.vue",
+        "app/pages/**/*.vue",
+        "app/components/**/*.vue",
+        "app/composables/**/*.ts",
+        "app/middleware/**/*.ts",
+        "app/plugins/**/*.ts",
+        "app/utils/**/*.ts",
+        "server/**/*.ts",
+        "modules/**/*.ts",
+        "config/**/*.ts",
+        "i18n/**/*.ts",
+        "lunaria.config.ts",
+        "pwa-assets.config.ts",
+        ".lighthouserc.cjs",
+        "lighthouse-setup.cjs",
+        "uno-preset-rtl.ts",
+        "scripts/**/*.ts",
         "lunaria/**/*.ts",
-        "modules/**/*.ts!",
-        "i18n/**/*.ts!"
+        "shared/**/*.ts"
       ],
+      "project": ["**/*.{ts,vue,cjs,mjs}"],
       "ignoreDependencies": [
-        "@iconify-json/carbon",
-        "@iconify-json/lucide",
-        "@iconify-json/simple-icons",
-        "@iconify-json/solar",
-        "@iconify-json/svg-spinners",
-        "@iconify-json/vscode-icons",
+        "@iconify-json/*",
         "@vercel/kv",
         "@voidzero-dev/vite-plus-core",
         "h3",
-        "ohash",
+        "puppeteer",
         "unplugin-vue-router",
+        "vite-plugin-pwa",
         "vue-router"
       ],
       "ignoreUnresolved": ["#components"]
     },
     "cli": {
-      "project": ["src/**/*.ts!"]
+      "project": ["src/**/*.ts"]
     },
     "docs": {
-      "entry": ["app/app.config.ts"],
-      "ignoreDependencies": ["docus", "better-sqlite3", "nuxt"]
+      "entry": ["app/**/*.{ts,vue}"],
+      "project": ["**/*.{ts,vue}"],
+      "ignoreDependencies": ["docus", "better-sqlite3"]
     }
   }
 }

lunaria/components.ts

···
 
 /**
  * Build an SVG file showing a summary of each language's translation progress.
- * @public
  */
 export const SvgSummary = (config: LunariaConfig, status: LunariaStatus): string => {
   const localeHeight = 56 // Each locale’s summary is 56px high.

lunaria/prepare-json-files.ts

···
 const localesFolder = path.resolve('i18n/locales')
 
 const defaultLocale = currentLocales.find(l => l.code === 'en-US')!
-/** @public */
 export { lunariaJSONFiles }
-/** @public */
 export const sourceLocale = {
   label: defaultLocale.name,
   lang: defaultLocale.code,
 }
-/** @public */
 export const locales: Locale[] = currentLocales
   .filter(l => l.code !== 'en-US')
   .map(l => ({

package.json

···
     "i18n:check:fix": "node --experimental-transform-types scripts/compare-translations.ts --fix",
     "knip": "knip",
     "knip:fix": "knip --fix",
-    "knip:production": "knip --production",
     "lint": "vite lint && vite fmt --check",
     "lint:fix": "vite lint --fix && vite fmt",
     "generate": "nuxt generate",
···
     "module-replacements": "2.11.0",
     "nuxt": "4.3.0",
     "nuxt-og-image": "5.1.13",
-    "ohash": "2.0.11",
     "perfect-debounce": "2.1.0",
     "sanitize-html": "2.17.0",
     "semver": "7.7.3",

pnpm-lock.yaml

···
       nuxt-og-image:
         specifier: 5.1.13
         version: 5.1.13(@unhead/vue@2.1.2(vue@3.5.27(typescript@5.9.3)))(magicast@0.5.1)(unstorage@1.17.4(@upstash/redis@1.36.1)(@vercel/kv@3.0.0)(db0@0.3.4(better-sqlite3@12.6.2))(ioredis@5.9.2))(vite@7.3.1(@types/node@24.10.9)(jiti@2.6.1)(lightningcss@1.31.1)(terser@5.46.0)(yaml@2.8.2))(vue@3.5.27(typescript@5.9.3))
-      ohash:
-        specifier: 2.0.11
-        version: 2.0.11
       perfect-debounce:
         specifier: 2.1.0
         version: 2.1.0

server/utils/atproto/oauth.ts

···
   return await client.restore(currentSession.tokenSet.sub)
 }
 
-/** @public */
 export function eventHandlerWithOAuthSession<T extends EventHandlerRequest, D>(
   handler: EventHandlerWithOAuthSession<T, D>,
 ) {

server/utils/code-highlight.ts

···
 
 /**
  * Determine the language for syntax highlighting based on file path
- * @public
  */
 export function getLanguageFromPath(filePath: string): string {
   const filename = filePath.split('/').pop() || ''
···
 /**
  * Highlight code using Shiki with line-by-line output for line highlighting.
  * Each line is wrapped in a span.line for individual line highlighting.
- * @public
  */
 export async function highlightCode(
   code: string,

server/utils/dependency-analysis.ts

···
 
 /**
  * Analyze entire dependency tree for vulnerabilities and deprecated packages.
- * @public
  */
 export const analyzeDependencyTree = defineCachedFunction(
   async (name: string, version: string): Promise<VulnerabilityTreeResult> => {

server/utils/error-handler.ts

···
 /**
  * Generic error handler for Nitro routes
  * Handles H3 errors, Valibot, and fallbacks in that order
- * @public
  */
 export function handleApiError(error: unknown, fallback: ErrorOptions): never {
   // If already a known Nuxt/H3 Error, re-throw

server/utils/file-tree.ts

···
 /**
  * Fetch and convert file tree for a package version.
  * Returns the full response including tree and metadata.
- * @public
  */
 export async function getPackageFileTree(
   packageName: string,

server/utils/import-resolver.ts

···
 
 /**
  * Flatten a nested file tree into a set of file paths for quick lookups.
- * @public
  */
 export function flattenFileTree(tree: PackageFileTree[]): FileSet {
   const files = new Set<string>()
···
 
 /**
  * Create a resolver function bound to a specific file tree and current file.
- * @public
  */
 export function createImportResolver(
   files: FileSet,

server/utils/install-size.ts

···
  * No filesystem operations - safe for serverless environments.
  *
  * Dependencies are resolved for linux-x64-glibc as a representative platform.
- * @public
  */
 export const calculateInstallSize = defineCachedFunction(
   async (name: string, version: string): Promise<InstallSizeResult> => {

server/utils/jsr.ts

···
  *
  * @param npmPackageName - The npm package name (e.g., "@hono/hono")
  * @returns JsrPackageInfo with existence status and metadata
- * @public
  */
 export const fetchJsrPackageInfo = defineCachedFunction(
   async (npmPackageName: string): Promise<JsrPackageInfo> => {

server/utils/npm.ts

···
 /**
  * Resolve multiple dependency constraints to their best matching versions.
  * Returns a map of package name to resolved version.
- * @public
  */
 export async function resolveDependencyVersions(
   dependencies: Record<string, string>,

server/utils/parse-package-params.ts

···
 /**
  * Parses Nitro router segments into packageName and an optional version
  * Handles patterns: [pkg], [pkg, 'v', version], [@scope, pkg], [@scope, pkg, 'v', version]
- * @public
  */
 export function parsePackageParams(segments: string[]): {
   rawPackageName: string

server/utils/readme.ts

···
   return resolved
 }
 
-/** @public */
 export async function renderReadmeHtml(
   content: string,
   packageName: string,

shared/schemas/package.ts

···
 /**
  * Automatically infer types for routes
  * Usage - prefer this over manually defining interfaces
- * @public
  */
 export type PackageRouteParams = v.InferOutput<typeof PackageRouteParamsSchema>
-/** @public */
 export type PackageVersionQuery = v.InferOutput<typeof PackageVersionQuerySchema>
-/** @public */
 export type PackageFileQuery = v.InferOutput<typeof PackageFileQuerySchema>

shared/types/dependency-analysis.ts

···
 
 /**
  * Package vulnerability response returned by our API
- * @public
  */
 export interface PackageVulnerabilities {
   package: string

shared/types/docs.ts

···
   message?: string
 }
 
-/** @public */
 export interface DocsSearchResponse {
   package: string
   version: string

shared/types/npm-registry.ts

···
   package: string
 }
 
-/** @public */
 export interface NpmDownloadRange {
   downloads: Array<{
     downloads: number
···
  * Organization API types
  * These require authentication
  * Note: Not covered by @npm/types
- * @public
  */
 export interface NpmOrgMember {
   user: string
   role: 'developer' | 'admin' | 'owner'
 }
 
-/** @public */
 export interface NpmTeam {
   name: string
   description?: string
   members?: string[]
 }
 
-/** @public */
 export interface NpmPackageAccess {
   permissions: 'read-only' | 'read-write'
 }
···
 /**
  * Trusted Publishing types
  * Note: Not covered by @npm/types
- * @public
  */
 export interface NpmTrustedPublisher {
   type: 'github-actions' | 'gitlab-ci'

shared/utils/constants.ts

···
 export const NPM_REGISTRY = 'https://registry.npmjs.org'
 export const ERROR_PACKAGE_ANALYSIS_FAILED = 'Failed to analyze package.'
 export const ERROR_PACKAGE_VERSION_AND_FILE_FAILED = 'Version and file path are required.'
-/** @public */
 export const ERROR_PACKAGE_REQUIREMENTS_FAILED =
   'Package name, version, and file path are required.'
 export const ERROR_FILE_LIST_FETCH_FAILED = 'Failed to fetch file list.'
···
 export const ERROR_JSR_FETCH_FAILED = 'Failed to fetch package from JSR registry.'
 export const ERROR_NPM_FETCH_FAILED = 'Failed to fetch package from npm registry.'
 export const UNSET_NUXT_SESSION_PASSWORD = 'NUXT_SESSION_PASSWORD not set'
-/** @public */
 export const ERROR_SUGGESTIONS_FETCH_FAILED = 'Failed to fetch suggestions.'
 
 // microcosm services

shared/utils/constellation.ts

···
 
 const HEADERS = { 'User-Agent': 'npmx' }
 
-/** @public */
 export class Constellation {
   private readonly cachedFetch: CachedFetchFunction
   constructor(fetch: CachedFetchFunction) {

shared/utils/git-providers.ts

···
 /**
  * Parse repository field from package.json into repository info.
  * Supports both full objects and shorthand strings.
- * @public
  */
 export function parseRepositoryInfo(
   repository?: { type?: string; url?: string; directory?: string } | string,
···
   }
 }
 
-/** @public */
 export function getProviderConfig(providerId: ProviderId): ProviderConfig | undefined {
   return providers.find(p => p.id === providerId)
 }
···
   return url
 }
 
-/** @public */
 export function isKnownGitProvider(url: string): boolean {
   return parseRepoUrl(url) !== null
 }

shared/utils/severity.ts

···
 
 /**
  * Badge color classes for severity levels
- * @public
  */
 export const SEVERITY_BADGE_COLORS: Record<OsvSeverityLevel, string> = {
   critical: 'bg-bg-muted border border-border text-fg',

shared/utils/spdx.ts

···
  * Generate an SPDX license URL for the given license identifier.
  * Returns null if the license is not a valid SPDX identifier.
  * @see https://spdx.org/licenses/
- * @public
  */
 export function getSpdxLicenseUrl(license: string | undefined): string | null {
   if (!license) return null

uno-preset-rtl.ts

···
 
 /**
  * CSS RTL support to detect, replace and warn wrong left/right usages.
- * @public
  */
 export function presetRtl(): Preset {
   return {