@oxiul/configs 0.0.0-stage → 0.4.0

package/README.md

@@ -1,3 +1,67 @@
-# Temporary Holding Version
+# Configs
 
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.
+## Lint config
+
+A shared config for oxlint
+
+## Format config
+
+A shared config for oxfmt
+
+## GitHub Actions
+
+Configure generation in `oxiul.config.ts`:
+
+```ts
+import type { Config } from "@oxiul/configs";
+
+export default {
+	workflows: {
+		workflows: [], // Optional { name, workflow } objects for project workflows.
+		jobs: {}, // Optional { jobName: <job> } object with CI jobs descriptions.
+	},
+} satisfies Config;
+```
+
+## Package.json verification
+
+Run `oxiul verify` to require a pinned Bun version of at least 1.4.4,
+a Node.js engine range starting at 26 or higher, and these exact scripts:
+
+```json
+{
+	"lint": "oxlint",
+	"lint:fix": "oxlint --fix",
+	"format": "oxfmt --write",
+	"format:verify": "oxfmt --check",
+	"workflows": "oxiul workflows --verify",
+	"workflows:generate": "oxiul workflows --generate",
+	"typecheck": "bun check",
+	"deps": "knip",
+	"oxiul:verify": "oxiul verify"
+}
+```
+
+Add requirements or override commands in `oxiul.config.ts`:
+
+```ts
+export default {
+	verify: {
+		scripts: {
+			build: "bun build src/index.ts",
+			test: "*", // Required script, any command.
+			lint: "oxlint --deny-warnings",
+		},
+	},
+} satisfies Config;
+```
+
+Other scripts are allowed and left unchecked. Verification reads `package.json`
+from the current directory and never modifies it.
+
+## Development
+
+### Prerequisites
+
+- Node.js (from `engines.node` field in `package.json`)
+- Bun (from `packageManager` field in `package.json`)

package/dist/bin.d.mts

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

package/dist/bin.mjs

@@ -0,0 +1,99 @@
+#!/usr/bin/env bun
+import { t as parse } from "./parse-DnOcFJT0.mjs";
+import { a as getDepsJob, c as getPackageJsonVerifyJob, d as getWorkflowsVerifyJob, i as getDefaultWorkflow, l as getSetupAction, o as getFormatVerifyJob, s as getLintJob, t as generateWorkflows, u as getTypecheckJob } from "./generate-BGCgStVl.mjs";
+import { gte, subset, valid, validRange } from "semver";
+import { z } from "zod";
+import { Crust, defineCommand } from "@crustjs/core";
+import { help } from "@crustjs/extensions";
+import { readFile } from "node:fs/promises";
+//#region src/schemas.ts
+const packageJsonSchema = z.object({
+	engines: z.object({ node: z.string() }),
+	packageManager: z.string(),
+	scripts: z.record(z.string(), z.string())
+}).partial();
+//#endregion
+//#region src/verify/package-json.ts
+const defaultScripts = {
+	deps: "knip",
+	format: "oxfmt --write",
+	"format:verify": "oxfmt --check",
+	lint: "oxlint",
+	"lint:fix": "oxlint --fix",
+	"oxiul:verify": "oxiul verify",
+	typecheck: "bun check",
+	workflows: "oxiul workflows --verify",
+	"workflows:generate": "oxiul workflows --generate"
+};
+const verifyPackageJson = (packageJson, { scripts: extraScripts, minBunVersion, minNodeVersion }) => {
+	const { scripts = {}, packageManager = "", engines: { node: nodeVersionRaw = "" } = { node: "" } } = packageJson;
+	const errors = [];
+	const bunVersion = /^bun@(?<version>[^+]+)(?:\+sha\d+\.[a-f\d]+)?$/u.exec(packageManager)?.groups?.version;
+	if (!bunVersion || !valid(bunVersion) || !gte(bunVersion, minBunVersion)) errors.push(`packageManager must pin bun@${minBunVersion} or higher`);
+	const nodeRange = validRange(nodeVersionRaw);
+	if (!nodeRange || !subset(nodeRange, `>=${minNodeVersion}`)) errors.push(`engines.node must require Node.js ${minNodeVersion} or higher`);
+	for (const [name, command] of Object.entries({
+		...defaultScripts,
+		...extraScripts
+	})) if (!scripts[name]) errors.push(`Missing script: ${name}`);
+	else if (command !== "*" && scripts[name] !== command) errors.push(`scripts[${name}] must be ${JSON.stringify(command)}`);
+	if (errors.length !== 0) throw new Error(`Package.json verification failed:\n${errors.join("\n")}`);
+};
+//#endregion
+//#region src/verify/bin.ts
+const command$1 = defineCommand("verify", { description: "Verify package.json" }, (def) => def.action(async ({ stdout }) => {
+	stdout("Verifying package.json...");
+	const config = await parse();
+	const parseResult = packageJsonSchema.safeParse(JSON.parse(await readFile("package.json", "utf8")));
+	if (!parseResult.success) throw new Error(`Invalid package.json: ${parseResult.error.message}`);
+	verifyPackageJson(parseResult.data, config.verify);
+	stdout("package.json verified successfully!");
+}));
+//#endregion
+//#region src/workflows/bin.ts
+const command = defineCommand("workflows", { description: "Workflows" }, (def) => def.flags({
+	name: "verify",
+	short: "r",
+	type: "boolean"
+}).flags({
+	name: "generate",
+	short: "g",
+	type: "boolean"
+}).action(async ({ flags, stdout }) => {
+	const config = await parse();
+	const options = {
+		actions: { "setup-env": getSetupAction() },
+		workflows: [getDefaultWorkflow({
+			jobs: {
+				deps: getDepsJob(),
+				format: getFormatVerifyJob(),
+				lint: getLintJob(),
+				typecheck: getTypecheckJob(),
+				verify: getPackageJsonVerifyJob(),
+				workflows: getWorkflowsVerifyJob(),
+				...config.workflows?.jobs
+			},
+			name: "CI"
+		}), ...config.workflows?.workflows ?? []]
+	};
+	if (flags.generate) {
+		stdout(`Generating the workflows..`);
+		await generateWorkflows({
+			...options,
+			check: false
+		});
+		stdout(`Workflows generated successfully!`);
+	} else {
+		stdout(`Verifying the workflows..`);
+		await generateWorkflows({
+			...options,
+			check: true
+		});
+		stdout(`Workflows verified successfully!`);
+	}
+}));
+//#endregion
+//#region src/bin.ts
+await new Crust("oxiul", { description: "Oxiul runner" }).add(command$1).add(command).extend(help()).execute();
+//#endregion
+export {};

package/dist/common-B9SE4GL9.mjs

