@venizia/dev-configs 0.2.1 → 0.3.1-0

package/README.md

@@ -1,35 +1,55 @@
 # @venizia/dev-configs
 
-The ESLint, Prettier and TypeScript settings every IGNIS package is built with. Install it as a dev
-dependency in an application that wants the same rules.
+The oxlint, oxfmt, ESLint, Prettier and TypeScript settings every IGNIS package is built with. Install
+it as a dev dependency in an application that wants the same rules.
 
 ## Install
 
 ```bash
-bun add -d @venizia/dev-configs eslint prettier typescript
+bun add -d @venizia/dev-configs oxlint oxlint-tsgolint oxfmt eslint typescript
 ```
 
-`eslint` (9 or 10), `prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the
-tools you use.
+`oxlint` (>=1.88.0), `oxlint-tsgolint` (>=7.0.2004), `oxfmt` (>=0.73.0), `eslint` (9 or 10),
+`prettier` (3) and `typescript` (5 or 6) are optional peers. Install only the tools you use. Keep the
+ESLint config `.mjs`: a TypeScript one (`.mts`) makes ESLint require `jiti`, one more dependency. A
+project that still runs ESLint and Prettier installs `eslint prettier` and skips the oxc tools.
 
 ## Use it
 
-Each tool takes one file.
+Each tool takes one file. IGNIS keeps them in a `.configs/` folder and passes `-c` to each tool.
 
-```javascript
-// eslint.config.mjs
-import { eslintConfigs } from '@venizia/dev-configs';
+```typescript
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { oxlintConfigs } from '@venizia/dev-configs/linters';
 
-export default [{ ignores: ['dist/'] }, ...eslintConfigs];
+export default defineConfig(oxlintConfigs);
 ```
 
-```javascript
-// .prettierrc.mjs
-import { prettierConfigs } from '@venizia/dev-configs';
+```typescript
+// .configs/oxfmt.config.mts
+import { defineConfig } from 'oxfmt';
+import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
 
