@monke-together-strong/oxc-config 0.1.1 → 0.4.0

package/README.md

@@ -1,6 +1,29 @@
 # `@monke-together-strong/oxc-config`
 
-Shared Oxlint and Oxfmt presets maintained by Monke Together Strong.
+Shared TypeScript, Oxlint, and Oxfmt presets maintained by Monke Together Strong.
+
+## TypeScript
+
+```sh
+bun add -D @monke-together-strong/oxc-config typescript
+```
+
+```json
+{
+  "extends": "@monke-together-strong/oxc-config/base.json",
+  "compilerOptions": {
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "noEmit": true
+  }
+}
+```
+
+The base preset contains runtime-neutral correctness and soundness settings. Consumers remain
+responsible for environment-specific options such as `lib`, `module`, `moduleResolution`, JSX,
+runtime types, and emit behavior.
+
+## Oxc
 
 The presets compose Ultracite's native Oxc configuration while allowing repository-specific settings to override shared defaults.
 
@@ -45,22 +68,50 @@ export { default } from "@monke-together-strong/oxc-config/oxfmt";
 
 ```ts
 // oxlint.config.ts
-export { default } from "@monke-together-strong/oxc-config/oxlint";
+import { createOxlintConfig } from "@monke-together-strong/oxc-config/oxlint";
+
+export default createOxlintConfig();
 ```
 
-The Oxfmt preset uses a print width of 100, ignores team-managed `skills/**` and `AGENTS.md`, and appends consumer `ignorePatterns` after its shared ignores. Other consumer fields override the shared formatter defaults.
+The Oxfmt preset formats JSDoc and uses a print width of 100. It formats first-party skill code and metadata while excluding imported skills, imported references, skill Markdown, and `AGENTS.md`. Consumer `ignorePatterns` append after these shared ignores; other consumer fields override the shared formatter defaults.
 
-The default Oxlint preset composes Ultracite's core and Vitest presets, enables type-aware linting and TypeScript type checking, and assumes files named `*.test.*`, `*.spec.*`, or stored under `__tests__` use Vitest.
+The default Oxlint preset composes Ultracite's core, anti-slop, and Vitest presets, enables type-aware linting and TypeScript type checking, and rejects console calls and direct environment access. Environment variables should be read and validated through a centralized configuration boundary. It uses `eslint-plugin-perfectionist` to sort object literals, destructuring, object types, interfaces, JSX props, enums, and heritage clauses while treating comments as intentional object and enum partitions, and disables Ultracite's `sort-keys` rule. It disables anti-slop's `no-array-filter-map` because its suggested `flatMap` and iterator-helper rewrites run slower than `filter().map()` on Bun. It also loads `eslint-plugin-jsdoc` through Oxlint's JavaScript-plugin compatibility layer to reject undefined JSDoc types that Oxlint does not yet implement natively. Files named `*.test.*`, `*.spec.*`, or stored under `__tests__` are assumed to use Vitest. Its framework-neutral test policy also covers files under `test/` and `tests/`, where `typescript/no-unsafe-type-assertion` is disabled because typed mock and fixture setup is not yet ergonomic enough to justify the churn.
 
-Mixed-framework repositories can exclude framework-owned paths from the Vitest preset:
+### Framework presets
+
+`frameworks` enables Ultracite's React, TanStack, and shadcn presets and React Doctor's rules in the listed directories, relative to the config. `"."` covers the whole repository.
 
 ```ts
-import { createOxlintConfig } from "@monke-together-strong/oxc-config/oxlint";
-import react from "ultracite/oxlint/react";
-import tanstack from "ultracite/oxlint/tanstack";
+export default createOxlintConfig({
+  frameworks: {
+    react: ["apps/web"],
+    "react-doctor": ["apps/web"],
+    shadcn: ["apps/web"],
+    tanstack: ["apps/web"]
+  },
+  rules: {
+    "shadcn/no-raw-colors": ["error", { allow: ["text-body"] }]
+  }
+});
+```
+
+Install `@shadcn/lint` for `shadcn` and `oxlint-plugin-react-doctor` for `react-doctor`. React Doctor's TanStack rules apply where the `react-doctor` and `tanstack` scopes overlap.
+
+`createOxlintConfig` throws when the root or a workspace `package.json` depends on one of these packages without a matching `frameworks` entry:
+
+- `react`, `@tanstack/react-router`, and `@tanstack/react-start` require the framework to cover the package that depends on them.
+- `@shadcn/lint` and `oxlint-plugin-react-doctor` require the framework to list at least one directory.
 