@@ -0,0 +1,11 @@
+//#region src/common.ts
+const baseIgnorePatterns = [
+	".history/",
+	"bun.lock",
+	"**/*.gen.ts"
+];
+const arraify = (input) => input === void 0 ? [] : Array.isArray(input) ? input : [input];
+const moduleName = "oxiul";
+const packageName = "@oxiul/configs";
+//#endregion
+export { packageName as i, baseIgnorePatterns as n, moduleName as r, arraify as t };

package/dist/generate-BGCgStVl.mjs

@@ -0,0 +1,103 @@
+import { mkdir, readFile, writeFile } from "node:fs/promises";
+import path from "node:path";
+import { stringify } from "yaml";
+//#region src/workflows/default.ts
+const DEFAULT_MACHINE = "ubuntu-26.04";
+const getSetupAction = () => ({
+	description: "Setup runtime",
+	name: "Runtime setup",
+	runs: {
+		steps: [
+			{
+				name: "Setup Node.js",
+				uses: "actions/setup-node@v7",
+				with: { "node-version-file": "package.json" }
+			},
+			{
+				name: "Setup Bun",
+				uses: "oven-sh/setup-bun@v2",
+				with: { "bun-version-file": "package.json" }
+			},
+			{
+				name: "Install dependencies",
+				run: "bun install --frozen-lockfile",
+				shell: "bash"
+			}
+		],
+		using: "composite"
+	}
+});
+const getDefaultWorkflow = ({ concurrency, on, name = "Default workflow", ...rest }) => ({
+	concurrency: {
+		"cancel-in-progress": true,
+		group: "${{ github.workflow }}-${{ github.ref }}",
+		...concurrency
+	},
+	name,
+	on: {
+		pull_request: {},
+		push: { branches: ["main"] },
+		workflow_dispatch: {},
+		...on
+	},
+	...rest
+});
+const getCheckJob = ({ "runs-on": runsOn = DEFAULT_MACHINE, steps, overrideSteps = false, ...rest }) => ({
+	"runs-on": runsOn,
+	steps: overrideSteps ? steps : [
+		{ uses: "actions/checkout@v7" },
+		{ uses: "./.github/actions/setup-env" },
+		...steps
+	],
+	...rest
+});
+const getFormatVerifyJob = () => getCheckJob({
+	name: "Format verification",
+	steps: [{ run: "bun run format:verify" }]
+});
+const getDepsJob = () => getCheckJob({
+	name: "Dependencies check",
+	steps: [{ run: "bun run deps" }]
+});
+const getTypecheckJob = () => getCheckJob({
+	name: "Typecheck",
+	steps: [{ run: "bun run typecheck" }]
+});
+const getLintJob = () => getCheckJob({
+	name: "Lint",
+	steps: [{ run: "bun run lint" }]
+});
+const getWorkflowsVerifyJob = () => getCheckJob({
+	name: "Workflows verification",
+	steps: [{ run: "bun run workflows" }]
+});
+const getPackageJsonVerifyJob = () => getCheckJob({
+	name: "Package.json verification",
+	steps: [{ run: "bun run oxiul:verify" }]
+});
+//#endregion
+//#region src/workflows/generate.ts
+const generateWorkflows = async ({ workflows = [], actions = {}, directory = ".", check = false }) => {
+	const files = /* @__PURE__ */ new Map();
+	const addFile = (name, filePath, value) => {
+		if (!name || !/^[\w-]+$/u.test(name)) throw new Error(`Invalid generated file name: ${name}`);
+		if (files.has(filePath)) throw new Error(`Duplicate generated file: ${filePath}`);
+		files.set(filePath, `# Generated by @oxiul/configs/workflows. Do not edit.\n${stringify(value, { lineWidth: 0 })}`);
+	};
+	for (const workflow of workflows) addFile(workflow.name, `.github/workflows/${workflow.name.toLowerCase()}.yml`, workflow);
+	for (const [name, action] of Object.entries(actions)) addFile(name, `.github/actions/${name}/action.yml`, action);
+	for (const [filePath, content] of files) {
+		const target = path.resolve(directory, filePath);
+		if (check) {
+			if (await readFile(target, "utf8").catch((error) => {
+				if (error instanceof Error && "code" in error && error.code === "ENOENT") return;
+				throw error;
+			}) !== content) throw new Error(`Generated file is out of date: ${filePath}`);
+		} else {
+			await mkdir(path.dirname(target), { recursive: true });
+			await writeFile(target, content);
+		}
+	}
+};
+//#endregion
+export { getDepsJob as a, getPackageJsonVerifyJob as c, getWorkflowsVerifyJob as d, getDefaultWorkflow as i, getSetupAction as l, DEFAULT_MACHINE as n, getFormatVerifyJob as o, getCheckJob as r, getLintJob as s, generateWorkflows as t, getTypecheckJob as u };

package/dist/hook/install.d.mts

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

package/dist/hook/install.mjs

@@ -0,0 +1,37 @@
+import { i as packageName } from "../common-B9SE4GL9.mjs";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { exec } from "node:child_process";
+import { promisify } from "node:util";
+//#region src/hook/install.ts
+const promisifiedExec = promisify(exec);
+const { stdout: rawGitRepositoryRoot } = await promisifiedExec("git rev-parse --show-toplevel");
+const gitRepositoryRoot = rawGitRepositoryRoot.trim();
+const { stdout: rawHooksDirectory } = await promisifiedExec("git rev-parse --path-format=absolute --git-path hooks");
+const hooksDirectory = rawHooksDirectory.trim();
+const packageJson = await fs.readFile(path.join(gitRepositoryRoot, "package.json"), "utf8");
+const { name } = JSON.parse(packageJson);
+const HOOK_CONTENT = ["#!/bin/bash", `node ${name === "@oxiul/configs" ? "." : `./node_modules/${packageName}`}/dist/hook/pre-commit.mjs`].join("\n");
+await fs.mkdir(hooksDirectory, { recursive: true });
+const preCommitPath = path.join(hooksDirectory, "pre-commit");
+let oldHook = "";
+if (await fs.stat(preCommitPath).then(() => true).catch(() => false)) {
+	if ((await fs.lstat(preCommitPath)).isSymbolicLink()) {
+		console.log("Detected an existing git pre-commit hook");
+		await fs.unlink(preCommitPath);
+	} else {
+		oldHook = await fs.readFile(preCommitPath, "utf8");
+		if (oldHook !== HOOK_CONTENT) {
+			console.log(`Found hooks path: "${hooksDirectory}"`);
+			console.log("Detected an existing git pre-commit hook");
+			await fs.writeFile(`${preCommitPath}.old`, oldHook);
+		}
+	}
+}
+if (oldHook !== HOOK_CONTENT) {
+	console.log(`Found hooks path: "${hooksDirectory}"`);
+	await fs.writeFile(preCommitPath, HOOK_CONTENT, { mode: 493 });
+	console.log("Hook saved");
+}
+//#endregion
+export {};