-export default prettierConfigs;
+export default defineConfig(oxfmtConfigs);
 ```
 
+```typescript
+// .configs/eslint.config.mjs - the one rule oxlint cannot run yet
+import { namingConventionConfigs } from '@venizia/dev-configs/linters';
+
+export default namingConventionConfigs;
+```
+
+```bash
+oxlint -c .configs/oxlint.config.mts --deny-warnings
+eslint -c .configs/eslint.config.mjs .
+oxfmt -c .configs/oxfmt.config.mts --check "**/*.{ts,tsx,mts,js,mjs}"
+```
+
+`tsconfig.json` stays at the project root. Bun, the editor and oxlint's type-aware engine only find it
+there.
+
 ```json
 // tsconfig.json
 {
@@ -38,39 +58,159 @@ export default prettierConfigs;
     "outDir": "dist",
     "rootDir": "src",
     "experimentalDecorators": true,
-    "emitDecoratorMetadata": true
+    "useDefineForClassFields": false
   },
   "include": ["src"]
 }
 ```
 
-## Declare the decorator flag in your own tsconfig
+The two options in `compilerOptions` repeat the base on purpose - see
+[Restate the runtime options](#restate-the-runtime-options-in-your-own-tsconfig).
 
-The base config sets `experimentalDecorators`. But Bun can miss a flag inherited through `extends`
-when it runs your source. Parameter decorators are then dropped with no error, and an `@inject`
-value is `undefined` at run time.
+### Browser and React projects
 
-Declare `experimentalDecorators: true` in your application's own `tsconfig.json`, as in the example
-earlier. Every IGNIS example does.
+The presets above target a Bun or Node backend. Code that runs in a browser swaps each one for its
+browser version. A React project swaps it for the React version, which builds on the browser one.
+
+| Tool | Backend | Browser | React |
+| :--- | :--- | :--- | :--- |
+| oxlint | `oxlintConfigs` | `BrowserOxlintConfigs.create()` | `ReactOxlintConfigs.create()` |
+| oxfmt | `oxfmtConfigs` | `browserOxfmtConfigs` | `browserOxfmtConfigs` |
+| ESLint | `namingConventionConfigs` | `namingConventionConfigs` | `reactNamingConventionConfigs` |
+| tsconfig | `tsconfig.common.json` | `tsconfig.browser.json` | `tsconfig.react.json` |
+
+## Restate the runtime options in your own tsconfig
+
+Bun ignores an `extends` that names a package. With `"extends": "@venizia/dev-configs/tsconfig.common.json"`,
+`bun run` and `bun test` see none of the preset's options - even one level deep (measured on Bun 1.4.2).
+Bun then compiles TC39 decorators: a parameter decorator such as `@inject` is dropped with no error,
+and a method decorator such as `@provide` receives the wrong arguments. Class fields get define
+semantics, while the `tsc` build uses assign semantics.
+
+`tsc` follows the whole chain, so typecheck and build stay green. Only what Bun runs diverges, which
+is why nothing reports it.
+
+In every `tsconfig.json` that Bun runs - an application, a package whose tests run under
+`bun test`, a browser or React project tested with Bun - restate the options that change the emitted
+code:
+
+```json
+"experimentalDecorators": true,
+"useDefineForClassFields": false
+```
+
+Every IGNIS package and example does.
 
 | Flag | Base value | Why |
 | :--- | :--- | :--- |
 | `experimentalDecorators` | `true` | `@inject`, `@controller`, `@repository` and the other decorators need it |
-| `emitDecoratorMetadata` | `true` | Optional. IGNIS reads `design:paramtypes` once, to validate a `@repository` constructor, and skips the check when the metadata is absent |
+| `emitDecoratorMetadata` | `true` | Optional - restate it only if your code reads `design:*` metadata. IGNIS reads `design:paramtypes` once, to validate a `@repository` constructor, and skips the check when the metadata is absent. Under Bun it turns an interface-typed constructor parameter into a runtime import, so import such names with `import type` |
 | `useDefineForClassFields` | `false` | Class fields are assigned, not defined, so a subclass field initializer does not shadow a value the base constructor set |
 
 ## Entry points
 
 | Entry point | What it gives |
 | :--- | :--- |
-| `@venizia/dev-configs` | `eslintConfigs` (flat config array), `ReactEslintConfigs`, `prettierConfigs`, `BunCompiler` |
-| `@venizia/dev-configs/tsconfig.base.json` | Target and lib ES2024, `module` Node16, strict mode with `noImplicitAny`, `strictPropertyInitialization` and `useUnknownInCatchVariables` off, `noEmitOnError`, tests excluded |
+| `@venizia/dev-configs` | Everything below, re-exported |
+| `@venizia/dev-configs/compilers` | `BunCompiler` |
+| `@venizia/dev-configs/formatters` | `oxfmtConfigs`, `browserOxfmtConfigs`, `prettierConfigs` |
+| `@venizia/dev-configs/linters` | `oxlintConfigs`, `BrowserOxlintConfigs`, `ReactOxlintConfigs`, `namingConventionConfigs`, `reactNamingConventionConfigs`, `eslintConfigs`, `ReactEslintConfigs`, the rule classes and their types |
+| `@venizia/dev-configs/tsconfig.base.json` | Target and lib ES2025, `module` Node16, strict mode with `noImplicitAny`, `strictPropertyInitialization` and `useUnknownInCatchVariables` off, `noEmitOnError`, tests excluded |
 | `@venizia/dev-configs/tsconfig.common.json` | Extends the base and switches `module` and `moduleResolution` to `nodenext` |
+| `@venizia/dev-configs/tsconfig.browser.json` | Extends the base for a browser library built with a bundler: `module` ESNext, `moduleResolution` bundler, lib ES2025 + `DOM` + `DOM.Iterable`, `types: []` so no Bun types reach `dist` |
+| `@venizia/dev-configs/tsconfig.react.json` | Extends `tsconfig.browser.json` and sets `jsx: react-jsx` |
 
 ## What each config sets
 
-`eslintConfigs` is `@minimaltech/eslint-node` (ESLint recommended, typescript-eslint, Prettier as a
-lint rule, naming conventions, `curly`, `eslint-plugin-n`) plus these IGNIS rules:
+### oxlintConfigs
+
+`oxlintConfigs` (type `OxlintConfig`) is a static port of the `eslintConfigs` rules, generated with
+`@oxlint/migrate`. It enables the `typescript` and `unicorn` plugins and type-aware linting, so it needs
+`oxlint-tsgolint`.
+
+Not ported:
+
+| Rule | Why |
+| :--- | :--- |
+| `@typescript-eslint/naming-convention` | oxlint has no equivalent yet - `namingConventionConfigs` runs it in ESLint |
+| `@typescript-eslint/prefer-optional-chain` | In oxlint's nursery |
+| `no-invalid-this` | `noImplicitThis` in `tsconfig.base.json` covers it |
+| `n/prefer-node-protocol` | Maps to `unicorn/prefer-node-protocol` |
+
+### namingConventionConfigs
+
+`namingConventionConfigs` (type `Linter.Config[]`) sets only `@typescript-eslint/naming-convention`, with
+the 15 LoopBack 4 selectors. It targets `.ts`, `.tsx`, `.mts` and `.cts`, and ignores `dist`, `build`,
+`coverage`, `*.d.ts` and plain JavaScript. ESLint does not report unused disable comments in this
+config, because oxlint owns the other rules.
+
+### Rule classes
+
+Each rule has a class with `static readonly NAME` and `static build(options)`. `build` returns the rule
+entry with the IGNIS defaults. Every `severity` defaults to `'error'`.
+
+| Class | Rule name | `build` options (default) |
+| :--- | :--- | :--- |
+| `EqeqeqRule` | `eqeqeq` | `mode`: `'always' \| 'smart'` (`'smart'`) |
+| `NoUnusedVarsRule` | `no-unused-vars` | `vars` (`'all'`), `args` (`'none'`), `ignoreRestSiblings` (`false`) |
+| `SwitchCaseBracesRule` | `unicorn/switch-case-braces` | `mode`: `'always' \| 'avoid'` (`'always'`) |
+| `NoRestrictedImportsRule` | `no-restricted-imports` | `extraPaths`: `IRestrictedImportPath[]` (none), added to `PATHS` (lodash) |
+| `NoRestrictedPropertiesRule` | `no-restricted-properties` | `extraProperties`: `IRestrictedProperty[]` (none), added to `SECURE_CONTEXT` (`crypto.randomUUID`) |
+| `PreferNullishCoalescingRule` | `typescript/prefer-nullish-coalescing` | `ignoreConditionalTests`, `ignoreMixedLogicalExpressions`, `ignoreTernaryTests` (oxlint's own defaults) |
+| `NamingConventionRule` | `@typescript-eslint/naming-convention` | `extraSelectors`: `TNamingSelector[]` (none), added after `SELECTORS` |
+
+Types: `TRuleSeverity`, `TOxlintRuleEntry`, `TNamingSelector`, `IRestrictedImportPath`.
+
+Replace a rule by key. This makes `==` an error everywhere and bans one more import:
+
+```typescript
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import {
+  EqeqeqRule,
+  NoRestrictedImportsRule,
+  oxlintConfigs,
+} from '@venizia/dev-configs/linters';
+
+export default defineConfig({
+  ...oxlintConfigs,
+  rules: {
+    ...oxlintConfigs.rules,
+    [EqeqeqRule.NAME]: EqeqeqRule.build({ mode: 'always' }),
+    [NoRestrictedImportsRule.NAME]: NoRestrictedImportsRule.build({
+      extraPaths: [{ name: 'moment', message: 'Use TemporalHelper instead.' }],
+    }),
+  },
+});
+```
+
+### oxfmtConfigs and prettierConfigs
+
+`oxfmtConfigs` (type `OxfmtConfig`) and `prettierConfigs` hold the same seven options, so the output
+matches. oxfmt differs from Prettier on long union types, which it breaks with a leading `|` per line.
+
+| Setting | Value |
+| :--- | :--- |
+| `printWidth` | `100` |
+| `tabWidth` | `2` |
+| `singleQuote` | `true` |
+| `semi` | `true` |
+| `trailingComma` | `'all'` |
+| `bracketSpacing` | `true` |
+| `arrowParens` | `'avoid'` |
+
+`browserOxfmtConfigs` is `oxfmtConfigs` with two changes for browser and React code:
+
+| Setting | Value | Effect |
+| :--- | :--- | :--- |
+| `arrowParens` | `'always'` | `(x) => x` instead of `x => x` |
+| `bracketSameLine` | `true` | The closing `>` of a multi-line JSX element stays on its last attribute line, which keeps JSX diffs small |
+
+### eslintConfigs
+
+`eslintConfigs` keeps its shape and resolves to the same rules as before, but is now owned here instead
+of wrapping `@minimaltech/eslint-node`: ESLint recommended, typescript-eslint, Prettier as a lint
+rule, naming conventions, `curly`, `eslint-plugin-n`, plus these IGNIS rules:
 
 | Rule | Setting |
 | :--- | :--- |
@@ -79,6 +219,8 @@ lint rule, naming conventions, `curly`, `eslint-plugin-n`) plus these IGNIS rule
 | `@typescript-eslint/no-namespace` | `error` |
 | `unicorn/switch-case-braces` | `['error', 'always']` |
 
+### ReactEslintConfigs
+
 `ReactEslintConfigs.create({ plugins })` is `eslintConfigs` plus what a React frontend needs. The
 plugins come in as options, so a backend installs none of them:
 
@@ -99,13 +241,13 @@ export default [
 | :--- | :--- |
 | React correctness (`jsx-key`, `no-children-prop`, `no-deprecated`, ... - 14 rules) | `error`, `.jsx`/`.tsx` |
 | `jsx-a11y` basics (`alt-text`, `aria-props`, `aria-role`, ... - 9 rules) | `error`, `.jsx`/`.tsx` |
-| `react-hooks/rules-of-hooks` / `exhaustive-deps` | `error` / `warn`, every source file |
+| `react-hooks/rules-of-hooks` / `exhaustive-deps` | `error`, every source file |
 | `@typescript-eslint/consistent-type-imports` | `['error', { prefer: 'type-imports' }]` |
 | `naming-convention` | the base rule, plus PascalCase functions (`function App()`), `.jsx`/`.tsx` |
-| `no-floating-promises`, `no-void`, `no-invalid-this`, `no-use-before-define` | `off` - a UI fires promises from handlers and uses components above their declaration |
-| `no-explicit-any` | `warn` (the base has it `off`) |
-| `no-shadow` | `warn` |
-| `no-unused-vars` | `warn`, `_`-prefixed names ignored |
+| `no-restricted-properties` | `NoRestrictedPropertiesRule.build()` - bans `crypto.randomUUID` |
+
+Nothing in the base is relaxed: frontend code meets the backend's standard, so a floating promise, a
+`void`, a use before declaration or a shadowed name fails the lint as it does in a service.
 
 Rules the automatic JSX runtime or `tsc` already enforce (`react-in-jsx-scope`, `prop-types`,
 `jsx-no-undef`, ...) are left out.
@@ -116,17 +258,57 @@ Rules the automatic JSX runtime or `tsc` already enforce (`react-in-jsx-scope`,
 - `consistent-type-imports` keeps the default `fixStyle`; a codebase that prefers
   `inline-type-imports` sets it on top.
 
-`prettierConfigs`:
+### BrowserOxlintConfigs
 
-| Setting | Value |
-| :--- | :--- |
-| `printWidth` | `100` |
-| `tabWidth` | `2` |
-| `singleQuote` | `true` |
-| `semi` | `true` |
-| `trailingComma` | `'all'` |
-| `bracketSpacing` | `true` |
-| `arrowParens` | `'avoid'` |
+`BrowserOxlintConfigs.create()` is `oxlintConfigs` plus `NoRestrictedPropertiesRule.build()`. That
+rule bans `crypto.randomUUID`, which exists only in a secure context (https, localhost). On a
+plain-http origin or in a WebView, the method is `undefined`. Use this preset for browser code that
+does not use React.
+
+```ts
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { BrowserOxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(BrowserOxlintConfigs.create());
+```
+
+### ReactOxlintConfigs and reactNamingConventionConfigs
+
+The oxlint version of the React preset. oxlint runs the React, hooks and `jsx-a11y` rules natively, so
+nothing is passed in. Pair it with `reactNamingConventionConfigs` on the ESLint side:
+
+```ts
+// .configs/oxlint.config.mts
+import { defineConfig } from 'oxlint';
+import { ReactOxlintConfigs } from '@venizia/dev-configs/linters';
+
+export default defineConfig(ReactOxlintConfigs.create());
+
+// .configs/eslint.config.mjs
+import { reactNamingConventionConfigs } from '@venizia/dev-configs/linters';
+
+export default reactNamingConventionConfigs;
+```
+
+`ReactOxlintConfigs.create()` is `BrowserOxlintConfigs.create()` plus the same rules as the ESLint
+table above, as strict as the base. `react/no-deprecated` is left out: oxlint has no port of it.
+
+The presets start strict. An application that wants less overrides the rule after the preset:
+
+```ts
+const base = ReactOxlintConfigs.create();
+
+export default defineConfig({
+  ...base,
+  rules: { ...base.rules, 'typescript/no-floating-promises': 'warn' },
+});
+```
+
+`reactNamingConventionConfigs` is `namingConventionConfigs` plus PascalCase functions in `.jsx` and
+`.tsx` files.
+
+### BunCompiler
 
 `BunCompiler.compile()` builds one Bun executable: minified, with a linked source map. The
 compile target comes from `BUN_TARGET` and defaults to `bun-linux-x64`.
@@ -146,6 +328,7 @@ The root of the chain, with no IGNIS dependency: **dev-configs** -> inversion ->
 
 - [Tooling configuration](https://ignis.venizia.ai/best-practices/code-style-standards/tooling)
 - [TypeScript 6 and toolchain changelog](https://ignis.venizia.ai/changelogs/2026-03-31-typescript-6-and-toolchain)
+- [oxlint and oxfmt changelog](https://ignis.venizia.ai/changelogs/2026-10-16-oxlint-oxfmt-migration)
 - [Changelog](https://ignis.venizia.ai/changelogs/)
 - [Source](https://github.com/VENIZIA-AI/ignis/blob/main/packages/dev-configs)
 

package/dist/{compile.d.ts → compilers/bun.d.ts}

@@ -12,4 +12,4 @@ export declare class BunCompiler {
         plugins?: Bun.BunPlugin[];
     }): Promise<void>;
 }
-//# sourceMappingURL=compile.d.ts.map
+//# sourceMappingURL=bun.d.ts.map

package/dist/compilers/bun.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.d.ts","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":"AAIA,gHAAgH;AAChH,qBAAa,WAAW;IACtB;;;;OAIG;WACU,OAAO,CAClB,IAAI,GAAE;QACJ,UAAU,CAAC,EAAE,MAAM,CAAC;QACpB,OAAO,CAAC,EAAE,MAAM,CAAC;QACjB,MAAM,CAAC,EAAE,MAAM,CAAC;QAChB,OAAO,CAAC,EAAE,GAAG,CAAC,SAAS,EAAE,CAAC;KACtB,GACL,OAAO,CAAC,IAAI,CAAC;CAgCjB"}

package/dist/{compile.js → compilers/bun.js}

@@ -1,9 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.BunCompiler = void 0;
-const DEFAULT_ENTRYPOINT = "./dist/index.js";
-const DEFAULT_OUTFILE = "./dist/bin";
-const DEFAULT_COMPILE_TARGET = "bun-linux-x64";
+const DEFAULT_ENTRYPOINT = './dist/index.js';
+const DEFAULT_OUTFILE = './dist/bin';
+const DEFAULT_COMPILE_TARGET = 'bun-linux-x64';
 /** Bundles and compiles a single Bun executable: minified, linked sourcemaps, target read from `BUN_TARGET`. */
 class BunCompiler {
     /**
@@ -15,12 +15,11 @@ class BunCompiler {
         const { entrypoint = DEFAULT_ENTRYPOINT, outfile = DEFAULT_OUTFILE, target = Bun.env.BUN_TARGET ?? DEFAULT_COMPILE_TARGET, plugins = [], } = opts;
         const built = await Bun.build({
             entrypoints: [entrypoint],
-            target: "bun",
+            target: 'bun',
             minify: { whitespace: true, syntax: true },
-            sourcemap: "linked",
+            sourcemap: 'linked',
             throw: false,
             compile: {
-                // `target` is read from an environment variable at runtime, so it cannot be checked against Bun's literal union at compile time.
                 target: target,
                 outfile,
             },
@@ -31,10 +30,10 @@ class BunCompiler {
             // create a circular workspace dependency, so a failed compile throws a plain `Error` instead.
             throw new Error([
                 `[BunCompiler] compile failed for entrypoint "${entrypoint}":`,
-                ...built.logs.map((log) => `[${log.level}] ${log.message}`),
-            ].join("\n"));
+                ...built.logs.map(log => `[${log.level}] ${log.message}`),
+            ].join('\n'));
         }
     }
 }
 exports.BunCompiler = BunCompiler;
-//# sourceMappingURL=compile.js.map
+//# sourceMappingURL=bun.js.map

package/dist/compilers/bun.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bun.js","sourceRoot":"","sources":["../../src/compilers/bun.ts"],"names":[],"mappings":";;;AAAA,MAAM,kBAAkB,GAAG,iBAAiB,CAAC;AAC7C,MAAM,eAAe,GAAG,YAAY,CAAC;AACrC,MAAM,sBAAsB,GAAG,eAAe,CAAC;AAE/C,gHAAgH;AAChH,MAAa,WAAW;IACtB;;;;OAIG;IACH,MAAM,CAAC,KAAK,CAAC,OAAO,CAClB,OAKI,EAAE;QAEN,MAAM,EACJ,UAAU,GAAG,kBAAkB,EAC/B,OAAO,GAAG,eAAe,EACzB,MAAM,GAAG,GAAG,CAAC,GAAG,CAAC,UAAU,IAAI,sBAAsB,EACrD,OAAO,GAAG,EAAE,GACb,GAAG,IAAI,CAAC;QAET,MAAM,KAAK,GAAG,MAAM,GAAG,CAAC,KAAK,CAAC;YAC5B,WAAW,EAAE,CAAC,UAAU,CAAC;YACzB,MAAM,EAAE,KAAK;YACb,MAAM,EAAE,EAAE,UAAU,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE;YAC1C,SAAS,EAAE,QAAQ;YACnB,KAAK,EAAE,KAAK;YACZ,OAAO,EAAE;gBACP,MAAM,EAAE,MAAiC;gBACzC,OAAO;aACR;YACD,OAAO;SACR,CAAC,CAAC;QAEH,IAAI,CAAC,KAAK,CAAC,OAAO,EAAE,CAAC;YACnB,4FAA4F;YAC5F,8FAA8F;YAC9F,MAAM,IAAI,KAAK,CACb;gBACE,gDAAgD,UAAU,IAAI;gBAC9D,GAAG,KAAK,CAAC,IAAI,CAAC,GAAG,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,GAAG,CAAC,KAAK,KAAK,GAAG,CAAC,OAAO,EAAE,CAAC;aAC1D,CAAC,IAAI,CAAC,IAAI,CAAC,CACb,CAAC;QACJ,CAAC;IACH,CAAC;CACF;AA7CD,kCA6CC"}

package/dist/compilers/index.d.ts

@@ -0,0 +1,2 @@
+export * from './bun';
+//# sourceMappingURL=index.d.ts.map

package/dist/compilers/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/compilers/index.ts"],"names":[],"mappings":"AAAA,cAAc,OAAO,CAAC"}

package/dist/compilers/index.js

@@ -0,0 +1,18 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./bun"), exports);
+//# sourceMappingURL=index.js.map

package/dist/compilers/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/compilers/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,wCAAsB"}

package/dist/formatters/index.d.ts

@@ -0,0 +1,3 @@
+export * from './oxfmt';
+export * from './prettier';
+//# sourceMappingURL=index.d.ts.map

package/dist/formatters/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":"AAAA,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC"}

package/dist/formatters/index.js

@@ -0,0 +1,19 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./oxfmt"), exports);
+__exportStar(require("./prettier"), exports);
+//# sourceMappingURL=index.js.map

package/dist/formatters/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/formatters/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,0CAAwB;AACxB,6CAA2B"}

package/dist/formatters/oxfmt.d.ts

@@ -0,0 +1,28 @@
+import type { OxfmtConfig } from 'oxfmt';
+/**
+ * The oxfmt port of `prettierConfigs` - the same seven options, so the output matches Prettier's.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(oxfmtConfigs);
+ * ```
+ */
+export declare const oxfmtConfigs: OxfmtConfig;
+/**
+ * `oxfmtConfigs` for browser and React code: arrow parameters always in parentheses (`(x) => x`),
+ * and the closing `>` of a multi-line JSX element on its last attribute line, which keeps JSX diffs
+ * small. `bracketSameLine` changes nothing outside JSX.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { browserOxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(browserOxfmtConfigs);
+ * ```
+ */
+export declare const browserOxfmtConfigs: OxfmtConfig;
+//# sourceMappingURL=oxfmt.d.ts.map

package/dist/formatters/oxfmt.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxfmt.d.ts","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,OAAO,CAAC;AAEzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,YAAY,EAAE,WAQ1B,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,mBAAmB,EAAE,WAIjC,CAAC"}

package/dist/formatters/oxfmt.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.browserOxfmtConfigs = exports.oxfmtConfigs = void 0;
+/**
+ * The oxfmt port of `prettierConfigs` - the same seven options, so the output matches Prettier's.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { oxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(oxfmtConfigs);
+ * ```
+ */
+exports.oxfmtConfigs = {
+    bracketSpacing: true,
+    singleQuote: true,
+    printWidth: 100,
+    tabWidth: 2,
+    trailingComma: 'all',
+    arrowParens: 'avoid',
+    semi: true,
+};
+/**
+ * `oxfmtConfigs` for browser and React code: arrow parameters always in parentheses (`(x) => x`),
+ * and the closing `>` of a multi-line JSX element on its last attribute line, which keeps JSX diffs
+ * small. `bracketSameLine` changes nothing outside JSX.
+ *
+ * ```ts
+ * // .configs/oxfmt.config.mts
+ * import { defineConfig } from 'oxfmt';
+ * import { browserOxfmtConfigs } from '@venizia/dev-configs/formatters';
+ *
+ * export default defineConfig(browserOxfmtConfigs);
+ * ```
+ */
+exports.browserOxfmtConfigs = {
+    ...exports.oxfmtConfigs,
+    arrowParens: 'always',
+    bracketSameLine: true,
+};
+//# sourceMappingURL=oxfmt.js.map

package/dist/formatters/oxfmt.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"oxfmt.js","sourceRoot":"","sources":["../../src/formatters/oxfmt.ts"],"names":[],"mappings":";;;AAEA;;;;;;;;;;GAUG;AACU,QAAA,YAAY,GAAgB;IACvC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC;AAEF;;;;;;;;;;;;GAYG;AACU,QAAA,mBAAmB,GAAgB;IAC9C,GAAG,oBAAY;IACf,WAAW,EAAE,QAAQ;IACrB,eAAe,EAAE,IAAI;CACtB,CAAC"}