+Workspaces come from `workspaces` in `package.json` and `packages` in `pnpm-workspace.yaml`. Set a framework to `false` to decline it. The check reads manifests from `root`, which defaults to the nearest directory at or above the working directory that contains `.git`. If the config is not at the repository root, pass its directory as `root`.
+
+Root `rules` for a directory-scoped framework's plugins, such as `react/*` or `shadcn/*`, apply inside its directories. When `react` is directory-scoped, an `overrides` entry that changes `react/*`, `react-perf/*`, or `jsx-a11y/*` rules must list those plugins in `plugins`. Otherwise Oxlint ignores the change.
+
+### Vitest scope
+
+Mixed-framework repositories can exclude framework-owned paths from the Vitest preset:
+
+```ts
 export default createOxlintConfig({
-  extends: [react, tanstack],
   ignorePatterns: [".repo-specific-output"],
   overrides: [
     {
@@ -78,6 +129,6 @@ export default createOxlintConfig({
 });
 ```
 
-`extends`, `ignorePatterns`, and `overrides` append after their shared lint values. Consumer `rules` and `options` override shared defaults. Other Oxlint fields pass through at the root.
+`extends`, `ignorePatterns`, `jsPlugins`, and `overrides` append after the preset's values. Consumer `rules`, `options`, and `settings` override the preset's defaults. Other Oxlint fields pass through at the root.
 
 The presets are published on public npm under the MIT license.

package/base.json

@@ -0,0 +1,18 @@
+{
+  "$schema": "https://json.schemastore.org/tsconfig",
+  "compilerOptions": {
+    "allowUnreachableCode": false,
+    "allowUnusedLabels": false,
+    "forceConsistentCasingInFileNames": true,
+    "isolatedModules": true,
+    "moduleDetection": "force",
+    "noFallthroughCasesInSwitch": true,
+    "noImplicitOverride": true,
+    "noImplicitReturns": true,
+    "noUncheckedIndexedAccess": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "skipLibCheck": true,
+    "strict": true
+  }
+}

package/dist/oxfmt.d.mts

@@ -1,6 +1,6 @@
 import { OxfmtConfig } from "oxfmt";
 //#region src/oxfmt.d.ts
-declare function createOxfmtConfig(options?: OxfmtConfig): OxfmtConfig;
-declare const oxfmtConfig: OxfmtConfig;
+export declare function createOxfmtConfig(options?: OxfmtConfig): OxfmtConfig;
+export declare const oxfmtConfig: OxfmtConfig;
 //#endregion
-export { createOxfmtConfig, oxfmtConfig as default, oxfmtConfig };
+export { oxfmtConfig as default };

package/dist/oxfmt.mjs

@@ -1,10 +1,17 @@
 import ultracite from "ultracite/oxfmt";
 //#region src/oxfmt.ts
