oxlint-plugin-effect 0.7.0 → 0.8.1

package/dist/rules/no-widen-then-assert.js

@@ -0,0 +1,199 @@
+import { fromId } 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-widen-then-assert.ts
+/**
+* Ported from dmmulroy/anti-slop at
+* b5d2288db1f00469a1d5f2e3b0e265e5a5676fd0.
+*/
+const functionBoundaryTypes = new Set([
+	"ArrowFunctionExpression",
+	"FunctionDeclaration",
+	"FunctionExpression",
+	"TSDeclareFunction",
+	"TSEmptyBodyFunctionExpression"
+]);
+function unwrapExpressionParentheses(expression) {
+	let current = expression;
+	while (current.type === "ParenthesizedExpression") current = current.expression;
+	return current;
+}
+function unwrapTypeParentheses(type) {
+	let current = type;
+	while (current.type === "TSParenthesizedType") current = current.typeAnnotation;
+	return current;
+}
+function typeReferenceName(type) {
+	return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isUnknownOrAnyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	return unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword";
+}
+function isBroadRecordKeyType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") return true;
+	if (unwrapped.type === "TSUnionType") return unwrapped.types.every(isBroadRecordKeyType);
+	return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === "PropertyKey";
+}
+function isBroadRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeReference") {
+		if (typeReferenceName(unwrapped) === "Readonly") {
+			const [inner] = unwrapped.typeArguments?.params ?? [];
+			return inner !== void 0 && isBroadRecordType(inner);
+		}
+		if (typeReferenceName(unwrapped) !== "Record") return false;
+		const parameters = unwrapped.typeArguments?.params ?? [];
+		return parameters.length === 2 && parameters[0] !== void 0 && parameters[1] !== void 0 && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
+	}
+	if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) return false;
+	const [member] = unwrapped.members;
+	const [parameter] = member?.type === "TSIndexSignature" ? member.parameters : [];
+	return member?.type === "TSIndexSignature" && member.parameters.length === 1 && parameter !== void 0 && isBroadRecordKeyType(parameter.typeAnnotation.typeAnnotation) && isUnknownOrAnyType(member.typeAnnotation.typeAnnotation);
+}
+function broadTypeKind(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSUnknownKeyword" || unwrapped.type === "TSAnyKeyword") return "top";
+	if (unwrapped.type === "TSObjectKeyword") return "object";
+	return isBroadRecordType(unwrapped) ? "record" : null;
+}
+function assertedExpression(node) {
+	return unwrapExpressionParentheses(node.expression);
+}
+function assertionFromExpression(expression) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	return unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion" ? unwrapped : null;
+}
+function normalizedTypeText(sourceText, type) {
+	return sourceText.slice(type.start, type.end).replaceAll(/\s+/gu, "");
+}
+function typesHaveSameSyntax(sourceText, left, right) {
+	return left !== null && normalizedTypeText(sourceText, unwrapTypeParentheses(left)) === normalizedTypeText(sourceText, unwrapTypeParentheses(right));
+}
+function isDefinitelyObjectType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	switch (unwrapped.type) {
+		case "TSArrayType":
+		case "TSConstructorType":
+		case "TSFunctionType":
+		case "TSMappedType":
+		case "TSObjectKeyword":
+		case "TSTupleType": return true;
+		case "TSTypeLiteral": return unwrapped.members.length > 0;
+		case "TSIntersectionType": return unwrapped.types.every(isDefinitelyObjectType);
+		case "TSTypeOperator": return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+		default: return false;
+	}
+}
+function isDefinitelyNarrowerRecordType(type) {
+	const unwrapped = unwrapTypeParentheses(type);
+	if (unwrapped.type === "TSTypeLiteral") return unwrapped.members.some((member) => member.type !== "TSIndexSignature");
+	if (unwrapped.type !== "TSTypeReference") return false;
+	if (typeReferenceName(unwrapped) === "Readonly") {
+		const [inner] = unwrapped.typeArguments?.params ?? [];
+		return inner !== void 0 && isDefinitelyNarrowerRecordType(inner);
+	}
+	if (typeReferenceName(unwrapped) !== "Record") return false;
+	const parameters = unwrapped.typeArguments?.params ?? [];
+	return parameters.length === 2 && parameters[1] !== void 0 && !isUnknownOrAnyType(parameters[1]);
+}
+function functionBoundary(node) {
+	let current = node.parent;
+	while (current !== null && current.type !== "Program") {
+		if (functionBoundaryTypes.has(current.type)) return current;
+		current = current.parent;
+	}
+	return null;
+}
+function resolvedVariableForIdentifier(scopes, identifier) {
+	for (const scope of scopes) {
+		const reference = scope.references.find((candidate) => candidate.identifier.start === identifier.start && candidate.identifier.end === identifier.end);
+		if (reference !== void 0) return reference.resolved;
+	}
+	return null;
+}
+function variableDeclarator(variable) {
+	for (const definition of variable.defs) if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") return definition.node;
+	return null;
+}
+function knownValueEvidence(expression, scopes, boundary, visitedVariables) {
+	const unwrapped = unwrapExpressionParentheses(expression);
+	if (unwrapped.type === "TSAsExpression" || unwrapped.type === "TSTypeAssertion") {
+		if (broadTypeKind(unwrapped.typeAnnotation) !== null) return null;
+		return { type: unwrapped.typeAnnotation };
+	}
+	if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral") return { type: null };
+	if (unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "ObjectExpression") return { type: null };
+	if (unwrapped.type !== "Identifier") return null;
+	const variable = resolvedVariableForIdentifier(scopes, unwrapped);
+	if (variable === null || visitedVariables.has(variable)) return null;
+	const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== void 0);
+	const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
+	if (annotation !== void 0 && annotatedIdentifier !== void 0) {
+		if (functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null) return null;
+		return { type: annotation };
+	}
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init) || functionBoundary(declarator) !== boundary) return null;
+	return knownValueEvidence(declarator.init, scopes, boundary, new Set([...visitedVariables, variable]));
+}
+function widenedBinding(variable, scopes) {
+	const declarator = variableDeclarator(variable);
+	if (declarator === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || declarator.id.type !== "Identifier" || declarator.init === null || variable.references.some((reference) => reference.isWrite() && !reference.init)) return null;
+	const identifier = variable.identifiers.find((candidate) => candidate.start === declarator.id.start && candidate.end === declarator.id.end);
+	const boundary = functionBoundary(declarator);
+	const declaredType = identifier?.typeAnnotation?.typeAnnotation;
+	const initializerAssertion = assertionFromExpression(declarator.init);
+	const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+	const broadKind = (declaredType === void 0 ? null : broadTypeKind(declaredType)) ?? initializerBroadKind;
+	if (broadKind === null) return null;
+	const evidence = knownValueEvidence(initializerAssertion !== null && initializerBroadKind !== null ? assertedExpression(initializerAssertion) : declarator.init, scopes, boundary, new Set([variable]));
+	return evidence === null ? null : {
+		broadKind,
+		evidence,
+		declaredAt: declarator.end,
+		boundary
+	};
+}
+function assertionIsNarrower(sourceText, broadKind, evidence, assertedType) {
+	if (broadTypeKind(assertedType) !== null) return false;
+	if (broadKind === "top") return true;
+	if (typesHaveSameSyntax(sourceText, evidence.type, assertedType)) return true;
+	if (broadKind === "object") return isDefinitelyObjectType(assertedType);
+	return isDefinitelyNarrowerRecordType(assertedType);
+}
+/** Detect immutable local bindings that erase a known type and are later asserted back to a narrower type. */
+const noWidenThenAssert = define({
+	name: "no-widen-then-assert",
+	meta: meta({
+		type: "problem",
+		description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type.",
+		messages: { widenThenAssert: "Binding \"{{name}}\" erases established type evidence by widening the value, then reconstructs that evidence with a type assertion. Preserve the precise type end-to-end; if the input is genuinely unknown, parse it once at the boundary instead." }
+	}),
+	create: function* () {
+		const context = yield* RuleContext;
+		const scopes = context.sourceCode.scopeManager.scopes;
+		const checkAssertion = (node) => {
+			const expression = assertedExpression(node);
+			if (expression.type !== "Identifier") return Effect.void;
+			const variable = resolvedVariableForIdentifier(scopes, expression);
+			if (variable === null) return Effect.void;
+			const widened = widenedBinding(variable, scopes);
+			if (widened === null || node.start <= widened.declaredAt || functionBoundary(node) !== widened.boundary || !assertionIsNarrower(context.sourceCode.text, widened.broadKind, widened.evidence, node.typeAnnotation)) return Effect.void;
+			return context.report(fromId({
+				node,
+				messageId: "widenThenAssert",
+				data: { name: expression.name }
+			}));
+		};
+		return {
+			TSAsExpression: checkAssertion,
+			TSTypeAssertion: checkAssertion
+		};
+	}
+});
+//#endregion
+export { noWidenThenAssert };