package/dist/formatters/prettier.d.ts

@@ -0,0 +1,3 @@
+import type { Config } from 'prettier';
+export declare const prettierConfigs: Config;
+//# sourceMappingURL=prettier.d.ts.map

package/dist/formatters/prettier.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.d.ts","sourceRoot":"","sources":["../../src/formatters/prettier.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,UAAU,CAAC;AAEvC,eAAO,MAAM,eAAe,EAAE,MAQ7B,CAAC"}

package/dist/{prettier.js → formatters/prettier.js}

@@ -6,8 +6,8 @@ exports.prettierConfigs = {
     singleQuote: true,
     printWidth: 100,
     tabWidth: 2,
-    trailingComma: "all",
-    arrowParens: "avoid",
+    trailingComma: 'all',
+    arrowParens: 'avoid',
     semi: true,
 };
 //# sourceMappingURL=prettier.js.map

package/dist/formatters/prettier.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"prettier.js","sourceRoot":"","sources":["../../src/formatters/prettier.ts"],"names":[],"mappings":";;;AAEa,QAAA,eAAe,GAAW;IACrC,cAAc,EAAE,IAAI;IACpB,WAAW,EAAE,IAAI;IACjB,UAAU,EAAE,GAAG;IACf,QAAQ,EAAE,CAAC;IACX,aAAa,EAAE,KAAK;IACpB,WAAW,EAAE,OAAO;IACpB,IAAI,EAAE,IAAI;CACX,CAAC"}

