oxlint-plugin-effect 0.2.2 → 0.3.0

package/dist/rules/no-effect-all-step-sequencing.js

@@ -0,0 +1,63 @@
+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-effect-all-step-sequencing.ts
+const isAstNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const statefulSteps = new Set([
+	"Atom.set",
+	"Effect.log",
+	"Effect.logDebug",
+	"Effect.logError",
+	"Effect.logFatal",
+	"Effect.logInfo",
+	"Effect.logTrace",
+	"Effect.logWarning",
+	"Fiber.interrupt",
+	"Reactivity.invalidate",
+	"Ref.set",
+	"SubscriptionRef.set"
+]);
+const memberName = (value) => {
+	if (!isAstNode(value) || value.type !== "MemberExpression") return void 0;
+	const object = value["object"];
+	const property = value["property"];
+	if (!isAstNode(object) || !isAstNode(property)) return void 0;
+	if (object.type !== "Identifier" || property.type !== "Identifier") return void 0;
+	return typeof object["name"] === "string" && typeof property["name"] === "string" ? `${object["name"]}.${property["name"]}` : void 0;
+};
+const containsStatefulStep = (value) => {
+	if (Array.isArray(value)) return value.some(containsStatefulStep);
+	if (!isAstNode(value)) return false;
+	if (value.type === "CallExpression" && statefulSteps.has(memberName(value["callee"]) ?? "")) return true;
+	return Object.entries(value).some(([key, child]) => key !== "parent" && containsStatefulStep(child));
+};
+const hasSequentialConcurrency = (value) => {
+	if (!isAstNode(value) || value.type !== "ObjectExpression") return false;
+	return (Array.isArray(value["properties"]) ? value["properties"] : []).some((property) => {
+		if (!isAstNode(property) || property.type !== "Property") return false;
+		const key = property["key"];
+		const propertyValue = property["value"];
+		return isAstNode(key) && (key["name"] === "concurrency" || key["value"] === "concurrency") && isAstNode(propertyValue) && propertyValue["value"] === 1;
+	});
+};
+const noEffectAllStepSequencing = define({
+	name: "no-effect-all-step-sequencing",
+	meta: meta({
+		type: "suggestion",
+		description: "Use a linear Effect pipeline for sequential stateful steps."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (memberName(node.callee) !== "Effect.all" || node.arguments.length < 2) return Effect.void;
+			return hasSequentialConcurrency(node.arguments[1]) && containsStatefulStep(node.arguments[0]) ? ctx.report(make({
+				node,
+				message: "Avoid Effect.all for sequential side-effect steps. Use one explicit linear pipeline with Effect.andThen or Effect.flatMap."
+			})) : Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noEffectAllStepSequencing };

package/dist/rules/no-hand-rolled-tagged-union.d.ts

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

package/dist/rules/no-hand-rolled-tagged-union.js

@@ -0,0 +1,70 @@
+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-hand-rolled-tagged-union.ts
+const isAstNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const getNodeField = (node, field) => {
+	const value = node[field];
+	return isAstNode(value) ? value : void 0;
+};
+const getStringField = (node, field) => {
+	const value = node[field];
+	return typeof value === "string" ? value : void 0;
+};
+const getNodeArrayField = (node, field) => {
+	const value = node[field];
+	return Array.isArray(value) ? value.filter(isAstNode) : void 0;
+};
+const getPropertyKeyName = (node) => {
+	if (node.type === "Identifier" || node.type === "StringLiteral" || node.type === "Literal") return getStringField(node, "name") ?? getStringField(node, "value");
+};
+const isPascalCaseTag = (value) => {
+	if (value.length === 0) return false;
+	const first = value.charAt(0);
+	return first === first.toUpperCase() && first !== first.toLowerCase();
+};
+const isReportableTagLiteral = (member) => {
+	if (member.type !== "TSPropertySignature") return false;
+	const key = getNodeField(member, "key");
+	if (key === void 0 || getPropertyKeyName(key) !== "_tag") return false;
+	const annotation = getNodeField(member, "typeAnnotation");
+	const inner = annotation === void 0 ? void 0 : getNodeField(annotation, "typeAnnotation");
+	if (inner?.type !== "TSLiteralType") return false;
+	const literal = getNodeField(inner, "literal");
+	if (literal === void 0) return false;
+	if (literal.type !== "StringLiteral" && literal.type !== "Literal") return false;
+	const value = getStringField(literal, "value");
+	return value !== void 0 && isPascalCaseTag(value);
+};
+const literalHasTag = (node) => {
+	if (node.type !== "TSTypeLiteral") return false;
+	const members = getNodeArrayField(node, "members");
+	return members !== void 0 && members.some(isReportableTagLiteral);
+};
+const noHandRolledTaggedUnion = define({
+	name: "no-hand-rolled-tagged-union",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Schema.TaggedUnion, Schema.TaggedStruct, or Schema.TaggedErrorClass instead of inline _tag union literals."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { TSUnionType: (node) => {
+			const types = getNodeArrayField(node, "types");
+			if (types === void 0 || types.length < 2) return Effect.void;
+			let tagged = 0;
+			for (const type of types) {
+				if (literalHasTag(type)) tagged += 1;
+				if (tagged >= 2) return ctx.report(make({
+					node,
+					message: "Hand-rolled `_tag` discriminated union. Use Schema.TaggedUnion, Schema.TaggedStruct, or Schema.TaggedErrorClass instead."
+				}));
+			}
+			return Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noHandRolledTaggedUnion };

package/dist/rules/no-make-unsafe.d.ts

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

package/dist/rules/no-make-unsafe.js

@@ -0,0 +1,30 @@
+import { memberNames } 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-make-unsafe.ts
+const noMakeUnsafe = define({
+	name: "no-make-unsafe",
+	meta: meta({
+		type: "problem",
+		description: "Avoid makeUnsafe constructors. Use safe Effectful or Option-returning construction."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (call.callee.type !== "MemberExpression") return Effect.void;
+			if (Option.isNone(memberNames(call.callee))) return Effect.void;
+			if (Option.getOrUndefined(memberNames(call.callee))?.[1] !== "makeUnsafe") return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Do not call `.makeUnsafe(...)`. Use safe Effectful/Option-returning construction instead of bypassing validation."
+			}));
+		} };
+	}
+});
+//#endregion
+export { noMakeUnsafe };

