golar 0.0.17 → 0.1.0

package/dist/addon.js

@@ -0,0 +1,16 @@
+import process from "node:process";
+import os from "node:os";
+import worker_threads from "node:worker_threads";
+import url from "node:url";
+
+//#region src/addon.ts
+const addonModule = { exports: {} };
+const golarAddonPath = url.fileURLToPath(import.meta.resolve(`@golar/${process.platform}-${process.arch}/golar.node`));
+process.dlopen(addonModule, golarAddonPath, os.constants.dlopen.RTLD_NOW | os.constants.dlopen.RTLD_GLOBAL);
+const { exports: addon } = addonModule;
+const syncBuf = /* @__PURE__ */ new ArrayBuffer(10 * 1024 * 1024);
+const syncView = new DataView(syncBuf);
+addon.setSyncBuffer(worker_threads.threadId, syncBuf);
+
+//#endregion
+export { addon, golarAddonPath, syncBuf, syncView };

package/dist/bin.d.ts

@@ -0,0 +1 @@
+export { };

package/dist/bin.js

@@ -1,45 +1,125 @@
 #!/usr/bin/env node
+import { addon, syncBuf, syncView } from "./addon.js";
+import { JsCodegenPlugin, globalState } from "./codegen-plugin.js";
+import { loadConfig, resolveConfig } from "./config.js";
+import { Workspace } from "./workspace.js";
+import { styleText } from "./utils.js";
 import process from "node:process";
-import fs from "node:fs/promises";
-import child_process from "node:child_process";
+import os from "node:os";
 import path from "node:path";
-import { fileURLToPath } from "node:url";
+import assert from "node:assert/strict";
+import worker_threads from "node:worker_threads";
+import fs from "node:fs";
 
 //#region src/bin.ts