package/dist/index.d.ts

@@ -1,5 +1,4 @@
-export * from "./compile";
-export * from "./eslint";
-export * from "./prettier";
-export * from "./react";
+export * from './compilers';
+export * from './formatters';
+export * from './linters';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,YAAY,CAAC;AAC3B,cAAc,SAAS,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,aAAa,CAAC;AAC5B,cAAc,cAAc,CAAC;AAC7B,cAAc,WAAW,CAAC"}

package/dist/index.js

@@ -14,8 +14,7 @@ var __exportStar = (this && this.__exportStar) || function(m, exports) {
     for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./compile"), exports);
-__exportStar(require("./eslint"), exports);
-__exportStar(require("./prettier"), exports);
-__exportStar(require("./react"), exports);
+__exportStar(require("./compilers"), exports);
+__exportStar(require("./formatters"), exports);
+__exportStar(require("./linters"), exports);
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,4CAA0B;AAC1B,2CAAyB;AACzB,6CAA2B;AAC3B,0CAAwB"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;AAAA,8CAA4B;AAC5B,+CAA6B;AAC7B,4CAA0B"}

package/dist/linters/browser.d.ts

@@ -0,0 +1,18 @@
+import type { OxlintConfig } from 'oxlint';
+/**
+ * `oxlintConfigs` for code that runs in a browser, React or not: the base rules plus the
+ * secure-context ban (`crypto.randomUUID` is `undefined` on a plain-http origin). Nothing in the base
+ * is relaxed. `ReactOxlintConfigs` builds on this preset.
+ *
+ * ```ts
+ * // .configs/oxlint.config.mts
+ * import { defineConfig } from 'oxlint';
+ * import { BrowserOxlintConfigs } from '@venizia/dev-configs/linters';
+ *
+ * export default defineConfig(BrowserOxlintConfigs.create());
+ * ```
+ */
+export declare class BrowserOxlintConfigs {
+    static create(): OxlintConfig;
+}
+//# sourceMappingURL=browser.d.ts.map

package/dist/linters/browser.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"browser.d.ts","sourceRoot":"","sources":["../../src/linters/browser.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,QAAQ,CAAC;AAI3C;;;;;;;;;;;;GAYG;AACH,qBAAa,oBAAoB;IAC/B,MAAM,CAAC,MAAM,IAAI,YAAY;CAS9B"}