package/dist/rules/prefer-effect-fn.d.ts

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

package/dist/rules/prefer-effect-fn.js

@@ -0,0 +1,31 @@
+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/prefer-effect-fn.ts
+const isStaticMember = (node, object, property) => node.type === "MemberExpression" && !node.computed && node.object.type === "Identifier" && node.object.name === object && node.property.type === "Identifier" && node.property.name === property;
+const isEffectGenCall = (node) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, "Effect", "gen");
+const isEffectWithSpanCall = (node) => node.type === "CallExpression" && node.callee.type !== "Super" && isStaticMember(node.callee, "Effect", "withSpan");
+const spansEffectGenDirectly = (node) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === "withSpan" && isEffectGenCall(node.callee.object);
+const pipesOnlyWithSpanFromEffectGen = (node) => node.callee.type !== "Super" && node.callee.type === "MemberExpression" && !node.callee.computed && node.callee.property.type === "Identifier" && node.callee.property.name === "pipe" && isEffectGenCall(node.callee.object) && node.arguments.length === 1 && node.arguments[0] !== void 0 && isEffectWithSpanCall(node.arguments[0]);
+const preferEffectFn = define({
+	name: "prefer-effect-fn",
+	meta: meta({
+		type: "suggestion",
+		description: "Use Effect.fn for a named generator operation."
+	}),
+	create: function* () {
+		const ctx = yield* RuleContext;
+		return { CallExpression: (node) => {
+			if (node.type !== "CallExpression") return Effect.void;
+			if (!spansEffectGenDirectly(node) && !pipesOnlyWithSpanFromEffectGen(node)) return Effect.void;
+			return ctx.report(make({
+				node,
+				message: "Avoid a span on Effect.gen. Define the named operation with Effect.fn."
+			}));
+		} };
+	}
+});
+//#endregion
+export { preferEffectFn };

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

