oxlint-plugin-arch 0.11.0 → 0.12.1

package/dist/vendor/dillon-anti-slop/index.js

@@ -0,0 +1,1770 @@
+// src/vendor/dillon-anti-slop/index.ts
+import { eslintCompatPlugin } from "@oxlint/plugins";
+
+// src/vendor/dillon-anti-slop/rules/no-chained-type-assertions.ts
+import { defineRule } from "@oxlint/plugins";
+
+// src/vendor/dillon-anti-slop/shared/expressions.ts
+function expressionsUnwrapParentheses(expression) {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function expressionsIsAssertion(node) {
+  return node.type === "TSAsExpression" || node.type === "TSTypeAssertion";
+}
+function expressionsIsConstAssertion(node) {
+  return node.typeAnnotation.type === "TSTypeReference" && node.typeAnnotation.typeName.type === "Identifier" && node.typeAnnotation.typeName.name === "const";
+}
+
+// src/vendor/dillon-anti-slop/rules/no-chained-type-assertions.ts
+var noChainedTypeAssertionsRule = defineRule({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow chained TypeScript as and angle-bracket assertions, including parenthesized chains."
+    },
+    messages: {
+      chained: "This assertion chain discards type evidence. Keep the original precise type, or parse untrusted input at its boundary before narrowing it."
+    }
+  },
+  createOnce(context) {
+    const checkTypeAssertion = (node) => {
+      let outer = node;
+      let parent = node.parent;
+      while (parent.type === "ParenthesizedExpression" && parent.expression === outer) {
+        outer = parent;
+        parent = parent.parent;
+      }
+      if (expressionsIsAssertion(parent) && parent.expression === outer) {
+        return;
+      }
+      let assertionCount = 0;
+      let hasNonConstAssertion = false;
+      let current = node;
+      while (expressionsIsAssertion(current)) {
+        assertionCount += 1;
+        hasNonConstAssertion ||= !expressionsIsConstAssertion(current);
+        current = expressionsUnwrapParentheses(current.expression);
+      }
+      if (assertionCount > 1 && hasNonConstAssertion) {
+        context.report({ node, messageId: "chained" });
+      }
+    };
+    return {
+      TSAsExpression: checkTypeAssertion,
+      TSTypeAssertion: checkTypeAssertion
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-conditional-empty-object-spread.ts
+import { defineRule as defineRule2 } from "@oxlint/plugins";
+function isEmptyObjectExpression(node) {
+  return node.type === "ObjectExpression" && node.properties.length === 0;
+}
+var noConditionalEmptyObjectSpreadRule = defineRule2({
+  meta: {
+    type: "suggestion",
+    docs: {
+      description: "Disallow object spreads that conditionally spread an empty object to omit fields."
+    },
+    messages: {
+      avoid: "This conditional spread hides property omission behind an empty object. Build the object in separate statements and add the property only when present."
+    }
+  },
+  createOnce(context) {
+    return {
+      SpreadElement(node) {
+        if (node.parent.type !== "ObjectExpression") {
+          return;
+        }
+        const conditional = expressionsUnwrapParentheses(node.argument);
+        if (conditional.type === "ConditionalExpression" && (isEmptyObjectExpression(conditional.consequent) || isEmptyObjectExpression(conditional.alternate))) {
+          context.report({ node, messageId: "avoid" });
+        }
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-known-value-widening.ts
+import { defineRule as defineRule4 } from "@oxlint/plugins";
+
+// src/vendor/dillon-anti-slop/shared/resolve-variable.ts
+function resolveVariable(sourceCode, identifier) {
+  let scope = sourceCode.getScope(identifier);
+  while (scope !== null) {
+    const variable = scope.set.get(identifier.name);
+    if (variable !== undefined) {
+      return variable;
+    }
+    scope = scope.upper;
+  }
+  return null;
+}
+
+// src/utils/ast.utils.ts
+import { defineRule as defineRule3 } from "@oxlint/plugins";
+
+// src/utils/options.utils.ts
+class OptionsError extends Error {
+}
+var optionsPatternSchema = {
+  anyOf: [{ type: "string" }, { type: "array", items: { type: "string" }, minItems: 1 }]
+};
+function optionsFirst(context, fallback) {
+  return context.options[0] ?? fallback;
+}
+function optionsAll(context) {
+  return context.options;
+}
+function optionsPatterns(pattern, flags) {
+  return optionsPatternsWithEmpty(pattern === undefined ? undefined : [pattern].flat().filter((source) => source !== ""), flags);
+}
+function optionsPatternsWithEmpty(pattern, flags) {
+  return pattern === undefined ? [] : [pattern].flat().map((source) => new RegExp(source, flags));
+}
+function optionsPatternsTest(patterns, value) {
+  return patterns.some((pattern) => {
+    pattern.lastIndex = 0;
+    return pattern.test(value);
+  });
+}
+function optionsGlob(pattern) {
+  const negated = [];
+  const source = pattern.replaceAll(/!\(([^()]*)\)/g, (_, options) => {
+    negated.push(options.split("|").map((option) => option.replaceAll(/[.+^$()|[\]\\*?{}]/g, "\\$&")).join("|"));
+    return `\x02${negated.length - 1}\x03`;
+  }).replaceAll(/[.+^$()|[\]\\]/g, "\\$&").replaceAll("?", "[^/]").replaceAll("**/", "\x00").replaceAll("**", "\x01").replaceAll("*", "[^/]*").replaceAll("\x00", "(?:.*/)?").replaceAll("\x01", ".*").replaceAll(/\{([^}]*)\}/g, (_, options) => `(?:${options.split(",").join("|")})`);
+  return new RegExp(`^${negated.reduce((text, names, index) => text.replace(`\x02${index}\x03`, `(?!(?:${names})(?:/|$))[^/]*`), source)}$`);
+}
+function optionsPatternLabel(pattern) {
+  return pattern === undefined ? "" : [pattern].flat().filter((source) => source !== "").join(" | ");
+}
+function optionsAssertMockingApis(patterns) {
+  if (patterns.some((pattern) => !/^(?:\*|(?:vi|jest|\*)\.(?:[A-Za-z_$][\w$]*|\*))$/.test(pattern))) {
+    throw new OptionsError("Test mocking APIs must be `*` or `<vi|jest|*>.<method|*>`.");
+  }
+}
+
+// src/utils/ast.utils.ts
+var astSkippedKeys = new Set(["parent", "type", "start", "end", "range", "loc", "tokens", "comments"]);
+function astIsNode(value) {
+  return value !== null && typeof value === "object" && typeof Reflect.get(value, "type") === "string";
+}
+function astVisit(node, ancestors, callback) {
+  if (Array.isArray(node)) {
+    for (const child of node) {
+      astVisit(child, ancestors, callback);
+    }
+    return;
+  }
+  if (!astIsNode(node)) {
+    return;
+  }
+  callback(node, ancestors);
+  ancestors.push(node);
+  for (const key in node) {
+    if (Object.hasOwn(node, key) && !astSkippedKeys.has(key)) {
+      astVisit(Reflect.get(node, key), ancestors, callback);
+    }
+  }
+  ancestors.pop();
+}
+function astMatchesCallee(name, callees, modifiers) {
+  return name !== undefined && callees.some((callee) => name === callee || name.startsWith(`${callee}.`) && name.slice(callee.length + 1).split(".").every((part) => modifiers.has(part)));
+}
+function astIsTypeOnlyImport(node) {
+  return node.importKind === "type" || node.specifiers.length > 0 && node.specifiers.every((specifier) => specifier.type === "ImportSpecifier" && specifier.importKind === "type");
+}
+function astStaticString(node) {
+  if (node.type === "Literal" && typeof node.value === "string") {
+    return node.value;
+  }
+  if (node.type === "TemplateLiteral" && node.expressions.length === 0) {
+    return node.quasis[0]?.value.cooked ?? node.quasis[0]?.value.raw;
+  }
+}
+function astContainsJsx(node) {
+  let found = false;
+  astVisit(node, [], (candidate) => {
+    if (candidate.type === "JSXElement" || candidate.type === "JSXFragment") {
+      found = true;
+    }
+  });
+  return found;
+}
+function astNearestFunction(ancestors) {
+  return ancestors.findLast((node) => node.type === "FunctionDeclaration" || node.type === "FunctionExpression" || node.type === "ArrowFunctionExpression");
+}
+function astReturnExpressions(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return [node.body];
+  }
+  const expressions = [];
+  astVisit(node.body, [node], (candidate, ancestors) => {
+    if (candidate.type === "ReturnStatement" && candidate.argument && astNearestFunction(ancestors) === node) {
+      expressions.push(candidate.argument);
+    }
+  });
+  return expressions;
+}
+function astSingleExpression(node) {
+  if (node.type === "ArrowFunctionExpression" && node.body.type !== "BlockStatement") {
+    return node.body;
+  }
+  if (node.body?.type !== "BlockStatement") {
+    return null;
+  }
+  const statements = node.body.body.filter((statement2) => statement2.type !== "EmptyStatement" && !(statement2.type === "ExpressionStatement" && statement2.directive));
+  if (statements.length !== 1) {
+    return null;
+  }
+  const [statement] = statements;
+  if (statement.type === "ReturnStatement") {
+    return statement.argument;
+  }
+  return statement.type === "ExpressionStatement" ? statement.expression : null;
+}
+function astUnwrap(expression) {
+  if (expression.type === "AwaitExpression") {
+    return astUnwrap(expression.argument);
+  }
+  if (expression.type === "ParenthesizedExpression" || expression.type === "TSAsExpression" || expression.type === "TSSatisfiesExpression" || expression.type === "TSTypeAssertion" || expression.type === "TSNonNullExpression" || expression.type === "ChainExpression") {
+    return astUnwrap(expression.expression);
+  }
+  return expression;
+}
+function astCallRoot(expression) {
+  if (expression.type === "Identifier") {
+    return expression.name;
+  }
+  return expression.type === "MemberExpression" && !expression.computed && !expression.optional ? astCallRoot(expression.object) : undefined;
+}
+function astIsForwarder(node, expression) {
+  const value = astUnwrap(expression);
+  if (value.type === "Literal") {
+    return !("regex" in value);
+  }
+  if (value.type === "TemplateLiteral") {
+    return value.expressions.length === 0;
+  }
+  if (value.type === "Identifier") {
+    return true;
+  }
+  if (value.type !== "CallExpression" || value.optional) {
+    return false;
+  }
+  const root = astCallRoot(value.callee);
+  if (!root || node.params.some((param) => param.type !== "Identifier")) {
+    return false;
+  }
+  const receiver = value.callee.type === "MemberExpression" ? root : undefined;
+  const forwarded = node.params.flatMap((param) => param.type === "Identifier" && param.name !== receiver ? [param.name] : []);
+  return value.arguments.length === forwarded.length && value.arguments.every((argument, index) => argument.type === "Identifier" && argument.name === forwarded[index]);
+}
+function astModuleName(node) {
+  return node.type === "Identifier" ? node.name : node.value;
+}
+function astBindings(pattern) {
+  switch (pattern.type) {
+    case "Identifier":
+      return [pattern];
+    case "AssignmentPattern":
+      return astBindings(pattern.left);
+    case "RestElement":
+      return astBindings(pattern.argument);
+    case "ObjectPattern":
+      return pattern.properties.flatMap((property) => astBindings(property.type === "RestElement" ? property : property.value));
+    case "ArrayPattern":
+      return pattern.elements.flatMap((element) => element ? astBindings(element) : []);
+  }
+}
+function astDeclaration(statement) {
+  return statement.type === "ExportNamedDeclaration" || statement.type === "ExportDefaultDeclaration" ? statement.declaration : statement;
+}
+function astMemberName(node) {
+  return !node.computed && node.property.type === "Identifier" ? node.property.name : undefined;
+}
+function astDottedName(node) {
+  if (node.type === "Identifier") {
+    return node.name;
+  }
+  if (node.type !== "MemberExpression") {
+    return;
+  }
+  const object = astDottedName(node.object);
+  const property = astMemberName(node);
+  return object && property ? `${object}.${property}` : undefined;
+}
+function astCallName(node) {
+  if (node.callee.type === "Identifier") {
+    return node.callee.name;
+  }
+  return node.callee.type === "MemberExpression" ? astMemberName(node.callee) : undefined;
+}
+function astSelectorRule(selector, message) {
+  return defineRule3({
+    meta: {
+      type: "problem",
+      schema: [{ type: "object", properties: { message: { type: "string" } }, additionalProperties: false }],
+      messages: { forbidden: "{{message}}" }
+    },
+    createOnce(context) {
+      return {
+        [selector]: (node) => {
+          const options = optionsFirst(context, {});
+          context.report({
+            node,
+            messageId: "forbidden",
+            data: { message: options.message ?? message }
+          });
+        }
+      };
+    }
+  });
+}
+
+// src/vendor/dillon-anti-slop/shared/type-reference-name.ts
+function typeReferenceName(type) {
+  return type.typeName.type === "Identifier" ? type.typeName.name : null;
+}
+
+// src/vendor/dillon-anti-slop/shared/type-environment.ts
+var BUILT_INS = new Set(["Record", "Readonly", "Partial", "Required", "Pick", "Omit", "PropertyKey", "NonNullable"]);
+var TRANSPARENT_WRAPPERS = new Set(["Readonly", "Partial", "Required", "NonNullable"]);
+function typeEnvironmentCreate(program) {
+  const aliases = new Map;
+  const interfaces = new Map;
+  const shadowedBuiltIns = new Set;
+  for (const statement of program.body) {
+    const declaration = astDeclaration(statement);
+    if (declaration?.type === "ImportDeclaration") {
+      for (const specifier of declaration.specifiers) {
+        if (BUILT_INS.has(specifier.local.name)) {
+          shadowedBuiltIns.add(specifier.local.name);
+        }
+      }
+      continue;
+    }
+    if (declaration?.type === "TSTypeAliasDeclaration") {
+      const existing = aliases.get(declaration.id.name);
+      if (existing === undefined) {
+        aliases.set(declaration.id.name, declaration);
+      } else {
+        shadowedBuiltIns.add(declaration.id.name);
+      }
+      if (BUILT_INS.has(declaration.id.name)) {
+        shadowedBuiltIns.add(declaration.id.name);
+      }
+      continue;
+    }
+    if (declaration?.type === "TSInterfaceDeclaration") {
+      const declarations = interfaces.get(declaration.id.name) ?? [];
+      declarations.push(declaration);
+      interfaces.set(declaration.id.name, declarations);
+      if (BUILT_INS.has(declaration.id.name)) {
+        shadowedBuiltIns.add(declaration.id.name);
+      }
+      continue;
+    }
+    if (declaration?.type === "TSEnumDeclaration") {
+      if (BUILT_INS.has(declaration.id.name)) {
+        shadowedBuiltIns.add(declaration.id.name);
+      }
+      continue;
+    }
+    if ((declaration?.type === "ClassDeclaration" || declaration?.type === "FunctionDeclaration") && declaration.id !== null && BUILT_INS.has(declaration.id.name)) {
+      shadowedBuiltIns.add(declaration.id.name);
+    }
+  }
+  return { aliases, interfaces, shadowedBuiltIns };
+}
+function typeEnvironmentIsBuiltIn(name, environment) {
+  return BUILT_INS.has(name) && !environment.shadowedBuiltIns.has(name);
+}
+function typeEnvironmentUnwrap(type) {
+  let current = type;
+  while (current.type === "TSParenthesizedType" || current.type === "TSTypeOperator" && current.operator === "readonly") {
+    current = current.typeAnnotation;
+  }
+  return current;
+}
+function typeEnvironmentReference(type, environment) {
+  if (type.type !== "TSTypeReference") {
+    return null;
+  }
+  const name = typeReferenceName(type);
+  if (name === null) {
+    return null;
+  }
+  return {
+    reference: type,
+    name,
+    transparent: TRANSPARENT_WRAPPERS.has(name) && typeEnvironmentIsBuiltIn(name, environment),
+    argument: type.typeArguments?.params.at(0)
+  };
+}
+function typeEnvironmentIsUnappliedReference(type, name) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  return unwrapped.type === "TSTypeReference" && typeReferenceName(unwrapped) === name && (unwrapped.typeArguments?.params.length ?? 0) === 0;
+}
+function resolvedSubstitutionArgument(type, base, resolving = new Set) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  if (unwrapped.type !== "TSTypeReference") {
+    return type;
+  }
+  const name = typeReferenceName(unwrapped);
+  if (name === null || resolving.has(name)) {
+    return type;
+  }
+  const substitution = base.get(name);
+  if (substitution === undefined) {
+    return type;
+  }
+  const nextResolving = new Set(resolving);
+  nextResolving.add(name);
+  return resolvedSubstitutionArgument(substitution, base, nextResolving);
+}
+function typeEnvironmentSubstitution(alias, type, base) {
+  const parameters = alias.typeParameters?.params ?? [];
+  const arguments_ = type.typeArguments?.params ?? [];
+  const next = new Map(base);
+  for (const [index, parameter] of parameters.entries()) {
+    const argument = arguments_.at(index) ?? parameter.default;
+    if (!argument) {
+      return null;
+    }
+    next.set(parameter.name.name, resolvedSubstitutionArgument(argument, next));
+  }
+  return next;
+}
+function typeEnvironmentResolveAlias(name, reference, environment, substitutions, resolving) {
+  const alias = environment.aliases.get(name);
+  if (alias === undefined || resolving.has(name)) {
+    return null;
+  }
+  const nextSubstitutions = typeEnvironmentSubstitution(alias, reference, substitutions);
+  if (nextSubstitutions === null) {
+    return null;
+  }
+  const nextResolving = new Set(resolving);
+  nextResolving.add(name);
+  return { type: alias.typeAnnotation, substitutions: nextSubstitutions, resolving: nextResolving };
+}
+
+// src/vendor/dillon-anti-slop/shared/dictionary-types.ts
+function isEffectivelyEmptyMember(member) {
+  return member.type === "TSPropertySignature" && member.optional && member.typeAnnotation !== null && typeEnvironmentUnwrap(member.typeAnnotation.typeAnnotation).type === "TSNeverKeyword";
+}
+function dictionaryTypesUnsafeValue(type, environment, substitutions, resolvingAliases) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  if (unwrapped.type === "TSUnknownKeyword") {
+    return "unknown";
+  }
+  if (unwrapped.type === "TSAnyKeyword") {
+    return "any";
+  }
+  if (unwrapped.type === "TSObjectKeyword") {
+    return "object";
+  }
+  if (unwrapped.type === "TSTypeLiteral" && unwrapped.members.every(isEffectivelyEmptyMember)) {
+    return "empty-object";
+  }
+  if (unwrapped.type === "TSUnionType") {
+    return unwrapped.types.some((member) => dictionaryTypesUnsafeValue(member, environment, substitutions, resolvingAliases) !== null) ? "union" : null;
+  }
+  if (unwrapped.type === "TSIntersectionType") {
+    const unsafeMembers = unwrapped.types.map((member) => dictionaryTypesUnsafeValue(member, environment, substitutions, resolvingAliases));
+    if (unsafeMembers.includes("any")) {
+      return "any";
+    }
+    return unsafeMembers.length > 0 && unsafeMembers.every((member) => member !== null) ? unsafeMembers[0] : null;
+  }
+  const named = typeEnvironmentReference(unwrapped, environment);
+  if (named === null) {
+    return null;
+  }
+  const { reference, name } = named;
+  if (named.transparent) {
+    return named.argument === undefined ? null : dictionaryTypesUnsafeValue(named.argument, environment, substitutions, resolvingAliases);
+  }
+  const substitution = substitutions.get(name);
+  if (substitution !== undefined) {
+    return typeEnvironmentIsUnappliedReference(substitution, name) ? null : dictionaryTypesUnsafeValue(substitution, environment, substitutions, resolvingAliases);
+  }
+  const interfaceDeclarations = environment.interfaces.get(name);
+  if (interfaceDeclarations !== undefined) {
+    const [declaration] = interfaceDeclarations;
+    return interfaceDeclarations.length === 1 && declaration.extends.length === 0 && declaration.body.body.every(isEffectivelyEmptyMember) ? "empty-object" : null;
+  }
+  const step = typeEnvironmentResolveAlias(name, reference, environment, substitutions, resolvingAliases);
+  return step === null ? null : dictionaryTypesUnsafeValue(step.type, environment, step.substitutions, step.resolving);
+}
+function dictionaryTypesValueTypes(type, environment, substitutions, resolvingAliases) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  if (unwrapped.type === "TSTypeLiteral") {
+    return unwrapped.members.flatMap((member) => member.type === "TSIndexSignature" ? [{ type: member.typeAnnotation.typeAnnotation, substitutions }] : []);
+  }
+  if (unwrapped.type === "TSMappedType") {
+    return unwrapped.typeAnnotation === null ? [] : [{ type: unwrapped.typeAnnotation, substitutions }];
+  }
+  const named = typeEnvironmentReference(unwrapped, environment);
+  if (named === null) {
+    return [];
+  }
+  const { reference, name } = named;
+  const substitution = substitutions.get(name);
+  if (substitution !== undefined) {
+    return typeEnvironmentIsUnappliedReference(substitution, name) ? [] : dictionaryTypesValueTypes(substitution, environment, substitutions, resolvingAliases);
+  }
+  if (named.transparent) {
+    return named.argument === undefined ? [] : dictionaryTypesValueTypes(named.argument, environment, substitutions, resolvingAliases);
+  }
+  if (name === "Record" && typeEnvironmentIsBuiltIn(name, environment)) {
+    const value = reference.typeArguments?.params[1] ?? null;
+    return value === null ? [] : [{ type: value, substitutions }];
+  }
+  if ((name === "Pick" || name === "Omit") && typeEnvironmentIsBuiltIn(name, environment)) {
+    const source = reference.typeArguments?.params[0];
+    return source === undefined ? [] : dictionaryTypesValueTypes(source, environment, substitutions, resolvingAliases);
+  }
+  const step = typeEnvironmentResolveAlias(name, reference, environment, substitutions, resolvingAliases);
+  return step === null ? [] : dictionaryTypesValueTypes(step.type, environment, step.substitutions, step.resolving);
+}
+function dictionaryTypesClassify(type, environment) {
+  for (const valueType of dictionaryTypesValueTypes(type, environment, new Map, new Set)) {
+    const unsafeValue = dictionaryTypesUnsafeValue(valueType.type, environment, valueType.substitutions, new Set);
+    if (unsafeValue !== null) {
+      return unsafeValue;
+    }
+  }
+  return null;
+}
+
+// src/vendor/dillon-anti-slop/shared/widening-targets.ts
+function keywordTarget(type) {
+  if (type.type === "TSUnknownKeyword") {
+    return { kind: "unknown" };
+  }
+  return type.type === "TSObjectKeyword" ? { kind: "object" } : null;
+}
+function isBroadMappedKey(type, environment, substitutions) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  if (unwrapped.type === "TSStringKeyword" || unwrapped.type === "TSNumberKeyword" || unwrapped.type === "TSSymbolKeyword") {
+    return true;
+  }
+  if (unwrapped.type === "TSUnionType") {
+    return unwrapped.types.every((member) => isBroadMappedKey(member, environment, substitutions));
+  }
+  const named = typeEnvironmentReference(unwrapped, environment);
+  if (named === null) {
+    return false;
+  }
+  const { name } = named;
+  const substitution = substitutions.get(name);
+  if (substitution !== undefined && !typeEnvironmentIsUnappliedReference(substitution, name)) {
+    return isBroadMappedKey(substitution, environment, substitutions);
+  }
+  return name === "PropertyKey" && typeEnvironmentIsBuiltIn(name, environment);
+}
+function classifyAliasBroadTarget(type, environment, substitutions, resolvingAliases) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  const keyword = keywordTarget(unwrapped);
+  if (keyword !== null) {
+    return keyword;
+  }
+  if (unwrapped.type === "TSTypeLiteral") {
+    return unwrapped.members.some((member) => member.type === "TSIndexSignature") ? { kind: "open dictionary" } : null;
+  }
+  if (unwrapped.type === "TSMappedType") {
+    return isBroadMappedKey(unwrapped.constraint, environment, substitutions) ? { kind: "open dictionary" } : null;
+  }
+  const named = typeEnvironmentReference(unwrapped, environment);
+  if (named === null) {
+    return null;
+  }
+  const { reference, name } = named;
+  const substitution = substitutions.get(name);
+  if (substitution !== undefined) {
+    return typeEnvironmentIsUnappliedReference(substitution, name) ? null : classifyAliasBroadTarget(substitution, environment, substitutions, resolvingAliases);
+  }
+  if (named.transparent) {
+    return named.argument === undefined ? null : classifyAliasBroadTarget(named.argument, environment, substitutions, resolvingAliases);
+  }
+  if (name === "Record" && typeEnvironmentIsBuiltIn(name, environment)) {
+    return { kind: "open dictionary" };
+  }
+  const step = typeEnvironmentResolveAlias(name, reference, environment, substitutions, resolvingAliases);
+  return step === null ? null : classifyAliasBroadTarget(step.type, environment, step.substitutions, step.resolving);
+}
+function wideningTargetsClassify(type, environment) {
+  const unwrapped = typeEnvironmentUnwrap(type);
+  const keyword = keywordTarget(unwrapped);
+  if (keyword !== null) {
+    return keyword;
+  }
+  if (unwrapped.type === "TSTypeLiteral") {
+    if (unwrapped.members.some((member) => member.type === "TSIndexSignature")) {
+      return { kind: "open dictionary" };
+    }
+    return unwrapped.members.length > 0 ? { kind: "anonymous object" } : null;
+  }
+  if (unwrapped.type === "TSMappedType") {
+    return { kind: "open dictionary" };
+  }
+  const named = typeEnvironmentReference(unwrapped, environment);
+  if (named === null) {
+    return null;
+  }
+  const { reference, name } = named;
+  if (named.transparent) {
+    return named.argument === undefined ? null : wideningTargetsClassify(named.argument, environment);
+  }
+  if (name === "Record" && typeEnvironmentIsBuiltIn(name, environment)) {
+    return { kind: "open dictionary" };
+  }
+  const alias = environment.aliases.get(name);
+  if (alias === undefined) {
+    return null;
+  }
+  const substitutions = typeEnvironmentSubstitution(alias, reference, new Map);
+  if ((alias.typeParameters?.params.length ?? 0) > 0) {
+    return substitutions !== null && dictionaryTypesValueTypes(alias.typeAnnotation, environment, substitutions, new Set([name])).length > 0 ? { kind: "generic container" } : null;
+  }
+  return substitutions === null ? null : classifyAliasBroadTarget(alias.typeAnnotation, environment, substitutions, new Set([name]));
+}
+
+// src/vendor/dillon-anti-slop/rules/no-known-value-widening.ts
+function unwrapExpression(expression) {
+  let current = expression;
+  while (current.type === "ParenthesizedExpression" || current.type === "TSAsExpression" || current.type === "TSSatisfiesExpression" || current.type === "TSTypeAssertion" || current.type === "TSNonNullExpression") {
+    current = current.expression;
+  }
+  return current;
+}
+function variableDeclarator(variable) {
+  if (variable.defs.length !== 1) {
+    return null;
+  }
+  const [definition] = variable.defs;
+  return definition.type === "Variable" && definition.node.type === "VariableDeclarator" ? definition.node : null;
+}
+function hasKnownEvidence(sourceCode, expression, visitedVariables = new Set) {
+  const unwrapped = unwrapExpression(expression);
+  if (unwrapped.type === "ObjectExpression" || unwrapped.type === "ArrayExpression" || unwrapped.type === "ArrowFunctionExpression" || unwrapped.type === "ClassExpression" || unwrapped.type === "FunctionExpression" || unwrapped.type === "NewExpression" || unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral" || unwrapped.type === "UnaryExpression") {
+    return true;
+  }
+  if (unwrapped.type !== "Identifier") {
+    return false;
+  }
+  const variable = resolveVariable(sourceCode, unwrapped);
+  if (variable === null || visitedVariables.has(variable)) {
+    return false;
+  }
+  const declarator = variableDeclarator(variable);
+  if (declarator === null) {
+    return false;
+  }
+  if (declarator.init === null || declarator.parent.type !== "VariableDeclaration" || declarator.parent.kind !== "const" || !variable.references.every((reference) => reference.init || !reference.isWrite())) {
+    return false;
+  }
+  visitedVariables.add(variable);
+  return hasKnownEvidence(sourceCode, declarator.init, visitedVariables);
+}
+function sourceKeyName(sourceCode, key) {
+  if (key.type === "Identifier" || key.type === "PrivateIdentifier") {
+    return key.name;
+  }
+  if (key.type === "Literal") {
+    return String(key.value);
+  }
+  return sourceCode.getText(key);
+}
+function functionName(sourceCode, owner) {
+  if (owner === null) {
+    return "anonymous function";
+  }
+  if (owner.id !== null) {
+    return owner.id.name;
+  }
+  const parent = owner.parent;
+  if (parent.type === "VariableDeclarator" && parent.id.type === "Identifier") {
+    return parent.id.name;
+  }
+  if (parent.type === "MethodDefinition") {
+    return sourceKeyName(sourceCode, parent.key);
+  }
+  return "anonymous function";
+}
+function hasParentAssertion(node) {
+  return node.parent?.type === "TSAsExpression" || node.parent?.type === "TSTypeAssertion";
+}
+var noKnownValueWideningRule = defineRule4({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow syntactically established values from flowing into explicitly broad or anonymous target types that discard useful evidence."
+    },
+    messages: {
+      widening: "The explicit {{target}} type on {{subject}} discards known type evidence. Keep inference, validate with `satisfies`, or use a named owner contract."
+    }
+  },
+  createOnce(context) {
+    let environment = null;
+    const reportFlow = (expression, destination, subject) => {
+      if (destination === null) {
+        return;
+      }
+      const unwrapped = unwrapExpression(expression);
+      if ((destination.kind === "open dictionary" || destination.kind === "generic container") && unwrapped.type === "ObjectExpression" && unwrapped.properties.length === 0) {
+        return;
+      }
+      if (!hasKnownEvidence(context.sourceCode, expression)) {
+        return;
+      }
+      context.report({
+        node: expression,
+        messageId: "widening",
+        data: { subject, target: destination.kind }
+      });
+    };
+    const targetFromAnnotation = (annotation) => environment === null || annotation === null || annotation === undefined ? null : wideningTargetsClassify(annotation.typeAnnotation, environment);
+    return {
+      Program(node) {
+        environment = typeEnvironmentCreate(node);
+      },
+      VariableDeclarator(node) {
+        if (node.init === null || node.id.type !== "Identifier") {
+          return;
+        }
+        reportFlow(node.init, targetFromAnnotation(node.id.typeAnnotation), `binding \`${node.id.name}\``);
+      },
+      PropertyDefinition(node) {
+        if (node.value === null) {
+          return;
+        }
+        reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+      },
+      AccessorProperty(node) {
+        if (node.value === null) {
+          return;
+        }
+        reportFlow(node.value, targetFromAnnotation(node.typeAnnotation), `property \`${sourceKeyName(context.sourceCode, node.key)}\``);
+      },
+      AssignmentExpression(node) {
+        if (node.operator !== "=" || node.left.type !== "Identifier") {
+          return;
+        }
+        const variable = resolveVariable(context.sourceCode, node.left);
+        const declarator = variable === null ? null : variableDeclarator(variable);
+        if (declarator?.id.type !== "Identifier") {
+          return;
+        }
+        reportFlow(node.right, targetFromAnnotation(declarator.id.typeAnnotation), `binding \`${declarator.id.name}\``);
+      },
+      ReturnStatement(node) {
+        if (node.argument === null) {
+          return;
+        }
+        let owner = null;
+        let current = node.parent;
+        while (owner === null && current.type !== "Program") {
+          if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") {
+            owner = current;
+          }
+          current = current.parent;
+        }
+        reportFlow(node.argument, targetFromAnnotation(owner?.returnType), `return value of \`${functionName(context.sourceCode, owner)}\``);
+      },
+      ArrowFunctionExpression(node) {
+        if (node.body.type === "BlockStatement") {
+          return;
+        }
+        reportFlow(node.body, targetFromAnnotation(node.returnType), `return value of \`${functionName(context.sourceCode, node)}\``);
+      },
+      TSAsExpression(node) {
+        if (environment === null || hasParentAssertion(node)) {
+          return;
+        }
+        reportFlow(node.expression, wideningTargetsClassify(node.typeAnnotation, environment), "assertion");
+      },
+      TSTypeAssertion(node) {
+        if (environment === null || hasParentAssertion(node)) {
+          return;
+        }
+        reportFlow(node.expression, wideningTargetsClassify(node.typeAnnotation, environment), "assertion");
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-module-mocking.ts
+import { defineRule as defineRule5 } from "@oxlint/plugins";
+var moduleMockMethods = new Set(["doMock", "mock", "unstable_mockModule"]);
+var defaultDeny = [
+  { api: "*.mock" },
+  { api: "*.doMock" },
+  { api: "*.unstable_mockModule" }
+];
+function testFramework(sourceCode, expression) {
+  if (expression.type !== "Identifier") {
+    return null;
+  }
+  const name = expression.name === "vi" || expression.name === "jest" ? expression.name : null;
+  if (name !== null && sourceCode.isGlobalReference(expression)) {
+    return name;
+  }
+  const variable = resolveVariable(sourceCode, expression);
+  if (variable === null || variable.defs.length === 0) {
+    return name;
+  }
+  for (const definition of variable.defs) {
+    if (definition.type !== "ImportBinding" || definition.parent?.type !== "ImportDeclaration") {
+      continue;
+    }
+    const source = definition.parent.source.value;
+    const specifier = definition.node;
+    let imported = null;
+    if (specifier.type === "ImportSpecifier") {
+      imported = astModuleName(specifier.imported);
+    }
+    if (source === "vitest" && imported === "vi") {
+      return "vi";
+    }
+    if (source === "@jest/globals" && imported === "jest") {
+      return "jest";
+    }
+  }
+  return null;
+}
+function propertyName(key, computed) {
+  if (key.type === "Literal" && typeof key.value === "string") {
+    return key.value;
+  }
+  return !computed && key.type === "Identifier" ? key.name : null;
+}
+function apiParts(api) {
+  const dot = api.indexOf(".");
+  return [api.slice(0, dot), api.slice(dot + 1)];
+}
+function apiMatches(pattern, api) {
+  if (pattern === "*") {
+    return true;
+  }
+  const [patternFramework, patternMethod] = apiParts(pattern);
+  const [framework, method] = apiParts(api);
+  return (patternFramework === "*" || patternFramework === framework) && (patternMethod === "*" || patternMethod === method);
+}
+var noModuleMockingRule = defineRule5({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow Vitest and Jest module mocking; tests must replace dependencies through real interfaces."
+    },
+    schema: [
+      {
+        type: "object",
+        additionalProperties: false,
+        properties: {
+          deny: {
+            type: "array",
+            items: {
+              anyOf: [
+                { type: "string" },
+                {
+                  type: "object",
+                  additionalProperties: false,
+                  properties: {
+                    api: { type: "string" },
+                    message: { type: "string" }
+                  },
+                  required: ["api"]
+                }
+              ]
+            }
+          },
+          allow: { type: "array", items: { type: "string" } },
+          checkDestructured: { type: "boolean" }
+        }
+      }
+    ],
+    messages: {
+      moduleMock: "Replace module mocking with dependency injection through a real interface, service layer, or faithful test implementation.",
+      testDouble: "Replace {{api}} with dependency injection through a real interface, service layer, or faithful test implementation.",
+      custom: "{{message}}"
+    }
+  },
+  createOnce(context) {
+    let deny = [];
+    let allow = [];
+    let checkDestructured = false;
+    return {
+      before() {
+        const options = optionsFirst(context, {});
+        deny = (options.deny ?? defaultDeny).map((entry) => typeof entry === "string" ? { api: entry } : entry);
+        allow = options.allow ?? [];
+        checkDestructured = options.checkDestructured ?? false;
+        optionsAssertMockingApis([...deny.map((entry) => entry.api), ...allow]);
+      },
+      CallExpression(node) {
+        const { callee } = node;
+        let framework = null;
+        let method = null;
+        if (callee.type === "MemberExpression") {
+          framework = testFramework(context.sourceCode, callee.object);
+          method = framework === null ? null : propertyName(callee.property, callee.computed);
+        } else if (checkDestructured && callee.type === "Identifier") {
+          const definition = resolveVariable(context.sourceCode, callee)?.defs[0];
+          const declarator = definition?.parent?.type === "VariableDeclaration" && definition.parent.kind === "const" ? definition.node : null;
+          if (declarator?.type === "VariableDeclarator" && declarator.id.type === "ObjectPattern" && declarator.init !== null) {
+            framework = testFramework(context.sourceCode, declarator.init);
+            const property = framework === null ? undefined : declarator.id.properties.find((candidate) => {
+              if (candidate.type !== "Property") {
+                return false;
+              }
+              const binding = candidate.value.type === "AssignmentPattern" ? candidate.value.left : candidate.value;
+              return binding.type === "Identifier" && binding.name === callee.name;
+            });
+            method = property === undefined ? null : propertyName(property.key, property.computed);
+          }
+        }
+        if (framework === null || method === null) {
+          return;
+        }
+        const api = `${framework}.${method}`;
+        if (allow.some((pattern) => apiMatches(pattern, api))) {
+          return;
+        }
+        const denied = deny.find((entry) => apiMatches(entry.api, api));
+        if (denied === undefined) {
+          return;
+        }
+        if (denied.message !== undefined) {
+          context.report({
+            node,
+            messageId: "custom",
+            data: { message: denied.message }
+          });
+          return;
+        }
+        context.report({
+          node,
+          messageId: moduleMockMethods.has(apiParts(api)[1]) ? "moduleMock" : "testDouble",
+          data: { api }
+        });
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-object-parameters.ts
+import { defineRule as defineRule6 } from "@oxlint/plugins";
+
+// src/vendor/dillon-anti-slop/shared/lexical-type-parameters.ts
+function isNode(value) {
+  return typeof value === "object" && value !== null && "type" in value && typeof value.type === "string";
+}
+function collectInferTypeParameterNames(node, visitorKeys, names) {
+  if (node.type === "TSInferType") {
+    names.add(node.typeParameter.name.name);
+  }
+  for (const key of visitorKeys[node.type] ?? []) {
+    const value = Reflect.get(node, key);
+    if (isNode(value)) {
+      collectInferTypeParameterNames(value, visitorKeys, names);
+      continue;
+    }
+    if (!Array.isArray(value)) {
+      continue;
+    }
+    for (const child of value) {
+      if (isNode(child)) {
+        collectInferTypeParameterNames(child, visitorKeys, names);
+      }
+    }
+  }
+}
+function lexicalTypeParametersNames(node, visitorKeys) {
+  const names = new Set;
+  let descendant = node;
+  let current = node;
+  while (current.type !== "Program") {
+    if ("typeParameters" in current) {
+      for (const parameter of current.typeParameters?.params ?? []) {
+        names.add(parameter.name.name);
+      }
+    }
+    if (current.type === "TSMappedType" && (descendant === current.nameType || descendant === current.typeAnnotation)) {
+      names.add(current.key.name);
+    }
+    if (current.type === "TSConditionalType" && descendant === current.trueType) {
+      collectInferTypeParameterNames(current.extendsType, visitorKeys, names);
+    }
+    descendant = current;
+    current = current.parent;
+  }
+  return names;
+}
+
+// src/vendor/dillon-anti-slop/shared/signatures.ts
+function signaturesParameterAnnotation(parameter) {
+  if (parameter.type === "TSParameterProperty") {
+    return signaturesParameterAnnotation(parameter.parameter);
+  }
+  if (parameter.type === "RestElement") {
+    return parameter.typeAnnotation ?? signaturesParameterAnnotation(parameter.argument);
+  }
+  if (parameter.type === "AssignmentPattern") {
+    return parameter.typeAnnotation ?? parameter.left.typeAnnotation;
+  }
+  return parameter.typeAnnotation;
+}
+function signaturesListeners(listener) {
+  return {
+    ArrowFunctionExpression: listener,
+    FunctionDeclaration: listener,
+    FunctionExpression: listener,
+    TSCallSignatureDeclaration: listener,
+    TSConstructSignatureDeclaration: listener,
+    TSConstructorType: listener,
+    TSDeclareFunction: listener,
+    TSEmptyBodyFunctionExpression: listener,
+    TSFunctionType: listener,
+    TSMethodSignature: listener
+  };
+}
+
+// src/vendor/dillon-anti-slop/shared/type-aliases.ts
+function typeAliasesCollect(program, includeGeneric) {
+  const aliases = new Map;
+  for (const statement of program.body) {
+    const declaration = statement.type === "ExportNamedDeclaration" ? statement.declaration : statement;
+    if (declaration?.type === "TSTypeAliasDeclaration" && (includeGeneric || !declaration.typeParameters)) {
+      aliases.set(declaration.id.name, declaration);
+    }
+  }
+  return aliases;
+}
+function typeAliasesResolvesTo(type, resolution, visited = new Set) {
+  if (type.type === resolution.keyword) {
+    return true;
+  }
+  if (type.type === "TSParenthesizedType") {
+    return typeAliasesResolvesTo(type.typeAnnotation, resolution, visited);
+  }
+  if (resolution.unions && type.type === "TSUnionType") {
+    return type.types.some((member) => typeAliasesResolvesTo(member, resolution, visited));
+  }
+  if (type.type !== "TSTypeReference" || type.typeName.type !== "Identifier") {
+    return false;
+  }
+  const name = type.typeName.name;
+  if (resolution.promises && (name === "Promise" || name === "PromiseLike")) {
+    const value = type.typeArguments?.params[0];
+    return value !== undefined && typeAliasesResolvesTo(value, resolution, visited);
+  }
+  if ((type.typeArguments?.params.length ?? 0) > 0 || visited.has(name) || resolution.shadowed.has(name)) {
+    return false;
+  }
+  const alias = resolution.aliases.get(name);
+  if (alias === undefined || alias.typeParameters) {
+    return false;
+  }
+  const nextVisited = new Set(visited);
+  nextVisited.add(name);
+  return typeAliasesResolvesTo(alias.typeAnnotation, resolution, nextVisited);
+}
+
+// src/vendor/dillon-anti-slop/rules/no-object-parameters.ts
+var noObjectParametersRule = defineRule6({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow object function parameters; inputs must use an owner-provided type and be parsed at their boundary."
+    },
+    messages: {
+      objectParameter: "Parameter `{{parameter}}` uses the broad `object` type. Accept a named owner type; parse external input at its boundary before calling this function."
+    }
+  },
+  createOnce(context) {
+    let aliases = new Map;
+    return {
+      Program(node) {
+        aliases = typeAliasesCollect(node, false);
+      },
+      ...signaturesListeners((node) => {
+        const shadowed = lexicalTypeParametersNames(node, context.sourceCode.visitorKeys);
+        for (const parameter of node.params) {
+          const annotation = signaturesParameterAnnotation(parameter);
+          if (annotation === null || annotation === undefined || !typeAliasesResolvesTo(annotation.typeAnnotation, {
+            aliases,
+            keyword: "TSObjectKeyword",
+            shadowed,
+            unions: true,
+            promises: false
+          })) {
+            continue;
+          }
+          context.report({
+            node: annotation.typeAnnotation,
+            messageId: "objectParameter",
+            data: {
+              parameter: parameter.type === "Identifier" ? parameter.name : context.sourceCode.getText(parameter).replace(/\s*:\s*object\s*$/u, "")
+            }
+          });
+        }
+      })
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/shared/reflect-method.ts
+import { defineRule as defineRule7 } from "@oxlint/plugins";
+function reflectMethodRule(methodName, messageId, description, message) {
+  return defineRule7({
+    meta: {
+      type: "problem",
+      docs: { description },
+      messages: { [messageId]: message }
+    },
+    createOnce(context) {
+      return {
+        CallExpression(node) {
+          const { callee } = node;
+          if (callee.type === "Super" || callee.type === "V8IntrinsicExpression" || !("property" in callee) || !("object" in callee) || !("computed" in callee)) {
+            return;
+          }
+          const { object, property } = callee;
+          if (object.type !== "Identifier" || object.name !== "Reflect") {
+            return;
+          }
+          if (!context.sourceCode.isGlobalReference(object)) {
+            const variable = resolveVariable(context.sourceCode, object);
+            if (variable !== null && variable.defs.length > 0) {
+              return;
+            }
+          }
+          if (callee.computed ? property.type === "Literal" && property.value === methodName : property.type === "Identifier" && property.name === methodName) {
+            context.report({ node, messageId });
+          }
+        }
+      };
+    }
+  });
+}
+
+// src/vendor/dillon-anti-slop/rules/no-reflect-apply.ts
+var noReflectApplyRule = reflectMethodRule("apply", "reflectApply", "Disallow Reflect.apply; call typed functions directly or model dynamic dispatch behind an interface.", "Replace `Reflect.apply` with a typed function call. Model dynamic dispatch behind a named interface.");
+
+// src/vendor/dillon-anti-slop/rules/no-reflect-get.ts
+var noReflectGetRule = reflectMethodRule("get", "reflectGet", "Disallow Reflect.get; use typed property access or parse dynamic input into a domain type.", "Replace `Reflect.get` with typed property access. Parse dynamic input into a named domain type before reading it.");
+
+// src/vendor/dillon-anti-slop/rules/no-runtime-typeof.ts
+import { defineRule as defineRule8 } from "@oxlint/plugins";
+var noRuntimeTypeofRule = defineRule8({
+  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) {
+        if (node.operator !== "typeof") {
+          return;
+        }
+        if (optionsFirst(context, {}).allowInTypeGuards === true) {
+          let current = node.parent;
+          while (current.type !== "Program") {
+            if (current.type === "ArrowFunctionExpression" || current.type === "FunctionDeclaration" || current.type === "FunctionExpression") {
+              if (current.returnType?.typeAnnotation.type === "TSTypePredicate") {
+                return;
+              }
+              break;
+            }
+            current = current.parent;
+          }
+        }
+        context.report({ node, messageId: "runtimeTypeof" });
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-shape-in-symbol-names.ts
+import { defineRule as defineRule9 } from "@oxlint/plugins";
+var FORBIDDEN_SYMBOL_NAME = "shape";
+function namesForeignApi(node) {
+  const parent = node.parent;
+  if (!parent) {
+    return false;
+  }
+  if (parent.type === "MemberExpression") {
+    return parent.property === node && !parent.computed;
+  }
+  if (parent.type === "TSQualifiedName") {
+    return parent.right === node;
+  }
+  if (parent.type === "ImportSpecifier") {
+    return parent.imported === node && parent.local !== node && "name" in node && parent.local.name !== node.name;
+  }
+  if (parent.type === "ExportSpecifier") {
+    return parent.local === node && parent.exported !== node && parent.parent.type === "ExportNamedDeclaration" && parent.parent.source !== null;
+  }
+  if (parent.type === "JSXMemberExpression") {
+    return parent.property === node;
+  }
+  if (parent.type === "JSXAttribute") {
+    return parent.name === node;
+  }
+  return parent.type === "Property" && parent.key === node && !parent.computed && (parent.shorthand || parent.parent.type === "ObjectPattern");
+}
+var noForbiddenTermInSymbolNamesRule = defineRule9({
+  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 (!node.name.toLowerCase().includes(FORBIDDEN_SYMBOL_NAME) || namesForeignApi(node)) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "forbiddenSymbolName",
+        data: { name: node.name }
+      });
+    };
+    return {
+      Identifier: reportForbiddenSymbolName,
+      PrivateIdentifier: reportForbiddenSymbolName,
+      JSXIdentifier: reportForbiddenSymbolName
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-unknown-parameters.ts
+import { defineRule as defineRule10 } from "@oxlint/plugins";
+function parameterName(parameter, sourceText) {
+  if (parameter.type === "TSParameterProperty") {
+    return parameterName(parameter.parameter, sourceText);
+  }
+  if (parameter.type === "AssignmentPattern") {
+    return parameterName(parameter.left, sourceText);
+  }
+  if (parameter.type === "RestElement") {
+    return parameterName(parameter.argument, sourceText);
+  }
+  return parameter.type === "Identifier" ? parameter.name : sourceText.replace(/\s*:\s*unknown\s*$/u, "");
+}
+var noUnknownParametersRule = defineRule10({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Disallow explicitly unknown function parameters except `error` and `cause`; decode unknown input at its I/O boundary instead."
+    },
+    messages: {
+      unknownParameter: "Parameter `{{parameter}}` leaves input unparsed. Accept a named domain type; run the expected schema or parser at the I/O boundary before calling this function."
+    }
+  },
+  createOnce(context) {
+    return signaturesListeners((node) => {
+      for (const parameter of node.params) {
+        const annotation = signaturesParameterAnnotation(parameter);
+        if (annotation?.typeAnnotation.type !== "TSUnknownKeyword") {
+          continue;
+        }
+        const name = parameterName(parameter, context.sourceCode.getText(parameter));
+        if (name === "cause" || name === "error") {
+          continue;
+        }
+        context.report({
+          node: annotation.typeAnnotation,
+          messageId: "unknownParameter",
+          data: { parameter: name }
+        });
+      }
+    });
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-unknown-returns.ts
+import { defineRule as defineRule11 } from "@oxlint/plugins";
+var noUnknownReturnsRule = defineRule11({
+  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 aliases = new Map;
+    return {
+      Program(node) {
+        aliases = typeAliasesCollect(node, true);
+      },
+      ...signaturesListeners((node) => {
+        const annotation = node.returnType;
+        if (annotation === null || annotation === undefined || !typeAliasesResolvesTo(annotation.typeAnnotation, {
+          aliases,
+          keyword: "TSUnknownKeyword",
+          shadowed: lexicalTypeParametersNames(node, context.sourceCode.visitorKeys),
+          unions: true,
+          promises: true
+        })) {
+          return;
+        }
+        context.report({ node: annotation.typeAnnotation, messageId: "unknownReturn" });
+      })
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-unknown-type-aliases.ts
+import { defineRule as defineRule12 } from "@oxlint/plugins";
+var noUnknownTypeAliasesRule = defineRule12({
+  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) {
+    return {
+      Program(node) {
+        const aliases = typeAliasesCollect(node, true);
+        const resolution = {
+          aliases,
+          keyword: "TSUnknownKeyword",
+          shadowed: new Set,
+          unions: false,
+          promises: false
+        };
+        for (const alias of aliases.values()) {
+          if (!typeAliasesResolvesTo(alias.typeAnnotation, resolution, new Set([alias.id.name]))) {
+            continue;
+          }
+          context.report({
+            node: alias.id,
+            messageId: "unknownAlias",
+            data: { alias: alias.id.name }
+          });
+        }
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-unsafe-dictionary-type.ts
+import { defineRule as defineRule13 } from "@oxlint/plugins";
+var typeNodeKinds = new Set([
+  "JSDocNonNullableType",
+  "JSDocNullableType",
+  "JSDocUnknownType",
+  "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);
+}
+var noUnsafeDictionaryTypeRule = defineRule13({
+  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) {
+        return;
+      }
+      if (node.type === "TSTypeReference" && (node.typeArguments?.params.length ?? 0) === 0) {
+        const name = typeReferenceName(node);
+        if (name !== null && environment.aliases.has(name)) {
+          let owner = node.parent;
+          while (owner.type !== "Program" && owner.type !== "TSTypeAliasDeclaration") {
+            owner = owner.parent;
+          }
+          if (owner.type !== "TSTypeAliasDeclaration") {
+            return;
+          }
+        }
+      }
+      const unsafe = dictionaryTypesClassify(node, environment);
+      if (unsafe === null) {
+        return;
+      }
+      let current = node.parent;
+      while (current.type !== "Program") {
+        if (isTypeNode(current) && dictionaryTypesClassify(current, environment) !== null) {
+          return;
+        }
+        current = current.parent;
+      }
+      report(node, unsafe);
+    };
+    return {
+      Program(node) {
+        environment = typeEnvironmentCreate(node);
+      },
+      TSTypeReference: reportIfUnsafe,
+      TSTypeLiteral: reportIfUnsafe,
+      TSMappedType: reportIfUnsafe,
+      TSIndexSignature(node) {
+        if (environment === null || node.parent.type === "TSTypeLiteral") {
+          return;
+        }
+        const unsafe = dictionaryTypesUnsafeValue(node.typeAnnotation.typeAnnotation, environment, new Map, new Set);
+        if (unsafe !== null) {
+          report(node, unsafe);
+        }
+      }
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/no-widen-then-assert.ts
+import { defineRule as defineRule14 } from "@oxlint/plugins";
+var functionBoundaryTypes = new Set([
+  "ArrowFunctionExpression",
+  "FunctionDeclaration",
+  "FunctionExpression",
+  "TSDeclareFunction",
+  "TSEmptyBodyFunctionExpression"
+]);
+var definitelyObjectTypes = new Set([
+  "TSArrayType",
+  "TSConstructorType",
+  "TSFunctionType",
+  "TSMappedType",
+  "TSObjectKeyword",
+  "TSTupleType"
+]);
+function unwrapTypeParentheses(type) {
+  let current = type;
+  while (current.type === "TSParenthesizedType") {
+    current = current.typeAnnotation;
+  }
+  return current;
+}
+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.at(0);
+      return inner !== undefined && isBroadRecordType(inner);
+    }
+    if (typeReferenceName(unwrapped) !== "Record") {
+      return false;
+    }
+    const parameters = unwrapped.typeArguments?.params ?? [];
+    return parameters.length === 2 && isBroadRecordKeyType(parameters[0]) && isUnknownOrAnyType(parameters[1]);
+  }
+  if (unwrapped.type !== "TSTypeLiteral" || unwrapped.members.length !== 1) {
+    return false;
+  }
+  const [member] = unwrapped.members;
+  return member.type === "TSIndexSignature" && member.parameters.length === 1 && isBroadRecordKeyType(member.parameters[0].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 normalizedTypeText(sourceText, type) {
+  const unwrapped = unwrapTypeParentheses(type);
+  return sourceText.slice(unwrapped.start, unwrapped.end).replaceAll(/\s+/gu, "");
+}
+function isDefinitelyObjectType(type) {
+  const unwrapped = unwrapTypeParentheses(type);
+  if (definitelyObjectTypes.has(unwrapped.type)) {
+    return true;
+  }
+  if (unwrapped.type === "TSTypeLiteral") {
+    return unwrapped.members.length > 0;
+  }
+  if (unwrapped.type === "TSIntersectionType") {
+    return unwrapped.types.every(isDefinitelyObjectType);
+  }
+  return unwrapped.type === "TSTypeOperator" && unwrapped.operator === "readonly" && isDefinitelyObjectType(unwrapped.typeAnnotation);
+}
+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.at(0);
+    return inner !== undefined && isDefinitelyNarrowerRecordType(inner);
+  }
+  if (typeReferenceName(unwrapped) !== "Record") {
+    return false;
+  }
+  const parameters = unwrapped.typeArguments?.params ?? [];
+  return parameters.length === 2 && !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 stableConstBinding(variable) {
+  for (const definition of variable.defs) {
+    if (definition.type === "Variable" && definition.node.type === "VariableDeclarator") {
+      const declarator = definition.node;
+      const { init } = declarator;
+      return init !== null && declarator.parent.type === "VariableDeclaration" && declarator.parent.kind === "const" && !variable.references.some((reference) => reference.isWrite() && !reference.init) ? { declarator, init } : null;
+    }
+  }
+  return null;
+}
+function knownValueEvidence(expression, sourceCode, boundary, visitedVariables) {
+  const unwrapped = expressionsUnwrapParentheses(expression);
+  if (expressionsIsAssertion(unwrapped)) {
+    return broadTypeKind(unwrapped.typeAnnotation) === null ? { type: unwrapped.typeAnnotation } : null;
+  }
+  if (unwrapped.type === "Literal" || unwrapped.type === "TemplateLiteral" || 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 = resolveVariable(sourceCode, unwrapped);
+  if (variable === null || visitedVariables.has(variable)) {
+    return null;
+  }
+  const annotatedIdentifier = variable.identifiers.find((identifier) => identifier.typeAnnotation !== null && identifier.typeAnnotation !== undefined);
+  const annotation = annotatedIdentifier?.typeAnnotation?.typeAnnotation;
+  if (annotation !== undefined && annotatedIdentifier !== undefined) {
+    return functionBoundary(annotatedIdentifier) !== boundary || broadTypeKind(annotation) !== null ? null : { type: annotation };
+  }
+  const binding = stableConstBinding(variable);
+  if (binding === null || functionBoundary(binding.declarator) !== boundary) {
+    return null;
+  }
+  return knownValueEvidence(binding.init, sourceCode, boundary, new Set([...visitedVariables, variable]));
+}
+var noWidenThenAssertRule = defineRule14({
+  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) {
+    const checkAssertion = (node) => {
+      const expression = expressionsUnwrapParentheses(node.expression);
+      if (expression.type !== "Identifier") {
+        return;
+      }
+      const variable = resolveVariable(context.sourceCode, expression);
+      const binding = variable === null ? null : stableConstBinding(variable);
+      if (variable === null || binding?.declarator.id.type !== "Identifier") {
+        return;
+      }
+      const { declarator, init } = binding;
+      const boundary = functionBoundary(declarator);
+      const declaredType = declarator.id.typeAnnotation?.typeAnnotation;
+      const initializer = expressionsUnwrapParentheses(init);
+      const initializerAssertion = expressionsIsAssertion(initializer) ? initializer : null;
+      const initializerBroadKind = initializerAssertion === null ? null : broadTypeKind(initializerAssertion.typeAnnotation);
+      const broadKind = (declaredType === undefined ? null : broadTypeKind(declaredType)) ?? initializerBroadKind;
+      if (broadKind === null) {
+        return;
+      }
+      const originalExpression = initializerAssertion !== null && initializerBroadKind !== null ? expressionsUnwrapParentheses(initializerAssertion.expression) : init;
+      const evidence = knownValueEvidence(originalExpression, context.sourceCode, boundary, new Set([variable]));
+      if (evidence === null || node.start <= declarator.end || functionBoundary(node) !== boundary) {
+        return;
+      }
+      const assertedType = node.typeAnnotation;
+      const sourceText = context.sourceCode.text;
+      const narrower = broadTypeKind(assertedType) === null && (broadKind === "top" || evidence.type !== null && normalizedTypeText(sourceText, evidence.type) === normalizedTypeText(sourceText, assertedType) || (broadKind === "object" ? isDefinitelyObjectType(assertedType) : isDefinitelyNarrowerRecordType(assertedType)));
+      if (!narrower) {
+        return;
+      }
+      context.report({
+        node,
+        messageId: "widenThenAssert",
+        data: { name: expression.name }
+      });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/rules/require-safety-comment-for-type-assertion.ts
+import { defineRule as defineRule15 } from "@oxlint/plugins";
+var commentOwnerKinds = new Set([
+  "ExpressionStatement",
+  "PropertyDefinition",
+  "ReturnStatement",
+  "ThrowStatement",
+  "VariableDeclaration"
+]);
+var requireSafetyCommentForTypeAssertionRule = defineRule15({
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Require a nearby SAFETY comment for every TypeScript type assertion except const assertions."
+    },
+    messages: {
+      missingSafetyComment: "This type assertion has no `SAFETY:` justification. State the checked invariant immediately before the assertion or its containing statement."
+    }
+  },
+  createOnce(context) {
+    const checkAssertion = (node) => {
+      if (expressionsIsConstAssertion(node)) {
+        return;
+      }
+      let current = node;
+      for (;; ) {
+        if (context.sourceCode.getCommentsBefore(current).some((comment) => comment.end <= node.start && /\bSAFETY\s*:/u.test(comment.value))) {
+          return;
+        }
+        const parent = current.parent;
+        if (commentOwnerKinds.has(current.type) && parent.type !== "ExportNamedDeclaration" && parent.type !== "ExportDefaultDeclaration" || parent.type === "Program") {
+          break;
+        }
+        current = parent;
+      }
+      context.report({ node, messageId: "missingSafetyComment" });
+    };
+    return {
+      TSAsExpression: checkAssertion,
+      TSTypeAssertion: checkAssertion
+    };
+  }
+});
+
+// src/vendor/dillon-anti-slop/index.ts
+var dillonAntiSlopPlugin = eslintCompatPlugin({
+  meta: { name: "dillon-anti-slop" },
+  rules: {
+    "no-chained-type-assertions": noChainedTypeAssertionsRule,
+    "no-conditional-empty-object-spread": noConditionalEmptyObjectSpreadRule,
+    "no-known-value-widening": noKnownValueWideningRule,
+    "no-module-mocking": noModuleMockingRule,
+    "no-object-parameters": noObjectParametersRule,
+    "no-reflect-apply": noReflectApplyRule,
+    "no-reflect-get": noReflectGetRule,
+    "no-runtime-typeof": noRuntimeTypeofRule,
+    "no-unsafe-dictionary-type": noUnsafeDictionaryTypeRule,
+    "no-shape-in-symbol-names": noForbiddenTermInSymbolNamesRule,
+    "no-unknown-parameters": noUnknownParametersRule,
+    "no-unknown-returns": noUnknownReturnsRule,
+    "no-unknown-type-aliases": noUnknownTypeAliasesRule,
+    "no-widen-then-assert": noWidenThenAssertRule,
+    "require-safety-comment-for-type-assertion": requireSafetyCommentForTypeAssertionRule
+  }
+});
+var dillon_anti_slop_default = dillonAntiSlopPlugin;
+export {
+  dillon_anti_slop_default as default
+};