package/dist/hook/pre-commit.d.mts

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

package/dist/hook/pre-commit.mjs

@@ -0,0 +1,51 @@
+import { t as parse } from "../parse-DnOcFJT0.mjs";
+import { spawn } from "node:child_process";
+import { Listr } from "listr2";
+//#region src/hook/pre-commit.ts
+const failedOutputs = /* @__PURE__ */ new Map();
+const run = (command, task) => new Promise((resolve, reject) => {
+	const child = spawn(command, {
+		env: {
+			...process.env,
+			FORCE_COLOR: "1"
+		},
+		shell: true,
+		stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		]
+	});
+	const window = task.stdout();
+	let output = "";
+	const onData = (chunk) => {
+		output += chunk;
+		window.write(chunk);
+	};
+	child.stdout.on("data", onData);
+	child.stderr.on("data", onData);
+	child.on("error", reject);
+	child.on("close", (code, signal) => {
+		if (code === 0) return resolve();
+		failedOutputs.set(command, output);
+		reject(/* @__PURE__ */ new Error(signal ? `killed by ${signal}` : `exited with code ${code}`));
+	});
+});
+try {
+	const config = await parse();
+	if (config.preCommitCommands && config.preCommitCommands.length !== 0) await new Listr(config.preCommitCommands.map((command) => ({
+		rendererOptions: {
+			outputBar: 5,
+			persistentOutput: false
+		},
+		task: (_ctx, task) => run(command, task),
+		title: command
+	})), { concurrent: false }).run();
+	else console.log(`No commands in pre-commit list found`);
+} catch {
+	for (const [command, output] of failedOutputs) console.error(`\n✖ Output of "${command}"\n${output}`);
+	console.error(`${failedOutputs.size} tasks failed: ${[...failedOutputs.keys()].join(", ")}`);
+	process.exit(1);
+}
+//#endregion
+export {};

package/dist/index-DqMadVlO.d.mts

@@ -0,0 +1,44 @@
+import { GeneratedWorkflowTypes, GeneratedWorkflowTypes as GeneratedWorkflowTypes$1 } from "@github-actions-workflow-ts/lib";
+//#region src/workflows/types.d.ts
+type CompositeAction = {
+  name: string;
+  description: string;
+  runs: {
+    using: "composite";
+    steps: GeneratedWorkflowTypes.Step[];
+  };
+};
+type Workflow = GeneratedWorkflowTypes.Workflow;
+//#endregion
+//#region src/workflows/default.d.ts
+declare const DEFAULT_MACHINE = "ubuntu-26.04";
+declare const getSetupAction: () => CompositeAction;
+declare const getDefaultWorkflow: ({ concurrency, on, name, ...rest }: Omit<GeneratedWorkflowTypes.Workflow, "on" | "concurrency"> & {
+  on?: Exclude<GeneratedWorkflowTypes.Workflow["on"], GeneratedWorkflowTypes.Event | GeneratedWorkflowTypes.Event[]>;
+  concurrency?: Exclude<GeneratedWorkflowTypes.Workflow["concurrency"], string>;
+}) => Omit<GeneratedWorkflowTypes.Workflow, "name"> & {
+  name: string;
+};
+declare const getCheckJob: ({ "runs-on": runsOn, steps, overrideSteps, ...rest }: Omit<GeneratedWorkflowTypes.NormalJob, "runs-on"> & {
+  overrideSteps?: boolean;
+  "runs-on"?: GeneratedWorkflowTypes.NormalJob["runs-on"];
+  steps: Exclude<GeneratedWorkflowTypes.NormalJob["steps"], undefined>;
+}) => GeneratedWorkflowTypes.NormalJob;
+declare const getFormatVerifyJob: () => GeneratedWorkflowTypes.NormalJob;
+declare const getDepsJob: () => GeneratedWorkflowTypes.NormalJob;
+declare const getTypecheckJob: () => GeneratedWorkflowTypes.NormalJob;
+declare const getLintJob: () => GeneratedWorkflowTypes.NormalJob;
+declare const getWorkflowsVerifyJob: () => GeneratedWorkflowTypes.NormalJob;
+declare const getPackageJsonVerifyJob: () => GeneratedWorkflowTypes.NormalJob;
+//#endregion
+//#region src/workflows/generate.d.ts
+declare const generateWorkflows: ({ workflows, actions, directory, check }: {
+  workflows?: (Omit<GeneratedWorkflowTypes.Workflow, "name"> & {
+    name: string;
+  })[];
+  actions?: Record<string, CompositeAction>;
+  directory?: string;
+  check?: boolean;
+}) => Promise<void>;
+//#endregion
+export { getDefaultWorkflow as a, getLintJob as c, getTypecheckJob as d, getWorkflowsVerifyJob as f, getCheckJob as i, getPackageJsonVerifyJob as l, Workflow as m, generateWorkflows as n, getDepsJob as o, CompositeAction as p, DEFAULT_MACHINE as r, getFormatVerifyJob as s, GeneratedWorkflowTypes$1 as t, getSetupAction as u };

package/dist/index.d.mts