@@ -196,4 +196,4 @@ declare const hasAncestor: {
   }, type: string): boolean;
 };
 //#endregion
-export { AST_d_exports, calleeName, findAncestor, hasAncestor, importSource, isCallOf, isImport, isMember, matchCallOf, matchImport, matchMember, memberNames, memberPath, narrow, objectGetValue, objectHasKey, objectKeys };
+export { AST_d_exports };

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

@@ -211,4 +211,4 @@ const findAncestor = dual(2, (node, type) => {
 */
 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 };
+export { AST_exports, calleeName, importSource, matchImport, matchMember, memberNames, narrow };

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

@@ -52,4 +52,4 @@ declare const isDisableDirective: (comment: Comment) => boolean;
  */
 declare const isEnableDirective: (comment: Comment) => boolean;
 //#endregion
-export { Comment_d_exports, isBlock, isDisableDirective, isEnableDirective, isJSDoc, isLine, isShebang, text };
+export { Comment_d_exports };

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

@@ -64,4 +64,4 @@ const isEnableDirective = (comment) => {
 	return Str.startsWith("eslint-enable")(trimmed) || Str.startsWith("oxlint-enable")(trimmed);
 };
 //#endregion
-export { Comment_exports, isBlock, isDisableDirective, isEnableDirective, isJSDoc, isLine, isShebang, text };
+export { Comment_exports };

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

@@ -83,4 +83,4 @@ declare const removeFix: (nodeOrToken: Ranged) => FixFn;
  */
 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 };
