@jameswyse/oxc-config 0.1.0

package/dist/vendor/anti-slop/rules/no-reflect-get.js

@@ -0,0 +1,26 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { isGlobalReflectMethodCall } from "../shared/reflect-method.js";
+export const noReflectGet = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.",
+        },
+        messages: {
+            reflectGet: "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it.",
+        },
+    },
+    createOnce(context) {
+        return {
+            CallExpression(node) {
+                if (node.callee.type === "Super" || node.callee.type === "V8IntrinsicExpression") {
+                    return;
+                }
+                if (isGlobalReflectMethodCall(context.sourceCode, node.callee, "get")) {
+                    context.report({ node, messageId: "reflectGet" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-runtime-typeof.d.ts

@@ -0,0 +1 @@
+export declare const noRuntimeTypeof: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-runtime-typeof.js

@@ -0,0 +1,63 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+function isRuntimeFunction(node) {
+    return (node.type === "ArrowFunctionExpression" ||
+        node.type === "FunctionDeclaration" ||
+        node.type === "FunctionExpression");
+}
+function isInsideTypeGuard(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (isRuntimeFunction(current)) {
+            return current.returnType?.typeAnnotation.type === "TSTypePredicate";
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isExistenceProbe(node) {
+    const parent = node.parent;
+    if (parent.type !== "BinaryExpression") {
+        return false;
+    }
+    if (!["===", "!==", "==", "!="].includes(parent.operator)) {
+        return false;
+    }
+    const other = parent.left === node ? parent.right : parent.left;
+    return other.type === "Literal" && other.value === "undefined";
+}
+export const noRuntimeTypeof = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow runtime typeof checks; external values must be decoded into meaningful types at their I/O boundary.",
+        },
+        messages: {
+            runtimeTypeof: "A `typeof` check narrows a representation without establishing its contract. Parse input at its I/O boundary, then branch on the domain value.",
+        },
+        schema: [
+            {
+                type: "object",
+                properties: { allowInTypeGuards: { type: "boolean" } },
+                additionalProperties: false,
+            },
+        ],
+        defaultOptions: [{ allowInTypeGuards: false }],
+    },
+    createOnce(context) {
+        return {
+            UnaryExpression(node) {
+                const option = context.options[0];
+                const allowInTypeGuards = typeof option === "object" &&
+                    option !== null &&
+                    !Array.isArray(option) &&
+                    option.allowInTypeGuards === true;
+                if (node.operator === "typeof" &&
+                    !isExistenceProbe(node) &&
+                    (!allowInTypeGuards || !isInsideTypeGuard(node))) {
+                    context.report({ node, messageId: "runtimeTypeof" });
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-shape-in-symbol-names.d.ts

@@ -0,0 +1 @@
+export declare const noForbiddenTermInSymbolNames: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-shape-in-symbol-names.js

@@ -0,0 +1,37 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+const FORBIDDEN_SYMBOL_NAME = "shape";
+function containsForbiddenSymbolName(name) {
+    return name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME);
+}
+function isBorrowedMemberName(node) {
+    const parent = node.parent;
+    if (parent === null || parent.type !== "MemberExpression") {
+        return false;
+    }
+    return parent.property === node && !parent.computed;
+}
+export const noForbiddenTermInSymbolNames = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: 'Disallow the case-insensitive substring "shape" in JavaScript, TypeScript, private, and JSX symbol names.',
+        },
+        messages: {
+            forbiddenSymbolName: 'Rename symbol "{{name}}" for its domain role; "shape" describes structure rather than ownership.',
+        },
+    },
+    createOnce(context) {
+        const reportForbiddenSymbolName = (node) => {
+            if (!containsForbiddenSymbolName(node.name) || isBorrowedMemberName(node)) {
+                return;
+            }
+            context.report({ node, messageId: "forbiddenSymbolName", data: { name: node.name } });
+        };
+        return {
+            Identifier: reportForbiddenSymbolName,
+            PrivateIdentifier: reportForbiddenSymbolName,
+            JSXIdentifier: reportForbiddenSymbolName,
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-unknown-returns.d.ts

@@ -0,0 +1 @@
+export declare const noUnknownReturns: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-unknown-returns.js

@@ -0,0 +1,61 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+export const noUnknownReturns = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow functions whose explicit return contract is unknown or Promise<unknown>.",
+        },
+        messages: {
+            unknownReturn: "This function exposes `unknown` to its caller. Parse the value at its boundary and return a named domain type.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToUnknown = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSUnknownKeyword") {
+                    return true;
+                }
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                if (resolved.type === "TSUnionType") {
+                    return resolved.types.some(matches);
+                }
+                if (resolved.type !== "TSTypeReference" ||
+                    resolved.typeName.type !== "Identifier" ||
+                    (resolved.typeName.name !== "Promise" && resolved.typeName.name !== "PromiseLike")) {
+                    return false;
+                }
+                const value = resolved.typeArguments?.params[0];
+                return value !== void 0 && matches(value);
+            });
+        const checkReturnType = (node) => {
+            const annotation = node.returnType;
+            if (annotation === null || annotation === void 0) {
+                return;
+            }
+            if (!resolvesToUnknown(annotation.typeAnnotation)) {
+                return;
+            }
+            context.report({ node: annotation.typeAnnotation, messageId: "unknownReturn" });
+        };
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            ArrowFunctionExpression: checkReturnType,
+            FunctionDeclaration: checkReturnType,
+            FunctionExpression: checkReturnType,
+            TSCallSignatureDeclaration: checkReturnType,
+            TSConstructSignatureDeclaration: checkReturnType,
+            TSConstructorType: checkReturnType,
+            TSDeclareFunction: checkReturnType,
+            TSEmptyBodyFunctionExpression: checkReturnType,
+            TSFunctionType: checkReturnType,
+            TSMethodSignature: checkReturnType,
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-unknown-type-aliases.d.ts

@@ -0,0 +1 @@
+export declare const noUnknownTypeAliases: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-unknown-type-aliases.js

@@ -0,0 +1,38 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { createTypeAliasEnvironment, resolvedTypeMatches, } from "../shared/type-alias-resolution.js";
+export const noUnknownTypeAliases = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow type aliases whose resolved type is unknown; unknown must remain visible at an allowed boundary.",
+        },
+        messages: {
+            unknownAlias: "Type alias `{{alias}}` hides `unknown`. Keep `unknown` explicit at the parsing boundary or on an allowed `cause` field; otherwise use the parsed owner type.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const resolvesToUnknown = (type) => environment !== null &&
+            resolvedTypeMatches(type, environment, (resolved, matches) => {
+                if (resolved.type === "TSUnknownKeyword") {
+                    return true;
+                }
+                if (resolved.type === "TSParenthesizedType") {
+                    return matches(resolved.typeAnnotation);
+                }
+                return resolved.type === "TSUnionType" && resolved.types.some(matches);
+            });
+        return {
+            Program(node) {
+                environment = createTypeAliasEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            TSTypeAliasDeclaration(node) {
+                if (!resolvesToUnknown(node.typeAnnotation)) {
+                    return;
+                }
+                context.report({ node: node.id, messageId: "unknownAlias", data: { alias: node.id.name } });
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-unsafe-dictionary-type.d.ts

@@ -0,0 +1 @@
+export declare const noUnsafeDictionaryType: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-unsafe-dictionary-type.js

@@ -0,0 +1,143 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+import { classifyUnsafeDictionary, classifyUnsafeDictionaryValue, createTypeEnvironment, } from "../shared/dictionary-types.js";
+import { visibleTypeAlias } from "../shared/type-alias-resolution.js";
+const typeNodeKinds = new Set([
+    "TSJSDocNonNullableType",
+    "TSJSDocNullableType",
+    "TSJSDocUnknownType",
+    "TSAnyKeyword",
+    "TSArrayType",
+    "TSBigIntKeyword",
+    "TSBooleanKeyword",
+    "TSConditionalType",
+    "TSConstructorType",
+    "TSFunctionType",
+    "TSImportType",
+    "TSIndexedAccessType",
+    "TSInferType",
+    "TSIntersectionType",
+    "TSIntrinsicKeyword",
+    "TSLiteralType",
+    "TSMappedType",
+    "TSNamedTupleMember",
+    "TSNeverKeyword",
+    "TSNullKeyword",
+    "TSNumberKeyword",
+    "TSObjectKeyword",
+    "TSParenthesizedType",
+    "TSStringKeyword",
+    "TSSymbolKeyword",
+    "TSTemplateLiteralType",
+    "TSThisType",
+    "TSTupleType",
+    "TSTypeLiteral",
+    "TSTypeOperator",
+    "TSTypePredicate",
+    "TSTypeQuery",
+    "TSTypeReference",
+    "TSUndefinedKeyword",
+    "TSUnionType",
+    "TSUnknownKeyword",
+    "TSVoidKeyword",
+]);
+function isTypeNode(node) {
+    return typeNodeKinds.has(node.type);
+}
+function typeReferenceName(type) {
+    return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+function isInsideTypeAliasDeclaration(node) {
+    let current = node.parent;
+    while (current !== null && current.type !== "Program") {
+        if (current.type === "TSTypeAliasDeclaration") {
+            return true;
+        }
+        current = current.parent;
+    }
+    return false;
+}
+function isPlainAliasConsumerUse(node, environment) {
+    if (node.type !== "TSTypeReference" || node.typeArguments?.params.length) {
+        return false;
+    }
+    const name = typeReferenceName(node);
+    return (name !== null &&
+        visibleTypeAlias(name, node, environment.typeAliases) !== null &&
+        !isInsideTypeAliasDeclaration(node));
+}
+function isInsideTypeParameterConstraint(node) {
+    let child = node;
+    let parent = node.parent;
+    while (parent.type !== "Program") {
+        if (parent.type === "TSTypeParameter" && parent.constraint === child) {
+            return true;
+        }
+        child = parent;
+        parent = child.parent;
+    }
+    return false;
+}
+function shouldReportType(node, environment) {
+    if (isInsideTypeParameterConstraint(node)) {
+        return false;
+    }
+    if (isPlainAliasConsumerUse(node, environment)) {
+        return false;
+    }
+    if (classifyUnsafeDictionary(node, environment) === null) {
+        return false;
+    }
+    let current = node.parent;
+    while (current.type !== "Program") {
+        if (isTypeNode(current) && classifyUnsafeDictionary(current, environment) !== null) {
+            return false;
+        }
+        current = current.parent;
+    }
+    return true;
+}
+export const noUnsafeDictionaryType = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow object-dictionary contracts whose direct value type is unknown, any, object, {}, or a union/alias containing one of those escape hatches.",
+        },
+        messages: {
+            unsafeDictionary: "This dictionary's {{value}} value type gives callers no concrete value contract. Use an owner/schema-derived value type; parse external payloads before insertion.",
+        },
+    },
+    createOnce(context) {
+        let environment = null;
+        const report = (node, value) => {
+            context.report({ node, messageId: "unsafeDictionary", data: { value } });
+        };
+        const reportIfUnsafe = (node) => {
+            if (environment === null || !shouldReportType(node, environment)) {
+                return;
+            }
+            const unsafe = classifyUnsafeDictionary(node, environment);
+            if (unsafe === null) {
+                return;
+            }
+            report(node, unsafe.unsafeValue);
+        };
+        return {
+            Program(node) {
+                environment = createTypeEnvironment(node, context.sourceCode.visitorKeys);
+            },
+            TSTypeReference: reportIfUnsafe,
+            TSTypeLiteral: reportIfUnsafe,
+            TSMappedType: reportIfUnsafe,
+            TSIndexSignature(node) {
+                if (environment === null || node.parent.type === "TSTypeLiteral") {
+                    return;
+                }
+                const unsafe = classifyUnsafeDictionaryValue(node.typeAnnotation.typeAnnotation, environment);
+                if (unsafe !== null) {
+                    report(node, unsafe.unsafeValue);
+                }
+            },
+        };
+    },
+});

package/dist/vendor/anti-slop/rules/no-widen-then-assert.d.ts

@@ -0,0 +1 @@
+export declare const noWidenThenAssert: import("@oxlint/plugins").Rule;

package/dist/vendor/anti-slop/rules/no-widen-then-assert.js

@@ -0,0 +1,288 @@
+// Adapted from dmmulroy/anti-slop
+import { defineRule } from "@oxlint/plugins";
+const functionBoundaryTypes = new Set([
+    "ArrowFunctionExpression",
+    "FunctionDeclaration",
+    "FunctionExpression",
+    "TSDeclareFunction",
+    "TSEmptyBodyFunctionExpression",
+]);
+const objectTypeKinds = new Set([
+    "TSArrayType",
+    "TSConstructorType",
+    "TSFunctionType",
+    "TSMappedType",
+    "TSObjectKeyword",
+    "TSTupleType",
+]);
+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);
+    if (unwrapped.type === "TSTypeLiteral") {
+        return unwrapped.members.length > 0;
+    }
+    if (unwrapped.type === "TSIntersectionType") {
+        return unwrapped.types.every(isDefinitelyObjectType);
+    }
+    if (unwrapped.type === "TSTypeOperator") {
+        return unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+    }
+    return objectTypeKinds.has(unwrapped.type);
+}
+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 boundary = functionBoundary(declarator);
+    const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
+    const initializerAssertion = assertionFromExpression(declarator.init);
+    const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+    const declaredBroadKind = declaredType === void 0 ? null : broadTypeKind(declaredType);
+    const broadKind = declaredBroadKind ?? initializerBroadKind;
+    if (broadKind === null) {
+        return null;
+    }
+    const originalExpression = initializerAssertion !== null && initializerBroadKind !== null
+        ? assertedExpression(initializerAssertion)
+        : declarator.init;
+    const evidence = knownValueEvidence(originalExpression, 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);
+}
+export const noWidenThenAssert = defineRule({
+    meta: {
+        type: "problem",
+        docs: {
+            description: "Disallow local const flows that explicitly widen a known value before asserting the widened binding to a narrower type.",
+        },
+        messages: {
+            widenThenAssert: 'Binding "{{name}}" discards type evidence and later recreates it with an assertion. Keep the precise type from initialization through use; parse boundary input once.',
+        },
+    },
+    createOnce(context) {
+        let scopes = [];
+        const checkAssertion = (node) => {
+            const expression = assertedExpression(node);
+            if (expression.type !== "Identifier") {
+                return;
+            }
+            const variable = resolvedVariableForIdentifier(scopes, expression);
+            if (variable === null) {
+                return;
+            }
+            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;
+            }
+            context.report({ node, messageId: "widenThenAssert", data: { name: expression.name } });
+        };
+        return {
+            Program() {
+                scopes = context.sourceCode.scopeManager.scopes;
+            },
+            TSAsExpression: checkAssertion,
+            TSTypeAssertion: checkAssertion,
+        };
+    },
+});