package/dist/rules/no-manual-data-guard.d.ts

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

package/dist/rules/no-manual-data-guard.js

@@ -0,0 +1,56 @@
+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-manual-data-guard.ts
+const isAstNode = (value) => typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+const functionTypes = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression"
+]);
+const findFunction = (node) => {
+	let parent = node.parent;
+	while (isAstNode(parent)) {
+		if (functionTypes.has(parent.type)) return parent;
+		parent = parent.parent;
+	}
+};
+const containsNodeType = (value, nodeTypes) => {
+	if (Array.isArray(value)) return value.some((item) => containsNodeType(item, nodeTypes));
+	if (!isAstNode(value)) return false;
+	if (nodeTypes.has(value.type)) return true;
+	return Object.entries(value).some(([key, child]) => key !== "parent" && containsNodeType(child, nodeTypes));
+};
+const containsInstanceOf = (value) => {
+	if (Array.isArray(value)) return value.some(containsInstanceOf);
+	if (!isAstNode(value)) return false;
+	if (value.type === "BinaryExpression" && value["operator"] === "instanceof") return true;
+	return Object.entries(value).some(([key, child]) => key !== "parent" && containsInstanceOf(child));
+};
+const parameterName = (parameter) => {
+	if (!isAstNode(parameter)) return void 0;
+	if ((parameter.type === "Identifier" || parameter.type === "BindingIdentifier") && typeof parameter["name"] === "string") return parameter["name"];
+};
+const noManualDataGuard = define({
+	name: "no-manual-data-guard",
+	meta: meta({
+		type: "suggestion",
+		description: "Decode unknown data with Schema instead of asserting it with a type predicate."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { TSTypePredicate: (node) => {
+			const fn = findFunction(node);
+			if (fn === void 0 || containsInstanceOf(fn["body"])) return Effect.void;
+			const predicateParameter = parameterName(node.parameterName);
+			return (Array.isArray(fn["params"]) ? fn["params"] : []).some((parameter) => parameterName(parameter) === predicateParameter && containsNodeType(parameter, new Set(["TSUnknownKeyword", "TSAnyKeyword"]))) ? ctx.report(make({
+				node,
+				message: "Avoid promoting unknown data with a manual type predicate. Decode it with the canonical Schema first."
+			})) : Effect.void;
+		} };
+	}
+});
+//#endregion
+export { noManualDataGuard };

package/dist/rules/no-promise-control-flow-in-tests.d.ts

@@ -0,0 +1,6 @@
+import * as _$_oxlint_plugins0 from "@oxlint/plugins";
+
+//#region src/rules/no-promise-control-flow-in-tests.d.ts
+declare const noPromiseControlFlowInTests: _$_oxlint_plugins0.CreateRule;
+//#endregion
+export { noPromiseControlFlowInTests };

package/dist/rules/no-promise-control-flow-in-tests.js

@@ -0,0 +1,94 @@
+import { memberNames } 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-promise-control-flow-in-tests.ts
+const isTestFilename = (filename) => /\.test\.tsx?$/.test(filename) || /\/tests\/.*\.[cm]?tsx?$/.test(filename);
+const promiseChainMethods = new Set([
+	"then",
+	"catch",
+	"finally"
+]);
+const promiseStaticMethods = new Set([
+	"all",
+	"allSettled",
+	"any",
+	"race",
+	"resolve",
+	"reject"
+]);
+const isAsyncFunction = (node) => "async" in node && node.async === true;
+const promiseChainMethodName = (node) => {
+	if (node.callee.type !== "MemberExpression") return void 0;
+	const names = Option.getOrUndefined(memberNames(node.callee));
+	if (names === void 0) return void 0;
+	const [object, property] = names;
+	if (object === "Effect") return void 0;
+	return promiseChainMethods.has(property) ? property : void 0;
+};
+const noPromiseControlFlowInTests = define({
+	name: "no-promise-control-flow-in-tests",
+	meta: meta({
+		type: "problem",
+		description: "Keep test control flow in Effect instead of async/await, try/finally, or Promise chains."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFilename(ctx.filename)) return {};
+		return {
+			TryStatement: (node) => {
+				if (!("finalizer" in node) || node.finalizer == null) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Do not use `try/finally` cleanup in tests. Use Effect scopes."
+				}));
+			},
+			FunctionDeclaration: (node) => isAsyncFunction(node) ? ctx.report(make({
+				node,
+				message: "Do not use async test functions. Return an Effect from the test body."
+			})) : Effect.void,
+			FunctionExpression: (node) => isAsyncFunction(node) ? ctx.report(make({
+				node,
+				message: "Do not use async test functions. Return an Effect from the test body."
+			})) : Effect.void,
+			ArrowFunctionExpression: (node) => isAsyncFunction(node) ? ctx.report(make({
+				node,
+				message: "Do not use async test functions. Return an Effect from the test body."
+			})) : Effect.void,
+			AwaitExpression: (node) => ctx.report(make({
+				node,
+				message: "Do not use `await` in tests. Use `yield*` inside Effect.gen."
+			})),
+			NewExpression: (node) => {
+				const expression = node;
+				if (expression.callee.type !== "Identifier" || expression.callee.name !== "Promise") return Effect.void;
+				return ctx.report(make({
+					node,
+					message: "Do not construct Promise directly in tests. Use Effect.async/Effect.promise at real boundaries."
+				}));
+			},
+			CallExpression: (node) => {
+				const call = node;
+				const chainMethod = promiseChainMethodName(call);
+				if (chainMethod !== void 0) return ctx.report(make({
+					node,
+					message: `Do not use Promise.${chainMethod} style chains in tests. Keep control flow in Effect.`
+				}));
+				if (call.callee.type !== "MemberExpression") return Effect.void;
+				const names = Option.getOrUndefined(memberNames(call.callee));
+				if (names === void 0) return Effect.void;
+				const [object, property] = names;
+				if (object !== "Promise" || !promiseStaticMethods.has(property)) return Effect.void;
+				return ctx.report(make({
+					node,
+					message: `Do not use Promise.${property} in tests. Use Effect concurrency primitives.`
+				}));
+			}
+		};
+	}
+});
+//#endregion
+export { noPromiseControlFlowInTests };