@@ -0,0 +1,168 @@
+import { t as GeneratedWorkflowTypes } from "./index-DqMadVlO.mjs";
+import { z } from "zod";
+import { OxlintConfig } from "oxlint";
+import { OxfmtConfig } from "oxfmt";
+import { KnipConfig } from "knip";
+//#region src/oxlint.d.ts
+export declare const disabledRules: OxlintConfig["rules"];
+export declare const overridenRules: OxlintConfig["rules"];
+type MergableConfig$1 = Omit<OxlintConfig, "plugins"> & {
+  plugins?: Partial<Record<NonNullable<OxlintConfig["plugins"]>[number], boolean>>;
+};
+type TailwindConfig = {
+  entryPoint: string;
+};
+type VitestConfig = {
+  files?: string[];
+};
+type TanstackRouterConfig = {
+  routes: string[];
+};
+type PackageJsonConfig = boolean;
+type PlaywrightConfig = {
+  files: string[];
+  assertFunctionNames?: string[];
+};
+type ServerSideConfig = {
+  files: string[];
+  allowConsole?: string[];
+  allowProcess?: string[];
+};
+type RestrictedSyntaxRule = {
+  selector: string;
+  message: string;
+};
+type RestrictedSyntaxOverride = {
+  files: string[];
+  rules: RestrictedSyntaxRule[];
+};
+type RestrictedSyntaxConfig = {
+  banBarrelImport?: boolean;
+  banReactMemo?: boolean;
+  overrides?: RestrictedSyntaxOverride[];
+  rulesOverrides?: RestrictedSyntaxRule[];
+  previousRules?: RestrictedSyntaxRule[];
+  previousOverrides?: RestrictedSyntaxOverride[];
+};
+type RestrictedConfig = {
+  globals?: {
+    name: string;
+    message: string;
+  }[];
+  properties?: {
+    object: string;
+    property: string;
+    message: string;
+  }[];
+  syntaxOverrides?: RestrictedSyntaxConfig["overrides"];
+  syntaxRulesOverrides?: RestrictedSyntaxConfig["rulesOverrides"];
+};
+type ReactConfig = {
+  allowedStrings?: string[];
+  additionalHooks?: string[];
+  banMemo?: boolean;
+};
+type I18nConfig = {
+  ignore?: string[] | true;
+};
+type ImportConfig = {
+  allowDefault?: string[];
+  banBarrel?: boolean;
+};
+type ConfigOptions$2 = {
+  jsPlugins?: Exclude<OxlintConfig["jsPlugins"], null>;
+  plugins?: MergableConfig$1["plugins"];
+  tailwind?: TailwindConfig;
+  vitest?: VitestConfig;
+  tanstackRouter?: TanstackRouterConfig;
+  packageJson?: PackageJsonConfig;
+  playwright?: PlaywrightConfig;
+  serverSide?: ServerSideConfig;
+  restricted?: RestrictedConfig;
+  react?: ReactConfig;
+  i18n?: I18nConfig;
+  import?: ImportConfig;
+} & Pick<OxlintConfig, "env" | "rules" | "options" | "ignorePatterns" | "categories" | "settings" | "overrides" | "globals"> & ReactConfig;
+declare const getConfig$2: ({ tailwind, tanstackRouter, vitest, packageJson, playwright, serverSide, restricted, react, i18n, import: importOptions, ...config }?: ConfigOptions$2) => Promise<OxlintConfig>;
+//#endregion
+//#region src/oxfmt.d.ts
+type ConfigOptions$1 = OxfmtConfig & {
+  tailwind?: {
+    stylesheet: string;
+    functions?: string[];
+  };
+  imports?: Exclude<OxfmtConfig["sortImports"], boolean>;
+};
+declare const getConfig: ({ ignorePatterns, tailwind, imports, sortImports, ...rest }?: ConfigOptions$1) => Promise<{
+  readonly arrowParens?: import("oxfmt").ArrowParensConfig;
+  readonly associations?: import("oxfmt").OxfmtAssociationConfig[];
+  astro: import("oxfmt").AstroUserConfig;
+  readonly bracketSameLine?: boolean;
+  readonly bracketSpacing?: boolean;
+  readonly embeddedLanguageFormatting?: import("oxfmt").EmbeddedLanguageFormattingConfig;
+  readonly endOfLine?: import("oxfmt").EndOfLineConfig;
+  readonly experimentalOperatorPosition?: import("oxfmt").OperatorPositionConfig;
+  readonly htmlWhitespaceSensitivity?: import("oxfmt").HtmlWhitespaceSensitivityConfig;
+  readonly insertFinalNewline?: boolean;
+  readonly jsdoc?: import("oxfmt").JsdocUserConfig;
+  readonly jsxSingleQuote?: boolean;
+  readonly objectWrap?: import("oxfmt").ObjectWrapConfig;
+  readonly overrides?: import("oxfmt").OxfmtOverrideConfig[];
+  printWidth: number;
+  readonly proseWrap?: import("oxfmt").ProseWrapConfig;
+  readonly quoteProps?: import("oxfmt").QuotePropsConfig;
+  readonly semi?: boolean;
+  readonly singleAttributePerLine?: boolean;
+  readonly singleQuote?: boolean;
+  sortPackageJson: boolean | import("oxfmt").SortPackageJsonConfig | {
+    readonly sortScripts: true;
+  };
+  sortTailwindcss: import("oxfmt").SortTailwindcssUserConfig;
+  readonly svelte?: import("oxfmt").SvelteUserConfig;
+  readonly tabWidth?: number;
+  readonly trailingComma?: import("oxfmt").TrailingCommaConfig;
+  useTabs: boolean;
+  readonly vueIndentScriptAndStyle?: boolean;
+  readonly ignorePatterns: string[];
+  readonly sortImports: import("oxfmt").SortImportsUserConfig;
+}>;
+//#endregion
+//#region src/knip.d.ts
+type KnipConfig$1 = Exclude<KnipConfig, Function>;
+type MergableConfig = Omit<KnipConfig$1, "include"> & {
+  include?: Partial<Record<NonNullable<KnipConfig$1["include"]>[number], boolean>>;
+};
+type BaseOptions = {
+  vitest?: boolean;
+  reactNative?: boolean;
+  opencode?: boolean;
+  eslint?: boolean;
+  workspaces?: boolean;
+};
+type ConfigOptions = {
+  options?: BaseOptions;
+} & MergableConfig;
+declare const getConfig$1: ({ options, ...overrides }?: ConfigOptions) => Promise<KnipConfig$1>;
+//#endregion
+//#region src/config/schema.d.ts
+export declare const configSchema: z.ZodObject<{
+  preCommitCommands: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  verify: z.ZodDefault<z.ZodObject<{
+    minBunVersion: z.ZodDefault<z.ZodString>;
+    minNodeVersion: z.ZodDefault<z.ZodString>;
+    scripts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodString>>;
+  }, z.core.$strip>>;
+  workflows: z.ZodOptional<z.ZodObject<{
+    branch: z.ZodOptional<z.ZodString>;
+    jobs: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodCustom<GeneratedWorkflowTypes.NormalJob, GeneratedWorkflowTypes.NormalJob>>>;
+    workflows: z.ZodOptional<z.ZodArray<z.ZodCustom<Omit<GeneratedWorkflowTypes.Workflow, "name"> & {
+      name: string;
+    }, Omit<GeneratedWorkflowTypes.Workflow, "name"> & {
+      name: string;
+    }>>>;
+  }, z.core.$strip>>;
+}, z.core.$strip>;
+type ConfigInput = z.input<typeof configSchema>;
+type ConfigOutput = z.output<typeof configSchema>;
+//#endregion
+export { type ConfigInput as Config, type ConfigOutput, getConfig as getFormatConfig, getConfig$1 as getKnipConfig, getConfig$2 as getLintConfig };

package/dist/index.mjs