-const sharedIgnorePatterns = ["skills/**", "AGENTS.md"];
+const sharedIgnorePatterns = [
+	"skills/imported/**",
+	"skills/references/imported/**",
+	"skills/**/*.md",
+	"AGENTS.md",
+	"**/routeTree.gen.ts"
+];
 function createOxfmtConfig(options = {}) {
 	const { ignorePatterns = [], ...config } = options;
 	return {
 		...ultracite,
+		jsdoc: true,
 		printWidth: 100,
 		proseWrap: "preserve",
 		trailingComma: "none",

package/dist/oxlint.d.mts

@@ -1,12 +1,27 @@
 import { OxlintConfig } from "oxlint";
+//#region src/frameworks.d.ts
+declare const frameworkNames: readonly ["react", "react-doctor", "shadcn", "tanstack"];
+type Framework = (typeof frameworkNames)[number];
+/**
+ * Directories each framework preset lints, relative to the config's directory. `"."` covers the
+ * whole repository, and `false` declines a framework that a dependency would otherwise require.
+ */
+type FrameworkScopes = Partial<Record<Framework, false | readonly string[]>>;
+//#endregion
 //#region src/oxlint.d.ts
-interface CreateOxlintConfigOptions extends OxlintConfig {
+export interface CreateOxlintConfigOptions extends OxlintConfig {
+  /** Ultracite framework presets and the directories they lint. */
+  frameworks?: FrameworkScopes;
+  /**
+   * Directory holding the config, whose package manifests are checked for framework dependencies.
+   * Defaults to the nearest directory at or above the working directory that contains `.git`.
+   */
+  root?: string;
   /** Files receiving framework-neutral test policy, including test helpers. */
   testFiles?: readonly string[];
   /** Non-Vitest test files to exclude from the default Vitest preset. */
   vitestExcludeFiles?: readonly string[];
 }
-declare function createOxlintConfig(options?: CreateOxlintConfigOptions): OxlintConfig;
-declare const oxlintConfig: OxlintConfig;
+export declare function createOxlintConfig(options?: CreateOxlintConfigOptions): OxlintConfig;
 //#endregion
-export { CreateOxlintConfigOptions, createOxlintConfig, oxlintConfig as default, oxlintConfig };
+export type { Framework, FrameworkScopes };

package/dist/oxlint.mjs

@@ -1,19 +1,235 @@
+import { createRequire } from "node:module";
+import antiSlop from "ultracite/oxlint/anti-slop";
 import core from "ultracite/oxlint/core";
 import vitest from "ultracite/oxlint/vitest";
+import { existsSync, globSync, readFileSync } from "node:fs";
+import path from "node:path";
+import { selectJsPlugins } from "ultracite/oxlint/js-plugins";
+import react from "ultracite/oxlint/react";
+import shadcn from "ultracite/oxlint/shadcn";
+import tanstack from "ultracite/oxlint/tanstack";
+import tanstackReactDoctor from "ultracite/oxlint/tanstack/js-plugins";
+import { parse } from "yaml";
+import * as z from "zod";
+//#region src/frameworks.ts
+const frameworkNames = [
+	"react",
+	"react-doctor",
+	"shadcn",
+	"tanstack"
+];
+const frameworkPresets = {
+	react: {
+		jsPluginNamespaces: [],
+		presets: (directories) => [{
+			directories,
+			preset: react
+		}]
+	},
+	"react-doctor": {
+		jsPluginNamespaces: ["react-doctor"],
+		presets: (directories, scopes) => [{
+			directories,
+			preset: selectJsPlugins(["react-doctor"])
+		}, {
+			directories: overlap(directories, normalizeDirectories(scopes.tanstack)),
+			preset: tanstackReactDoctor
+		}]
+	},
+	shadcn: {
+		jsPluginNamespaces: ["shadcn"],
+		presets: (directories) => [{
+			directories,
+			preset: shadcn
+		}]
+	},
+	tanstack: {
+		jsPluginNamespaces: [],
+		presets: (directories) => [{
+			directories,
+			preset: tanstack
+		}]
+	}
+};
+const frameworkDependencies = /* @__PURE__ */ new Map([
+	["@shadcn/lint", {
+		coversPackage: false,
+		framework: "shadcn"
+	}],
+	["@tanstack/react-router", {
+		coversPackage: true,
+		framework: "tanstack"
+	}],
+	["@tanstack/react-start", {
+		coversPackage: true,
+		framework: "tanstack"
+	}],
+	["oxlint-plugin-react-doctor", {
+		coversPackage: false,
+		framework: "react-doctor"
+	}],
+	["react", {
+		coversPackage: true,
+		framework: "react"
+	}]
+]);
+const manifestSchema = z.object({
+	dependencies: z.record(z.string(), z.unknown()).optional(),
+	devDependencies: z.record(z.string(), z.unknown()).optional(),
+	peerDependencies: z.record(z.string(), z.unknown()).optional(),
+	workspaces: z.union([z.array(z.string()), z.object({ packages: z.array(z.string()).optional() })]).optional()
+});
+const pnpmWorkspaceSchema = z.object({ packages: z.array(z.string()).optional() }).nullable();
+/**
+* Returns the nearest directory at or above `start` that contains `.git`, or `start` when none
+* does. Vite+ evaluates the config with the invoking directory, which can be a subdirectory of the
+* repository, as the working directory.
+*/
+function findRepositoryRoot(start = process.cwd()) {
+	for (let directory = start;; directory = path.dirname(directory)) {
+		if (existsSync(path.join(directory, ".git"))) return directory;
+		if (path.dirname(directory) === directory) return start;
+	}
+}
+/** Throws when a package depends on a framework that `scopes` neither covers nor declines. */
+function checkFrameworkCoverage(root, scopes) {
+	const rootManifest = readManifest(root);
+	if (!rootManifest) return;
+	const problems = [".", ...workspaceDirectories(root, rootManifest)].flatMap((directory) => {
+		const manifestPath = directory === "." ? "package.json" : `${directory}/package.json`;
+		const location = directory === "." ? "the repository root" : directory;
+		return dependencyNames(readManifest(path.join(root, directory))).flatMap((dependency) => {
+			const signal = frameworkDependencies.get(dependency);
+			const scope = signal && scopes[signal.framework];
+			if (!signal || scope === false) return [];
+			if (!signal.coversPackage) return normalizeDirectories(scope).length === 0 ? [`${manifestPath} depends on ${dependency}, but frameworks["${signal.framework}"] lists no directories.`] : [];
+			return covers(scope ?? [], directory) ? [] : [`${manifestPath} depends on ${dependency}, but frameworks["${signal.framework}"] does not cover ${location}.`];
+		});
+	});
+	if (problems.length > 0) throw new Error([
+		"Framework presets do not cover these dependencies:",
+		...problems.map((problem) => `- ${problem}`),
+		"Set each framework to the directories it lints (\".\" for the whole repository), or to false to decline it."
+	].join("\n"));
+}
+/**
+* Applies framework presets. Repository-wide presets extend the config. Directory-scoped presets
+* become overrides, followed by a copy of the root `rules` for their plugins, because Oxlint
+* applies overrides after root rules.
+*/
+function resolveFrameworks(scopes, rules) {
+	const resolved = {
+		extends: [],
+		overrides: [],
+		settings: {}
+	};
+	for (const framework of frameworkNames) {
+		const directories = normalizeDirectories(scopes[framework]);
+		if (directories.length === 0) continue;
+		const { jsPluginNamespaces, presets } = frameworkPresets[framework];
+		const placed = presets(directories, scopes).filter((entry) => entry.directories.length > 0);
+		for (const { directories: presetDirectories, preset } of placed) {
+			resolved.settings = {
+				...resolved.settings,
+				...preset.settings
+			};
+			if (presetDirectories.includes(".")) resolved.extends.push(preset);
+			else resolved.overrides.push(...scopePreset(preset, presetDirectories));
+		}
+		const scoped = [...new Set(placed.flatMap((entry) => entry.directories.includes(".") ? [] : entry.directories))];
+		const plugins = placed.flatMap(({ preset }) => preset.plugins ?? []);
+		const namespaces = /* @__PURE__ */ new Set([...plugins, ...jsPluginNamespaces]);
+		const tuning = Object.entries(rules).filter(([rule]) => namespaces.has(rule.split("/")[0] ?? ""));
+		if (scoped.length > 0 && tuning.length > 0) resolved.overrides.push({
+			files: within(scoped, ["**"]),
+			plugins,
+			rules: Object.fromEntries(tuning)
+		});
+	}
+	return resolved;
+}
+function scopePreset(preset, directories) {
+	const scoped = { files: within(directories, ["**"]) };
+	if (preset.plugins) scoped.plugins = preset.plugins;
+	if (preset.jsPlugins) scoped.jsPlugins = preset.jsPlugins;
+	if (preset.rules) scoped.rules = preset.rules;
+	return [scoped, ...(preset.overrides ?? []).map((override) => {
+		const nested = {
+			...override,
+			files: within(directories, override.files)
+		};
+		if (override.excludeFiles) nested.excludeFiles = within(directories, override.excludeFiles);
+		return nested;
+	})];
+}
+function within(directories, globs) {
+	return directories.flatMap((directory) => globs.map((glob) => `${directory}/${glob}`));
+}
+function normalizeDirectories(scope) {
+	return (scope === false ? [] : scope ?? []).map((directory) => path.posix.normalize(directory).replace(/\/$/u, ""));
+}
+function covers(scope, directory) {
+	return normalizeDirectories(scope).some((scoped) => scoped === "." || directory === scoped || directory.startsWith(`${scoped}/`));
+}
+/** Returns the directories covered by both scopes, keeping the narrower directory of each pair. */
+function overlap(left, right) {
+	return [...new Set(left.flatMap((outer) => right.flatMap((inner) => {
+		if (covers([outer], inner)) return [inner];
+		return covers([inner], outer) ? [outer] : [];
+	})))];
+}
+function readManifest(directory) {
+	const file = path.join(directory, "package.json");
+	return existsSync(file) ? manifestSchema.parse(JSON.parse(readFileSync(file, "utf-8"))) : void 0;
+}
+function dependencyNames(manifest) {
+	return Object.keys({
+		...manifest?.dependencies,
+		...manifest?.devDependencies,
+		...manifest?.peerDependencies
+	});
+}
+function workspaceDirectories(root, manifest) {
+	const pnpmWorkspace = path.join(root, "pnpm-workspace.yaml");
+	const patterns = [...Array.isArray(manifest.workspaces) ? manifest.workspaces : manifest.workspaces?.packages ?? [], ...existsSync(pnpmWorkspace) ? pnpmWorkspaceSchema.parse(parse(readFileSync(pnpmWorkspace, "utf-8")))?.packages ?? [] : []];
+	const expand = (globs) => new Set(globs.flatMap((glob) => globSync(glob, { cwd: root })).map((match) => path.posix.normalize(match.split(path.sep).join("/"))));
+	const excluded = expand(patterns.filter((pattern) => pattern.startsWith("!")).map((pattern) => pattern.slice(1)));
+	return [...expand(patterns.filter((pattern) => !pattern.startsWith("!")))].filter((directory) => directory !== "." && !excluded.has(directory) && existsSync(path.join(root, directory, "package.json")));
+}
+//#endregion
 //#region src/oxlint.ts
-const defaultTestFiles = ["**/*.{test,spec}.{ts,tsx,js,jsx}", "**/__tests__/**/*.{ts,tsx,js,jsx}"];
+const localRequire = createRequire(import.meta.url);
+const jsdocPlugin = {
+	name: "jsdoc-js",
+	specifier: localRequire.resolve("eslint-plugin-jsdoc")
+};
+const perfectionistPlugin = {
+	name: "perfectionist",
+	specifier: localRequire.resolve("eslint-plugin-perfectionist")
+};
+const defaultTestFiles = [
+	"**/*.{test,spec}.{ts,tsx,js,jsx,mts,cts,mjs,cjs}",
+	"**/__tests__/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}",
+	"**/__mocks__/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}",
+	"**/{test,tests}/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"
+];
+const executableTestFiles = ["**/*.{test,spec}.{ts,tsx,js,jsx,mts,cts,mjs,cjs}"];
+const generatedFileIgnorePatterns = ["**/routeTree.gen.ts"];
 function createOxlintConfig(options = {}) {
-	const { extends: extensions = [], ignorePatterns = [], options: lintOptions = {}, overrides = [], rules = {}, testFiles = defaultTestFiles, vitestExcludeFiles = [], ...config } = options;
+	const { extends: extensions = [], frameworks = {}, ignorePatterns = [], jsPlugins = [], options: lintOptions = {}, overrides = [], root = findRepositoryRoot(), rules = {}, settings = {}, testFiles = defaultTestFiles, vitestExcludeFiles = [], ...config } = options;
+	checkFrameworkCoverage(root, frameworks);
+	const framework = resolveFrameworks(frameworks, rules);
 	const vitestOverrides = (vitest.overrides ?? []).map((override) => {
 		const excludeFiles = [...override.excludeFiles ?? [], ...vitestExcludeFiles];
-		return {
+		const resolvedOverride = {
 			...override,
-			...excludeFiles.length > 0 ? { excludeFiles } : {},
 			rules: {
 				...override.rules,
 				"vitest/max-expects": "off"
 			}
 		};
+		if (excludeFiles.length > 0) resolvedOverride.excludeFiles = excludeFiles;
+		return resolvedOverride;
 	});
 	const vitestConfig = {
 		...vitest,
@@ -23,42 +239,113 @@ function createOxlintConfig(options = {}) {
 		...config,
 		extends: [
 			core,
+			antiSlop,
 			vitestConfig,
+			...framework.extends,
 			...extensions
 		],
-		ignorePatterns: [...core.ignorePatterns ?? [], ...ignorePatterns],
+		ignorePatterns: [
+			...core.ignorePatterns ?? [],
+			...generatedFileIgnorePatterns,
+			...ignorePatterns
+		],
+		jsPlugins: [
+			jsdocPlugin,
+			perfectionistPlugin,
+			...jsPlugins ?? []
+		],
 		options: {
 			typeAware: true,
 			typeCheck: true,
 			...lintOptions
 		},
 		overrides: [
+			{
+				files: executableTestFiles,
+				rules: { complexity: "off" }
+			},
 			{
 				files: [...testFiles],
-				rules: { "no-await-in-loop": "off" }
+				rules: {
+					"no-await-in-loop": "off",
+					"no-console": "off",
+					"no-inline-comments": "off",
+					"no-script-url": "off",
+					"node/no-process-env": "off",
+					"require-await": "off",
+					"typescript/no-dynamic-delete": "off",
+					"typescript/no-unsafe-type-assertion": "off",
+					"typescript/restrict-template-expressions": "off",
+					"typescript/unbound-method": "off",
+					"unicorn/consistent-function-scoping": "off",
+					"unicorn/no-object-as-default-parameter": "off"
+				}
+			},
+			{
+				files: ["**/skills/**"],
+				rules: { "node/no-process-env": "off" }
 			},
 			{
 				files: ["**/*.{ts,tsx}"],
 				rules: { "unicorn/no-useless-undefined": ["error", { checkArguments: false }] }
 			},
+			...framework.overrides,
 			...overrides
 		],
 		rules: {
+			"anti-slop/no-array-filter-map": "off",
+			"anti-slop/no-conditional-empty-object-spread": "off",
+			"class-methods-use-this": "off",
+			eqeqeq: ["error", "smart"],
 			"func-style": "off",
+			"jsdoc-js/no-undefined-types": "error",
+			"max-classes-per-file": "off",
+			"no-console": "error",
+			"no-eq-null": "off",
+			"no-negated-condition": "off",
 			"no-nested-ternary": "off",
-			"no-use-before-define": ["error", { functions: false }],
+			"no-use-before-define": ["error", {
+				classes: false,
+				functions: false,
+				variables: false
+			}],
 			"no-warning-comments": "off",
+			"node/no-process-env": "error",
+			"perfectionist/sort-enums": ["error", {
+				partitionByComment: true,
+				sortByValue: "always"
+			}],
+			"perfectionist/sort-heritage-clauses": "error",
+			"perfectionist/sort-interfaces": "error",
+			"perfectionist/sort-jsx-props": "error",
+			"perfectionist/sort-object-types": "error",
+			"perfectionist/sort-objects": ["error", { partitionByComment: true }],
 			"prefer-regex-literals": "off",
 			"promise/avoid-new": "off",
 			"promise/prefer-await-to-callbacks": "off",
 			"promise/prefer-await-to-then": "off",
+			"sort-keys": "off",
+			"typescript/consistent-return": "off",
+			"typescript/explicit-module-boundary-types": "off",
+			"typescript/no-extraneous-class": ["error", { allowWithDecorator: true }],
+			"typescript/parameter-properties": "off",
+			"typescript/prefer-nullish-coalescing": ["error", { ignorePrimitives: { string: true } }],
 			"typescript/promise-function-async": "off",
-			"typescript/return-await": ["error", "in-try-catch"],
+			"typescript/strict-boolean-expressions": ["error", {
+				allowNullableBoolean: true,
+				allowNullableObject: true,
+				allowNullableString: true
+			}],
+			"unicorn/no-array-reduce": "off",
+			"unicorn/no-negated-condition": "off",
 			"unicorn/no-nested-ternary": "off",
 			...rules
+		},
+		settings: {
+			...framework.settings,
+			...settings
 		}
 	};
 }
-const oxlintConfig = createOxlintConfig();
 //#endregion
-export { createOxlintConfig, oxlintConfig as default, oxlintConfig };
+export { createOxlintConfig };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@monke-together-strong/oxc-config",
-  "version": "0.1.1",
-  "description": "Shared Oxlint and Oxfmt presets.",
+  "version": "0.4.0",
+  "description": "Shared TypeScript, Oxlint, and Oxfmt presets.",
   "homepage": "https://github.com/monke-together-strong/monke-tools/tree/main/packages/oxc-config#readme",
   "bugs": {
     "url": "https://github.com/monke-together-strong/monke-tools/issues"
@@ -13,12 +13,14 @@
     "directory": "packages/oxc-config"
   },
   "files": [
+    "base.json",
     "dist",
     "LICENSE",
     "README.md"
   ],
   "type": "module",
   "exports": {
+    "./base.json": "./base.json",
     "./oxfmt": {
       "types": "./dist/oxfmt.d.mts",
       "import": "./dist/oxfmt.mjs"
@@ -35,15 +37,19 @@
     "prepack": "vp pack"
   },
   "dependencies": {
-    "ultracite": "7.9.4"
+    "eslint-plugin-jsdoc": "63.3.3",
+    "eslint-plugin-perfectionist": "5.10.1",
+    "ultracite": "8.0.1",
+    "yaml": "^2.8.3",
+    "zod": "^4.5.4"
   },
   "devDependencies": {
-    "oxfmt": "0.60.0",
-    "oxlint": "1.75.0"
+    "oxfmt": "0.73.0",
+    "oxlint": "1.88.0"
   },
   "peerDependencies": {
-    "oxfmt": "^0.60.0",
-    "oxlint": "^1.75.0",
-    "oxlint-tsgolint": ">=7.0.2001"
+    "oxfmt": ">=0.71.0 <1",
+    "oxlint": "^1.86.0",
+    "oxlint-tsgolint": ">=7.0.2004"
   }
 }