package/dist/rules/no-schema-struct.d.ts

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

package/dist/rules/no-schema-struct.js

@@ -0,0 +1,28 @@
+import { matchCallOf } 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-schema-struct.ts
+const noSchemaStruct = define({
+	name: "no-schema-struct",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Schema.Class instead of Schema.Struct."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			const call = node;
+			if (Option.isNone(matchCallOf(call, "Schema", "Struct"))) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Use Schema.Class instead of Schema.Struct."
+			}));
+		} };
+	}
+});
+//#endregion
+export { noSchemaStruct };

package/dist/rules/no-sleep-in-tests.d.ts

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

package/dist/rules/no-sleep-in-tests.js

@@ -0,0 +1,55 @@
+import { memberNames } 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-sleep-in-tests.ts
+const allowPattern = /\beffect\/no-sleep-in-tests:\s*allow\s+\S/;
+const isTestFilename = (filename) => /\.test\.tsx?$/.test(filename) || /\/tests\/.*\.[cm]?tsx?$/.test(filename);
+const getLine = (node, edge) => {
+	const loc = node["loc"];
+	if (typeof loc !== "object" || loc === null) return void 0;
+	const point = loc[edge];
+	if (typeof point !== "object" || point === null) return void 0;
+	const line = point["line"];
+	return typeof line === "number" ? line : void 0;
+};
+const hasAllowComment = (node, comments) => {
+	const startLine = getLine(node, "start");
+	if (startLine === void 0) return false;
+	return comments.some((comment) => {
+		const endLine = getLine(comment, "end");
+		if (endLine === void 0) return false;
+		if (endLine !== startLine - 1 && endLine !== startLine) return false;
+		return allowPattern.test(comment.value);
+	});
+};
+const noSleepInTests = define({
+	name: "no-sleep-in-tests",
+	meta: meta({
+		type: "problem",
+		description: "Avoid fixed sleeps in tests. Use deterministic synchronization."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		if (!isTestFilename(ctx.filename)) return {};
+		return { CallExpression: (node) => {
+			const call = node;
+			if (call.callee.type !== "MemberExpression") return Effect.void;
+			const names = Option.getOrUndefined(memberNames(call.callee));
+			if (names === void 0) return Effect.void;
+			const [object, property] = names;
+			if (property !== "sleep") return Effect.void;
+			if (object !== "Effect" && object !== "Bun") return Effect.void;
+			if (hasAllowComment(node, ctx.sourceCode.getAllComments())) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: `Avoid ${object}.sleep(...) in tests. Wait on Deferred, polling helpers, or test controls instead of fixed delays.`
+			}));
+		} };
+	}
+});
+//#endregion
+export { noSleepInTests };