@@ -0,0 +1,479 @@
+import { n as baseIgnorePatterns, t as arraify } from "./common-B9SE4GL9.mjs";
+import { t as configSchema } from "./schema-BuCl21uv.mjs";
+import { isNonNullish, mapValues, omitBy } from "remeda";
+//#region src/oxlint.ts
+const disabledRules = {
+	"eslint/capitalized-comments": "off",
+	"eslint/default-case": "off",
+	"eslint/id-length": "off",
+	"eslint/max-lines": "off",
+	"eslint/max-lines-per-function": "off",
+	"eslint/max-params": "off",
+	"eslint/max-statements": "off",
+	"eslint/no-await-in-loop": "off",
+	"eslint/no-continue": "off",
+	"eslint/no-duplicate-imports": "off",
+	"eslint/no-inline-comments": "off",
+	"eslint/no-nested-ternary": "off",
+	"eslint/no-ternary": "off",
+	"eslint/no-undefined": "off",
+	"eslint/no-warning-comments": "off",
+	"eslint/one-var": "off",
+	"eslint/require-await": "off",
+	"import/exports-last": "off",
+	"import/group-exports": "off",
+	"import/max-dependencies": "off",
+	"import/no-named-export": "off",
+	"import/no-namespace": "off",
+	"import/no-unassigned-import": "off",
+	"import/prefer-default-export": "off",
+	"import/unambiguous": "off",
+	"oxc/no-accumulating-spread": "off",
+	"oxc/no-async-await": "off",
+	"oxc/no-map-spread": "off",
+	"oxc/no-optional-chaining": "off",
+	"oxc/no-rest-spread-properties": "off",
+	"promise/avoid-new": "off",
+	"promise/prefer-await-to-callbacks": "off",
+	"promise/prefer-await-to-then": "off",
+	"react-perf/jsx-no-jsx-as-prop": "off",
+	"react-perf/jsx-no-new-array-as-prop": "off",
+	"react-perf/jsx-no-new-function-as-prop": "off",
+	"react-perf/jsx-no-new-object-as-prop": "off",
+	"react/display-name": "off",
+	"react/forbid-component-props": "off",
+	"react/jsx-filename-extension": "off",
+	"react/jsx-handler-names": "off",
+	"react/jsx-max-depth": "off",
+	"react/jsx-props-no-spreading": "off",
+	"react/no-multi-comp": "off",
+	"react/only-export-components": "off",
+	"react/react-in-jsx-scope": "off",
+	"react/rule-suppression": "off",
+	"typescript/consistent-return": "off",
+	"typescript/explicit-function-return-type": "off",
+	"typescript/explicit-module-boundary-types": "off",
+	"typescript/no-confusing-void-expression": "off",
+	"typescript/no-dynamic-delete": "off",
+	"typescript/no-invalid-void-type": "off",
+	"typescript/no-unnecessary-type-parameters": "off",
+	"typescript/no-unsafe-type-assertion": "off",
+	"typescript/prefer-nullish-coalescing": "off",
+	"typescript/prefer-readonly-parameter-types": "off",
+	"typescript/promise-function-async": "off",
+	"unicorn/no-array-callback-reference": "off",
+	"unicorn/no-array-reduce": "off",
+	"unicorn/no-nested-ternary": "off",
+	"unicorn/no-null": "off",
+	"unicorn/no-useless-undefined": "off",
+	"unicorn/number-literal-case": "off",
+	"unicorn/prefer-global-this": "off",
+	"unicorn/prefer-spread": "off",
+	"vitest/max-expects": "off",
+	"vitest/no-conditional-in-test": "off",
+	"vitest/no-hooks": "off",
+	"vitest/no-importing-vitest-globals": "off",
+	"vitest/no-standalone-expect": "off",
+	"vitest/prefer-called-once": "off",
+	"vitest/prefer-expect-assertions": "off",
+	"vitest/prefer-importing-vitest-globals": "off",
+	"vitest/prefer-lowercase-title": "off",
+	"vitest/prefer-to-be": "off",
+	"vitest/prefer-to-be-falsy": "off",
+	"vitest/prefer-to-be-truthy": "off",
+	"vitest/require-hook": "off",
+	"vitest/require-test-timeout": "off"
+};
+const disabledTailwindRules = {
+	"better-tailwindcss/enforce-consistent-class-order": "off",
+	"better-tailwindcss/enforce-consistent-line-wrapping": "off"
+};
+const overridenRules = {
+	"eslint/no-magic-numbers": ["error", { ignore: [
+		0,
+		1,
+		-1
+	] }],
+	"eslint/no-void": ["error", { allowAsStatement: true }],
+	"eslint/sort-imports": ["error", { ignoreDeclarationSort: true }],
+	"react/function-component-definition": ["error", {
+		namedComponents: "arrow-function",
+		unnamedComponents: "arrow-function"
+	}],
+	"react/jsx-no-useless-fragment": ["error", { allowExpressions: true }],
+	"typescript/consistent-type-definitions": ["error", "type"],
+	"typescript/no-misused-promises": ["error", { checksVoidReturn: {
+		arguments: false,
+		attributes: false
+	} }],
+	"typescript/no-unnecessary-condition": ["error", { allowConstantLoopConditions: true }],
+	"typescript/restrict-template-expressions": ["error", { allowNumber: true }],
+	"typescript/strict-boolean-expressions": ["error", {
+		allowNullableBoolean: true,
+		allowNullableNumber: true,
+		allowNullableString: true,
+		allowNumber: true,
+		allowString: true
+	}],
+	"typescript/switch-exhaustiveness-check": ["error", { considerDefaultExhaustiveForUnions: true }],
+	"unicorn/explicit-length-check": ["error", { "non-zero": "not-equal" }],
+	"unicorn/max-nested-calls": ["error", { max: 5 }],
+	"unicorn/switch-case-braces": ["error", "avoid"],
+	"vitest/consistent-test-it": ["error", { fn: "test" }]
+};
+const mergeConfigs$1 = (...configs) => configs.reduce(({ categories, env, globals, ignorePatterns, jsPlugins, options, overrides, plugins, rules, settings, ...rest }, { categories: configCategories, env: configEnv, globals: configGlobals, ignorePatterns: configIgnorePatterns, jsPlugins: configJsPlugins, options: configOptions, overrides: configOverrides, plugins: configPlugins, rules: configRules, settings: configSettings, ...configRest }) => ({
+	categories: {
+		...categories,
+		...configCategories
+	},
+	env: {
+		...env,
+		...configEnv
+	},
+	globals: {
+		...globals,
+		...configGlobals
+	},
+	ignorePatterns: [...ignorePatterns ?? [], ...configIgnorePatterns ?? []],
+	jsPlugins: [...jsPlugins ?? [], ...configJsPlugins ?? []],
+	options: {
+		...options,
+		...configOptions
+	},
+	overrides: [...overrides ?? [], ...configOverrides ?? []],
+	plugins: {
+		...plugins,
+		...configPlugins
+	},
+	rules: {
+		...rules,
+		...configRules
+	},
+	settings: {
+		...settings,
+		...configSettings
+	},
+	...rest,
+	...configRest
+}), {});
+const getTailwindConfig = async (config) => {
+	if (!config) return {};
+	const tailwindPlugin = await import("eslint-plugin-better-tailwindcss");
+	return {
+		jsPlugins: [{
+			name: "better-tailwindcss",
+			specifier: "eslint-plugin-better-tailwindcss"
+		}],
+		rules: {
+			...Object.fromEntries(Object.keys(tailwindPlugin.default.rules).map((key) => [`better-tailwindcss/${key}`, "error"])),
+			...disabledTailwindRules
+		},
+		settings: { "better-tailwindcss": { entryPoint: config.entryPoint } }
+	};
+};
+const getVitestConfig = (config) => {
+	if (!config) return {};
+	return {
+		overrides: config.files ? [{
+			files: config.files,
+			rules: { "react/rules-of-hooks": "off" }
+		}] : [],
+		plugins: { vitest: true }
+	};
+};
+const getTanstackRouterConfig = async (config) => {
+	if (!config) return {};
+	const plugin = await import("@tanstack/eslint-plugin-router");
+	return {
+		jsPlugins: [{
+			name: "@tanstack/router",
+			specifier: "@tanstack/eslint-plugin-router"
+		}],
+		overrides: [{
+			files: config.routes,
+			rules: { "no-use-before-define": "off" }
+		}],
+		rules: plugin.default.configs["flat/recommended"][0].rules
+	};
+};
+const getPackageJsonConfig = async (config) => {
+	if (!config) return {};
+	return {
+		jsPlugins: [{
+			name: "package-json",
+			specifier: "eslint-plugin-package-json"
+		}],
+		rules: (await import("eslint-plugin-package-json")).configs.recommended.rules
+	};
+};
+const getPlaywrightConfig = async (config) => {
+	if (!config) return {};
+	const plugin = await import("eslint-plugin-playwright");
+	return {
+		jsPlugins: [{
+			name: "playwright",
+			specifier: "eslint-plugin-playwright"
+		}],
+		overrides: [{
+			files: config.files,
+			rules: {
+				...plugin.default.configs["flat/recommended"].rules,
+				...config.assertFunctionNames ? { "playwright/expect-expect": ["error", { assertFunctionNames: config.assertFunctionNames }] } : {},
+				"react/rules-of-hooks": "off",
+				"vitest/consistent-test-filename": "off",
+				"vitest/prefer-each": "off",
+				"vitest/valid-expect": "off"
+			}
+		}]
+	};
+};
+const getServerSideConfig = (config) => {
+	if (!config) return {};
+	return { overrides: [
+		{
+			files: config.files,
+			rules: { "import/no-nodejs-modules": "off" }
+		},
+		config.allowConsole ? {
+			files: config.allowConsole,
+			rules: { "no-console": "off" }
+		} : null,
+		config.allowProcess ? {
+			files: config.allowProcess,
+			rules: { "node/no-process-env": "off" }
+		} : null
+	].filter(isNonNullish) };
+};
+const getRestrictedSyntaxConfig = (config) => {
+	if (!config) return {};
+	const overrides = config.overrides ?? [];
+	const rawRules = [config.banBarrelImport ? {
+		message: "Do not use barrel export, prefer named export",
+		selector: "ExportAllDeclaration"
+	} : null, config.banReactMemo ? {
+		message: "No need to use `React.memo`, we have a react compiler turned on",
+		selector: "MemberExpression[object.name='React'][property.name='memo']"
+	} : null].filter(isNonNullish);
+	return {
+		overrides: overrides.map(({ files, rules }) => ({
+			files,
+			rules: { "eslint-js/no-restricted-syntax": ["error", [
+				...rawRules,
+				...rules,
+				...config.rulesOverrides ?? []
+			]] }
+		})),
+		rules: { "eslint-js/no-restricted-syntax": [
+			"error",
+			...rawRules,
+			...config.rulesOverrides ?? []
+		] }
+	};
+};
+const getRestrictedConfig = (config) => {
+	if (!config) return {};
+	return { rules: {
+		"eslint/no-restricted-globals": config.globals ? ["error", ...config.globals] : "error",
+		"eslint/no-restricted-properties": config.properties ? ["error", ...config.properties] : "error"
+	} };
+};
+const getReactConfig = (config) => {
+	if (!config) return {};
+	return { rules: {
+		"react/exhaustive-deps": config.additionalHooks ? ["error", { additionalHooks: `(${config.additionalHooks.join(",")})` }] : "error",
+		"react/jsx-no-literals": ["error", {
+			allowedStrings: config.allowedStrings,
+			ignoreProps: true,
+			noAttributeStrings: true,
+			noStrings: true
+		}]
+	} };
+};
+const getI18nConfig = (config) => {
+	if (!config) return {};
+	return {
+		overrides: Array.isArray(config.ignore) ? [{
+			files: config.ignore,
+			rules: { "react/jsx-no-literals": "off" }
+		}] : [],
+		rules: config.ignore === true ? { "react/jsx-no-literals": "off" } : {}
+	};
+};
+const getImportConfig = (config) => {
+	if (!config) return {};
+	return { overrides: [config.allowDefault ? {
+		files: config.allowDefault,
+		rules: { "import/no-default-export": "off" }
+	} : null].filter(isNonNullish) };
+};
+const getBaseConfig$1 = () => ({
+	categories: {
+		correctness: "error",
+		nursery: "error",
+		pedantic: "error",
+		perf: "error",
+		restriction: "error",
+		style: "error",
+		suspicious: "error"
+	},
+	env: {
+		browser: true,
+		es2026: true
+	},
+	ignorePatterns: baseIgnorePatterns,
+	jsPlugins: [{
+		name: "eslint-js",
+		specifier: "oxlint-plugin-eslint"
+	}],
+	options: {
+		denyWarnings: true,
+		reportUnusedDisableDirectives: "error",
+		typeAware: true
+	},
+	overrides: [
+		{
+			files: ["**/*.config.{j,t}s"],
+			rules: {
+				"import/no-default-export": "off",
+				"import/no-nodejs-modules": "off",
+				"node/no-top-level-await": "off"
+			}
+		},
+		{
+			files: ["**/*.d.ts"],
+			rules: { "typescript/triple-slash-reference": "off" }
+		},
+		{
+			files: ["workflows.config.ts"],
+			rules: { "eslint/no-template-curly-in-string": "off" }
+		}
+	],
+	plugins: {
+		eslint: true,
+		import: true,
+		"jsx-a11y": true,
+		node: true,
+		oxc: true,
+		promise: true,
+		react: true,
+		"react-perf": true,
+		typescript: true,
+		unicorn: true
+	},
+	rules: {
+		...disabledRules,
+		...overridenRules
+	}
+});
+const getConfig$2 = async ({ tailwind, tanstackRouter, vitest, packageJson = true, playwright, serverSide, restricted, react, i18n, import: importOptions, ...config } = {}) => {
+	const baseConfig = getBaseConfig$1();
+	const tailwindConfig = await getTailwindConfig(tailwind);
+	const tanstackRouterConfig = await getTanstackRouterConfig(tanstackRouter);
+	const vitestConfig = getVitestConfig(vitest);
+	const packageJsonConfig = await getPackageJsonConfig(packageJson);
+	const playwrightConfig = await getPlaywrightConfig(playwright);
+	const serverSideConfig = getServerSideConfig(serverSide);
+	const reactConfig = getReactConfig(react);
+	const i18nConfig = getI18nConfig(i18n);
+	const importConfig = getImportConfig(importOptions);
+	const restrictedConfig = getRestrictedConfig(restricted);
+	const rawMergedConfig = mergeConfigs$1(baseConfig, vitestConfig, tanstackRouterConfig, packageJsonConfig, playwrightConfig, tailwindConfig, serverSideConfig, restrictedConfig, reactConfig, i18nConfig, importConfig, config);
+	const restrictedSyntaxConfig = getRestrictedSyntaxConfig({
+		banBarrelImport: importOptions?.banBarrel,
+		banReactMemo: react?.banMemo,
+		overrides: restricted?.syntaxOverrides,
+		previousOverrides: rawMergedConfig.overrides?.map((override) => override.rules?.["eslint-js/no-restricted-syntax"] === void 0 ? void 0 : {
+			files: override.files,
+			rules: override.rules["eslint-js/no-restricted-syntax"].slice(1)
+		}).filter(isNonNullish),
+		previousRules: (rawMergedConfig.rules?.["eslint-js/no-restricted-syntax"])?.slice(1),
+		rulesOverrides: restricted?.syntaxRulesOverrides
+	});
+	const { plugins: pluginsRecord = {}, ...mergedConfig } = mergeConfigs$1(rawMergedConfig, restrictedSyntaxConfig);
+	return {
+		...mergedConfig,
+		plugins: Object.entries(pluginsRecord).filter(([, value]) => value).map(([key]) => key)
+	};
+};
+//#endregion
+//#region src/oxfmt.ts
+const getConfig = async ({ ignorePatterns = [], tailwind, imports, sortImports, ...rest } = {}) => ({
+	astro: true,
+	ignorePatterns: [...baseIgnorePatterns, ...ignorePatterns],
+	printWidth: 80,
+	sortImports: sortImports ?? (imports ? {
+		newlinesBetween: false,
+		order: "asc",
+		...imports
+	} : true),
+	sortPackageJson: { sortScripts: true },
+	sortTailwindcss: tailwind ? {
+		functions: tailwind.functions,
+		stylesheet: tailwind.stylesheet
+	} : void 0,
+	useTabs: true,
+	...rest
+});
+//#endregion
+//#region src/knip.ts
+const mergeConfigs = (...configs) => configs.reduce(({ include, ignore, ignoreDependencies, entry, ignoreIssues, workspaces = {}, ...rest }, { include: configInclude, ignore: configIgnore, ignoreDependencies: configIgnoreDependencies, entry: configEntry, ignoreIssues: configIgnoreIssues, workspaces: configWorkspaces = {}, ...configRest }) => ({
+	entry: [...arraify(entry), ...arraify(configEntry)],
+	ignore: [...arraify(ignore), ...arraify(configIgnore)],
+	ignoreDependencies: [...arraify(ignoreDependencies), ...arraify(configIgnoreDependencies)],
+	ignoreIssues: {
+		...ignoreIssues,
+		...configIgnoreIssues
+	},
+	include: {
+		...include,
+		...configInclude
+	},
+	workspaces: {
+		...mapValues(workspaces, (workspace, key) => ({
+			...workspace,
+			...configWorkspaces[key]
+		})),
+		...omitBy(configWorkspaces, (_value, key) => Boolean(workspaces[key]))
+	},
+	...rest,
+	...configRest
+}), {});
+const getBaseConfig = ({ opencode = false, reactNative = false, eslint = true, vitest = true, workspaces = false } = {}) => ({
+	entry: workspaces ? [] : ["**/*.config.ts"],
+	ignore: [process.env.CI ? void 0 : ".history/**", opencode ? ".opencode/**" : void 0].filter(isNonNullish),
+	ignoreDependencies: [
+		reactNative ? "expo-doctor" : void 0,
+		vitest ? "@vitest/coverage-v8" : void 0,
+		eslint ? "oxlint-plugin-eslint" : void 0
+	].filter(isNonNullish),
+	ignoreIssues: { "**/*.gen.ts": ["types"] },
+	include: {
+		catalog: true,
+		catalogReferences: true,
+		cycles: true,
+		dependencies: true,
+		duplicates: true,
+		enumMembers: true,
+		exports: true,
+		files: true,
+		namespaceMembers: true,
+		nsExports: true,
+		nsTypes: true,
+		types: true,
+		unlisted: true,
+		unresolved: true
+	},
+	treatConfigHintsAsErrors: true,
+	treatTagHintsAsErrors: true,
+	workspaces: workspaces ? { ".": { entry: ["**/*.config.ts"] } } : {}
+});
+const getConfig$1 = async ({ options, ...overrides } = {}) => {
+	const baseConfig = getBaseConfig(options);
+	const { include: includeRecord = {}, ...mergedConfig } = mergeConfigs(baseConfig, overrides);
+	return {
+		...mergedConfig,
+		include: Object.entries(includeRecord).filter(([, value]) => value).map(([key]) => key)
+	};
+};
+//#endregion
+export { configSchema, disabledRules, getConfig as getFormatConfig, getConfig$1 as getKnipConfig, getConfig$2 as getLintConfig, overridenRules };

