oxlint-plugin-effect 0.1.0 → 0.2.1

package/dist/rules/no-unnecessary-pipe-chain.js

@@ -0,0 +1,36 @@
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unnecessary-pipe-chain.ts
+const isMethodPipe = (node) => {
+	if (node.type !== "CallExpression") return false;
+	const callee = node["callee"];
+	if (callee == null || typeof callee !== "object" || !("type" in callee)) return false;
+	if (callee.type !== "MemberExpression") return false;
+	const prop = callee["property"];
+	if (prop == null || typeof prop !== "object" || !("type" in prop)) return false;
+	return prop.type === "Identifier" && "name" in prop && prop.name === "pipe";
+};
+const noUnnecessaryPipeChain = define({
+	name: "no-unnecessary-pipe-chain",
+	meta: meta({
+		type: "suggestion",
+		description: "Avoid chaining .pipe().pipe(). Merge into a single .pipe() call."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (!isMethodPipe(node)) return Effect.void;
+			const obj = node["callee"]["object"];
+			if (obj != null && typeof obj === "object" && isMethodPipe(obj)) return ctx.report(make({
+				node,
+				message: "Unnecessary .pipe() chain. Merge into a single .pipe() call."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noUnnecessaryPipeChain };

package/dist/rules/no-unnecessary-pipe.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-unnecessary-pipe.d.ts
+declare const noUnnecessaryPipe: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noUnnecessaryPipe };

package/dist/rules/no-unnecessary-pipe.js

@@ -0,0 +1,29 @@
+import { calleeName } from "../vendor/effect-oxlint/AST.js";
+import { make } from "../vendor/effect-oxlint/Diagnostic.js";
+import { RuleContext } from "../vendor/effect-oxlint/RuleContext.js";
+import { define, meta } from "../vendor/effect-oxlint/Rule.js";
+import "../vendor/effect-oxlint/index.js";
+import * as Option from "effect/Option";
+import * as Effect from "effect/Effect";
+//#region src/rules/no-unnecessary-pipe.ts
+const noUnnecessaryPipe = define({
+	name: "no-unnecessary-pipe",
+	meta: meta({
+		type: "suggestion",
+		description: "Unnecessary pipe() with single argument. Use the value directly.",
+		fixable: "code"
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (Option.getOrUndefined(calleeName(node)) !== "pipe") return Effect.void;
+			if ("arguments" in node && Array.isArray(node.arguments) && node.arguments.length === 1) return ctx.report(make({
+				node,
+				message: "Unnecessary pipe() with single argument. Use the value directly."
+			}));
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noUnnecessaryPipe };

package/dist/vendor/effect-oxlint/AST.d.ts

@@ -0,0 +1,199 @@
+import * as Arr from "effect/Array";
+import * as Option from "effect/Option";
+import { ESTree } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/AST.d.ts
+declare namespace AST_d_exports {
+  export { calleeName, findAncestor, hasAncestor, importSource, isCallOf, isImport, isMember, matchCallOf, matchImport, matchMember, memberNames, memberPath, narrow, objectGetValue, objectHasKey, objectKeys };
+}
+/**
+ * Match a `MemberExpression` of the form `obj.prop` where `obj` is an
+ * identifier with the given name and `prop` matches one of the given
+ * property names.
+ *
+ * @example
+ * ```ts
+ * // Match JSON.parse or JSON.stringify
+ * AST.matchMember(node, 'JSON', ['parse', 'stringify'])
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const matchMember: {
+  (obj: string, prop: string | ReadonlyArray<string>): (node: ESTree.MemberExpression) => Option.Option<ESTree.StaticMemberExpression>;
+  (node: ESTree.MemberExpression, obj: string, prop: string | ReadonlyArray<string>): Option.Option<ESTree.StaticMemberExpression>;
+};
+/**
+ * Check whether a `MemberExpression` is `obj.prop`.
+ *
+ * Pure boolean predicate — use `matchMember` when you need the narrowed node.
+ *
+ * @since 0.1.0
+ */
+declare const isMember: {
+  (obj: string, prop: string | ReadonlyArray<string>): (node: ESTree.MemberExpression) => boolean;
+  (node: ESTree.MemberExpression, obj: string, prop: string | ReadonlyArray<string>): boolean;
+};
+/**
+ * Match a `CallExpression` whose callee is `obj.prop(...)`.
+ *
+ * Returns the call expression narrowed to confirm its callee is a
+ * static member expression.
+ *
+ * @example
+ * ```ts
+ * AST.matchCallOf(node, 'Effect', 'gen')
+ * AST.matchCallOf(node, 'Effect', ['fn', 'fnUntraced'])
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const matchCallOf: {
+  (obj: string, prop: string | ReadonlyArray<string>): (node: ESTree.CallExpression) => Option.Option<ESTree.CallExpression>;
+  (node: ESTree.CallExpression, obj: string, prop: string | ReadonlyArray<string>): Option.Option<ESTree.CallExpression>;
+};
+/**
+ * Boolean predicate: is this `CallExpression` a call of `obj.prop(...)`?
+ *
+ * @since 0.1.0
+ */
+declare const isCallOf: {
+  (obj: string, prop: string | ReadonlyArray<string>): (node: ESTree.CallExpression) => boolean;
+  (node: ESTree.CallExpression, obj: string, prop: string | ReadonlyArray<string>): boolean;
+};
+/**
+ * Match an `ImportDeclaration` whose source matches a string or predicate.
+ *
+ * @example
+ * ```ts
+ * AST.matchImport(node, 'node:fs')
+ * AST.matchImport(node, (src) => src.startsWith('node:'))
+ * ```
+ *
+ * @since 0.1.0
+ */
+declare const matchImport: {
+  (source: string | ((source: string) => boolean)): (node: ESTree.ImportDeclaration) => Option.Option<ESTree.ImportDeclaration>;
+  (node: ESTree.ImportDeclaration, source: string | ((source: string) => boolean)): Option.Option<ESTree.ImportDeclaration>;
+};
+/**
+ * Boolean predicate: does this `ImportDeclaration` import from the given source?
+ *
+ * @since 0.1.0
+ */
+declare const isImport: {
+  (source: string | ((source: string) => boolean)): (node: ESTree.ImportDeclaration) => boolean;
+  (node: ESTree.ImportDeclaration, source: string | ((source: string) => boolean)): boolean;
+};
+/**
+ * Extract the callee name from a `CallExpression` when the callee is a
+ * bare identifier (e.g. `fetch(...)`).
+ *
+ * @since 0.1.0
+ */
+declare const calleeName: (node: ESTree.CallExpression) => Option.Option<string>;
+/**
+ * Extract the object and property names from a static `MemberExpression`.
+ *
+ * Returns `Option<readonly [objectName, propertyName]>`.
+ *
+ * @since 0.1.0
+ */
+declare const memberNames: (node: ESTree.MemberExpression) => Option.Option<readonly [obj: string, prop: string]>;
+/**
+ * Extract the import source string from an `ImportDeclaration`.
+ *
+ * @since 0.1.0
+ */
+declare const importSource: (node: ESTree.ImportDeclaration) => string;
+/**
+ * Collect the statically-known key names from an `ObjectExpression`.
+ *
+ * Spread elements and computed properties are ignored.
+ *
+ * @since 0.1.0
+ */
+declare const objectKeys: (node: ESTree.ObjectExpression) => ReadonlyArray<string>;
+/**
+ * Check whether an `ObjectExpression` has a property with the given key.
+ *
+ * @since 0.1.0
+ */
+declare const objectHasKey: {
+  (key: string): (node: ESTree.ObjectExpression) => boolean;
+  (node: ESTree.ObjectExpression, key: string): boolean;
+};
+/**
+ * Get the value expression for a given key in an `ObjectExpression`.
+ *
+ * @since 0.1.0
+ */
+declare const objectGetValue: {
+  (key: string): (node: ESTree.ObjectExpression) => Option.Option<ESTree.Expression>;
+  (node: ESTree.ObjectExpression, key: string): Option.Option<ESTree.Expression>;
+};
+declare const narrow: {
+  <T extends string>(type: T): (node: ESTree.Node) => Option.Option<ESTree.Node & {
+    readonly type: T;
+  }>;
+  <T extends string>(node: ESTree.Node, type: T): Option.Option<ESTree.Node & {
+    readonly type: T;
+  }>;
+};
+/**
+ * Extract the full member path from a (possibly chained) `MemberExpression`.
+ *
+ * Walks `a.b.c` → `['a', 'b', 'c']`. Returns `Option.none()` if any
+ * segment is computed or non-identifier.
+ *
+ * @example
+ * ```ts
+ * // node is `Effect.gen` → Some(['Effect', 'gen'])
+ * AST.memberPath(node)
+ * // node is `a.b.c.d` → Some(['a', 'b', 'c', 'd'])
+ * AST.memberPath(node)
+ * // node is `a[b].c` → None (computed segment)
+ * AST.memberPath(node)
+ * ```
+ *
+ * @since 0.2.0
+ */
+declare const memberPath: (node: ESTree.MemberExpression) => Option.Option<Arr.NonEmptyReadonlyArray<string>>;
+/**
+ * Walk the `.parent` chain and return the first ancestor whose `type`
+ * matches the given string.
+ *
+ * Returns the ancestor as an opaque record — callers should narrow
+ * via `type` checks or other AST helpers rather than casting.
+ *
+ * @since 0.1.0
+ */
+declare const findAncestor: {
+  (type: string): (node: {
+    readonly parent?: unknown;
+  }) => Option.Option<{
+    readonly type: string;
+    readonly parent?: unknown;
+  }>;
+  (node: {
+    readonly parent?: unknown;
+  }, type: string): Option.Option<{
+    readonly type: string;
+    readonly parent?: unknown;
+  }>;
+};
+/**
+ * Check whether any ancestor of the node has the given `type`.
+ *
+ * @since 0.1.0
+ */
+declare const hasAncestor: {
+  (type: string): (node: {
+    readonly parent?: unknown;
+  }) => boolean;
+  (node: {
+    readonly parent?: unknown;
+  }, type: string): boolean;
+};
+//#endregion
+export { AST_d_exports, calleeName, findAncestor, hasAncestor, importSource, isCallOf, isImport, isMember, matchCallOf, matchImport, matchMember, memberNames, memberPath, narrow, objectGetValue, objectHasKey, objectKeys };

package/dist/vendor/effect-oxlint/AST.js

@@ -0,0 +1,214 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import * as Arr from "effect/Array";
+import { dual, pipe } from "effect/Function";
+import * as Option from "effect/Option";
+import * as P from "effect/Predicate";
+import * as Result from "effect/Result";
+//#region src/vendor/effect-oxlint/AST.ts
+var AST_exports = /* @__PURE__ */ __exportAll({
+	calleeName: () => calleeName,
+	findAncestor: () => findAncestor,
+	hasAncestor: () => hasAncestor,
+	importSource: () => importSource,
+	isCallOf: () => isCallOf,
+	isImport: () => isImport,
+	isMember: () => isMember,
+	matchCallOf: () => matchCallOf,
+	matchImport: () => matchImport,
+	matchMember: () => matchMember,
+	memberNames: () => memberNames,
+	memberPath: () => memberPath,
+	narrow: () => narrow,
+	objectGetValue: () => objectGetValue,
+	objectHasKey: () => objectHasKey,
+	objectKeys: () => objectKeys
+});
+/** @internal */
+const isIdentifier = (node) => P.isObject(node) && "type" in node && node["type"] === "Identifier" && "name" in node && P.isString(node["name"]);
+/** @internal */
+const identifierName = (node) => isIdentifier(node) ? Option.some(node.name) : Option.none();
+/** @internal */
+const isStaticMember = (node) => !node.computed && node.property.type !== "PrivateIdentifier";
+/**
+* Match a `MemberExpression` of the form `obj.prop` where `obj` is an
+* identifier with the given name and `prop` matches one of the given
+* property names.
+*
+* @example
+* ```ts
+* // Match JSON.parse or JSON.stringify
+* AST.matchMember(node, 'JSON', ['parse', 'stringify'])
+* ```
+*
+* @since 0.1.0
+*/
+const matchMember = dual(3, (node, obj, prop) => {
+	if (!isStaticMember(node)) return Option.none();
+	const props = P.isString(prop) ? [prop] : prop;
+	return pipe(identifierName(node.object), Option.filter((name) => name === obj), Option.flatMap(() => identifierName(node.property)), Option.filter((name) => Arr.contains(props, name)), Option.map(() => node));
+});
+/**
+* Check whether a `MemberExpression` is `obj.prop`.
+*
+* Pure boolean predicate — use `matchMember` when you need the narrowed node.
+*
+* @since 0.1.0
+*/
+const isMember = dual(3, (node, obj, prop) => Option.isSome(matchMember(node, obj, prop)));
+/**
+* Match a `CallExpression` whose callee is `obj.prop(...)`.
+*
+* Returns the call expression narrowed to confirm its callee is a
+* static member expression.
+*
+* @example
+* ```ts
+* AST.matchCallOf(node, 'Effect', 'gen')
+* AST.matchCallOf(node, 'Effect', ['fn', 'fnUntraced'])
+* ```
+*
+* @since 0.1.0
+*/
+const matchCallOf = dual(3, (node, obj, prop) => node.callee.type === "MemberExpression" ? pipe(matchMember(node.callee, obj, prop), Option.map(() => node)) : Option.none());
+/**
+* Boolean predicate: is this `CallExpression` a call of `obj.prop(...)`?
+*
+* @since 0.1.0
+*/
+const isCallOf = dual(3, (node, obj, prop) => Option.isSome(matchCallOf(node, obj, prop)));
+/**
+* Match an `ImportDeclaration` whose source matches a string or predicate.
+*
+* @example
+* ```ts
+* AST.matchImport(node, 'node:fs')
+* AST.matchImport(node, (src) => src.startsWith('node:'))
+* ```
+*
+* @since 0.1.0
+*/
+const matchImport = dual(2, (node, source) => {
+	const src = node.source.value;
+	return (P.isString(source) ? src === source : source(src)) ? Option.some(node) : Option.none();
+});
+/**
+* Boolean predicate: does this `ImportDeclaration` import from the given source?
+*
+* @since 0.1.0
+*/
+const isImport = dual(2, (node, source) => Option.isSome(matchImport(node, source)));
+/**
+* Extract the callee name from a `CallExpression` when the callee is a
+* bare identifier (e.g. `fetch(...)`).
+*
+* @since 0.1.0
+*/
+const calleeName = (node) => identifierName(node.callee);
+/**
+* Extract the object and property names from a static `MemberExpression`.
+*
+* Returns `Option<readonly [objectName, propertyName]>`.
+*
+* @since 0.1.0
+*/
+const memberNames = (node) => node.computed ? Option.none() : pipe(identifierName(node.object), Option.flatMap((obj) => pipe(identifierName(node.property), Option.map((prop) => [obj, prop]))));
+/**
+* Extract the import source string from an `ImportDeclaration`.
+*
+* @since 0.1.0
+*/
+const importSource = (node) => node.source.value;
+/**
+* Collect the statically-known key names from an `ObjectExpression`.
+*
+* Spread elements and computed properties are ignored.
+*
+* @since 0.1.0
+*/
+const objectKeys = (node) => pipe(node.properties, Arr.filterMap((p) => {
+	if (p.type !== "Property") return Result.fail(void 0);
+	return pipe(identifierName(p.key), Option.orElse(() => p.key.type === "Literal" && P.isString(p.key.value) ? Option.some(p.key.value) : Option.none()), Result.fromOption(() => void 0));
+}));
+/**
+* Check whether an `ObjectExpression` has a property with the given key.
+*
+* @since 0.1.0
+*/
+const objectHasKey = dual(2, (node, key) => Arr.contains(objectKeys(node), key));
+/**
+* Get the value expression for a given key in an `ObjectExpression`.
+*
+* @since 0.1.0
+*/
+const objectGetValue = dual(2, (node, key) => pipe(node.properties, Arr.findFirst((p) => p.type === "Property" && (identifierName(p.key).pipe(Option.map((n) => n === key), Option.getOrElse(() => false)) || p.key.type === "Literal" && p.key.value === key)), Option.map((p) => p.value)));
+/**
+* Narrow an AST node to a specific `type` string, returning `Option<Node>`.
+*
+* This is a safe alternative to casting — returns `Option.none()` if the
+* node's `type` doesn't match.
+*
+* @example
+* ```ts
+* AST.narrow(node, 'Identifier')       // Option<Node & { type: "Identifier" }>
+* AST.narrow(node, 'CallExpression')    // Option<Node & { type: "CallExpression" }>
+* ```
+*
+* @since 0.2.0
+*/
+/** @internal Type guard: does the node's `type` match the literal? */
+const hasType = (node, type) => node.type === type;
+const narrow = dual(2, (node, type) => hasType(node, type) ? Option.some(node) : Option.none());
+/**
+* Extract the full member path from a (possibly chained) `MemberExpression`.
+*
+* Walks `a.b.c` → `['a', 'b', 'c']`. Returns `Option.none()` if any
+* segment is computed or non-identifier.
+*
+* @example
+* ```ts
+* // node is `Effect.gen` → Some(['Effect', 'gen'])
+* AST.memberPath(node)
+* // node is `a.b.c.d` → Some(['a', 'b', 'c', 'd'])
+* AST.memberPath(node)
+* // node is `a[b].c` → None (computed segment)
+* AST.memberPath(node)
+* ```
+*
+* @since 0.2.0
+*/
+const memberPath = (node) => {
+	/** @internal Collect property names from right to left. */
+	const collect = (current, acc) => {
+		if (!P.isObject(current) || !("type" in current) || current.type !== "MemberExpression") return pipe(identifierName(current), Option.map((rootName) => [rootName, ...acc]));
+		if (current.computed) return Option.none();
+		return pipe(identifierName(current.property), Option.flatMap((propName) => collect(current.object, [propName, ...acc])));
+	};
+	return collect(node, []);
+};
+/** @internal Type guard for objects with a string `type` and optional `parent`. */
+const isASTShape = (value) => P.isObject(value) && "type" in value && P.isString(value["type"]);
+/**
+* Walk the `.parent` chain and return the first ancestor whose `type`
+* matches the given string.
+*
+* Returns the ancestor as an opaque record — callers should narrow
+* via `type` checks or other AST helpers rather than casting.
+*
+* @since 0.1.0
+*/
+const findAncestor = dual(2, (node, type) => {
+	const walk = (current) => {
+		if (!isASTShape(current)) return Option.none();
+		if (current.type === type) return Option.some(current);
+		return walk(current.parent);
+	};
+	return walk(node.parent);
+});
+/**
+* Check whether any ancestor of the node has the given `type`.
+*
+* @since 0.1.0
+*/
+const hasAncestor = dual(2, (node, type) => Option.isSome(findAncestor(node, type)));
+//#endregion
+export { AST_exports, calleeName, findAncestor, hasAncestor, importSource, isCallOf, isImport, isMember, matchCallOf, matchImport, matchMember, memberNames, memberPath, narrow, objectGetValue, objectHasKey, objectKeys };

package/dist/vendor/effect-oxlint/Comment.d.ts

@@ -0,0 +1,55 @@
+import { Comment } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Comment.d.ts
+declare namespace Comment_d_exports {
+  export { isBlock, isDisableDirective, isEnableDirective, isJSDoc, isLine, isShebang, text };
+}
+/**
+ * Check whether a comment is a line comment (`// ...`).
+ *
+ * @since 0.2.0
+ */
+declare const isLine: (comment: Comment) => boolean;
+/**
+ * Check whether a comment is a block comment (`/* ... *​/`).
+ *
+ * @since 0.2.0
+ */
+declare const isBlock: (comment: Comment) => boolean;
+/**
+ * Check whether a comment is a shebang (`#!/usr/bin/env node`).
+ *
+ * @since 0.2.0
+ */
+declare const isShebang: (comment: Comment) => boolean;
+/**
+ * Get the text content of a comment (without delimiters).
+ *
+ * @since 0.2.0
+ */
+declare const text: (comment: Comment) => string;
+/**
+ * Check whether a comment is a JSDoc comment (`/** ... *​/`).
+ *
+ * A JSDoc comment is a block comment whose value starts with `*`.
+ *
+ * @since 0.2.0
+ */
+declare const isJSDoc: (comment: Comment) => boolean;
+/**
+ * Check whether a comment is an eslint/oxlint disable directive.
+ *
+ * Matches line comments like `// eslint-disable-next-line ...`
+ * and block comments like `/* eslint-disable ... *​/`.
+ *
+ * @since 0.2.0
+ */
+declare const isDisableDirective: (comment: Comment) => boolean;
+/**
+ * Check whether a comment is an eslint/oxlint enable directive.
+ *
+ * @since 0.2.0
+ */
+declare const isEnableDirective: (comment: Comment) => boolean;
+//#endregion
+export { Comment_d_exports, isBlock, isDisableDirective, isEnableDirective, isJSDoc, isLine, isShebang, text };

package/dist/vendor/effect-oxlint/Comment.js

@@ -0,0 +1,67 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
+import * as Str from "effect/String";
+//#region src/vendor/effect-oxlint/Comment.ts
+var Comment_exports = /* @__PURE__ */ __exportAll({
+	isBlock: () => isBlock,
+	isDisableDirective: () => isDisableDirective,
+	isEnableDirective: () => isEnableDirective,
+	isJSDoc: () => isJSDoc,
+	isLine: () => isLine,
+	isShebang: () => isShebang,
+	text: () => text
+});
+/**
+* Check whether a comment is a line comment (`// ...`).
+*
+* @since 0.2.0
+*/
+const isLine = (comment) => comment.type === "Line";
+/**
+* Check whether a comment is a block comment (`/* ... *​/`).
+*
+* @since 0.2.0
+*/
+const isBlock = (comment) => comment.type === "Block";
+/**
+* Check whether a comment is a shebang (`#!/usr/bin/env node`).
+*
+* @since 0.2.0
+*/
+const isShebang = (comment) => comment.type === "Shebang";
+/**
+* Get the text content of a comment (without delimiters).
+*
+* @since 0.2.0
+*/
+const text = (comment) => comment.value;
+/**
+* Check whether a comment is a JSDoc comment (`/** ... *​/`).
+*
+* A JSDoc comment is a block comment whose value starts with `*`.
+*
+* @since 0.2.0
+*/
+const isJSDoc = (comment) => comment.type === "Block" && Str.startsWith("*")(comment.value);
+/**
+* Check whether a comment is an eslint/oxlint disable directive.
+*
+* Matches line comments like `// eslint-disable-next-line ...`
+* and block comments like `/* eslint-disable ... *​/`.
+*
+* @since 0.2.0
+*/
+const isDisableDirective = (comment) => {
+	const trimmed = Str.trim(comment.value);
+	return Str.startsWith("eslint-disable")(trimmed) || Str.startsWith("oxlint-disable")(trimmed);
+};
+/**
+* Check whether a comment is an eslint/oxlint enable directive.
+*
+* @since 0.2.0
+*/
+const isEnableDirective = (comment) => {
+	const trimmed = Str.trim(comment.value);
+	return Str.startsWith("eslint-enable")(trimmed) || Str.startsWith("oxlint-enable")(trimmed);
+};
+//#endregion
+export { Comment_exports, isBlock, isDisableDirective, isEnableDirective, isJSDoc, isLine, isShebang, text };

package/dist/vendor/effect-oxlint/Diagnostic.d.ts

@@ -0,0 +1,86 @@
+import { Diagnostic as OxlintDiagnostic, DiagnosticData, FixFn, Ranged, Suggestion } from "@oxlint/plugins";
+
+//#region src/vendor/effect-oxlint/Diagnostic.d.ts
+declare namespace Diagnostic_d_exports {
+  export { OxlintDiagnostic as Diagnostic, composeFixes, fromId, insertAfter, insertBefore, make, removeFix, replaceText, withFix, withSuggestions };
+}
+/**
+ * Create a diagnostic with a message and node location.
+ *
+ * @since 0.1.0
+ */
+declare const make: (opts: {
+  readonly node: Ranged;
+  readonly message: string;
+  readonly data?: DiagnosticData;
+}) => OxlintDiagnostic;
+/**
+ * Create a diagnostic using a `messageId` from `meta.messages`.
+ *
+ * @since 0.1.0
+ */
+declare const fromId: (opts: {
+  readonly node: Ranged;
+  readonly messageId: string;
+  readonly data?: DiagnosticData;
+}) => OxlintDiagnostic;
+/**
+ * Attach an autofix function to a diagnostic.
+ *
+ * @since 0.1.0
+ */
+declare const withFix: {
+  (fix: FixFn): (diagnostic: OxlintDiagnostic) => OxlintDiagnostic;
+  (diagnostic: OxlintDiagnostic, fix: FixFn): OxlintDiagnostic;
+};
+/**
+ * Attach suggestion fixes to a diagnostic.
+ *
+ * @since 0.1.0
+ */
+declare const withSuggestions: {
+  (suggestions: ReadonlyArray<Suggestion>): (diagnostic: OxlintDiagnostic) => OxlintDiagnostic;
+  (diagnostic: OxlintDiagnostic, suggestions: ReadonlyArray<Suggestion>): OxlintDiagnostic;
+};
+/**
+ * Composable fix operations.
+ *
+ * Each function returns a `FixFn` that can be passed to `withFix`
+ * or composed via `composeFixes`.
+ *
+ * @since 0.1.0
+ */
+/**
+ * Replace the text of a node or token.
+ *
+ * @since 0.1.0
+ */
+declare const replaceText: (nodeOrToken: Ranged, text: string) => FixFn;
+/**
+ * Insert text before a node or token.
+ *
+ * @since 0.1.0
+ */
+declare const insertBefore: (nodeOrToken: Ranged, text: string) => FixFn;
+/**
+ * Insert text after a node or token.
+ *
+ * @since 0.1.0
+ */
+declare const insertAfter: (nodeOrToken: Ranged, text: string) => FixFn;
+/**
+ * Remove a node or token.
+ *
+ * @since 0.1.0
+ */
+declare const removeFix: (nodeOrToken: Ranged) => FixFn;
+/**
+ * Compose multiple fix functions into one.
+ *
+ * All individual fixes are collected into a single array result.
+ *
+ * @since 0.1.0
+ */
+declare const composeFixes: (...fixes: ReadonlyArray<FixFn>) => FixFn;
+//#endregion
+export { type OxlintDiagnostic as Diagnostic, Diagnostic_d_exports, composeFixes, fromId, insertAfter, insertBefore, make, removeFix, replaceText, withFix, withSuggestions };