+export { Diagnostic_d_exports };

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

@@ -112,4 +112,4 @@ const extractFixes = (result) => {
 */
 const composeFixes = (...fixes) => (fixer) => Arr.flatMap(fixes, (fn) => Array.from(extractFixes(fn(fixer))));
 //#endregion
-export { Diagnostic_exports, composeFixes, fromId, insertAfter, insertBefore, make, removeFix, replaceText, withFix, withSuggestions };
+export { Diagnostic_exports, fromId, make, replaceText, withFix };

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

@@ -35,4 +35,4 @@ declare const define: (config: {
  */
 declare const merge: (...plugins: ReadonlyArray<OxlintPlugin>) => OxlintPlugin;
 //#endregion
-export { type OxlintPlugin as Plugin, Plugin_d_exports, define, merge };
+export { OxlintPlugin, Plugin_d_exports };

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

@@ -42,4 +42,4 @@ const merge = (...plugins) => ({
 	}))
 });
 //#endregion
-export { Plugin_exports, define, merge };
+export { Plugin_exports, define };

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

@@ -215,4 +215,4 @@ declare const banMultiple: (config: {
   readonly specs: ReadonlyArray<BanSpec>;
 }) => CreateRule;
 //#endregion
-export { BanSpec, EffectVersion, RuleConfig, Rule_d_exports, banCallOf, banImport, banMember, banMultiple, banNewExpr, banStatement, define, meta };
+export { Rule_d_exports };

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

@@ -306,4 +306,4 @@ const banMultiple = (config) => {
 	});
 };
 //#endregion
-export { Rule_exports, banCallOf, banImport, banMember, banMultiple, banNewExpr, banStatement, define, meta };
+export { Rule_exports, banMember, define, meta };

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

@@ -22,12 +22,6 @@ declare const RuleContext_base: Context$1.ServiceClass<RuleContext, "oxlint-plug
  * @since 0.1.0
  */
 declare class RuleContext extends RuleContext_base {}
-/**
- * Build a `RuleContext` value from the raw oxlint `Context`.
- *
- * @internal
- */
-declare const fromOxlintContext: (ctx: Context) => RuleContext["Service"];
 /**
  * Effectful access to the rule ID.
  *
@@ -74,4 +68,4 @@ declare const ast: Effect.Effect<ESTree.Program, never, RuleContext>;
  */
 declare const report: (diagnostic: Diagnostic) => Effect.Effect<void, never, RuleContext>;
 //#endregion
-export { RuleContext, ast, cwd, filename, fromOxlintContext, id, report, sourceCode, text };
+export { RuleContext, ast, cwd, filename, id, report, sourceCode, text };

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

@@ -97,4 +97,4 @@ declare const throughReferences: (scope: Scope) => ReadonlyArray<Reference>;
  */
 declare const isStrict: (scope: Scope) => boolean;
 //#endregion
-export { Scope_d_exports, childScopes, findVariable, findVariableUp, getReadReferences, getReferences, getWriteReferences, isReadOnly, isStrict, isUsed, isWritten, throughReferences, upper, variables };
+export { Scope_d_exports };

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