package/dist/rules/no-spread.d.ts

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

package/dist/rules/no-spread.js

@@ -0,0 +1,26 @@
+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";
+//#region src/rules/no-spread.ts
+const message = "Avoid spread syntax. Use explicit construction or a named transformation instead.";
+const noSpread = define({
+	name: "no-spread",
+	meta: meta({
+		type: "suggestion",
+		description: message
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		const reportSpread = (node) => ctx.report(make({
+			node,
+			message
+		}));
+		return {
+			SpreadElement: reportSpread,
+			JSXSpreadAttribute: reportSpread
+		};
+	}
+});
+//#endregion
+export { noSpread };

package/dist/rules/no-try-catch.js

@@ -8,7 +8,7 @@ import * as Effect from "effect/Effect";
 import * as Ref from "effect/Ref";
 //#region src/rules/no-try-catch.ts
 /**
-* Ban `try/catch` statements. Context-aware messaging.
+* Ban all `try` statements: try/catch, try/finally, and try/catch/finally.
 *
 * Inside Effect.gen/fn: "Use Effect.try or Effect.tryPromise"
 * Outside: "Wrap with Effect.fn and use Effect.try for error handling"
@@ -19,14 +19,14 @@ const noTryCatch = define({
 	name: "no-try-catch",
 	meta: meta({
 		type: "suggestion",
-		description: "Avoid try/catch. Use Effect.try or Effect.tryPromise."
+		description: "Avoid try/catch/finally blocks. Use Effect error handling and finalization operators."
 	}),
 	create: function* () {
 		const ctx = yield* RuleContext;
 		const [depth, tracker] = yield* makeEffectContextTracker;
 		return merge(tracker, { TryStatement: (node) => Effect.flatMap(Ref.get(depth), (d) => ctx.report(make({
 			node,
-			message: d > 0 ? "Avoid try/catch inside Effect.gen/fn. Use Effect.try({ try: () => ..., catch: (e) => new MyError({ cause: e }) })." : "Avoid try/catch. Wrap this function with Effect.fn and use Effect.try or Effect.tryPromise for error handling."
+			message: d > 0 ? "Avoid try/catch/finally inside Effect.gen/fn. Use Effect.try or Effect.tryPromise for failures and Effect.ensuring or Effect.acquireUseRelease for finalization." : "Avoid try/catch/finally. Use Effect.try or Effect.tryPromise for failures and Effect.ensuring or Effect.acquireUseRelease for finalization."
 		}))) });
 	}
 });

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

@@ -58,7 +58,7 @@ declare const define: <Options = undefined>(config: RuleConfig<Options>) => Crea
  *
  * @since 0.2.0
  */
-type EffectVersion = 'v3' | 'v4' | 'both';
+type EffectVersion = "v3" | "v4" | "both";
 /**
  * Build `RuleMeta` with sensible defaults.
  *
@@ -168,24 +168,24 @@ declare const banStatement: (nodeType: string, opts: {
  * @since 0.3.0
  */
 type BanSpec = {
-  readonly type: 'member';
+  readonly type: "member";
   readonly object: string;
   readonly property: string | ReadonlyArray<string>;
   readonly message: string;
 } | {
-  readonly type: 'call';
+  readonly type: "call";
   readonly name: string | ReadonlyArray<string>;
   readonly message: string;
 } | {
-  readonly type: 'new';
+  readonly type: "new";
   readonly name: string | ReadonlyArray<string>;
   readonly message: string;
 } | {
-  readonly type: 'import';
+  readonly type: "import";
   readonly source: string | ((source: string) => boolean);
   readonly message: string;
 } | {
-  readonly type: 'statement';
+  readonly type: "statement";
   readonly nodeType: string;
   readonly message: string;
 };

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

@@ -3,7 +3,7 @@ import * as Context$1 from "effect/Context";
 import { Context, Diagnostic, ESTree, LanguageOptions, Options, Settings, SourceCode } from "@oxlint/plugins";
 
 //#region src/vendor/effect-oxlint/RuleContext.d.ts
-declare const RuleContext_base: Context$1.ServiceClass<RuleContext, "effect-oxlint/RuleContext", {
+declare const RuleContext_base: Context$1.ServiceClass<RuleContext, "oxlint-plugin-effect/vendor/effect-oxlint/RuleContext", {
   /** Report a lint diagnostic for the current file. */readonly report: (diagnostic: Diagnostic) => Effect.Effect<void>; /** Rule ID in `plugin/rule` form. */
   readonly id: string; /** Absolute path of the file being linted. */
   readonly filename: string; /** Current working directory. */

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

@@ -9,7 +9,7 @@ import * as Context from "effect/Context";
 *
 * @since 0.1.0
 */
-var RuleContext = class extends Context.Service()("effect-oxlint/RuleContext") {};
+var RuleContext = class extends Context.Service()("oxlint-plugin-effect/vendor/effect-oxlint/RuleContext") {};
 /**
 * Build a `RuleContext` value from the raw oxlint `Context`.
 *

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

@@ -866,7 +866,10 @@ const mockRuleContextLayer = (opts) => {
 *
 * @since 0.2.0
 */
-const withMockRuleContext = (effect, opts) => Effect.provide(effect, mockRuleContextLayer(opts));
+const withMockRuleContext = (effect, opts) => {
+	const { context } = createMockContext(opts);
+	return Effect.provideService(effect, RuleContext, fromOxlintContext(context));
+};
 /** @internal Call a visitor handler on a mock AST node. */
 const callHandler = (visitors, key, visitorNode) => {
 	const handler = visitors[key];

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

@@ -18,7 +18,7 @@ declare namespace Visitor_d_exports {
  */
 type EffectHandler<N = ESTree.Node> = {
   bivarianceHack(node: N): Effect.Effect<void, never, RuleContext>;
-}['bivarianceHack'];
+}["bivarianceHack"];
 /**
  * A map from AST node type names (and `"NodeType:exit"` variants) to
  * effectful handlers.

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

@@ -10,4 +10,10 @@ import { SourceCode_d_exports } from "./SourceCode.js";
 import { Testing_d_exports } from "./Testing.js";
 import { Token_d_exports } from "./Token.js";
 import { Comment as OxlintComment, Context, CreateOnceRule, CreateRule, Definition, DefinitionType, ESTree, Fix, FixFn, Fixer, LineColumn, Location, Plugin as OxlintPlugin, Range, Ranged, Reference, Rule as OxlintRule, RuleDocs, RuleMeta, Scope as OxlintScope, ScopeManager, ScopeType, Settings, SourceCode as OxlintSourceCode, Span, Suggestion, Token as OxlintToken, Variable, Visitor as OxlintVisitor } from "@oxlint/plugins";
-export { AST_d_exports as AST, Comment_d_exports as Comment, type Context, type CreateOnceRule, type CreateRule, type Definition, type DefinitionType, Diagnostic_d_exports as Diagnostic, type ESTree, type Fix, type FixFn, type Fixer, type LineColumn, type Location, type OxlintComment, type OxlintPlugin, type OxlintRule, type OxlintScope, type OxlintSourceCode, type OxlintToken, type OxlintVisitor, Plugin_d_exports as Plugin, type Range, type Ranged, type Reference, Rule_d_exports as Rule, RuleContext, type RuleDocs, type RuleMeta, Scope_d_exports as Scope, type ScopeManager, type ScopeType, type Settings, SourceCode_d_exports as SourceCode, type Span, type Suggestion, Testing_d_exports as Testing, Token_d_exports as Token, type Variable, Visitor_d_exports as Visitor, ast, cwd, filename, id, report, sourceCode, text };
+
+//#region src/vendor/effect-oxlint/index.d.ts
+declare namespace index_d_exports {
+  export { AST_d_exports as AST, Comment_d_exports as Comment, Context, CreateOnceRule, CreateRule, Definition, DefinitionType, Diagnostic_d_exports as Diagnostic, ESTree, Fix, FixFn, Fixer, LineColumn, Location, OxlintComment, OxlintPlugin, OxlintRule, OxlintScope, OxlintSourceCode, OxlintToken, OxlintVisitor, Plugin_d_exports as Plugin, Range, Ranged, Reference, Rule_d_exports as Rule, RuleContext, RuleDocs, RuleMeta, Scope_d_exports as Scope, ScopeManager, ScopeType, Settings, SourceCode_d_exports as SourceCode, Span, Suggestion, Testing_d_exports as Testing, Token_d_exports as Token, Variable, Visitor_d_exports as Visitor, ast, cwd, filename, id, report, sourceCode, text };
+}
+//#endregion
+export { AST_d_exports as AST, Comment_d_exports as Comment, type Context, type CreateOnceRule, type CreateRule, type Definition, type DefinitionType, Diagnostic_d_exports as Diagnostic, type ESTree, type Fix, type FixFn, type Fixer, type LineColumn, type Location, type OxlintComment, type OxlintPlugin, type OxlintRule, type OxlintScope, type OxlintSourceCode, type OxlintToken, type OxlintVisitor, Plugin_d_exports as Plugin, type Range, type Ranged, type Reference, Rule_d_exports as Rule, RuleContext, type RuleDocs, type RuleMeta, Scope_d_exports as Scope, type ScopeManager, type ScopeType, type Settings, SourceCode_d_exports as SourceCode, type Span, type Suggestion, Testing_d_exports as Testing, Token_d_exports as Token, type Variable, Visitor_d_exports as Visitor, ast, cwd, filename, id, index_d_exports, report, sourceCode, text };

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

@@ -1,3 +1,4 @@
+import { __exportAll } from "../../_virtual/_rolldown/runtime.js";
 import { AST_exports } from "./AST.js";
 import { Comment_exports } from "./Comment.js";
 import { Diagnostic_exports } from "./Diagnostic.js";
@@ -9,4 +10,26 @@ import { Scope_exports } from "./Scope.js";
 import { SourceCode_exports } from "./SourceCode.js";
 import { Testing_exports } from "./Testing.js";
 import { Token_exports } from "./Token.js";
-export { AST_exports as AST, Comment_exports as Comment, Diagnostic_exports as Diagnostic, Plugin_exports as Plugin, Rule_exports as Rule, RuleContext, Scope_exports as Scope, SourceCode_exports as SourceCode, Testing_exports as Testing, Token_exports as Token, Visitor_exports as Visitor, ast, cwd, filename, id, report, sourceCode, text };
+//#region src/vendor/effect-oxlint/index.ts
+var effect_oxlint_exports = /* @__PURE__ */ __exportAll({
+	AST: () => AST_exports,
+	Comment: () => Comment_exports,
+	Diagnostic: () => Diagnostic_exports,
+	Plugin: () => Plugin_exports,
+	Rule: () => Rule_exports,
+	RuleContext: () => RuleContext,
+	Scope: () => Scope_exports,
+	SourceCode: () => SourceCode_exports,
+	Testing: () => Testing_exports,
+	Token: () => Token_exports,
+	Visitor: () => Visitor_exports,
+	ast: () => ast,
+	cwd: () => cwd,
+	filename: () => filename,
+	id: () => id,
+	report: () => report,
+	sourceCode: () => sourceCode,
+	text: () => text
+});
+//#endregion
+export { AST_exports as AST, Comment_exports as Comment, Diagnostic_exports as Diagnostic, Plugin_exports as Plugin, Rule_exports as Rule, RuleContext, Scope_exports as Scope, SourceCode_exports as SourceCode, Testing_exports as Testing, Token_exports as Token, Visitor_exports as Visitor, ast, cwd, effect_oxlint_exports, filename, id, report, sourceCode, text };