package/dist/parse-DnOcFJT0.mjs

@@ -0,0 +1,14 @@
+import { r as moduleName } from "./common-B9SE4GL9.mjs";
+import { t as configSchema } from "./schema-BuCl21uv.mjs";
+import { z } from "zod";
+import { cosmiconfig } from "cosmiconfig";
+//#region src/config/parse.ts
+const explorer = cosmiconfig(moduleName);
+const parse = async () => {
+	const rawConfig = await explorer.search();
+	const parsedConfig = z.safeParse(configSchema, rawConfig?.config ?? {});
+	if (!parsedConfig.success) throw new Error(`Validation error: ${parsedConfig.error.message}`);
+	return parsedConfig.data;
+};
+//#endregion
+export { parse as t };

package/dist/schema-BuCl21uv.mjs

@@ -0,0 +1,23 @@
+import { valid } from "semver";
+import { z } from "zod";
+//#region src/config/schema.ts
+const MIN_NODE_VERSION = "26.0.0";
+const MIN_BUN_VERSION = "1.4.4";
+const configSchema = z.object({
+	preCommitCommands: z.string().array().optional(),
+	verify: z.object({
+		minBunVersion: z.string().refine((version) => valid(version)).default(() => MIN_BUN_VERSION),
+		minNodeVersion: z.string().refine((version) => valid(version)).default(() => MIN_NODE_VERSION),
+		scripts: z.record(z.string(), z.string()).optional()
+	}).default(() => ({
+		minBunVersion: MIN_BUN_VERSION,
+		minNodeVersion: MIN_NODE_VERSION
+	})),
+	workflows: z.object({
+		branch: z.string().optional(),
+		jobs: z.record(z.string(), z.custom()).optional(),
+		workflows: z.custom().array().optional()
+	}).optional()
+});
+//#endregion
+export { configSchema as t };