-const plugins = /* @__PURE__ */ new Map();
-const filename = import.meta.filename.replaceAll("\\", "/");
-await Promise.all(filename.matchAll(/\/node_modules\//g).map(async (nodeModulesMatch) => {
-	const nodeModulesPath = filename.slice(0, nodeModulesMatch.index + nodeModulesMatch[0].length);
-	for (const orgName of await fs.readdir(nodeModulesPath)) {
-		if (!orgName.startsWith("@")) continue;
-		for (const packageName of await fs.readdir(path.join(nodeModulesPath, orgName))) {
-			if ((orgName !== "@golar" || ![
-				"astro",
-				"ember",
-				"svelte",
-				"vue"
-			].includes(packageName)) && !/^golar-plugin(-.+)?$/.exec(packageName)) continue;
-			const packageSpecifier = `${orgName}/${packageName}`;
-			const mod = await import(`${packageSpecifier}/golar-entry`);
-			if (typeof mod.getGolarEntry !== "function") continue;
-			plugins.set(packageSpecifier, await mod.getGolarEntry());
+const argv = process.argv.slice(2);
+const cwd = process.cwd();
+const configPath = path.join(cwd, "golar.config.ts");
+if (argv[0] === "--help") {
+	console.log(`
+Usage: golar [command]
+
+Commands:
+  golar                    Lint and typecheck the current workspace (recommended)
+  golar lint               Run lint checks only
+  golar typecheck          Run typechecking only
+  golar tsc [tsc args...]  Forward arguments to TypeScript CLI
+
+Options:
+  --help                   Show this help message
+  --version                Print Golar version`);
+	process.exit(0);
+} else if (argv[0] === "--version") {
+	const { default: { version } } = await import("../package.json", { with: { type: "json" } });
+	console.log(`Golar version ${version}`);
+	process.exit(0);
+}
+if (!fs.existsSync(configPath)) {
+	console.log(`${styleText("red", "Error:")} ./golar.config.ts not found`);
+	process.exit(1);
+}
+console.log(`${styleText("dim", "Using config from")} ./golar.config.ts${styleText("dim", "...")}`);
+const config = await loadConfig(configPath);
+const hasJsCodegenPlugins = globalState.codegenPlugins.values().some((v) => v instanceof JsCodegenPlugin);
+const selfExtname = path.extname(import.meta.filename);
+const workerPath = path.join(import.meta.dirname, `worker${selfExtname}`);
+const textEncoder = new TextEncoder();
+if (argv[0] === "tsc") {
+	for (const plugin of globalState.codegenPlugins.values()) plugin.register();
+	const args = argv.slice(1);
+	let offset = 0;
+	syncView.setUint32(offset, args.length, true);
+	offset += 4;
+	for (const arg of args) {
+		const { written: argLen } = textEncoder.encodeInto(arg, new Uint8Array(syncBuf, offset + 4));
+		syncView.setUint32(offset, argLen, true);
+		offset += 4 + argLen;
+	}
+	addon.tsc(worker_threads.threadId, (exitCode) => process.exit(exitCode));
+	if (hasJsCodegenPlugins) {
+		worker_threads.setEnvironmentData("golar-env", {
+			configPath,
+			cwd,
+			mode: "codegen-only"
+		});
+		const workersCount = Math.floor(Math.max(Math.min(os.availableParallelism() / 2, 4), 1)) - 1;
+		const promises = [];
+		for (let i = 0; i < workersCount; i++) {
+			const w = new worker_threads.Worker(workerPath);
+			promises.push(new Promise((resolve) => w.once("message", resolve)));
 		}
+		await Promise.all(promises);
+	}
+} else {
+	const lintOnly = argv[0] === "lint";
+	const typecheckOnly = argv[0] === "typecheck";
+	if (!lintOnly && !typecheckOnly && [
+		"--noEmit",
+		"-b",
+		"--build",
+		"--declaration",
+		"--emitDeclarationOnly"
+	].some((flag) => argv.includes(flag))) {
+		let message = `${styleText("red", "Error:")} Golar v0.1+ doesn't support passing tsc flags to the root subcommand.\n`;
+		if (argv.includes("--declaration") || argv.includes("--emitDeclarationOnly")) message += `Instead, run: ${styleText("bold", `golar ${styleText("green", "tsc")} ${argv.join(" ")}`)}`;
+		else message += `Instead, run ${styleText("bold", "golar")} without any arguments.`;
+		console.log(message);
+		process.exit(1);
 	}
-}));
-const exePath = fileURLToPath(import.meta.resolve(`@golar/${process.platform}-${process.arch}/golar${process.platform === "win32" ? ".exe" : ""}`));
-try {
-	child_process.execFileSync(exePath, process.argv.slice(2), {
-		env: {
-			GOLAR_PLUGINS: Array.from(plugins.values().map((args) => args.join(""))).join(""),
-			...process.env
-		},
-		stdio: "inherit"
-	});
-} catch (e) {
-	if (e instanceof Error) {
-		if ("status" in e && typeof e.status === "number") process.exit(e.status);
+	for (const plugin of globalState.codegenPlugins.values()) plugin.register();
+	const { files, builtinRulesByFile, nativeRulesByFile, jsFilesByWorker, jsRulesByFile, typecheckFiles } = resolveConfig(cwd, config);
+	const { meta, workspace: wsPromise } = await Workspace.create(cwd, files);
+	const ws = await wsPromise;
+	if (!typecheckOnly) {
+		ws.lintBuiltin(builtinRulesByFile);
+		ws.lintNative(nativeRulesByFile, path.dirname(configPath));
+		const promises = [];
+		if (jsRulesByFile.size > 0) {
+			worker_threads.setEnvironmentData("golar-env", {
+				configPath,
+				cwd,
+				mode: "lint"
+			});
+			jsFilesByWorker.slice(0, -1).map((workerFiles) => {
+				const worker = new worker_threads.Worker(workerPath);
+				promises.push(new Promise((resolve) => worker.once("message", resolve)));
+				worker.postMessage({
+					meta,
+					jsFiles: workerFiles
+				});
+				return worker;
+			});
+		}
+		if (jsRulesByFile.size > 0) {
+			const mainJsFiles = jsFilesByWorker.at(-1);
+			assert.ok(mainJsFiles);
+			ws.preloadRequestedFiles(mainJsFiles);
+			ws.lintJs(new Map(mainJsFiles.map((file) => [file, Array.from(jsRulesByFile.get(file).values())])));
+		}
+		await Promise.all(promises);
 	}
-	throw e;
+	if (!lintOnly) process.exit(ws.typecheck(typecheckFiles));
+	process.exit(0);
 }
 
 //#endregion

package/dist/builtin-rules.d.ts

@@ -0,0 +1,10 @@
+import { input } from "./node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/core/core.js";
+import { ZodObject } from "./node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+import { GolarBrand } from "./internal/linter/rule-creator.js";
+import { LintConfiguredRule } from "./config.js";
+import { rules as rules$1 } from "./builtin-rules.generated.js";
+
+//#region src/builtin-rules.d.ts
+declare const rules: (configs: { [TRule in keyof typeof rules$1]?: true | undefined | input<ZodObject<(typeof rules$1)[TRule][typeof GolarBrand]['options']>> }) => LintConfiguredRule[];
+//#endregion
+export { rules };

package/dist/builtin-rules.generated.d.ts

@@ -0,0 +1,12 @@
+import { ZodBoolean, ZodDefault } from "./node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+import { RuleDefinition } from "./internal/linter/rule-creator.js";
+
+//#region src/builtin-rules.generated.d.ts
+declare const rules: {
+  readonly 'explicit-anys': RuleDefinition<{
+    fixToUnknown: ZodDefault<ZodBoolean>;
+    ignoreRestArgs: ZodDefault<ZodBoolean>;
+  }>;
+};
+//#endregion
+export { rules };

package/dist/builtin-rules.generated.js

@@ -0,0 +1,7 @@
+import { rule } from "./internal/linter/rules/explicit-anys/config.js";
+
+//#region src/builtin-rules.generated.ts
+const rules = { "explicit-anys": rule };
+
+//#endregion
+export { rules };

package/dist/builtin-rules.js

@@ -0,0 +1,10 @@
+import { rules as rules$1 } from "./builtin-rules.generated.js";
+
+//#region src/builtin-rules.ts
+const rules = (configs) => Object.entries(configs).map(([name, config]) => ({
+	rule: rules$1[name],
+	options: config === true ? {} : config
+}));
+
+//#endregion
+export { rules };

package/dist/codegen-plugin.d.ts

@@ -0,0 +1,78 @@
+//#region src/codegen-plugin.d.ts
+type FileExtension = {
+  /** Include the leading dot, e.g. '.vue'. */extension: string;
+  stripFromDeclarationFileName: boolean;
+  allowExtensionlessImports: boolean;
+};
+type Promisable<T> = T | Promise<T>;
+type CodegenMapping = {
+  sourceOffset: number;
+  serviceOffset: number;
+  sourceLength: number;
+  serviceLength?: number | undefined;
+  suppressedDiagnostics?: number[] | undefined;
+};
+type IgnoreDirectiveCodegenMapping = {
+  serviceOffset: number;
+  serviceLength: number;
+};
+type ExpectErrorDirectiveCodegenMapping = {
+  sourceOffset: number;
+  serviceOffset: number;
+  sourceLength: number;
+  serviceLength: number;
+};
+type CodegenScriptKind = 'js' | 'jsx' | 'ts' | 'tsx';
+type ServiceCodeError = {
+  message: string;
+  start: number;
+  end: number;
+};
+type ServiceCode = {
+  mappings: CodegenMapping[];
+  errors?: never;
+  serviceText: string;
+  scriptKind: CodegenScriptKind; /** @default false */
+  declarationFile?: boolean | undefined;
+  ignoreMappings?: IgnoreDirectiveCodegenMapping[] | undefined;
+  expectErrorMappings?: ExpectErrorDirectiveCodegenMapping[] | undefined;
+  ignoreNotMappedDiagnostics?: boolean | undefined;
+} | {
+  mappings?: never;
+  errors: ServiceCodeError[];
+};
+type CodegenPlugin = JsCodegenPlugin | IpcCodegenPlugin;
+declare const globalState: {
+  codegenPlugins: Map<string, CodegenPlugin>;
+};
+type CreateServiceCodeFn = (cwd: string, configFileName: string | null, fileName: string, sourceText: string) => Promisable<ServiceCode>;
+type JsCodegenPluginOptions = {
+  id: string;
+  extensions: FileExtension[];
+  createServiceCode: CreateServiceCodeFn;
+};
+declare class JsCodegenPlugin {
+  readonly id: string;
+  readonly idNumeric: number;
+  readonly extensions: FileExtension[];
+  readonly createServiceCode: CreateServiceCodeFn;
+  static pluginIdCounter: number;
+  constructor(opts: JsCodegenPluginOptions);
+  register(): void;
+  executeCreateServiceCode(): Promise<void>;
+  private processCreatedServiceCode;
+}
+type IpcCodegenPluginOptions = {
+  id: string;
+  cmd: readonly string[];
+  extensions: FileExtension[];
+};
+declare class IpcCodegenPlugin {
+  readonly id: string;
+  readonly cmd: readonly string[];
+  readonly extensions: FileExtension[];
+  constructor(opts: IpcCodegenPluginOptions);
+  register(): void;
+}
+//#endregion
+export { CodegenMapping, CodegenPlugin, CodegenScriptKind, CreateServiceCodeFn, ExpectErrorDirectiveCodegenMapping, FileExtension, IgnoreDirectiveCodegenMapping, IpcCodegenPlugin, IpcCodegenPluginOptions, JsCodegenPlugin, JsCodegenPluginOptions, Promisable, ServiceCode, ServiceCodeError, globalState };

package/dist/codegen-plugin.js

@@ -0,0 +1,187 @@
+import { addon, syncBuf, syncView } from "./addon.js";
+import os from "node:os";
+import worker_threads from "node:worker_threads";
+
+//#region src/codegen-plugin.ts
+const textDecoder = new TextDecoder();
+const textEncoder = new TextEncoder();
+const SERVICE_CODE_PROPERTIES = {
+	ERROR: 1,
+	DECLARATION_FILE: 2,
+	IGNORE_NOT_MAPPED_DIAGNOSTICS: 4
+};
+const SCRIPT_KIND = {
+	js: 0,
+	jsx: 1,
+	ts: 2,
+	tsx: 3
+};
+const stateSymbol = Symbol.for("golar-global-state");
+const globalTyped = globalThis;
+const globalState = globalTyped[stateSymbol] ??= { codegenPlugins: /* @__PURE__ */ new Map() };
+function registerCodegenPlugin(plugin) {
+	if (globalState.codegenPlugins.get(plugin.id)) throw new Error(`Duplicate ${plugin.id} codegen plugin`);
+	globalState.codegenPlugins.set(plugin.id, plugin);
+}
+var JsCodegenPlugin = class JsCodegenPlugin {
+	id;
+	idNumeric;
+	extensions;
+	createServiceCode;
+	static pluginIdCounter = 0;
+	constructor(opts) {
+		this.id = opts.id;
+		this.idNumeric = JsCodegenPlugin.pluginIdCounter++;
+		this.extensions = opts.extensions;
+		this.createServiceCode = opts.createServiceCode;
+		registerCodegenPlugin(this);
+	}
+	register() {
+		let offset = 0;
+		syncView.setUint32(offset, this.idNumeric, true);
+		offset += 4;
+		const { written: initializationLen } = textEncoder.encodeInto(JSON.stringify({ extensions: this.extensions }), new Uint8Array(syncBuf, offset + 4));
+		syncView.setUint32(offset, initializationLen, true);
+		offset += 4 + initializationLen;
+		addon.registerJsCodegen(worker_threads.threadId, () => this.executeCreateServiceCode());
+	}
+	async executeCreateServiceCode() {
+		let offset = 0;
+		const codegenPluginPtr = syncView.getBigUint64(offset, true);
+		offset += 8;
+		const cwdLen = syncView.getUint32(offset, true);
+		const cwd = textDecoder.decode(new Uint8Array(syncBuf, offset += 4, cwdLen));
+		offset += cwdLen;
+		const configFileNameLen = syncView.getUint32(offset, true);
+		const configFileName = textDecoder.decode(new Uint8Array(syncBuf, offset += 4, configFileNameLen));
+		offset += configFileNameLen;
+		const fileNameLen = syncView.getUint32(offset, true);
+		const fileName = textDecoder.decode(new Uint8Array(syncBuf, offset += 4, fileNameLen));
+		offset += fileNameLen;
+		const sourceTextLen = syncView.getUint32(offset, true);
+		const sourceText = textDecoder.decode(new Uint8Array(syncBuf, offset += 4, sourceTextLen));
+		offset += sourceTextLen;
+		const resp = this.createServiceCode(cwd, configFileName === "/dev/null/inferred" ? null : configFileName, fileName, sourceText);
+		if (resp instanceof Promise) return resp.then((resp) => this.processCreatedServiceCode(sourceText, codegenPluginPtr, resp));
+		return this.processCreatedServiceCode(sourceText, codegenPluginPtr, resp);
+	}
+	processCreatedServiceCode(sourceText, codegenPluginPtr, resp) {
+		let offset = 0;
+		let properties = 0;
+		if ("errors" in resp) {
+			const errorLocationsUtf8 = mapIndicesToUtf8(sourceText, resp.errors[Symbol.iterator]().flatMap((e) => [e.start, e.end]));
+			syncView.setBigUint64(offset, codegenPluginPtr, true);
+			syncView.setUint8(offset += 8, properties | SERVICE_CODE_PROPERTIES.ERROR);
+			syncView.setUint32(offset += 1, resp.errors.length, true);
+			offset += 4;
+			for (const err of resp.errors) {
+				const { written: msgLen } = textEncoder.encodeInto(err.message, new Uint8Array(syncBuf, offset + 4));
+				syncView.setUint32(offset, msgLen, true);
+				offset += 4 + msgLen;
+				syncView.setUint32(offset, errorLocationsUtf8(err.start), true);
+				syncView.setUint32(offset += 4, errorLocationsUtf8(err.end), true);
+				offset += 4;
+			}
+			return;
+		}
+		if (resp.declarationFile) properties |= SERVICE_CODE_PROPERTIES.DECLARATION_FILE;
+		if (resp.ignoreNotMappedDiagnostics) properties |= SERVICE_CODE_PROPERTIES.IGNORE_NOT_MAPPED_DIAGNOSTICS;
+		const writeUint32 = os.endianness() === "LE" ? (offset, value) => syncView.setUint32(offset, value, true) : (offset, value) => syncView.setUint32(offset, value, false);
+		syncView.setBigUint64(offset, codegenPluginPtr, true);
+		syncView.setUint8(offset += 8, properties);
+		syncView.setUint8(offset += 1, SCRIPT_KIND[resp.scriptKind]);
+		offset += 1;
+		const { written: serviceTextLen } = textEncoder.encodeInto(resp.serviceText, new Uint8Array(syncBuf, offset + 4));
+		syncView.setUint32(offset, serviceTextLen, true);
+		offset += 4 + serviceTextLen;
+		const sourceIndicesUtf8 = mapIndicesToUtf8(sourceText, (function* () {
+			for (const m of resp.mappings) {
+				yield m.sourceOffset;
+				yield m.sourceOffset + m.sourceLength;
+			}
+			for (const m of resp.expectErrorMappings ?? []) {
+				yield m.sourceOffset;
+				yield m.sourceOffset + m.sourceLength;
+			}
+		})());
+		const serviceIndicesUtf8 = mapIndicesToUtf8(resp.serviceText, (function* () {
+			for (const m of resp.mappings) {
+				yield m.serviceOffset;
+				yield m.serviceOffset + (m.serviceLength ?? m.sourceLength);
+			}
+			for (const m of resp.ignoreMappings ?? []) {
+				yield m.serviceOffset;
+				yield m.serviceOffset + m.serviceLength;
+			}
+			for (const m of resp.expectErrorMappings ?? []) {
+				yield m.serviceOffset;
+				yield m.serviceOffset + m.serviceLength;
+			}
+		})());
+		syncView.setUint32(offset, resp.mappings.length, true);
+		offset += 4;
+		for (const m of resp.mappings) {
+			const sourceOffsetUtf8 = sourceIndicesUtf8(m.sourceOffset);
+			const serviceOffsetUtf8 = serviceIndicesUtf8(m.serviceOffset);
+			writeUint32(offset, sourceOffsetUtf8);
+			writeUint32(offset += 4, serviceOffsetUtf8);
+			writeUint32(offset += 4, sourceIndicesUtf8(m.sourceOffset + m.sourceLength) - sourceOffsetUtf8);
+			writeUint32(offset += 4, serviceIndicesUtf8(m.serviceOffset + (m.serviceLength ?? m.sourceLength)) - serviceOffsetUtf8);
+			const suppressedDiagnostics = m.suppressedDiagnostics ?? [];
+			writeUint32(offset += 4, suppressedDiagnostics.length);
+			offset += 4;
+			for (const code of suppressedDiagnostics) {
+				writeUint32(offset, code);
+				offset += 4;
+			}
+		}
+		syncView.setUint32(offset, resp.ignoreMappings?.length ?? 0, true);
+		offset += 4;
+		for (const m of resp.ignoreMappings ?? []) {
+			const serviceOffsetUtf8 = serviceIndicesUtf8(m.serviceOffset);
+			writeUint32(offset, serviceOffsetUtf8);
+			writeUint32(offset += 4, serviceIndicesUtf8(m.serviceOffset + m.serviceLength) - serviceOffsetUtf8);
+			offset += 4;
+		}
+		syncView.setUint32(offset, resp.expectErrorMappings?.length ?? 0, true);
+		offset += 4;
+		for (const m of resp.expectErrorMappings ?? []) {
+			const sourceOffsetUtf8 = sourceIndicesUtf8(m.sourceOffset);
+			const serviceOffsetUtf8 = serviceIndicesUtf8(m.serviceOffset);
+			writeUint32(offset, sourceOffsetUtf8);
+			writeUint32(offset += 4, serviceOffsetUtf8);
+			writeUint32(offset += 4, sourceIndicesUtf8(m.sourceOffset + m.sourceLength) - sourceOffsetUtf8);
+			writeUint32(offset += 4, serviceIndicesUtf8(m.serviceOffset + m.serviceLength) - serviceOffsetUtf8);
+			offset += 4;
+		}
+	}
+};
+var IpcCodegenPlugin = class {
+	id;
+	cmd;
+	extensions;
+	constructor(opts) {
+		this.id = opts.id;
+		this.cmd = opts.cmd;
+		this.extensions = opts.extensions;
+		registerCodegenPlugin(this);
+	}
+	register() {
+		const { written: initializationLen } = textEncoder.encodeInto(JSON.stringify({
+			cmd: this.cmd,
+			extensions: this.extensions
+		}), new Uint8Array(syncBuf, 4));
+		syncView.setUint32(0, initializationLen, true);
+		addon.registerIpcCodegen();
+	}
+};
+function mapIndicesToUtf8(text, indices) {
+	const mapped = /* @__PURE__ */ new Map();
+	const sorted = Array.from(new Set(indices)).sort((a, b) => a - b);
+	let utf8Offset = 0;
+	for (const [i, idx] of sorted.entries()) mapped.set(idx, utf8Offset += Buffer.byteLength(text.slice(sorted[i - 1] ?? 0, idx)));
+	return mapped.get.bind(mapped);
+}
+
+//#endregion
+export { IpcCodegenPlugin, JsCodegenPlugin, globalState };

package/dist/config.d.ts

@@ -0,0 +1,33 @@
+import { GolarBrand } from "./internal/linter/rule-creator.js";
+
+//#region src/config.d.ts
+type LintConfiguredRule = {
+  [GolarBrand]: {
+    rule: true;
+  };
+};
+type LintConfigUseDefinition = {
+  files: string[];
+  rules: LintConfiguredRule[];
+};
+type Config = {
+  lint?: {
+    use: LintConfigUseDefinition[];
+  } | undefined;
+  typecheck?: {
+    include: string[];
+    exclude?: string[] | undefined;
+  };
+};
+declare function defineConfig(config: Config): Config;
+declare function loadConfig(configPath: string): Promise<Config>;
+declare function resolveConfig(cwd: string, config: Config): {
+  files: string[];
+  builtinRulesByFile: Map<string, LintConfiguredRule[]>;
+  jsFilesByWorker: string[][];
+  jsRulesByFile: Map<string, Map<any, LintConfiguredRule>>;
+  nativeRulesByFile: Map<string, LintConfiguredRule[]>;
+  typecheckFiles: string[];
+};
+//#endregion
+export { Config, LintConfigUseDefinition, LintConfiguredRule, defineConfig, loadConfig, resolveConfig };

package/dist/config.js

@@ -0,0 +1,71 @@
+import { globalState } from "./codegen-plugin.js";
+import path from "node:path";
+import fs from "node:fs";
+import url from "node:url";
+import util from "node:util";
+import { Debug } from "@golar/util";
+
+//#region src/config.ts
+const debug = Debug.create("config");
+function defineConfig(config) {
+	return config;
+}
+async function loadConfig(configPath) {
+	const { default: config } = await import(url.pathToFileURL(configPath).href);
+	return config;
+}
+function resolveConfig(cwd, config) {
+	const allFiles = /* @__PURE__ */ new Set();
+	const builtinEffectiveRulesByFile = /* @__PURE__ */ new Map();
+	const jsEffectiveRulesByFile = /* @__PURE__ */ new Map();
+	const nativeEffectiveRulesByFile = /* @__PURE__ */ new Map();
+	for (const group of config.lint?.use ?? []) for (const file of new Set(fs.globSync(group.files, {
+		cwd,
+		withFileTypes: true
+	}).filter((entry) => entry.isFile()).map((entry) => path.resolve(cwd, entry.parentPath, entry.name)))) {
+		allFiles.add(file);
+		for (const rule of group.rules) {
+			let rulesByFile;
+			if (rule.rule.isBuiltin) rulesByFile = builtinEffectiveRulesByFile;
+			else if (rule.rule.isCustomJs) rulesByFile = jsEffectiveRulesByFile;
+			else if (rule.rule.isNative) rulesByFile = nativeEffectiveRulesByFile;
+			else throw new Error(`Invalid rule: ${util.inspect(rule)}`);
+			let effectiveRules = rulesByFile.get(file);
+			if (effectiveRules == null) rulesByFile.set(file, effectiveRules = /* @__PURE__ */ new Map());
+			effectiveRules.set(rule.rule, rule);
+		}
+	}
+	const builtinRulesByFile = new Map(builtinEffectiveRulesByFile.entries().map(([file, rulesById]) => [file, Array.from(rulesById.values())]));
+	const jsFiles = Array.from(jsEffectiveRulesByFile.keys());
+	const jsWorkersCount = Math.min(jsFiles.length, 4);
+	const jsFilesPerThread = Math.ceil(jsFiles.length / jsWorkersCount);
+	const jsEffectiveRulesIter = jsEffectiveRulesByFile.keys();
+	const jsFilesByWorker = Array(jsWorkersCount).fill(null).map(() => Array.from(jsEffectiveRulesIter.take(jsFilesPerThread)));
+	const nativeRulesByFile = new Map(nativeEffectiveRulesByFile.entries().map(([file, rulesById]) => [file, Array.from(rulesById.values())]));
+	let typecheckFiles = null;
+	const typecheckInclude = config.typecheck == null ? ["**/*.{ts,tsx}", ...globalState.codegenPlugins.values().flatMap((plugin) => plugin.extensions).map(({ extension }) => `**/*${extension}`).toArray()] : config.typecheck.include;
+	const typecheckExclude = [
+		...config.typecheck?.exclude ?? [],
+		"**/node_modules",
+		"**/.git",
+		"**/.jj"
+	];
+	typecheckFiles = fs.globSync(typecheckInclude, {
+		cwd,
+		exclude: typecheckExclude,
+		withFileTypes: true
+	}).filter((entry) => entry.isFile()).map((entry) => path.resolve(cwd, entry.parentPath, entry.name));
+	for (const file of typecheckFiles) allFiles.add(file);
+	debug.print("typecheck files:\n" + typecheckFiles.join("\n"));
+	return {
+		files: Array.from(allFiles),
+		builtinRulesByFile,
+		jsFilesByWorker,
+		jsRulesByFile: jsEffectiveRulesByFile,
+		nativeRulesByFile,
+		typecheckFiles
+	};
+}
+
+//#endregion
+export { defineConfig, loadConfig, resolveConfig };

package/dist/internal/linter/rule-creator.d.ts

@@ -0,0 +1,11 @@
+import { ZodDefault } from "../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+
+//#region ../../internal/linter/rule-creator.d.ts
+declare const GolarBrand: unique symbol;
+type RuleDefinition<TOptions extends Record<string, ZodDefault>> = {
+  [GolarBrand]: {
+    options: TOptions;
+  };
+};
+//#endregion
+export { GolarBrand, RuleDefinition };

package/dist/internal/linter/rule-creator.js

@@ -0,0 +1,46 @@
+import { array, discriminatedUnion, literal, strictObject, string, union } from "../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+import path from "node:path";
+
+//#region ../../internal/linter/rule-creator.ts
+function ruleConfig(config) {
+	return {
+		...config,
+		isBuiltin: true,
+		name: path.basename(config.dirname)
+	};
+}
+const typeOrValueSpecifier = array(discriminatedUnion("from", [
+	strictObject({
+		from: literal("file"),
+		name: union([string(), array(string())]),
+		path: string().optional()
+	}),
+	strictObject({
+		from: literal("lib"),
+		name: union([string(), array(string())])
+	}),
+	strictObject({
+		from: literal("package"),
+		name: union([string(), array(string())]),
+		package: string()
+	})
+]).transform((v) => {
+	const res = {
+		from: v.from,
+		name: Array.isArray(v.name) ? v.name : [v.name]
+	};
+	switch (v.from) {
+		case "file": return {
+			...res,
+			filePath: v.path ?? ""
+		};
+		case "lib": return res;
+		case "package": return {
+			...res,
+			package: v.package ?? ""
+		};
+	}
+}));
+
+//#endregion
+export { ruleConfig };

package/dist/internal/linter/rules/explicit-anys/config.js

@@ -0,0 +1,14 @@
+import { boolean } from "../../../../node_modules/.pnpm/zod@4.3.6/node_modules/zod/v4/classic/schemas.js";
+import { ruleConfig } from "../../rule-creator.js";
+
+//#region ../../internal/linter/rules/explicit-anys/config.ts
+const rule = ruleConfig({
+	dirname: import.meta.dirname,
+	options: {
+		fixToUnknown: boolean().default(false).describe("Whether to enable auto-fixing in which the `any` type is converted to the `unknown` type."),
+		ignoreRestArgs: boolean().default(false).describe("Whether to ignore rest parameter arrays.")
+	}
+});
+
+//#endregion
+export { rule };