@@ -107,4 +107,4 @@ const throughReferences = (scope) => scope.through;
 */
 const isStrict = (scope) => scope.isStrict;
 //#endregion
-export { Scope_exports, childScopes, findVariable, findVariableUp, getReadReferences, getReferences, getWriteReferences, isReadOnly, isStrict, isUsed, isWritten, throughReferences, upper, variables };
+export { Scope_exports, findVariableUp };

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

@@ -177,4 +177,4 @@ declare const isSpaceBetween: (first: ESTree.Node | Token | Comment, second: EST
  */
 declare const getLines: () => Effect.Effect<ReadonlyArray<string>, never, RuleContext>;
 //#endregion
-export { SourceCode_d_exports, commentsExistBetween, getAllComments, getAncestors, getCommentsAfter, getCommentsBefore, getCommentsInside, getDeclaredVariables, getFirstToken, getFirstTokenBetween, getIndexFromLoc, getJSDocComment, getLastToken, getLines, getLocFromIndex, getNodeByRangeIndex, getRange, getScope, getText, getTokenAfter, getTokenBefore, getTokenByRangeStart, getTokens, getTokensBetween, isGlobalReference, isSpaceBetween, markVariableAsUsed };
+export { SourceCode_d_exports };

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

@@ -200,4 +200,4 @@ const isSpaceBetween = (first, second) => withSourceCode((sc) => sc.isSpaceBetwe
 */
 const getLines = () => withSourceCode((sc) => sc.getLines());
 //#endregion
-export { SourceCode_exports, commentsExistBetween, getAllComments, getAncestors, getCommentsAfter, getCommentsBefore, getCommentsInside, getDeclaredVariables, getFirstToken, getFirstTokenBetween, getIndexFromLoc, getJSDocComment, getLastToken, getLines, getLocFromIndex, getNodeByRangeIndex, getRange, getScope, getText, getTokenAfter, getTokenBefore, getTokenByRangeStart, getTokens, getTokensBetween, isGlobalReference, isSpaceBetween, markVariableAsUsed };
+export { SourceCode_exports, isGlobalReference };

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

@@ -507,4 +507,4 @@ declare const expectDiagnostics: (result: ReadonlyArray<ReportedDiagnostic>, exp
  */
 declare const expectNoDiagnostics: (result: ReadonlyArray<ReportedDiagnostic>) => void;
 //#endregion
-export { MockContextOptions, ReportedDiagnostic, Testing_d_exports, arrowFn, astNode, binaryExpr, blockStmt, boolLiteral, callExpr, callOfMember, chainedMemberExpr, classDecl, comment, computedMemberExpr, createMockContext, doWhileStmt, expectDiagnostics, expectNoDiagnostics, exportNamedDecl, exprStmt, forInStmt, forOfStmt, forStmt, id, ifStmt, importDecl, importDeclWithSpecifiers, importNamespaceSpecifier, importSpecifier, interfaceDecl, memberExpr, messageIds, messages, methodDef, mockRuleContextLayer, newExpr, numLiteral, objectExpr, objectExprLiteralKeys, objectExprWithSpread, program, propertyDef, returnStmt, runRule, runRuleMulti, scope, strLiteral, switchStmt, throwStmt, token, tryStmt, tsAsExpr, tsTypeLiteral, tsTypeRef, tsUnionType, typeAliasDecl, unaryExpr, varDecl, varDeclarator, variable, whileStmt, withMockRuleContext, withParentChain, yieldExpr };
+export { Testing_d_exports };

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

@@ -963,4 +963,4 @@ const expectNoDiagnostics = (result) => Arr.match(result, {
 	}
 });
 //#endregion
-export { Testing_exports, arrowFn, astNode, binaryExpr, blockStmt, boolLiteral, callExpr, callOfMember, chainedMemberExpr, classDecl, comment, computedMemberExpr, createMockContext, doWhileStmt, expectDiagnostics, expectNoDiagnostics, exportNamedDecl, exprStmt, forInStmt, forOfStmt, forStmt, id, ifStmt, importDecl, importDeclWithSpecifiers, importNamespaceSpecifier, importSpecifier, interfaceDecl, memberExpr, messageIds, messages, methodDef, mockRuleContextLayer, newExpr, numLiteral, objectExpr, objectExprLiteralKeys, objectExprWithSpread, program, propertyDef, returnStmt, runRule, runRuleMulti, scope, strLiteral, switchStmt, throwStmt, token, tryStmt, tsAsExpr, tsTypeLiteral, tsTypeRef, tsUnionType, typeAliasDecl, unaryExpr, varDecl, varDeclarator, variable, whileStmt, withMockRuleContext, withParentChain, yieldExpr };
+export { Testing_exports };

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

@@ -95,4 +95,4 @@ declare const value: (token: Token) => string;
  */
 declare const type: (token: Token) => string;
 //#endregion
-export { Token_d_exports, isBoolean, isIdentifier, isKeyword, isNull, isNumeric, isPrivateIdentifier, isPunctuator, isRegularExpression, isString, isTemplate, type, value };
+export { Token_d_exports };

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

@@ -100,4 +100,4 @@ const value = (token) => token.value;
 */
 const type = (token) => token.type;
 //#endregion
-export { Token_exports, isBoolean, isIdentifier, isKeyword, isNull, isNumeric, isPrivateIdentifier, isPunctuator, isRegularExpression, isString, isTemplate, type, value };
+export { Token_exports };

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

@@ -163,4 +163,4 @@ declare const accumulate: <A>(nodeType: string, extract: (node: ESTree.Node) =>
  */
 declare const toOxlintVisitor: (effectVisitor: EffectVisitor, runHandler: (effect: Effect.Effect<void, never, RuleContext>) => void) => Visitor;
 //#endregion
-export { EffectHandler, EffectVisitor, TypedEffectVisitor, VisitorNodeType, Visitor_d_exports, accumulate, filter, merge, on, onExit, toOxlintVisitor, tracked };
+export { EffectVisitor, Visitor_d_exports };

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

@@ -135,4 +135,4 @@ const accumulate = (nodeType, extract, analyze) => Effect.gen(function* () {
 */
 const toOxlintVisitor = (effectVisitor, runHandler) => R.map(effectVisitor, (handler) => (node) => runHandler(handler(node)));
 //#endregion
-export { Visitor_exports, accumulate, filter, merge, on, onExit, toOxlintVisitor, tracked };
+export { Visitor_exports, merge, toOxlintVisitor };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "oxlint-plugin-effect",
-  "version": "0.7.0",
+  "version": "0.8.1",
   "description": "oxlint plugin with Effect-specific lint rules",
   "license": "MIT",
   "repository": {
@@ -8,7 +8,8 @@
     "url": "https://github.com/cevr/effect-oxlint"
   },
   "files": [
-    "dist"
+    "dist",
+    "THIRD_PARTY_NOTICES.md"
   ],
   "type": "module",
   "exports": {
@@ -48,8 +49,9 @@
     "fmt": "oxfmt",
     "fmt:check": "oxfmt --check",
     "test": "bun run build && bun test",
-    "gate": "concurrently -n type,style,test -c blue,yellow,green \"bun run typecheck\" \"bun run lint\" \"bun run test\"",
+    "gate": "concurrently -n type,style,generated,test -c blue,yellow,magenta,green \"bun run typecheck\" \"bun run lint\" \"bun run codegen:check\" \"bun run test\"",
     "codegen": "bun run scripts/codegen.ts",
+    "codegen:check": "bun run scripts/codegen.ts --check",
     "add-rule": "bun run scripts/add-rule.ts",
     "version": "changeset version",
     "release": "bun run build && changeset publish",