package/dist/workflows/index.d.mts

@@ -0,0 +1,2 @@
+import { a as getDefaultWorkflow, c as getLintJob, d as getTypecheckJob, f as getWorkflowsVerifyJob, i as getCheckJob, l as getPackageJsonVerifyJob, m as Workflow, n as generateWorkflows, o as getDepsJob, p as CompositeAction, r as DEFAULT_MACHINE, s as getFormatVerifyJob, t as GeneratedWorkflowTypes, u as getSetupAction } from "../index-DqMadVlO.mjs";
+export { type CompositeAction, DEFAULT_MACHINE, type GeneratedWorkflowTypes, type Workflow, generateWorkflows, getCheckJob, getDefaultWorkflow, getDepsJob, getFormatVerifyJob, getLintJob, getPackageJsonVerifyJob, getSetupAction, getTypecheckJob, getWorkflowsVerifyJob };

package/dist/workflows/index.mjs

@@ -0,0 +1 @@
+export { n as DEFAULT_MACHINE, t as generateWorkflows, r as getCheckJob, i as getDefaultWorkflow, a as getDepsJob, o as getFormatVerifyJob, s as getLintJob, c as getPackageJsonVerifyJob, l as getSetupAction, u as getTypecheckJob, d as getWorkflowsVerifyJob } from "../generate-BGCgStVl.mjs";

package/package.json

@@ -1,6 +1,85 @@
 {
-  "name": "@oxiul/configs",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
-}
+	"name": "@oxiul/configs",
+	"version": "0.4.0",
+	"license": "MIT",
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/oxiul/configs.git"
+	},
+	"bin": {
+		"oxiul": "./dist/bin.mjs"
+	},
+	"files": [
+		"dist/**",
+		"scripts/postinstall.mjs"
+	],
+	"type": "module",
+	"sideEffects": false,
+	"main": "./dist/index.mjs",
+	"module": "./dist/index.mjs",
+	"exports": {
+		".": {
+			"types": "./dist/index.d.mts",
+			"default": "./dist/index.mjs"
+		},
+		"./workflows": {
+			"types": "./dist/workflows/index.d.mts",
+			"default": "./dist/workflows/index.mjs"
+		}
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"scripts": {
+		"build": "tsdown",
+		"changeset": "changeset add",
+		"deps": "knip",
+		"format": "oxfmt --write",
+		"format:verify": "oxfmt --check",
+		"lint": "oxlint",
+		"lint:fix": "oxlint --fix",
+		"oxiul:verify": "bun src/bin.ts verify",
+		"postinstall": "node scripts/postinstall.mjs",
+		"typecheck": "bun check",
+		"workflows": "bun src/bin.ts workflows --verify",
+		"workflows:generate": "bun src/bin.ts workflows --generate"
+	},
+	"dependencies": {
+		"@crustjs/core": "^0.5.6",
+		"@crustjs/extensions": "^0.5.6",
+		"@github-actions-workflow-ts/lib": "^2.6.1",
+		"cosmiconfig": "^10.0.1",
+		"listr2": "^11.4.0",
+		"oxlint-plugin-eslint": "^1.88.0",
+		"semver": "^7.8.5",
+		"yaml": "^2.9.1",
+		"zod": "^4.6.7"
+	},
+	"devDependencies": {
+		"@arethetypeswrong/core": "^0.18.5",
+		"@changesets/changelog-github": "^1.0.1",
+		"@changesets/cli": "^3.0.3",
+		"@tanstack/eslint-plugin-router": "^1.162.0",
+		"@types/bun": "1.4.3",
+		"@types/semver": "^7.8.0",
+		"eslint-plugin-better-tailwindcss": "^4.9.1",
+		"eslint-plugin-package-json": "^1.10.1",
+		"eslint-plugin-playwright": "^2.12.1",
+		"knip": "^6.42.0",
+		"oxfmt": "^0.73.0",
+		"oxlint": "^1.88.0",
+		"oxlint-tsgolint": "^7.0.2004",
+		"publint": "^0.3.25",
+		"remeda": "^2.52.0",
+		"tsdown": "^0.23.1"
+	},
+	"peerDependencies": {
+		"knip": "^6.42.0",
+		"oxfmt": "^0.73.0",
+		"oxlint": "^1.88.0"
+	},
+	"engines": {
+		"node": "26"
+	},
+	"packageManager": "bun@1.4.4"
+}

package/scripts/postinstall.mjs

@@ -0,0 +1,39 @@
+import { execFileSync, spawnSync } from "node:child_process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+
+if (process.env.CI) {
+	process.exit(0);
+}
+
+const readName = (dir) => {
+	try {
+		// oxlint-disable-next-line typescript/no-unsafe-argument
+		const fileContent = readFileSync(path.join(dir, "package.json"), "utf8");
+		// oxlint-disable-next-line typescript/no-unsafe-return typescript/no-unsafe-member-access
+		return JSON.parse(fileContent).name;
+	} catch {
+		return undefined;
+	}
+};
+
+// oxlint-disable-next-line typescript/no-unsafe-assignment
+const ownName = readName(process.cwd());
+
+let gitRoot = "";
+try {
+	gitRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], {
+		encoding: "utf8",
+		stdio: ["ignore", "pipe", "ignore"],
+	}).trim();
+} catch {
+	process.exit(0);
+}
+
+const [cmd, ...args] =
+	readName(gitRoot) === ownName
+		? ["bun", "src/hook/install.ts"]
+		: ["node", "dist/hook/install.mjs"];
+
+const result = spawnSync(cmd, args, { stdio: "inherit" });
+process.exit(result.status ?? 1);